leadping 1.0.0__py3-none-any.whl

leadping/models/phone_lookup_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 PhoneLookup_location(PhoneNumberLocation, Parsable):
+    """
+    The location value for this phone lookup.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneLookup_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: PhoneLookup_location
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneLookup_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_availability_request.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 PhoneNumberAvailabilityRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for phone number availability.
+    """
+    # 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 phone number associated with this phone number availability.
+    phone_number: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberAvailabilityRequest:
+        """
+        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: PhoneNumberAvailabilityRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberAvailabilityRequest()
+    
+    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]] = {
+            "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_str_value("phoneNumber", self.phone_number)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone_number_availability_response.py

@@ -0,0 +1,69 @@
+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_availability_response_location import PhoneNumberAvailabilityResponse_location
+
+@dataclass
+class PhoneNumberAvailabilityResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing phone number availability 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 ISO currency code for monetary values in this phone number availability.
+    currency: Optional[str] = None
+    # Whether this phone number availability is available.
+    is_available: Optional[bool] = None
+    # The location value for this phone number availability.
+    location: Optional[PhoneNumberAvailabilityResponse_location] = None
+    # The phone number associated with this phone number availability.
+    phone_number: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberAvailabilityResponse:
+        """
+        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: PhoneNumberAvailabilityResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberAvailabilityResponse()
+    
+    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_availability_response_location import PhoneNumberAvailabilityResponse_location
+
+        from .phone_number_availability_response_location import PhoneNumberAvailabilityResponse_location
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "currency": lambda n : setattr(self, 'currency', n.get_str_value()),
+            "isAvailable": lambda n : setattr(self, 'is_available', n.get_bool_value()),
+            "location": lambda n : setattr(self, 'location', n.get_object_value(PhoneNumberAvailabilityResponse_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_str_value("currency", self.currency)
+        writer.write_bool_value("isAvailable", self.is_available)
+        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_availability_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 PhoneNumberAvailabilityResponse_location(PhoneNumberLocation, Parsable):
+    """
+    The location value for this phone number availability.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberAvailabilityResponse_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: PhoneNumberAvailabilityResponse_location
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberAvailabilityResponse_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_billing_attribution.py

@@ -0,0 +1,70 @@
+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 PhoneNumberBillingAttribution(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing phone number billing attribution 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 business ID associated with this phone number billing attribution.
+    business_id: Optional[str] = None
+    # The business name value for this phone number billing attribution.
+    business_name: Optional[str] = None
+    # The channel value for this phone number billing attribution.
+    channel: Optional[str] = None
+    # The subscription item ID associated with this phone number billing attribution.
+    subscription_item_id: Optional[str] = None
+    # The user ID associated with this phone number billing attribution.
+    user_id: Optional[str] = None
+    # The user name value for this phone number billing attribution.
+    user_name: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberBillingAttribution:
+        """
+        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: PhoneNumberBillingAttribution
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberBillingAttribution()
+    
+    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]] = {
+            "businessId": lambda n : setattr(self, 'business_id', n.get_str_value()),
+            "businessName": lambda n : setattr(self, 'business_name', n.get_str_value()),
+            "channel": lambda n : setattr(self, 'channel', n.get_str_value()),
+            "subscriptionItemId": lambda n : setattr(self, 'subscription_item_id', n.get_str_value()),
+            "userId": lambda n : setattr(self, 'user_id', n.get_str_value()),
+            "userName": lambda n : setattr(self, 'user_name', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("businessId", self.business_id)
+        writer.write_str_value("businessName", self.business_name)
+        writer.write_str_value("channel", self.channel)
+        writer.write_str_value("subscriptionItemId", self.subscription_item_id)
+        writer.write_str_value("userId", self.user_id)
+        writer.write_str_value("userName", self.user_name)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone_number_capabilities.py

@@ -0,0 +1,62 @@
+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 PhoneNumberCapabilities(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing phone number capabilities data used by Leadping API contracts.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # Whether SMS applies to this phone number capabilities.
+    sms: Optional[bool] = None
+    # Whether testing applies to this phone number capabilities.
+    testing: Optional[bool] = None
+    # Whether voice applies to this phone number capabilities.
+    voice: Optional[bool] = None
+    # Whether warmup applies to this phone number capabilities.
+    warmup: Optional[bool] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberCapabilities:
+        """
+        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: PhoneNumberCapabilities
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberCapabilities()
+    
+    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]] = {
+            "sms": lambda n : setattr(self, 'sms', n.get_bool_value()),
+            "testing": lambda n : setattr(self, 'testing', n.get_bool_value()),
+            "voice": lambda n : setattr(self, 'voice', n.get_bool_value()),
+            "warmup": lambda n : setattr(self, 'warmup', 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_bool_value("sms", self.sms)
+        writer.write_bool_value("testing", self.testing)
+        writer.write_bool_value("voice", self.voice)
+        writer.write_bool_value("warmup", self.warmup)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone_number_event_record.py

@@ -0,0 +1,86 @@
+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_event_record_state import PhoneNumberEventRecord_state
+
+@dataclass
+class PhoneNumberEventRecord(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing phone number event record 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 actor ID associated with this phone number event record.
+    actor_id: Optional[str] = None
+    # The actor name value for this phone number event record.
+    actor_name: Optional[str] = None
+    # The date and time for the created at value on this phone number event record.
+    created_at: Optional[datetime.datetime] = None
+    # The details value for this phone number event record.
+    details: Optional[str] = None
+    # The unique ID for this phone number event record.
+    id: Optional[str] = None
+    # Leadping-owned inventory state for phone-number assignment and routing.
+    state: Optional[PhoneNumberEventRecord_state] = None
+    # The title value for this phone number event record.
+    title: Optional[str] = None
+    # The type classification for this phone number event record.
+    type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberEventRecord:
+        """
+        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: PhoneNumberEventRecord
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberEventRecord()
+    
+    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_event_record_state import PhoneNumberEventRecord_state
+
+        from .phone_number_event_record_state import PhoneNumberEventRecord_state
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "actorId": lambda n : setattr(self, 'actor_id', n.get_str_value()),
+            "actorName": lambda n : setattr(self, 'actor_name', n.get_str_value()),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "details": lambda n : setattr(self, 'details', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "state": lambda n : setattr(self, 'state', n.get_enum_value(PhoneNumberEventRecord_state)),
+            "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("actorId", self.actor_id)
+        writer.write_str_value("actorName", self.actor_name)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_str_value("details", self.details)
+        writer.write_str_value("id", self.id)
+        writer.write_enum_value("state", self.state)
+        writer.write_str_value("title", self.title)
+        writer.write_str_value("type", self.type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone_number_event_record_state.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class PhoneNumberEventRecord_state(str, Enum):
+    Available = "Available",
+    Assigned = "Assigned",
+    PendingVerification = "Pending verification",
+    ReadyForSMS = "Ready for SMS",
+    ReadyForVoice = "Ready for voice",
+    Restricted = "Restricted",
+    Suspended = "Suspended",
+    Failed = "Failed",
+    Released = "Released",
+    PendingRelease = "Pending release",
+    WarmupOnly = "Warmup-only",
+    InternalTestOnly = "Internal/test-only",
+

leadping/models/phone_number_inventory_state.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class PhoneNumberInventoryState(str, Enum):
+    Available = "Available",
+    Assigned = "Assigned",
+    PendingVerification = "Pending verification",
+    ReadyForSMS = "Ready for SMS",
+    ReadyForVoice = "Ready for voice",
+    Restricted = "Restricted",
+    Suspended = "Suspended",
+    Failed = "Failed",
+    Released = "Released",
+    PendingRelease = "Pending release",
+    WarmupOnly = "Warmup-only",
+    InternalTestOnly = "Internal/test-only",
+

leadping/models/phone_number_location.py

@@ -0,0 +1,73 @@
+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_location_coordinate import PhoneNumberLocation_coordinate
+
+@dataclass
+class PhoneNumberLocation(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing phone number location 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 coordinate inferred for this phone number location.
+    coordinate: Optional[PhoneNumberLocation_coordinate] = None
+    # The country code value for this phone number location.
+    country_code: Optional[str] = None
+    # The location value for this phone number location.
+    location: Optional[str] = None
+    # The current state for this phone number location.
+    state: Optional[str] = None
+    # The IANA time zone identifier inferred for this phone number location.
+    time_zone_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneNumberLocation:
+        """
+        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: PhoneNumberLocation
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneNumberLocation()
+    
+    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_coordinate import PhoneNumberLocation_coordinate
+
+        from .phone_number_location_coordinate import PhoneNumberLocation_coordinate
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "coordinate": lambda n : setattr(self, 'coordinate', n.get_object_value(PhoneNumberLocation_coordinate)),
+            "countryCode": lambda n : setattr(self, 'country_code', n.get_str_value()),
+            "location": lambda n : setattr(self, 'location', n.get_str_value()),
+            "state": lambda n : setattr(self, 'state', n.get_str_value()),
+            "timeZoneId": lambda n : setattr(self, 'time_zone_id', 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("coordinate", self.coordinate)
+        writer.write_str_value("countryCode", self.country_code)
+        writer.write_str_value("location", self.location)
+        writer.write_str_value("state", self.state)
+        writer.write_str_value("timeZoneId", self.time_zone_id)
+        writer.write_additional_data_value(self.additional_data)
+    
+

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