leadping 1.0.0__py3-none-any.whl

leadping/models/lead_request.py

@@ -0,0 +1,94 @@
+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_contact import LeadContact
+    from .lead_metadata import LeadMetadata
+    from .lead_profile import LeadProfile
+    from .lead_request_admin_enablement_override import LeadRequest_adminEnablementOverride
+
+@dataclass
+class LeadRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for lead.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The adminEnablementOverride property
+    admin_enablement_override: Optional[LeadRequest_adminEnablementOverride] = None
+    # The contact value for this lead.
+    contact: Optional[LeadContact] = None
+    # The profile value for this lead.
+    customer: Optional[LeadProfile] = None
+    # The enabled property
+    enabled: Optional[bool] = None
+    # The unique identifier for the entity, when updating an existing entity.
+    id: Optional[str] = None
+    # Safe, non-secret metadata associated with this lead.
+    metadata: Optional[LeadMetadata] = None
+    # Existing business tag ids to apply when the lead is created.
+    tag_ids: Optional[list[str]] = None
+    # Business tag names to apply when the lead is created. Missing names are created safely by lead creation flows.
+    tag_names: Optional[list[str]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadRequest:
+        """
+        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: LeadRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadRequest()
+    
+    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_contact import LeadContact
+        from .lead_metadata import LeadMetadata
+        from .lead_profile import LeadProfile
+        from .lead_request_admin_enablement_override import LeadRequest_adminEnablementOverride
+
+        from .lead_contact import LeadContact
+        from .lead_metadata import LeadMetadata
+        from .lead_profile import LeadProfile
+        from .lead_request_admin_enablement_override import LeadRequest_adminEnablementOverride
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "adminEnablementOverride": lambda n : setattr(self, 'admin_enablement_override', n.get_object_value(LeadRequest_adminEnablementOverride)),
+            "contact": lambda n : setattr(self, 'contact', n.get_object_value(LeadContact)),
+            "customer": lambda n : setattr(self, 'customer', n.get_object_value(LeadProfile)),
+            "enabled": lambda n : setattr(self, 'enabled', n.get_bool_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "metadata": lambda n : setattr(self, 'metadata', n.get_object_value(LeadMetadata)),
+            "tagIds": lambda n : setattr(self, 'tag_ids', n.get_collection_of_primitive_values(str)),
+            "tagNames": lambda n : setattr(self, 'tag_names', 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_object_value("adminEnablementOverride", self.admin_enablement_override)
+        writer.write_object_value("contact", self.contact)
+        writer.write_object_value("customer", self.customer)
+        writer.write_bool_value("enabled", self.enabled)
+        writer.write_str_value("id", self.id)
+        writer.write_object_value("metadata", self.metadata)
+        writer.write_collection_of_primitive_values("tagIds", self.tag_ids)
+        writer.write_collection_of_primitive_values("tagNames", self.tag_names)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/lead_request_admin_enablement_override.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .admin_enablement_override import AdminEnablementOverride
+
+from .admin_enablement_override import AdminEnablementOverride
+
+@dataclass
+class LeadRequest_adminEnablementOverride(AdminEnablementOverride, Parsable):
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadRequest_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: LeadRequest_adminEnablementOverride
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadRequest_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/lead_response.py

@@ -0,0 +1,129 @@
+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 .lead_contact import LeadContact
+    from .lead_metadata import LeadMetadata
+    from .lead_profile import LeadProfile
+    from .lead_response_admin_enablement_override import LeadResponse_adminEnablementOverride
+    from .lead_response_current_disposition import LeadResponse_currentDisposition
+    from .tag_summary import TagSummary
+
+@dataclass
+class LeadResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing lead 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 adminEnablementOverride property
+    admin_enablement_override: Optional[LeadResponse_adminEnablementOverride] = None
+    # The archiveNote property
+    archive_note: Optional[str] = None
+    # Defines why a lead was removed from the active working pipeline.
+    archive_reason: Optional[int] = None
+    # The archivedAt property
+    archived_at: Optional[datetime.datetime] = None
+    # The archivedByUserId property
+    archived_by_user_id: Optional[str] = None
+    # The contact value for this lead.
+    contact: Optional[LeadContact] = None
+    # The date and time when the entity was created.
+    created_at: Optional[datetime.datetime] = None
+    # Compact current disposition state stored directly on a lead and surfaced with conversation data.
+    current_disposition: Optional[LeadResponse_currentDisposition] = None
+    # The profile value for this lead.
+    customer: Optional[LeadProfile] = None
+    # The enabled property
+    enabled: Optional[bool] = None
+    # The unique identifier for the entity.
+    id: Optional[str] = None
+    # The isArchived property
+    is_archived: Optional[bool] = None
+    # Safe, non-secret metadata associated with this lead.
+    metadata: Optional[LeadMetadata] = None
+    # The date and time when the entity was last modified, if applicable.
+    modified_at: Optional[datetime.datetime] = None
+    # Tags currently assigned to this lead.
+    tags: Optional[list[TagSummary]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadResponse:
+        """
+        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: LeadResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadResponse()
+    
+    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_contact import LeadContact
+        from .lead_metadata import LeadMetadata
+        from .lead_profile import LeadProfile
+        from .lead_response_admin_enablement_override import LeadResponse_adminEnablementOverride
+        from .lead_response_current_disposition import LeadResponse_currentDisposition
+        from .tag_summary import TagSummary
+
+        from .lead_contact import LeadContact
+        from .lead_metadata import LeadMetadata
+        from .lead_profile import LeadProfile
+        from .lead_response_admin_enablement_override import LeadResponse_adminEnablementOverride
+        from .lead_response_current_disposition import LeadResponse_currentDisposition
+        from .tag_summary import TagSummary
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "adminEnablementOverride": lambda n : setattr(self, 'admin_enablement_override', n.get_object_value(LeadResponse_adminEnablementOverride)),
+            "archiveNote": lambda n : setattr(self, 'archive_note', n.get_str_value()),
+            "archiveReason": lambda n : setattr(self, 'archive_reason', n.get_int_value()),
+            "archivedAt": lambda n : setattr(self, 'archived_at', n.get_datetime_value()),
+            "archivedByUserId": lambda n : setattr(self, 'archived_by_user_id', n.get_str_value()),
+            "contact": lambda n : setattr(self, 'contact', n.get_object_value(LeadContact)),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "currentDisposition": lambda n : setattr(self, 'current_disposition', n.get_object_value(LeadResponse_currentDisposition)),
+            "customer": lambda n : setattr(self, 'customer', n.get_object_value(LeadProfile)),
+            "enabled": lambda n : setattr(self, 'enabled', n.get_bool_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isArchived": lambda n : setattr(self, 'is_archived', n.get_bool_value()),
+            "metadata": lambda n : setattr(self, 'metadata', n.get_object_value(LeadMetadata)),
+            "modifiedAt": lambda n : setattr(self, 'modified_at', n.get_datetime_value()),
+            "tags": lambda n : setattr(self, 'tags', n.get_collection_of_object_values(TagSummary)),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_object_value("adminEnablementOverride", self.admin_enablement_override)
+        writer.write_str_value("archiveNote", self.archive_note)
+        writer.write_int_value("archiveReason", self.archive_reason)
+        writer.write_datetime_value("archivedAt", self.archived_at)
+        writer.write_str_value("archivedByUserId", self.archived_by_user_id)
+        writer.write_object_value("contact", self.contact)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_object_value("currentDisposition", self.current_disposition)
+        writer.write_object_value("customer", self.customer)
+        writer.write_bool_value("enabled", self.enabled)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isArchived", self.is_archived)
+        writer.write_object_value("metadata", self.metadata)
+        writer.write_datetime_value("modifiedAt", self.modified_at)
+        writer.write_collection_of_object_values("tags", self.tags)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/lead_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 LeadResponse_adminEnablementOverride(AdminEnablementOverride, Parsable):
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadResponse_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: LeadResponse_adminEnablementOverride
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadResponse_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/lead_response_current_disposition.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 .current_disposition_summary import CurrentDispositionSummary
+
+from .current_disposition_summary import CurrentDispositionSummary
+
+@dataclass
+class LeadResponse_currentDisposition(CurrentDispositionSummary, Parsable):
+    """
+    Compact current disposition state stored directly on a lead and surfaced with conversation data.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadResponse_currentDisposition:
+        """
+        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: LeadResponse_currentDisposition
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadResponse_currentDisposition()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .current_disposition_summary import CurrentDispositionSummary
+
+        from .current_disposition_summary import CurrentDispositionSummary
+
+        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/lead_table_row.py

@@ -0,0 +1,140 @@
+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 .lead_table_row_admin_enablement_override import LeadTableRow_adminEnablementOverride
+    from .lead_table_row_current_disposition import LeadTableRow_currentDisposition
+    from .tag_summary import TagSummary
+
+@dataclass
+class LeadTableRow(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing lead 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 admin force enablement override on this lead.
+    admin_enablement_override: Optional[LeadTableRow_adminEnablementOverride] = None
+    # Defines why a lead was removed from the active working pipeline.
+    archive_reason: Optional[int] = None
+    # The date and time this lead left the active pipeline.
+    archived_at: Optional[datetime.datetime] = None
+    # The user who archived the lead, if available.
+    archived_by_user_id: Optional[str] = None
+    # The business ID associated with this lead.
+    business_id: Optional[str] = None
+    # The business name value for this lead.
+    business_name: Optional[str] = None
+    # The date and time for the created at value on this lead.
+    created_at: Optional[datetime.datetime] = None
+    # The current lifecycle disposition for this lead.
+    current_disposition: Optional[LeadTableRow_currentDisposition] = None
+    # The email address associated with this lead.
+    email: Optional[str] = None
+    # Whether this lead is enabled.
+    enabled: Optional[bool] = None
+    # The first name value for this lead.
+    first_name: Optional[str] = None
+    # The unique ID for this lead.
+    id: Optional[str] = None
+    # Whether this lead is archived.
+    is_archived: Optional[bool] = None
+    # The date and time for the last name value on this lead.
+    last_name: Optional[str] = None
+    # The phone number associated with this lead.
+    phone: Optional[str] = None
+    # The source ID associated with this lead.
+    source_id: Optional[str] = None
+    # The source name value for this lead.
+    source_name: Optional[str] = None
+    # The current status for this lead.
+    status: Optional[str] = None
+    # The status tone value for this lead.
+    status_tone: Optional[str] = None
+    # Compact tags assigned to the lead.
+    tags: Optional[list[TagSummary]] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadTableRow:
+        """
+        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: LeadTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadTableRow()
+    
+    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_admin_enablement_override import LeadTableRow_adminEnablementOverride
+        from .lead_table_row_current_disposition import LeadTableRow_currentDisposition
+        from .tag_summary import TagSummary
+
+        from .lead_table_row_admin_enablement_override import LeadTableRow_adminEnablementOverride
+        from .lead_table_row_current_disposition import LeadTableRow_currentDisposition
+        from .tag_summary import TagSummary
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "adminEnablementOverride": lambda n : setattr(self, 'admin_enablement_override', n.get_object_value(LeadTableRow_adminEnablementOverride)),
+            "archiveReason": lambda n : setattr(self, 'archive_reason', n.get_int_value()),
+            "archivedAt": lambda n : setattr(self, 'archived_at', n.get_datetime_value()),
+            "archivedByUserId": lambda n : setattr(self, 'archived_by_user_id', n.get_str_value()),
+            "businessId": lambda n : setattr(self, 'business_id', n.get_str_value()),
+            "businessName": lambda n : setattr(self, 'business_name', n.get_str_value()),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "currentDisposition": lambda n : setattr(self, 'current_disposition', n.get_object_value(LeadTableRow_currentDisposition)),
+            "email": lambda n : setattr(self, 'email', n.get_str_value()),
+            "enabled": lambda n : setattr(self, 'enabled', n.get_bool_value()),
+            "firstName": lambda n : setattr(self, 'first_name', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isArchived": lambda n : setattr(self, 'is_archived', n.get_bool_value()),
+            "lastName": lambda n : setattr(self, 'last_name', n.get_str_value()),
+            "phone": lambda n : setattr(self, 'phone', n.get_str_value()),
+            "sourceId": lambda n : setattr(self, 'source_id', n.get_str_value()),
+            "sourceName": lambda n : setattr(self, 'source_name', n.get_str_value()),
+            "status": lambda n : setattr(self, 'status', n.get_str_value()),
+            "statusTone": lambda n : setattr(self, 'status_tone', n.get_str_value()),
+            "tags": lambda n : setattr(self, 'tags', n.get_collection_of_object_values(TagSummary)),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_object_value("adminEnablementOverride", self.admin_enablement_override)
+        writer.write_int_value("archiveReason", self.archive_reason)
+        writer.write_datetime_value("archivedAt", self.archived_at)
+        writer.write_str_value("archivedByUserId", self.archived_by_user_id)
+        writer.write_str_value("businessId", self.business_id)
+        writer.write_str_value("businessName", self.business_name)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_object_value("currentDisposition", self.current_disposition)
+        writer.write_str_value("email", self.email)
+        writer.write_bool_value("enabled", self.enabled)
+        writer.write_str_value("firstName", self.first_name)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isArchived", self.is_archived)
+        writer.write_str_value("lastName", self.last_name)
+        writer.write_str_value("phone", self.phone)
+        writer.write_str_value("sourceId", self.source_id)
+        writer.write_str_value("sourceName", self.source_name)
+        writer.write_str_value("status", self.status)
+        writer.write_str_value("statusTone", self.status_tone)
+        writer.write_collection_of_object_values("tags", self.tags)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/lead_table_row_admin_enablement_override.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 .admin_enablement_override import AdminEnablementOverride
+
+from .admin_enablement_override import AdminEnablementOverride
+
+@dataclass
+class LeadTableRow_adminEnablementOverride(AdminEnablementOverride, Parsable):
+    """
+    The admin force enablement override on this lead.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadTableRow_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: LeadTableRow_adminEnablementOverride
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadTableRow_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/lead_table_row_current_disposition.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 .current_disposition_summary import CurrentDispositionSummary
+
+from .current_disposition_summary import CurrentDispositionSummary
+
+@dataclass
+class LeadTableRow_currentDisposition(CurrentDispositionSummary, Parsable):
+    """
+    The current lifecycle disposition for this lead.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadTableRow_currentDisposition:
+        """
+        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: LeadTableRow_currentDisposition
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadTableRow_currentDisposition()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .current_disposition_summary import CurrentDispositionSummary
+
+        from .current_disposition_summary import CurrentDispositionSummary
+
+        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)
+    
+