leadping 1.0.0__py3-none-any.whl

leadping/models/source_table_row_business.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 .id_name_pair import IdNamePair
+
+from .id_name_pair import IdNamePair
+
+@dataclass
+class SourceTableRow_business(IdNamePair, Parsable):
+    """
+    The business value for this source.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SourceTableRow_business:
+        """
+        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: SourceTableRow_business
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SourceTableRow_business()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .id_name_pair import IdNamePair
+
+        from .id_name_pair import IdNamePair
+
+        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/source_table_row_created_by_user.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 .id_name_pair import IdNamePair
+
+from .id_name_pair import IdNamePair
+
+@dataclass
+class SourceTableRow_createdByUser(IdNamePair, Parsable):
+    """
+    The user that created this source.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SourceTableRow_createdByUser:
+        """
+        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: SourceTableRow_createdByUser
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SourceTableRow_createdByUser()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .id_name_pair import IdNamePair
+
+        from .id_name_pair import IdNamePair
+
+        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/source_table_row_modified_by_user.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 .id_name_pair import IdNamePair
+
+from .id_name_pair import IdNamePair
+
+@dataclass
+class SourceTableRow_modifiedByUser(IdNamePair, Parsable):
+    """
+    The user that most recently modified this source.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SourceTableRow_modifiedByUser:
+        """
+        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: SourceTableRow_modifiedByUser
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SourceTableRow_modifiedByUser()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .id_name_pair import IdNamePair
+
+        from .id_name_pair import IdNamePair
+
+        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/source_table_row_user.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 .id_name_pair import IdNamePair
+
+from .id_name_pair import IdNamePair
+
+@dataclass
+class SourceTableRow_user(IdNamePair, Parsable):
+    """
+    The user value for this source.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> SourceTableRow_user:
+        """
+        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: SourceTableRow_user
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return SourceTableRow_user()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .id_name_pair import IdNamePair
+
+        from .id_name_pair import IdNamePair
+
+        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/street_address.py

