leadping 1.0.0__py3-none-any.whl

leadping/models/phone_number_warmup_call_response.py

@@ -0,0 +1,98 @@
+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 .phone_number_warmup_call_status import PhoneNumberWarmupCallStatus
+
+@dataclass
+class PhoneNumberWarmupCallResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing a voice call warmup attempt.
+    """
+    # 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 answeredAt property
+    answered_at: Optional[datetime.datetime] = None
+    # The completedAt property
+    completed_at: Optional[datetime.datetime] = None
+    # The destinationPhoneNumber property
+    destination_phone_number: Optional[str] = None
+    # The destinationPhoneNumberId property
+    destination_phone_number_id: Optional[str] = None
+    # The failureReason property
+    failure_reason: Optional[str] = None
+    # The id property
+    id: Optional[str] = None
+    # The scheduledAt property
+    scheduled_at: Optional[datetime.datetime] = None
+    # The sourcePhoneNumber property
+    source_phone_number: Optional[str] = None
+    # The sourcePhoneNumberId property
+    source_phone_number_id: Optional[str] = None
+    # Defines the durable state machine statuses for voice call warmup attempts.
+    status: Optional[PhoneNumberWarmupCallStatus] = None
+    # The targetDurationSeconds property
+    target_duration_seconds: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberWarmupCallResponse:
+        """
+        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: PhoneNumberWarmupCallResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberWarmupCallResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .phone_number_warmup_call_status import PhoneNumberWarmupCallStatus
+
+        from .phone_number_warmup_call_status import PhoneNumberWarmupCallStatus
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "answeredAt": lambda n : setattr(self, 'answered_at', n.get_datetime_value()),
+            "completedAt": lambda n : setattr(self, 'completed_at', n.get_datetime_value()),
+            "destinationPhoneNumber": lambda n : setattr(self, 'destination_phone_number', n.get_str_value()),
+            "destinationPhoneNumberId": lambda n : setattr(self, 'destination_phone_number_id', n.get_str_value()),
+            "failureReason": lambda n : setattr(self, 'failure_reason', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "scheduledAt": lambda n : setattr(self, 'scheduled_at', n.get_datetime_value()),
+            "sourcePhoneNumber": lambda n : setattr(self, 'source_phone_number', n.get_str_value()),
+            "sourcePhoneNumberId": lambda n : setattr(self, 'source_phone_number_id', n.get_str_value()),
+            "status": lambda n : setattr(self, 'status', n.get_enum_value(PhoneNumberWarmupCallStatus)),
+            "targetDurationSeconds": lambda n : setattr(self, 'target_duration_seconds', 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("answeredAt", self.answered_at)
+        writer.write_datetime_value("completedAt", self.completed_at)
+        writer.write_str_value("destinationPhoneNumber", self.destination_phone_number)
+        writer.write_str_value("destinationPhoneNumberId", self.destination_phone_number_id)
+        writer.write_str_value("failureReason", self.failure_reason)
+        writer.write_str_value("id", self.id)
+        writer.write_datetime_value("scheduledAt", self.scheduled_at)
+        writer.write_str_value("sourcePhoneNumber", self.source_phone_number)
+        writer.write_str_value("sourcePhoneNumberId", self.source_phone_number_id)
+        writer.write_enum_value("status", self.status)
+        writer.write_int_value("targetDurationSeconds", self.target_duration_seconds)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone_number_warmup_call_status.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+class PhoneNumberWarmupCallStatus(str, Enum):
+    Created = "Created",
+    Scheduled = "Scheduled",
+    Placing = "Placing",
+    Ringing = "Ringing",
+    Answered = "Answered",
+    Connected = "Connected",
+    Completed = "Completed",
+    Failed = "Failed",
+    Canceled = "Canceled",
+    Skipped = "Skipped",
+    TimedOut = "TimedOut",
+

leadping/models/phone_number_warmup_health_status.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class PhoneNumberWarmupHealthStatus(str, Enum):
+    NotStarted = "Not Started",
+    NotEligible = "Not Eligible",
+    Warming = "Warming",
+    Warmed = "Warmed",
+    Paused = "Paused",
+    NeedsAttention = "Needs Attention",
+    Blocked = "Blocked",
+

leadping/models/phone_number_warmup_stage.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class PhoneNumberWarmupStage(str, Enum):
+    Stage0 = "Stage 0",
+    Stage1 = "Stage 1",
+    Stage2 = "Stage 2",
+    Stage3 = "Stage 3",
+    Stage4 = "Stage 4",
+

leadping/models/phone_number_warmup_status_response.py

@@ -0,0 +1,156 @@
+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 .phone_number_warmup_call_response import PhoneNumberWarmupCallResponse
+    from .phone_number_warmup_health_status import PhoneNumberWarmupHealthStatus
+    from .phone_number_warmup_stage import PhoneNumberWarmupStage
+
+@dataclass
+class PhoneNumberWarmupStatusResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing voice call warmup status for a Leadping-managed phone number.
+    """
+    # 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 callsThisHour property
+    calls_this_hour: Optional[int] = None
+    # The callsToday property
+    calls_today: Optional[int] = None
+    # The completedAt property
+    completed_at: Optional[datetime.datetime] = None
+    # The consecutiveFailedCalls property
+    consecutive_failed_calls: Optional[int] = None
+    # The consecutiveSuccessfulCalls property
+    consecutive_successful_calls: Optional[int] = None
+    # The dailyCap property
+    daily_cap: Optional[int] = None
+    # The failureReason property
+    failure_reason: Optional[str] = None
+    # The hourlyCap property
+    hourly_cap: Optional[int] = None
+    # The lastSuccessfulWarmupAt property
+    last_successful_warmup_at: Optional[datetime.datetime] = None
+    # The lowConfidenceTimeZone property
+    low_confidence_time_zone: Optional[bool] = None
+    # The maxTargetDurationSeconds property
+    max_target_duration_seconds: Optional[int] = None
+    # The minTargetDurationSeconds property
+    min_target_duration_seconds: Optional[int] = None
+    # The networkWarmupOptIn property
+    network_warmup_opt_in: Optional[bool] = None
+    # The nextEligibleAt property
+    next_eligible_at: Optional[datetime.datetime] = None
+    # The phoneNumber property
+    phone_number: Optional[str] = None
+    # The phoneNumberId property
+    phone_number_id: Optional[str] = None
+    # The recentCalls property
+    recent_calls: Optional[list[PhoneNumberWarmupCallResponse]] = None
+    # Defines the supported voice call warmup stages for a Leadping-managed phone number.
+    stage: Optional[PhoneNumberWarmupStage] = None
+    # The startAt property
+    start_at: Optional[datetime.datetime] = None
+    # Defines the supported health states for controlled internal voice call warmup.
+    status: Optional[PhoneNumberWarmupHealthStatus] = None
+    # The timeZoneId property
+    time_zone_id: Optional[str] = None
+    # The totalFailedCalls property
+    total_failed_calls: Optional[int] = None
+    # The totalSuccessfulCalls property
+    total_successful_calls: Optional[int] = None
+    # The warmupEnabled property
+    warmup_enabled: Optional[bool] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberWarmupStatusResponse:
+        """
+        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: PhoneNumberWarmupStatusResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberWarmupStatusResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .phone_number_warmup_call_response import PhoneNumberWarmupCallResponse
+        from .phone_number_warmup_health_status import PhoneNumberWarmupHealthStatus
+        from .phone_number_warmup_stage import PhoneNumberWarmupStage
+
+        from .phone_number_warmup_call_response import PhoneNumberWarmupCallResponse
+        from .phone_number_warmup_health_status import PhoneNumberWarmupHealthStatus
+        from .phone_number_warmup_stage import PhoneNumberWarmupStage
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "callsThisHour": lambda n : setattr(self, 'calls_this_hour', n.get_int_value()),
+            "callsToday": lambda n : setattr(self, 'calls_today', n.get_int_value()),
+            "completedAt": lambda n : setattr(self, 'completed_at', n.get_datetime_value()),
+            "consecutiveFailedCalls": lambda n : setattr(self, 'consecutive_failed_calls', n.get_int_value()),
+            "consecutiveSuccessfulCalls": lambda n : setattr(self, 'consecutive_successful_calls', n.get_int_value()),
+            "dailyCap": lambda n : setattr(self, 'daily_cap', n.get_int_value()),
+            "failureReason": lambda n : setattr(self, 'failure_reason', n.get_str_value()),
+            "hourlyCap": lambda n : setattr(self, 'hourly_cap', n.get_int_value()),
+            "lastSuccessfulWarmupAt": lambda n : setattr(self, 'last_successful_warmup_at', n.get_datetime_value()),
+            "lowConfidenceTimeZone": lambda n : setattr(self, 'low_confidence_time_zone', n.get_bool_value()),
+            "maxTargetDurationSeconds": lambda n : setattr(self, 'max_target_duration_seconds', n.get_int_value()),
+            "minTargetDurationSeconds": lambda n : setattr(self, 'min_target_duration_seconds', n.get_int_value()),
+            "networkWarmupOptIn": lambda n : setattr(self, 'network_warmup_opt_in', n.get_bool_value()),
+            "nextEligibleAt": lambda n : setattr(self, 'next_eligible_at', n.get_datetime_value()),
+            "phoneNumber": lambda n : setattr(self, 'phone_number', n.get_str_value()),
+            "phoneNumberId": lambda n : setattr(self, 'phone_number_id', n.get_str_value()),
+            "recentCalls": lambda n : setattr(self, 'recent_calls', n.get_collection_of_object_values(PhoneNumberWarmupCallResponse)),
+            "stage": lambda n : setattr(self, 'stage', n.get_enum_value(PhoneNumberWarmupStage)),
+            "startAt": lambda n : setattr(self, 'start_at', n.get_datetime_value()),
+            "status": lambda n : setattr(self, 'status', n.get_enum_value(PhoneNumberWarmupHealthStatus)),
+            "timeZoneId": lambda n : setattr(self, 'time_zone_id', n.get_str_value()),
+            "totalFailedCalls": lambda n : setattr(self, 'total_failed_calls', n.get_int_value()),
+            "totalSuccessfulCalls": lambda n : setattr(self, 'total_successful_calls', n.get_int_value()),
+            "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_int_value("callsThisHour", self.calls_this_hour)
+        writer.write_int_value("callsToday", self.calls_today)
+        writer.write_datetime_value("completedAt", self.completed_at)
+        writer.write_int_value("consecutiveFailedCalls", self.consecutive_failed_calls)
+        writer.write_int_value("consecutiveSuccessfulCalls", self.consecutive_successful_calls)
+        writer.write_int_value("dailyCap", self.daily_cap)
+        writer.write_str_value("failureReason", self.failure_reason)
+        writer.write_int_value("hourlyCap", self.hourly_cap)
+        writer.write_datetime_value("lastSuccessfulWarmupAt", self.last_successful_warmup_at)
+        writer.write_bool_value("lowConfidenceTimeZone", self.low_confidence_time_zone)
+        writer.write_int_value("maxTargetDurationSeconds", self.max_target_duration_seconds)
+        writer.write_int_value("minTargetDurationSeconds", self.min_target_duration_seconds)
+        writer.write_bool_value("networkWarmupOptIn", self.network_warmup_opt_in)
+        writer.write_datetime_value("nextEligibleAt", self.next_eligible_at)
+        writer.write_str_value("phoneNumber", self.phone_number)
+        writer.write_str_value("phoneNumberId", self.phone_number_id)
+        writer.write_collection_of_object_values("recentCalls", self.recent_calls)
+        writer.write_enum_value("stage", self.stage)
+        writer.write_datetime_value("startAt", self.start_at)
+        writer.write_enum_value("status", self.status)
+        writer.write_str_value("timeZoneId", self.time_zone_id)
+        writer.write_int_value("totalFailedCalls", self.total_failed_calls)
+        writer.write_int_value("totalSuccessfulCalls", self.total_successful_calls)
+        writer.write_bool_value("warmupEnabled", self.warmup_enabled)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/problem_details.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.api_error import APIError
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class ProblemDetails(APIError, 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 detail property
+    detail: Optional[str] = None
+    # The instance property
+    instance: Optional[str] = None
+    # The title property
+    title: Optional[str] = None
+    # The type property
+    type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ProblemDetails:
+        """
+        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: ProblemDetails
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ProblemDetails()
+    
+    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]] = {
+            "detail": lambda n : setattr(self, 'detail', n.get_str_value()),
+            "instance": lambda n : setattr(self, 'instance', n.get_str_value()),
+            "title": lambda n : setattr(self, 'title', n.get_str_value()),
+            "type": lambda n : setattr(self, 'type', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("detail", self.detail)
+        writer.write_str_value("instance", self.instance)
+        writer.write_str_value("title", self.title)
+        writer.write_str_value("type", self.type)
+        writer.write_additional_data_value(self.additional_data)
+    
+    @property
+    def primary_message(self) -> Optional[str]:
+        """
+        The primary error message.
+        """
+        return super().message
+

leadping/models/range_filter.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 RangeFilter(AdditionalDataHolder, Parsable):
+    """
+    A generic object for handling range filtering during querying
+    """
+    # 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 field to filter by.
+    field: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> RangeFilter:
+        """
+        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: RangeFilter
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return RangeFilter()
+    
+    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]] = {
+            "field": lambda n : setattr(self, 'field', 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("field", self.field)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/request_data_options.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 .exact_match_filter import ExactMatchFilter
+    from .order_by_option import OrderByOption
+    from .range_filter import RangeFilter
+
+@dataclass
+class RequestDataOptions(AdditionalDataHolder, Parsable):
+    """
+    Options for flexible, efficient, and explicit querying in Cosmos DB or similar repositories.
+    """
+    # 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)
+
+    # Opaque Cosmos DB continuation token. ‑ on the **first** request. ‑ Client must echo back the NextToken it received from the previous page.
+    continuation_token: Optional[str] = None
+    # Key-value exact match filters (e.g., Status = Active).
+    filters: Optional[list[ExactMatchFilter]] = None
+    # Whether to include the total count in the response (for pagination).
+    include_count: Optional[bool] = None
+    # List of sort instructions, in priority order.
+    order_by: Optional[list[OrderByOption]] = None
+    # Maximum items to return in one page
+    page_size: Optional[int] = None
+    # Advanced range-based filters (e.g., Price > 50 and Price <= 200).
+    range_filters: Optional[list[RangeFilter]] = None
+    # The search term to filter results (applied to ).
+    search: Optional[str] = None
+    # The list of fields to apply the Search term to (must be string properties).
+    search_fields: Optional[list[str]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> RequestDataOptions:
+        """
+        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: RequestDataOptions
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return RequestDataOptions()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .exact_match_filter import ExactMatchFilter
+        from .order_by_option import OrderByOption
+        from .range_filter import RangeFilter
+
+        from .exact_match_filter import ExactMatchFilter
+        from .order_by_option import OrderByOption
+        from .range_filter import RangeFilter
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "continuationToken": lambda n : setattr(self, 'continuation_token', n.get_str_value()),
+            "filters": lambda n : setattr(self, 'filters', n.get_collection_of_object_values(ExactMatchFilter)),
+            "includeCount": lambda n : setattr(self, 'include_count', n.get_bool_value()),
+            "orderBy": lambda n : setattr(self, 'order_by', n.get_collection_of_object_values(OrderByOption)),
+            "pageSize": lambda n : setattr(self, 'page_size', n.get_int_value()),
+            "rangeFilters": lambda n : setattr(self, 'range_filters', n.get_collection_of_object_values(RangeFilter)),
+            "search": lambda n : setattr(self, 'search', n.get_str_value()),
+            "searchFields": lambda n : setattr(self, 'search_fields', 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("continuationToken", self.continuation_token)
+        writer.write_collection_of_object_values("filters", self.filters)
+        writer.write_bool_value("includeCount", self.include_count)
+        writer.write_collection_of_object_values("orderBy", self.order_by)
+        writer.write_int_value("pageSize", self.page_size)
+        writer.write_collection_of_object_values("rangeFilters", self.range_filters)
+        writer.write_str_value("search", self.search)
+        writer.write_collection_of_primitive_values("searchFields", self.search_fields)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/send_sms_request.py

@@ -0,0 +1,136 @@
+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 .send_sms_request_outbound_priority import SendSmsRequest_outboundPriority
+    from .send_sms_request_outbound_source import SendSmsRequest_outboundSource
+    from .send_sms_request_selection_reason import SendSmsRequest_selectionReason
+
+@dataclass
+class SendSmsRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for send SMS.
+    """
+    # 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 automation ID responsible for this SMS, if applicable.
+    automation_id: Optional[str] = None
+    # The campaign ID associated with this SMS.
+    campaign_id: Optional[str] = None
+    # The conversation ID associated with this SMS.
+    conversation_id: Optional[str] = None
+    # The from phone number ID associated with this SMS.
+    from_phone_number_id: Optional[str] = None
+    # Whether required consent is known for this outbound SMS.
+    has_required_consent: Optional[bool] = None
+    # The import batch ID responsible for this SMS, if applicable.
+    import_batch_id: Optional[str] = None
+    # Whether this SMS is automated.
+    is_automated: Optional[bool] = None
+    # Whether this SMS is for an imported lead.
+    is_imported_lead: Optional[bool] = None
+    # The outbound delivery request ID assigned by delivery control.
+    outbound_delivery_request_id: Optional[str] = None
+    # Optional idempotency key for retry-safe outbound delivery control.
+    outbound_idempotency_key: Optional[str] = None
+    # Defines priority classes used when pacing outbound delivery.
+    outbound_priority: Optional[SendSmsRequest_outboundPriority] = None
+    # The outbound reservation ID assigned by delivery control.
+    outbound_reservation_id: Optional[str] = None
+    # Defines the source that requested outbound delivery.
+    outbound_source: Optional[SendSmsRequest_outboundSource] = None
+    # The date and time for the scheduled for value on this SMS.
+    scheduled_for: Optional[datetime.datetime] = None
+    # Defines the supported Outgoing Number Selection Reason values.
+    selection_reason: Optional[SendSmsRequest_selectionReason] = None
+    # The SMS event ID associated with this SMS.
+    sms_event_id: Optional[str] = None
+    # The source ID associated with this SMS.
+    source_id: Optional[str] = None
+    # The text value for this SMS.
+    text: Optional[str] = None
+    # Whether this SMS was manually overridden.
+    was_manually_overridden: Optional[bool] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SendSmsRequest:
+        """
+        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: SendSmsRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SendSmsRequest()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .send_sms_request_outbound_priority import SendSmsRequest_outboundPriority
+        from .send_sms_request_outbound_source import SendSmsRequest_outboundSource
+        from .send_sms_request_selection_reason import SendSmsRequest_selectionReason
+
+        from .send_sms_request_outbound_priority import SendSmsRequest_outboundPriority
+        from .send_sms_request_outbound_source import SendSmsRequest_outboundSource
+        from .send_sms_request_selection_reason import SendSmsRequest_selectionReason
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "automationId": lambda n : setattr(self, 'automation_id', n.get_str_value()),
+            "campaignId": lambda n : setattr(self, 'campaign_id', n.get_str_value()),
+            "conversationId": lambda n : setattr(self, 'conversation_id', n.get_str_value()),
+            "fromPhoneNumberId": lambda n : setattr(self, 'from_phone_number_id', n.get_str_value()),
+            "hasRequiredConsent": lambda n : setattr(self, 'has_required_consent', n.get_bool_value()),
+            "importBatchId": lambda n : setattr(self, 'import_batch_id', n.get_str_value()),
+            "isAutomated": lambda n : setattr(self, 'is_automated', n.get_bool_value()),
+            "isImportedLead": lambda n : setattr(self, 'is_imported_lead', n.get_bool_value()),
+            "outboundDeliveryRequestId": lambda n : setattr(self, 'outbound_delivery_request_id', n.get_str_value()),
+            "outboundIdempotencyKey": lambda n : setattr(self, 'outbound_idempotency_key', n.get_str_value()),
+            "outboundPriority": lambda n : setattr(self, 'outbound_priority', n.get_enum_value(SendSmsRequest_outboundPriority)),
+            "outboundReservationId": lambda n : setattr(self, 'outbound_reservation_id', n.get_str_value()),
+            "outboundSource": lambda n : setattr(self, 'outbound_source', n.get_enum_value(SendSmsRequest_outboundSource)),
+            "scheduledFor": lambda n : setattr(self, 'scheduled_for', n.get_datetime_value()),
+            "selectionReason": lambda n : setattr(self, 'selection_reason', n.get_enum_value(SendSmsRequest_selectionReason)),
+            "smsEventId": lambda n : setattr(self, 'sms_event_id', n.get_str_value()),
+            "sourceId": lambda n : setattr(self, 'source_id', n.get_str_value()),
+            "text": lambda n : setattr(self, 'text', n.get_str_value()),
+            "wasManuallyOverridden": lambda n : setattr(self, 'was_manually_overridden', 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("automationId", self.automation_id)
+        writer.write_str_value("campaignId", self.campaign_id)
+        writer.write_str_value("conversationId", self.conversation_id)
+        writer.write_str_value("fromPhoneNumberId", self.from_phone_number_id)
+        writer.write_bool_value("hasRequiredConsent", self.has_required_consent)
+        writer.write_str_value("importBatchId", self.import_batch_id)
+        writer.write_bool_value("isAutomated", self.is_automated)
+        writer.write_bool_value("isImportedLead", self.is_imported_lead)
+        writer.write_str_value("outboundDeliveryRequestId", self.outbound_delivery_request_id)
+        writer.write_str_value("outboundIdempotencyKey", self.outbound_idempotency_key)
+        writer.write_enum_value("outboundPriority", self.outbound_priority)
+        writer.write_str_value("outboundReservationId", self.outbound_reservation_id)
+        writer.write_enum_value("outboundSource", self.outbound_source)
+        writer.write_datetime_value("scheduledFor", self.scheduled_for)
+        writer.write_enum_value("selectionReason", self.selection_reason)
+        writer.write_str_value("smsEventId", self.sms_event_id)
+        writer.write_str_value("sourceId", self.source_id)
+        writer.write_str_value("text", self.text)
+        writer.write_bool_value("wasManuallyOverridden", self.was_manually_overridden)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/send_sms_request_outbound_priority.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+class SendSmsRequest_outboundPriority(str, Enum):
+    Critical_internal_notification = "critical_internal_notification",
+    Fresh_inbound_lead_response = "fresh_inbound_lead_response",
+    Manual_user_initiated = "manual_user_initiated",
+    Active_conversation_reply = "active_conversation_reply",
+    Automation_follow_up = "automation_follow_up",
+    Campaign_message = "campaign_message",
+    Imported_lead_campaign = "imported_lead_campaign",
+    Warmup = "warmup",
+    Retry = "retry",
+