leadping 1.0.0__py3-none-any.whl

leadping/models/paged_result_of_lead_table_row.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 .lead_table_row import LeadTableRow
+
+@dataclass
+class PagedResultOfLeadTableRow(AdditionalDataHolder, Parsable):
+    """
+    A generic container for paginated results returned to the client.
+    """
+    # 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 storage continuation token. ‑ `null` → the current page was the last page.
+    continuation_token: Optional[str] = None
+    # The subset of items returned for the current page.
+    items: Optional[list[LeadTableRow]] = None
+    # The number of items returned per page in the response. This may reflect the client's requested page size, or a server-defined default or limit.
+    page_size: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PagedResultOfLeadTableRow:
+        """
+        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: PagedResultOfLeadTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfLeadTableRow()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .lead_table_row import LeadTableRow
+
+        from .lead_table_row import LeadTableRow
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "continuationToken": lambda n : setattr(self, 'continuation_token', n.get_str_value()),
+            "items": lambda n : setattr(self, 'items', n.get_collection_of_object_values(LeadTableRow)),
+            "pageSize": lambda n : setattr(self, 'page_size', 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_str_value("continuationToken", self.continuation_token)
+        writer.write_collection_of_object_values("items", self.items)
+        writer.write_int_value("pageSize", self.page_size)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/paged_result_of_notification_table_row.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 .notification_table_row import NotificationTableRow
+
+@dataclass
+class PagedResultOfNotificationTableRow(AdditionalDataHolder, Parsable):
+    """
+    A generic container for paginated results returned to the client.
+    """
+    # 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 storage continuation token. ‑ `null` → the current page was the last page.
+    continuation_token: Optional[str] = None
+    # The subset of items returned for the current page.
+    items: Optional[list[NotificationTableRow]] = None
+    # The number of items returned per page in the response. This may reflect the client's requested page size, or a server-defined default or limit.
+    page_size: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PagedResultOfNotificationTableRow:
+        """
+        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: PagedResultOfNotificationTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfNotificationTableRow()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .notification_table_row import NotificationTableRow
+
+        from .notification_table_row import NotificationTableRow
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "continuationToken": lambda n : setattr(self, 'continuation_token', n.get_str_value()),
+            "items": lambda n : setattr(self, 'items', n.get_collection_of_object_values(NotificationTableRow)),
+            "pageSize": lambda n : setattr(self, 'page_size', 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_str_value("continuationToken", self.continuation_token)
+        writer.write_collection_of_object_values("items", self.items)
+        writer.write_int_value("pageSize", self.page_size)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/paged_result_of_phone_number_table_row.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 .phone_number_table_row import PhoneNumberTableRow
+
+@dataclass
+class PagedResultOfPhoneNumberTableRow(AdditionalDataHolder, Parsable):
+    """
+    A generic container for paginated results returned to the client.
+    """
+    # 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 storage continuation token. ‑ `null` → the current page was the last page.
+    continuation_token: Optional[str] = None
+    # The subset of items returned for the current page.
+    items: Optional[list[PhoneNumberTableRow]] = None
+    # The number of items returned per page in the response. This may reflect the client's requested page size, or a server-defined default or limit.
+    page_size: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PagedResultOfPhoneNumberTableRow:
+        """
+        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: PagedResultOfPhoneNumberTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfPhoneNumberTableRow()
+    
+    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_table_row import PhoneNumberTableRow
+
+        from .phone_number_table_row import PhoneNumberTableRow
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "continuationToken": lambda n : setattr(self, 'continuation_token', n.get_str_value()),
+            "items": lambda n : setattr(self, 'items', n.get_collection_of_object_values(PhoneNumberTableRow)),
+            "pageSize": lambda n : setattr(self, 'page_size', 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_str_value("continuationToken", self.continuation_token)
+        writer.write_collection_of_object_values("items", self.items)
+        writer.write_int_value("pageSize", self.page_size)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/paged_result_of_sms_event_table_row.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_event_table_row import SmsEventTableRow
+
+@dataclass
+class PagedResultOfSmsEventTableRow(AdditionalDataHolder, Parsable):
+    """
+    A generic container for paginated results returned to the client.
+    """
+    # 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 storage continuation token. ‑ `null` → the current page was the last page.
+    continuation_token: Optional[str] = None
+    # The subset of items returned for the current page.
+    items: Optional[list[SmsEventTableRow]] = None
+    # The number of items returned per page in the response. This may reflect the client's requested page size, or a server-defined default or limit.
+    page_size: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PagedResultOfSmsEventTableRow:
+        """
+        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: PagedResultOfSmsEventTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfSmsEventTableRow()
+    
+    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_event_table_row import SmsEventTableRow
+
+        from .sms_event_table_row import SmsEventTableRow
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "continuationToken": lambda n : setattr(self, 'continuation_token', n.get_str_value()),
+            "items": lambda n : setattr(self, 'items', n.get_collection_of_object_values(SmsEventTableRow)),
+            "pageSize": lambda n : setattr(self, 'page_size', 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_str_value("continuationToken", self.continuation_token)
+        writer.write_collection_of_object_values("items", self.items)
+        writer.write_int_value("pageSize", self.page_size)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/paged_result_of_source_table_row.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 .source_table_row import SourceTableRow
+
+@dataclass
+class PagedResultOfSourceTableRow(AdditionalDataHolder, Parsable):
+    """
+    A generic container for paginated results returned to the client.
+    """
+    # 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 storage continuation token. ‑ `null` → the current page was the last page.
+    continuation_token: Optional[str] = None
+    # The subset of items returned for the current page.
+    items: Optional[list[SourceTableRow]] = None
+    # The number of items returned per page in the response. This may reflect the client's requested page size, or a server-defined default or limit.
+    page_size: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PagedResultOfSourceTableRow:
+        """
+        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: PagedResultOfSourceTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfSourceTableRow()
+    
+    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_table_row import SourceTableRow
+
+        from .source_table_row import SourceTableRow
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "continuationToken": lambda n : setattr(self, 'continuation_token', n.get_str_value()),
+            "items": lambda n : setattr(self, 'items', n.get_collection_of_object_values(SourceTableRow)),
+            "pageSize": lambda n : setattr(self, 'page_size', 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_str_value("continuationToken", self.continuation_token)
+        writer.write_collection_of_object_values("items", self.items)
+        writer.write_int_value("pageSize", self.page_size)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/paged_result_of_transaction_table_row.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 .transaction_table_row import TransactionTableRow
+
+@dataclass
+class PagedResultOfTransactionTableRow(AdditionalDataHolder, Parsable):
+    """
+    A generic container for paginated results returned to the client.
+    """
+    # 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 storage continuation token. ‑ `null` → the current page was the last page.
+    continuation_token: Optional[str] = None
+    # The subset of items returned for the current page.
+    items: Optional[list[TransactionTableRow]] = None
+    # The number of items returned per page in the response. This may reflect the client's requested page size, or a server-defined default or limit.
+    page_size: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PagedResultOfTransactionTableRow:
+        """
+        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: PagedResultOfTransactionTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfTransactionTableRow()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .transaction_table_row import TransactionTableRow
+
+        from .transaction_table_row import TransactionTableRow
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "continuationToken": lambda n : setattr(self, 'continuation_token', n.get_str_value()),
+            "items": lambda n : setattr(self, 'items', n.get_collection_of_object_values(TransactionTableRow)),
+            "pageSize": lambda n : setattr(self, 'page_size', 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_str_value("continuationToken", self.continuation_token)
+        writer.write_collection_of_object_values("items", self.items)
+        writer.write_int_value("pageSize", self.page_size)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/paged_result_of_usage_ledger_table_row.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 .usage_ledger_table_row import UsageLedgerTableRow
+
+@dataclass
+class PagedResultOfUsageLedgerTableRow(AdditionalDataHolder, Parsable):
+    """
+    A generic container for paginated results returned to the client.
+    """
+    # 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 storage continuation token. ‑ `null` → the current page was the last page.
+    continuation_token: Optional[str] = None
+    # The subset of items returned for the current page.
+    items: Optional[list[UsageLedgerTableRow]] = None
+    # The number of items returned per page in the response. This may reflect the client's requested page size, or a server-defined default or limit.
+    page_size: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PagedResultOfUsageLedgerTableRow:
+        """
+        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: PagedResultOfUsageLedgerTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfUsageLedgerTableRow()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .usage_ledger_table_row import UsageLedgerTableRow
+
+        from .usage_ledger_table_row import UsageLedgerTableRow
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "continuationToken": lambda n : setattr(self, 'continuation_token', n.get_str_value()),
+            "items": lambda n : setattr(self, 'items', n.get_collection_of_object_values(UsageLedgerTableRow)),
+            "pageSize": lambda n : setattr(self, 'page_size', 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_str_value("continuationToken", self.continuation_token)
+        writer.write_collection_of_object_values("items", self.items)
+        writer.write_int_value("pageSize", self.page_size)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone.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 .phone_lookup import Phone_lookup
+
+@dataclass
+class Phone(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing phone 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 lookup value for this phone.
+    lookup: Optional[Phone_lookup] = None
+    # The number value for this phone.
+    number: Optional[str] = None
+    # The type classification for this phone.
+    type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> Phone:
+        """
+        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: Phone
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return Phone()
+    
+    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_lookup import Phone_lookup
+
+        from .phone_lookup import Phone_lookup
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "lookup": lambda n : setattr(self, 'lookup', n.get_object_value(Phone_lookup)),
+            "number": lambda n : setattr(self, 'number', 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_object_value("lookup", self.lookup)
+        writer.write_str_value("number", self.number)
+        writer.write_str_value("type", self.type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone_lookup.py

@@ -0,0 +1,92 @@
+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_lookup_carrier_type import PhoneLookup_carrierType
+    from .phone_lookup_line_type import PhoneLookup_lineType
+    from .phone_lookup_location import PhoneLookup_location
+
+@dataclass
+class PhoneLookup(AdditionalDataHolder, Parsable):
+    """
+    Represents phone information retrieved from a phone number lookup
+    """
+    # 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)
+
+    # An enumerator describing carrier types
+    carrier_type: Optional[PhoneLookup_carrierType] = None
+    # Gets or sets created at.
+    created_at: Optional[datetime.datetime] = None
+    # Gets or sets id.
+    id: Optional[str] = None
+    # Whether this phone lookup is valid.
+    is_valid: Optional[bool] = None
+    # An enumerator describing phone line types
+    line_type: Optional[PhoneLookup_lineType] = None
+    # The location value for this phone lookup.
+    location: Optional[PhoneLookup_location] = None
+    # Gets or sets modified at.
+    modified_at: Optional[datetime.datetime] = None
+    # The number value for this phone lookup.
+    number: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> PhoneLookup:
+        """
+        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
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PhoneLookup()
+    
+    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_lookup_carrier_type import PhoneLookup_carrierType
+        from .phone_lookup_line_type import PhoneLookup_lineType
+        from .phone_lookup_location import PhoneLookup_location
+
+        from .phone_lookup_carrier_type import PhoneLookup_carrierType
+        from .phone_lookup_line_type import PhoneLookup_lineType
+        from .phone_lookup_location import PhoneLookup_location
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "carrierType": lambda n : setattr(self, 'carrier_type', n.get_enum_value(PhoneLookup_carrierType)),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isValid": lambda n : setattr(self, 'is_valid', n.get_bool_value()),
+            "lineType": lambda n : setattr(self, 'line_type', n.get_enum_value(PhoneLookup_lineType)),
+            "location": lambda n : setattr(self, 'location', n.get_object_value(PhoneLookup_location)),
+            "modifiedAt": lambda n : setattr(self, 'modified_at', n.get_datetime_value()),
+            "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_enum_value("carrierType", self.carrier_type)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isValid", self.is_valid)
+        writer.write_enum_value("lineType", self.line_type)
+        writer.write_object_value("location", self.location)
+        writer.write_datetime_value("modifiedAt", self.modified_at)
+        writer.write_str_value("number", self.number)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/phone_lookup_carrier_type.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class PhoneLookup_carrierType(str, Enum):
+    FixedLine = "FixedLine",
+    Mobile = "Mobile",
+    Voip = "Voip",
+    FixedLineOrMobile = "FixedLineOrMobile",
+    TollFree = "TollFree",
+    PremiumRate = "PremiumRate",
+    SharedCost = "SharedCost",
+    PersonalNumber = "PersonalNumber",
+    Pager = "Pager",
+    Uan = "Uan",
+    Voicemail = "Voicemail",
+    Unknown = "Unknown",
+

leadping/models/phone_lookup_line_type.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class PhoneLookup_lineType(str, Enum):
+    Wireline = "Wireline",
+    Wireless = "Wireless",
+    VoWiFi = "VoWiFi",
+    VoIP = "VoIP",
+    PrePaidWireless = "PrePaidWireless",
+    Unknown = "Unknown",
+