leadping 1.0.0__py3-none-any.whl

leadping/models/outgoing_number_manual_override_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 .outgoing_number_selection_request import OutgoingNumberSelectionRequest
+
+@dataclass
+class OutgoingNumberManualOverrideRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for outgoing number manual override.
+    """
+    # 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 from phone number ID associated with this outgoing number manual override.
+    from_phone_number_id: Optional[str] = None
+    # The selection value for this outgoing number manual override.
+    selection: Optional[OutgoingNumberSelectionRequest] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OutgoingNumberManualOverrideRequest:
+        """
+        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: OutgoingNumberManualOverrideRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OutgoingNumberManualOverrideRequest()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .outgoing_number_selection_request import OutgoingNumberSelectionRequest
+
+        from .outgoing_number_selection_request import OutgoingNumberSelectionRequest
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "fromPhoneNumberId": lambda n : setattr(self, 'from_phone_number_id', n.get_str_value()),
+            "selection": lambda n : setattr(self, 'selection', n.get_object_value(OutgoingNumberSelectionRequest)),
+        }
+        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("fromPhoneNumberId", self.from_phone_number_id)
+        writer.write_object_value("selection", self.selection)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/outgoing_number_selection_reason.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class OutgoingNumberSelectionReason(str, Enum):
+    StickyConversation = "StickyConversation",
+    LeadAssigned = "LeadAssigned",
+    CampaignOrSource = "CampaignOrSource",
+    Preferred = "Preferred",
+    LocalArea = "LocalArea",
+    HealthyPool = "HealthyPool",
+    FallbackDefault = "FallbackDefault",
+    ManualOverride = "ManualOverride",
+

leadping/models/outgoing_number_selection_request.py

