leadping 1.0.0__py3-none-any.whl

leadping/models/feedback_response.py

@@ -0,0 +1,157 @@
+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 .feedback_status import FeedbackStatus
+    from .feedback_type import FeedbackType
+
+@dataclass
+class FeedbackResponse(AdditionalDataHolder, Parsable):
+    """
+    Feedback item returned to admins and submitters.
+    """
+    # 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 adminNote property
+    admin_note: Optional[str] = None
+    # The allowContact property
+    allow_contact: Optional[bool] = None
+    # The area property
+    area: Optional[str] = None
+    # The businessId property
+    business_id: Optional[str] = None
+    # The businessNameSnapshot property
+    business_name_snapshot: Optional[str] = None
+    # The clientVersion property
+    client_version: Optional[str] = None
+    # The closedAt property
+    closed_at: Optional[datetime.datetime] = None
+    # The closedByUserId property
+    closed_by_user_id: Optional[str] = None
+    # The createdAt property
+    created_at: Optional[datetime.datetime] = None
+    # The duplicateOfFeedbackItemId property
+    duplicate_of_feedback_item_id: Optional[str] = None
+    # The environment property
+    environment: Optional[str] = None
+    # The externalIssueUrl property
+    external_issue_url: Optional[str] = None
+    # The id property
+    id: Optional[str] = None
+    # The message property
+    message: Optional[str] = None
+    # The reviewedAt property
+    reviewed_at: Optional[datetime.datetime] = None
+    # The reviewedByUserId property
+    reviewed_by_user_id: Optional[str] = None
+    # The route property
+    route: Optional[str] = None
+    # The serverVersion property
+    server_version: Optional[str] = None
+    # Defines admin triage statuses for durable product feedback.
+    status: Optional[FeedbackStatus] = None
+    # The subscriptionPlanSnapshot property
+    subscription_plan_snapshot: Optional[str] = None
+    # Defines the type of product feedback submitted from inside Leadping.
+    type: Optional[FeedbackType] = None
+    # The userAgent property
+    user_agent: Optional[str] = None
+    # The userDisplayNameSnapshot property
+    user_display_name_snapshot: Optional[str] = None
+    # The userEmailSnapshot property
+    user_email_snapshot: Optional[str] = None
+    # The userId property
+    user_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> FeedbackResponse:
+        """
+        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: FeedbackResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return FeedbackResponse()
+    
+    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_status import FeedbackStatus
+        from .feedback_type import FeedbackType
+
+        from .feedback_status import FeedbackStatus
+        from .feedback_type import FeedbackType
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "adminNote": lambda n : setattr(self, 'admin_note', n.get_str_value()),
+            "allowContact": lambda n : setattr(self, 'allow_contact', n.get_bool_value()),
+            "area": lambda n : setattr(self, 'area', n.get_str_value()),
+            "businessId": lambda n : setattr(self, 'business_id', n.get_str_value()),
+            "businessNameSnapshot": lambda n : setattr(self, 'business_name_snapshot', n.get_str_value()),
+            "clientVersion": lambda n : setattr(self, 'client_version', n.get_str_value()),
+            "closedAt": lambda n : setattr(self, 'closed_at', n.get_datetime_value()),
+            "closedByUserId": lambda n : setattr(self, 'closed_by_user_id', n.get_str_value()),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "duplicateOfFeedbackItemId": lambda n : setattr(self, 'duplicate_of_feedback_item_id', n.get_str_value()),
+            "environment": lambda n : setattr(self, 'environment', n.get_str_value()),
+            "externalIssueUrl": lambda n : setattr(self, 'external_issue_url', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "message": lambda n : setattr(self, 'message', n.get_str_value()),
+            "reviewedAt": lambda n : setattr(self, 'reviewed_at', n.get_datetime_value()),
+            "reviewedByUserId": lambda n : setattr(self, 'reviewed_by_user_id', n.get_str_value()),
+            "route": lambda n : setattr(self, 'route', n.get_str_value()),
+            "serverVersion": lambda n : setattr(self, 'server_version', n.get_str_value()),
+            "status": lambda n : setattr(self, 'status', n.get_enum_value(FeedbackStatus)),
+            "subscriptionPlanSnapshot": lambda n : setattr(self, 'subscription_plan_snapshot', n.get_str_value()),
+            "type": lambda n : setattr(self, 'type', n.get_enum_value(FeedbackType)),
+            "userAgent": lambda n : setattr(self, 'user_agent', n.get_str_value()),
+            "userDisplayNameSnapshot": lambda n : setattr(self, 'user_display_name_snapshot', n.get_str_value()),
+            "userEmailSnapshot": lambda n : setattr(self, 'user_email_snapshot', n.get_str_value()),
+            "userId": lambda n : setattr(self, 'user_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("adminNote", self.admin_note)
+        writer.write_bool_value("allowContact", self.allow_contact)
+        writer.write_str_value("area", self.area)
+        writer.write_str_value("businessId", self.business_id)
+        writer.write_str_value("businessNameSnapshot", self.business_name_snapshot)
+        writer.write_str_value("clientVersion", self.client_version)
+        writer.write_datetime_value("closedAt", self.closed_at)
+        writer.write_str_value("closedByUserId", self.closed_by_user_id)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_str_value("duplicateOfFeedbackItemId", self.duplicate_of_feedback_item_id)
+        writer.write_str_value("environment", self.environment)
+        writer.write_str_value("externalIssueUrl", self.external_issue_url)
+        writer.write_str_value("id", self.id)
+        writer.write_str_value("message", self.message)
+        writer.write_datetime_value("reviewedAt", self.reviewed_at)
+        writer.write_str_value("reviewedByUserId", self.reviewed_by_user_id)
+        writer.write_str_value("route", self.route)
+        writer.write_str_value("serverVersion", self.server_version)
+        writer.write_enum_value("status", self.status)
+        writer.write_str_value("subscriptionPlanSnapshot", self.subscription_plan_snapshot)
+        writer.write_enum_value("type", self.type)
+        writer.write_str_value("userAgent", self.user_agent)
+        writer.write_str_value("userDisplayNameSnapshot", self.user_display_name_snapshot)
+        writer.write_str_value("userEmailSnapshot", self.user_email_snapshot)
+        writer.write_str_value("userId", self.user_id)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/feedback_status.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class FeedbackStatus(str, Enum):
+    New = "new",
+    Reviewed = "reviewed",
+    Planned = "planned",
+    In_progress = "in_progress",
+    Shipped = "shipped",
+    Closed = "closed",
+    Ignored = "ignored",
+

leadping/models/feedback_type.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class FeedbackType(str, Enum):
+    Bug = "bug",
+    Confusing = "confusing",
+    Feature_request = "feature_request",
+    Missing_capability = "missing_capability",
+    Other = "other",
+

leadping/models/id_name_pair.py

@@ -0,0 +1,54 @@
+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 IdNamePair(AdditionalDataHolder, Parsable):
+    """
+    A minimal Record type with an (string), (string), and maximum JSON compatibility. The reason for this type (over something like KeyValuePair, dictionary) is because of JSON serialization support.
+    """
+    # 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 unique identifier.
+    id: Optional[str] = None
+    # The display name.
+    name: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> IdNamePair:
+        """
+        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: IdNamePair
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return IdNamePair()
+    
+    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]] = {
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "name": lambda n : setattr(self, '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("id", self.id)
+        writer.write_str_value("name", self.name)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/id_name_value.py

@@ -0,0 +1,58 @@
+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 IdNameValue(AdditionalDataHolder, Parsable):
+    """
+    A minimal Record type with an Id (string), Name (string), nullable Value (string?) and maximum JSON compatibility
+    """
+    # 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 unique identifier.
+    id: Optional[str] = None
+    # The display name.
+    name: Optional[str] = None
+    # The optional value associated with the identifier and name.
+    value: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> IdNameValue:
+        """
+        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: IdNameValue
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return IdNameValue()
+    
+    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]] = {
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "value": lambda n : setattr(self, 'value', 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("id", self.id)
+        writer.write_str_value("name", self.name)
+        writer.write_str_value("value", self.value)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/internal_phone_number_status.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class InternalPhoneNumberStatus(str, Enum):
+    Unregistered = "Unregistered",
+    Provisioning = "Provisioning",
+    FailedProvisioning = "FailedProvisioning",
+    Active = "Active",
+    Expired = "Expired",
+    Suspended = "Suspended",
+    PendingRelease = "PendingRelease",
+

leadping/models/lead_archive_request.py

@@ -0,0 +1,54 @@
+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 LeadArchiveRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for archiving a lead without deleting its history.
+    """
+    # 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)
+
+    # Optional internal note explaining the archive decision.
+    note: Optional[str] = None
+    # Reason the lead should leave the active working pipeline.
+    reason: Optional[int] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadArchiveRequest:
+        """
+        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: LeadArchiveRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadArchiveRequest()
+    
+    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]] = {
+            "note": lambda n : setattr(self, 'note', n.get_str_value()),
+            "reason": lambda n : setattr(self, 'reason', 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("note", self.note)
+        writer.write_int_value("reason", self.reason)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/lead_contact.py

@@ -0,0 +1,87 @@
+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_coordinate import LeadContact_coordinate
+    from .lead_contact_phone import LeadContact_phone
+    from .lead_contact_street_address import LeadContact_streetAddress
+
+@dataclass
+class LeadContact(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing lead contact 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 lead contact.
+    coordinate: Optional[LeadContact_coordinate] = None
+    # The email address associated with this lead contact.
+    email: Optional[str] = None
+    # The first name value for this lead contact.
+    first_name: Optional[str] = None
+    # The date and time for the last name value on this lead contact.
+    last_name: Optional[str] = None
+    # The phone number associated with this lead contact.
+    phone: Optional[LeadContact_phone] = None
+    # The street address value for this lead contact.
+    street_address: Optional[LeadContact_streetAddress] = None
+    # The IANA time zone identifier inferred for this lead contact.
+    time_zone_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadContact:
+        """
+        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: LeadContact
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadContact()
+    
+    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_coordinate import LeadContact_coordinate
+        from .lead_contact_phone import LeadContact_phone
+        from .lead_contact_street_address import LeadContact_streetAddress
+
+        from .lead_contact_coordinate import LeadContact_coordinate
+        from .lead_contact_phone import LeadContact_phone
+        from .lead_contact_street_address import LeadContact_streetAddress
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "coordinate": lambda n : setattr(self, 'coordinate', n.get_object_value(LeadContact_coordinate)),
+            "email": lambda n : setattr(self, 'email', n.get_str_value()),
+            "firstName": lambda n : setattr(self, 'first_name', n.get_str_value()),
+            "lastName": lambda n : setattr(self, 'last_name', n.get_str_value()),
+            "phone": lambda n : setattr(self, 'phone', n.get_object_value(LeadContact_phone)),
+            "streetAddress": lambda n : setattr(self, 'street_address', n.get_object_value(LeadContact_streetAddress)),
+            "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("email", self.email)
+        writer.write_str_value("firstName", self.first_name)
+        writer.write_str_value("lastName", self.last_name)
+        writer.write_object_value("phone", self.phone)
+        writer.write_object_value("streetAddress", self.street_address)
+        writer.write_str_value("timeZoneId", self.time_zone_id)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/lead_contact_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 LeadContact_coordinate(Coordinate, Parsable):
+    """
+    The coordinate inferred for this lead contact.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadContact_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: LeadContact_coordinate
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadContact_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)
+    
+

leadping/models/lead_contact_phone.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 import Phone
+
+from .phone import Phone
+
+@dataclass
+class LeadContact_phone(Phone, Parsable):
+    """
+    The phone number associated with this lead contact.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadContact_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: LeadContact_phone
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadContact_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 import Phone
+
+        from .phone import Phone
+
+        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_contact_street_address.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 .street_address import StreetAddress
+
+from .street_address import StreetAddress
+
+@dataclass
+class LeadContact_streetAddress(StreetAddress, Parsable):
+    """
+    The street address value for this lead contact.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> LeadContact_streetAddress:
+        """
+        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: LeadContact_streetAddress
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return LeadContact_streetAddress()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .street_address import StreetAddress
+
+        from .street_address import StreetAddress
+
+        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)
+    
+