leadping 1.0.0__py3-none-any.whl

leadping/models/phone_number_response_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 PhoneNumberResponse_adminEnablementOverride(AdminEnablementOverride, Parsable):
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberResponse_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: PhoneNumberResponse_adminEnablementOverride
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberResponse_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)
+    
+

leadping/models/phone_number_response_business.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .id_name_pair import IdNamePair
+
+from .id_name_pair import IdNamePair
+
+@dataclass
+class PhoneNumberResponse_business(IdNamePair, Parsable):
+    """
+    The business value for this phone number.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberResponse_business:
+        """
+        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: PhoneNumberResponse_business
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberResponse_business()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .id_name_pair import IdNamePair
+
+        from .id_name_pair import IdNamePair
+
+        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/phone_number_response_call_warmup_stage.py

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

leadping/models/phone_number_response_call_warmup_state.py

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

leadping/models/phone_number_response_health_status.py

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

leadping/models/phone_number_response_location.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .phone_number_location import PhoneNumberLocation
+
+from .phone_number_location import PhoneNumberLocation
+
+@dataclass
+class PhoneNumberResponse_location(PhoneNumberLocation, Parsable):
+    """
+    The location value for this phone number.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberResponse_location:
+        """
+        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: PhoneNumberResponse_location
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberResponse_location()
+    
+    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_location import PhoneNumberLocation
+
+        from .phone_number_location import PhoneNumberLocation
+
+        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/phone_number_response_user.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .id_name_pair import IdNamePair
+
+from .id_name_pair import IdNamePair
+
+@dataclass
+class PhoneNumberResponse_user(IdNamePair, Parsable):
+    """
+    The user value for this phone number.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberResponse_user:
+        """
+        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: PhoneNumberResponse_user
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberResponse_user()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .id_name_pair import IdNamePair
+
+        from .id_name_pair import IdNamePair
+
+        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/phone_number_response_warmup_state.py

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

leadping/models/phone_number_routing_metadata.py