@@ -0,0 +1,81 @@
+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 .outgoing_number_selection_request_channel import OutgoingNumberSelectionRequest_channel
+
+@dataclass
+class OutgoingNumberSelectionRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for outgoing number selection.
+    """
+    # 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 outgoing number selection.
+    campaign_id: Optional[str] = None
+    # Defines the supported Outgoing Number Channel values.
+    channel: Optional[OutgoingNumberSelectionRequest_channel] = None
+    # The conversation ID associated with this outgoing number selection.
+    conversation_id: Optional[str] = None
+    # The lead ID associated with this outgoing number selection.
+    lead_id: Optional[str] = None
+    # The recipient phone number value for this outgoing number selection.
+    recipient_phone_number: Optional[str] = None
+    # The source ID associated with this outgoing number selection.
+    source_id: Optional[str] = None
+    # The team ID associated with this outgoing number selection.
+    team_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OutgoingNumberSelectionRequest:
+        """
+        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: OutgoingNumberSelectionRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OutgoingNumberSelectionRequest()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .outgoing_number_selection_request_channel import OutgoingNumberSelectionRequest_channel
+
+        from .outgoing_number_selection_request_channel import OutgoingNumberSelectionRequest_channel
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "campaignId": lambda n : setattr(self, 'campaign_id', n.get_str_value()),
+            "channel": lambda n : setattr(self, 'channel', n.get_enum_value(OutgoingNumberSelectionRequest_channel)),
+            "conversationId": lambda n : setattr(self, 'conversation_id', n.get_str_value()),
+            "leadId": lambda n : setattr(self, 'lead_id', n.get_str_value()),
+            "recipientPhoneNumber": lambda n : setattr(self, 'recipient_phone_number', n.get_str_value()),
+            "sourceId": lambda n : setattr(self, 'source_id', n.get_str_value()),
+            "teamId": lambda n : setattr(self, 'team_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_str_value("campaignId", self.campaign_id)
+        writer.write_enum_value("channel", self.channel)
+        writer.write_str_value("conversationId", self.conversation_id)
+        writer.write_str_value("leadId", self.lead_id)
+        writer.write_str_value("recipientPhoneNumber", self.recipient_phone_number)
+        writer.write_str_value("sourceId", self.source_id)
+        writer.write_str_value("teamId", self.team_id)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/outgoing_number_selection_request_channel.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+class OutgoingNumberSelectionRequest_channel(str, Enum):
+    Sms = "sms",
+    Call = "call",
+

leadping/models/outgoing_number_selection_response.py

@@ -0,0 +1,115 @@
+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 .eligible_outgoing_number_response import EligibleOutgoingNumberResponse
+    from .outgoing_number_selection_response_health_status import OutgoingNumberSelectionResponse_healthStatus
+    from .outgoing_number_selection_response_selection_reason import OutgoingNumberSelectionResponse_selectionReason
+
+@dataclass
+class OutgoingNumberSelectionResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing outgoing number selection 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 campaign ID associated with this outgoing number selection.
+    campaign_id: Optional[str] = None
+    # Whether the caller can send this outgoing number selection.
+    can_send: Optional[bool] = None
+    # The display number value for this outgoing number selection.
+    display_number: Optional[str] = None
+    # The eligible numbers included with this outgoing number selection.
+    eligible_numbers: Optional[list[EligibleOutgoingNumberResponse]] = None
+    # The health label value for this outgoing number selection.
+    health_label: Optional[str] = None
+    # Defines the supported SMS Warmup Health State values.
+    health_status: Optional[OutgoingNumberSelectionResponse_healthStatus] = None
+    # The health warning value for this outgoing number selection.
+    health_warning: Optional[str] = None
+    # The number value for this outgoing number selection.
+    number: Optional[str] = None
+    # The phone number ID associated with this outgoing number selection.
+    phone_number_id: Optional[str] = None
+    # The reason label value for this outgoing number selection.
+    reason_label: Optional[str] = None
+    # Defines the supported Outgoing Number Selection Reason values.
+    selection_reason: Optional[OutgoingNumberSelectionResponse_selectionReason] = None
+    # The setup message value for this outgoing number selection.
+    setup_message: Optional[str] = None
+    # The source ID associated with this outgoing number selection.
+    source_id: Optional[str] = None
+    # Whether this outgoing number selection was manually overridden.
+    was_manually_overridden: Optional[bool] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> OutgoingNumberSelectionResponse:
+        """
+        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: OutgoingNumberSelectionResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return OutgoingNumberSelectionResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .eligible_outgoing_number_response import EligibleOutgoingNumberResponse
+        from .outgoing_number_selection_response_health_status import OutgoingNumberSelectionResponse_healthStatus
+        from .outgoing_number_selection_response_selection_reason import OutgoingNumberSelectionResponse_selectionReason
+
+        from .eligible_outgoing_number_response import EligibleOutgoingNumberResponse
+        from .outgoing_number_selection_response_health_status import OutgoingNumberSelectionResponse_healthStatus
+        from .outgoing_number_selection_response_selection_reason import OutgoingNumberSelectionResponse_selectionReason
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "campaignId": lambda n : setattr(self, 'campaign_id', n.get_str_value()),
+            "canSend": lambda n : setattr(self, 'can_send', n.get_bool_value()),
+            "displayNumber": lambda n : setattr(self, 'display_number', n.get_str_value()),
+            "eligibleNumbers": lambda n : setattr(self, 'eligible_numbers', n.get_collection_of_object_values(EligibleOutgoingNumberResponse)),
+            "healthLabel": lambda n : setattr(self, 'health_label', n.get_str_value()),
+            "healthStatus": lambda n : setattr(self, 'health_status', n.get_enum_value(OutgoingNumberSelectionResponse_healthStatus)),
+            "healthWarning": lambda n : setattr(self, 'health_warning', n.get_str_value()),
+            "number": lambda n : setattr(self, 'number', n.get_str_value()),
+            "phoneNumberId": lambda n : setattr(self, 'phone_number_id', n.get_str_value()),
+            "reasonLabel": lambda n : setattr(self, 'reason_label', n.get_str_value()),
+            "selectionReason": lambda n : setattr(self, 'selection_reason', n.get_enum_value(OutgoingNumberSelectionResponse_selectionReason)),
+            "setupMessage": lambda n : setattr(self, 'setup_message', n.get_str_value()),
+            "sourceId": lambda n : setattr(self, 'source_id', n.get_str_value()),
+            "wasManuallyOverridden": lambda n : setattr(self, 'was_manually_overridden', n.get_bool_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("campaignId", self.campaign_id)
+        writer.write_bool_value("canSend", self.can_send)
+        writer.write_str_value("displayNumber", self.display_number)
+        writer.write_collection_of_object_values("eligibleNumbers", self.eligible_numbers)
+        writer.write_str_value("healthLabel", self.health_label)
+        writer.write_enum_value("healthStatus", self.health_status)
+        writer.write_str_value("healthWarning", self.health_warning)
+        writer.write_str_value("number", self.number)
+        writer.write_str_value("phoneNumberId", self.phone_number_id)
+        writer.write_str_value("reasonLabel", self.reason_label)
+        writer.write_enum_value("selectionReason", self.selection_reason)
+        writer.write_str_value("setupMessage", self.setup_message)
+        writer.write_str_value("sourceId", self.source_id)
+        writer.write_bool_value("wasManuallyOverridden", self.was_manually_overridden)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/outgoing_number_selection_response_health_status.py

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

leadping/models/outgoing_number_selection_response_selection_reason.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class OutgoingNumberSelectionResponse_selectionReason(str, Enum):
+    StickyConversation = "StickyConversation",
+    LeadAssigned = "LeadAssigned",
+    CampaignOrSource = "CampaignOrSource",
+    Preferred = "Preferred",
+    LocalArea = "LocalArea",
+    HealthyPool = "HealthyPool",
+    FallbackDefault = "FallbackDefault",
+    ManualOverride = "ManualOverride",
+

leadping/models/paged_result_of_automation_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 .automation_table_row import AutomationTableRow
+
+@dataclass
+class PagedResultOfAutomationTableRow(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[AutomationTableRow]] = 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) -> PagedResultOfAutomationTableRow:
+        """
+        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: PagedResultOfAutomationTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfAutomationTableRow()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .automation_table_row import AutomationTableRow
+
+        from .automation_table_row import AutomationTableRow
+
+        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(AutomationTableRow)),
+            "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_call_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 .call_event_table_row import CallEventTableRow
+
+@dataclass
+class PagedResultOfCallEventTableRow(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[CallEventTableRow]] = 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) -> PagedResultOfCallEventTableRow:
+        """
+        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: PagedResultOfCallEventTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfCallEventTableRow()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .call_event_table_row import CallEventTableRow
+
+        from .call_event_table_row import CallEventTableRow
+
+        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(CallEventTableRow)),
+            "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_conversation_response.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 .conversation_response import ConversationResponse
+
+@dataclass
+class PagedResultOfConversationResponse(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[ConversationResponse]] = 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) -> PagedResultOfConversationResponse:
+        """
+        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: PagedResultOfConversationResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfConversationResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .conversation_response import ConversationResponse
+
+        from .conversation_response import ConversationResponse
+
+        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(ConversationResponse)),
+            "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_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 .event_table_row import EventTableRow
+
+@dataclass
+class PagedResultOfEventTableRow(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[EventTableRow]] = 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) -> PagedResultOfEventTableRow:
+        """
+        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: PagedResultOfEventTableRow
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfEventTableRow()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .event_table_row import EventTableRow
+
+        from .event_table_row import EventTableRow
+
+        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(EventTableRow)),
+            "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_feedback_response.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 .feedback_response import FeedbackResponse
+
+@dataclass
+class PagedResultOfFeedbackResponse(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[FeedbackResponse]] = 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) -> PagedResultOfFeedbackResponse:
+        """
+        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: PagedResultOfFeedbackResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return PagedResultOfFeedbackResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .feedback_response import FeedbackResponse
+
+        from .feedback_response import FeedbackResponse
+
+        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(FeedbackResponse)),
+            "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)
+    
+