@@ -0,0 +1,82 @@
+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 StreetAddress(AdditionalDataHolder, Parsable):
+    """
+    A minimal, serializable record type for physical mailing addresses, with support for international formats and compatibility with common APIs.
+    """
+    # 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 additional notes or delivery instructions.
+    additional_info: Optional[str] = None
+    # The city, town, or locality.
+    city: Optional[str] = None
+    # The ISO 3166-1 alpha-2 country code (e.g., "US", "GB", "CA").
+    country: Optional[str] = None
+    # The primary address line (e.g., street address, P.O. box, company name).
+    line1: Optional[str] = None
+    # The secondary address line (e.g., apartment, suite, unit, or building).
+    line2: Optional[str] = None
+    # The postal or ZIP code.
+    postal_code: Optional[str] = None
+    # The province or territory, if distinct from state in your use case (optional, use with care).
+    province: Optional[str] = None
+    # The broader region, district, or administrative area (e.g., prefecture or county).
+    region: Optional[str] = None
+    # The state, province, or equivalent administrative region. Commonly used in countries like the US, Canada, and Australia.
+    state: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> 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: StreetAddress
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return StreetAddress()
+    
+    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]] = {
+            "additionalInfo": lambda n : setattr(self, 'additional_info', n.get_str_value()),
+            "city": lambda n : setattr(self, 'city', n.get_str_value()),
+            "country": lambda n : setattr(self, 'country', n.get_str_value()),
+            "line1": lambda n : setattr(self, 'line1', n.get_str_value()),
+            "line2": lambda n : setattr(self, 'line2', n.get_str_value()),
+            "postalCode": lambda n : setattr(self, 'postal_code', n.get_str_value()),
+            "province": lambda n : setattr(self, 'province', n.get_str_value()),
+            "region": lambda n : setattr(self, 'region', n.get_str_value()),
+            "state": lambda n : setattr(self, 'state', 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("additionalInfo", self.additional_info)
+        writer.write_str_value("city", self.city)
+        writer.write_str_value("country", self.country)
+        writer.write_str_value("line1", self.line1)
+        writer.write_str_value("line2", self.line2)
+        writer.write_str_value("postalCode", self.postal_code)
+        writer.write_str_value("province", self.province)
+        writer.write_str_value("region", self.region)
+        writer.write_str_value("state", self.state)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/stripe_payment_method_response.py

@@ -0,0 +1,75 @@
+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
+
+@dataclass
+class StripePaymentMethodResponse(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing stripe payment method 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 brand value for this Stripe payment method.
+    brand: Optional[str] = None
+    # The date and time for the created at value on this Stripe payment method.
+    created_at: Optional[datetime.datetime] = None
+    # The exp month value for this Stripe payment method.
+    exp_month: Optional[int] = None
+    # The exp year value for this Stripe payment method.
+    exp_year: Optional[int] = None
+    # The unique ID for this Stripe payment method.
+    id: Optional[str] = None
+    # Whether this Stripe payment method is default.
+    is_default: Optional[bool] = None
+    # The date and time for the last4 value on this Stripe payment method.
+    last4: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> StripePaymentMethodResponse:
+        """
+        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: StripePaymentMethodResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return StripePaymentMethodResponse()
+    
+    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]] = {
+            "brand": lambda n : setattr(self, 'brand', n.get_str_value()),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "expMonth": lambda n : setattr(self, 'exp_month', n.get_int_value()),
+            "expYear": lambda n : setattr(self, 'exp_year', n.get_int_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isDefault": lambda n : setattr(self, 'is_default', n.get_bool_value()),
+            "last4": lambda n : setattr(self, 'last4', 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("brand", self.brand)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_int_value("expMonth", self.exp_month)
+        writer.write_int_value("expYear", self.exp_year)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isDefault", self.is_default)
+        writer.write_str_value("last4", self.last4)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/tag_request.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class TagRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for creating or updating a business tag.
+    """
+    # 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 palette token used for compact tag display.
+    color: Optional[str] = None
+    # Optional internal description for the tag.
+    description: Optional[str] = None
+    # The unique identifier for the entity, when updating an existing entity.
+    id: Optional[str] = None
+    # The business-facing tag name.
+    name: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TagRequest:
+        """
+        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: TagRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TagRequest()
+    
+    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]] = {
+            "color": lambda n : setattr(self, 'color', n.get_str_value()),
+            "description": lambda n : setattr(self, 'description', n.get_str_value()),
+            "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("color", self.color)
+        writer.write_str_value("description", self.description)
+        writer.write_str_value("id", self.id)
+        writer.write_str_value("name", self.name)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/tag_response.py

@@ -0,0 +1,91 @@
+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
+
+@dataclass
+class TagResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing business tag data.
+    """
+    # 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 archivedAt property
+    archived_at: Optional[datetime.datetime] = None
+    # The businessId property
+    business_id: Optional[str] = None
+    # The color property
+    color: Optional[str] = None
+    # The date and time when the entity was created.
+    created_at: Optional[datetime.datetime] = None
+    # The createdByUserId property
+    created_by_user_id: Optional[str] = None
+    # The description property
+    description: Optional[str] = None
+    # The unique identifier for the entity.
+    id: Optional[str] = None
+    # The isArchived property
+    is_archived: Optional[bool] = None
+    # The date and time when the entity was last modified, if applicable.
+    modified_at: Optional[datetime.datetime] = None
+    # The name property
+    name: Optional[str] = None
+    # The normalizedName property
+    normalized_name: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TagResponse:
+        """
+        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: TagResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TagResponse()
+    
+    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]] = {
+            "archivedAt": lambda n : setattr(self, 'archived_at', n.get_datetime_value()),
+            "businessId": lambda n : setattr(self, 'business_id', n.get_str_value()),
+            "color": lambda n : setattr(self, 'color', n.get_str_value()),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "createdByUserId": lambda n : setattr(self, 'created_by_user_id', n.get_str_value()),
+            "description": lambda n : setattr(self, 'description', 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()),
+            "modifiedAt": lambda n : setattr(self, 'modified_at', n.get_datetime_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "normalizedName": lambda n : setattr(self, 'normalized_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_datetime_value("archivedAt", self.archived_at)
+        writer.write_str_value("businessId", self.business_id)
+        writer.write_str_value("color", self.color)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_str_value("createdByUserId", self.created_by_user_id)
+        writer.write_str_value("description", self.description)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isArchived", self.is_archived)
+        writer.write_datetime_value("modifiedAt", self.modified_at)
+        writer.write_str_value("name", self.name)
+        writer.write_str_value("normalizedName", self.normalized_name)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/tag_summary.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class TagSummary(AdditionalDataHolder, Parsable):
+    """
+    Compact tag data safe to embed on tagged entities.
+    """
+    # 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 color property
+    color: Optional[str] = None
+    # The id property
+    id: Optional[str] = None
+    # The name property
+    name: Optional[str] = None
+    # The normalizedName property
+    normalized_name: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> TagSummary:
+        """
+        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: TagSummary
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return TagSummary()
+    
+    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]] = {
+            "color": lambda n : setattr(self, 'color', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "normalizedName": lambda n : setattr(self, 'normalized_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("color", self.color)
+        writer.write_str_value("id", self.id)
+        writer.write_str_value("name", self.name)
+        writer.write_str_value("normalizedName", self.normalized_name)
+        writer.write_additional_data_value(self.additional_data)
+    
+