@@ -0,0 +1,82 @@
+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 PhoneNumberRoutingMetadata(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing phone number routing metadata 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 campaign ID associated with this phone number routing metadata.
+    campaign_id: Optional[str] = None
+    # Whether internal test only applies to this phone number routing metadata.
+    internal_test_only: Optional[bool] = None
+    # The messaging profile ID associated with this phone number routing metadata.
+    messaging_profile_id: Optional[str] = None
+    # Whether SMS is enabled for this phone number routing metadata.
+    sms_enabled: Optional[bool] = None
+    # The source ID associated with this phone number routing metadata.
+    source_id: Optional[str] = None
+    # The team ID associated with this phone number routing metadata.
+    team_id: Optional[str] = None
+    # The voice connection ID associated with this phone number routing metadata.
+    voice_connection_id: Optional[str] = None
+    # Whether voice is enabled for this phone number routing metadata.
+    voice_enabled: Optional[bool] = None
+    # Whether warmup only applies to this phone number routing metadata.
+    warmup_only: Optional[bool] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberRoutingMetadata:
+        """
+        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: PhoneNumberRoutingMetadata
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberRoutingMetadata()
+    
+    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]] = {
+            "campaignId": lambda n : setattr(self, 'campaign_id', n.get_str_value()),
+            "internalTestOnly": lambda n : setattr(self, 'internal_test_only', n.get_bool_value()),
+            "messagingProfileId": lambda n : setattr(self, 'messaging_profile_id', n.get_str_value()),
+            "smsEnabled": lambda n : setattr(self, 'sms_enabled', n.get_bool_value()),
+            "sourceId": lambda n : setattr(self, 'source_id', n.get_str_value()),
+            "teamId": lambda n : setattr(self, 'team_id', n.get_str_value()),
+            "voiceConnectionId": lambda n : setattr(self, 'voice_connection_id', n.get_str_value()),
+            "voiceEnabled": lambda n : setattr(self, 'voice_enabled', n.get_bool_value()),
+            "warmupOnly": lambda n : setattr(self, 'warmup_only', 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("campaignId", self.campaign_id)
+        writer.write_bool_value("internalTestOnly", self.internal_test_only)
+        writer.write_str_value("messagingProfileId", self.messaging_profile_id)
+        writer.write_bool_value("smsEnabled", self.sms_enabled)
+        writer.write_str_value("sourceId", self.source_id)
+        writer.write_str_value("teamId", self.team_id)
+        writer.write_str_value("voiceConnectionId", self.voice_connection_id)
+        writer.write_bool_value("voiceEnabled", self.voice_enabled)
+        writer.write_bool_value("warmupOnly", self.warmup_only)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone_number_search_request.py

@@ -0,0 +1,61 @@
+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 .phone_number_search_request_location import PhoneNumberSearchRequest_location
+
+@dataclass
+class PhoneNumberSearchRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for phone number search.
+    """
+    # 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 location value for this phone number search.
+    location: Optional[PhoneNumberSearchRequest_location] = None
+    # The phone number associated with this phone number search.
+    phone_number: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberSearchRequest:
+        """
+        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: PhoneNumberSearchRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberSearchRequest()
+    
+    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_search_request_location import PhoneNumberSearchRequest_location
+
+        from .phone_number_search_request_location import PhoneNumberSearchRequest_location
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "location": lambda n : setattr(self, 'location', n.get_object_value(PhoneNumberSearchRequest_location)),
+            "phoneNumber": lambda n : setattr(self, 'phone_number', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_object_value("location", self.location)
+        writer.write_str_value("phoneNumber", self.phone_number)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone_number_search_request_location.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .phone_number_location import PhoneNumberLocation
+
+from .phone_number_location import PhoneNumberLocation
+
+@dataclass
+class PhoneNumberSearchRequest_location(PhoneNumberLocation, Parsable):
+    """
+    The location value for this phone number search.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberSearchRequest_location:
+        """
+        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: PhoneNumberSearchRequest_location
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberSearchRequest_location()
+    
+    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_location import PhoneNumberLocation
+
+        from .phone_number_location import PhoneNumberLocation
+
+        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/phone_number_search_response.py

@@ -0,0 +1,57 @@
+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 .phone_number_search_result import PhoneNumberSearchResult
+
+@dataclass
+class PhoneNumberSearchResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing phone number search 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 numbers included with this phone number search.
+    numbers: Optional[list[PhoneNumberSearchResult]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberSearchResponse:
+        """
+        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: PhoneNumberSearchResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberSearchResponse()
+    
+    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_search_result import PhoneNumberSearchResult
+
+        from .phone_number_search_result import PhoneNumberSearchResult
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "numbers": lambda n : setattr(self, 'numbers', n.get_collection_of_object_values(PhoneNumberSearchResult)),
+        }
+        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_collection_of_object_values("numbers", self.numbers)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone_number_search_result.py

@@ -0,0 +1,61 @@
+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 .phone_number_search_result_location import PhoneNumberSearchResult_location
+
+@dataclass
+class PhoneNumberSearchResult(AdditionalDataHolder, Parsable):
+    """
+    API response containing phone number search result 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 location value for this phone number search result.
+    location: Optional[PhoneNumberSearchResult_location] = None
+    # The number value for this phone number search result.
+    number: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberSearchResult:
+        """
+        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: PhoneNumberSearchResult
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberSearchResult()
+    
+    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_search_result_location import PhoneNumberSearchResult_location
+
+        from .phone_number_search_result_location import PhoneNumberSearchResult_location
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "location": lambda n : setattr(self, 'location', n.get_object_value(PhoneNumberSearchResult_location)),
+            "number": lambda n : setattr(self, 'number', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_object_value("location", self.location)
+        writer.write_str_value("number", self.number)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone_number_search_result_location.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .phone_number_location import PhoneNumberLocation
+
+from .phone_number_location import PhoneNumberLocation
+
+@dataclass
+class PhoneNumberSearchResult_location(PhoneNumberLocation, Parsable):
+    """
+    The location value for this phone number search result.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberSearchResult_location:
+        """
+        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: PhoneNumberSearchResult_location
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberSearchResult_location()
+    
+    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_location import PhoneNumberLocation
+
+        from .phone_number_location import PhoneNumberLocation
+
+        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)
+    
+