leadping 1.0.0__py3-none-any.whl

leadping/leads/leads_request_builder.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.base_request_builder import BaseRequestBuilder
+from kiota_abstractions.base_request_configuration import RequestConfiguration
+from kiota_abstractions.default_query_parameters import QueryParameters
+from kiota_abstractions.get_path_parameters import get_path_parameters
+from kiota_abstractions.method import Method
+from kiota_abstractions.request_adapter import RequestAdapter
+from kiota_abstractions.request_information import RequestInformation
+from kiota_abstractions.request_option import RequestOption
+from kiota_abstractions.serialization import Parsable, ParsableFactory
+from typing import Any, Optional, TYPE_CHECKING, Union
+from warnings import warn
+
+if TYPE_CHECKING:
+    from ..models.lead_request import LeadRequest
+    from ..models.lead_response import LeadResponse
+    from ..models.problem_details import ProblemDetails
+    from .all.all_request_builder import AllRequestBuilder
+    from .intake.intake_request_builder import IntakeRequestBuilder
+    from .item.leads_item_request_builder import LeadsItemRequestBuilder
+
+class LeadsRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /leads
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None:
+        """
+        Instantiates a new LeadsRequestBuilder and sets the default values.
+        param path_parameters: The raw url or the url-template parameters for the request.
+        param request_adapter: The request adapter to use to execute the requests.
+        Returns: None
+        """
+        super().__init__(request_adapter, "{+baseurl}/leads{?sourceKey*}", path_parameters)
+    
+    def by_id(self,id: str) -> LeadsItemRequestBuilder:
+        """
+        Gets an item from the leadping.leads.item collection
+        param id: The ID of the lead to retrieve.
+        Returns: LeadsItemRequestBuilder
+        """
+        if id is None:
+            raise TypeError("id cannot be null.")
+        from .item.leads_item_request_builder import LeadsItemRequestBuilder
+
+        url_tpl_params = get_path_parameters(self.path_parameters)
+        url_tpl_params["id"] = id
+        return LeadsItemRequestBuilder(self.request_adapter, url_tpl_params)
+    
+    async def post(self,body: LeadRequest, request_configuration: Optional[RequestConfiguration[LeadsRequestBuilderPostQueryParameters]] = None) -> Optional[LeadResponse]:
+        """
+        Creates a source-authenticated lead captured outside Leadping, starting follow-up, routing, and automation from structured lead data.
+        param body: Request payload for lead.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: Optional[LeadResponse]
+        """
+        if body is None:
+            raise TypeError("body cannot be null.")
+        request_info = self.to_post_request_information(
+            body, request_configuration
+        )
+        from ..models.problem_details import ProblemDetails
+
+        error_mapping: dict[str, type[ParsableFactory]] = {
+            "400": ProblemDetails,
+            "401": ProblemDetails,
+            "403": ProblemDetails,
+            "404": ProblemDetails,
+        }
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        from ..models.lead_response import LeadResponse
+
+        return await self.request_adapter.send_async(request_info, LeadResponse, error_mapping)
+    
+    def to_post_request_information(self,body: LeadRequest, request_configuration: Optional[RequestConfiguration[LeadsRequestBuilderPostQueryParameters]] = None) -> RequestInformation:
+        """
+        Creates a source-authenticated lead captured outside Leadping, starting follow-up, routing, and automation from structured lead data.
+        param body: Request payload for lead.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: RequestInformation
+        """
+        if body is None:
+            raise TypeError("body cannot be null.")
+        request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters)
+        request_info.configure(request_configuration)
+        request_info.headers.try_add("Accept", "application/json")
+        request_info.set_content_from_parsable(self.request_adapter, "application/json", body)
+        return request_info
+    
+    def with_url(self,raw_url: str) -> LeadsRequestBuilder:
+        """
+        Returns a request builder with the provided arbitrary URL. Using this method means any other path or query parameters are ignored.
+        param raw_url: The raw URL to use for the request builder.
+        Returns: LeadsRequestBuilder
+        """
+        if raw_url is None:
+            raise TypeError("raw_url cannot be null.")
+        return LeadsRequestBuilder(self.request_adapter, raw_url)
+    
+    @property
+    def all(self) -> AllRequestBuilder:
+        """
+        The all property
+        """
+        from .all.all_request_builder import AllRequestBuilder
+
+        return AllRequestBuilder(self.request_adapter, self.path_parameters)
+    
+    @property
+    def intake(self) -> IntakeRequestBuilder:
+        """
+        The intake property
+        """
+        from .intake.intake_request_builder import IntakeRequestBuilder
+
+        return IntakeRequestBuilder(self.request_adapter, self.path_parameters)
+    
+    @dataclass
+    class LeadsRequestBuilderPostQueryParameters():
+        """
+        Creates a source-authenticated lead captured outside Leadping, starting follow-up, routing, and automation from structured lead data.
+        """
+        def get_query_parameter(self,original_name: str) -> str:
+            """
+            Maps the query parameters names to their encoded names for the URI template parsing.
+            param original_name: The original query parameter name in the class.
+            Returns: str
+            """
+            if original_name is None:
+                raise TypeError("original_name cannot be null.")
+            if original_name == "source_key":
+                return "sourceKey"
+            return original_name
+        
+        # The Leadping source key supplied as a query string parameter.
+        source_key: Optional[str] = None
+
+    
+    @dataclass
+    class LeadsRequestBuilderPostRequestConfiguration(RequestConfiguration[LeadsRequestBuilderPostQueryParameters]):
+        """
+        Configuration for the request such as headers, query parameters, and middleware options.
+        """
+        warn("This class is deprecated. Please use the generic RequestConfiguration class generated by the generator.", DeprecationWarning)
+    
+

leadping/models/accept_business_invitation_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 AcceptBusinessInvitationRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for accept business invitation.
+    """
+    # 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 email address associated with this business invitation.
+    email: Optional[str] = None
+    # The first name value for this business invitation.
+    first_name: Optional[str] = None
+    # The date and time for the last name value on this business invitation.
+    last_name: Optional[str] = None
+    # The token supplied to authorize or complete this business invitation.
+    token: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AcceptBusinessInvitationRequest:
+        """
+        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: AcceptBusinessInvitationRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AcceptBusinessInvitationRequest()
+    
+    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]] = {
+            "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()),
+            "token": lambda n : setattr(self, 'token', 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("email", self.email)
+        writer.write_str_value("firstName", self.first_name)
+        writer.write_str_value("lastName", self.last_name)
+        writer.write_str_value("token", self.token)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/activation_domain_option.py

@@ -0,0 +1,70 @@
+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 ActivationDomainOption(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing activation domain option 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 current availability status for this activation domain option.
+    availability_status: Optional[str] = None
+    # The domain name associated with this activation domain option.
+    domain_name: Optional[str] = None
+    # The industry relevance value for this activation domain option.
+    industry_relevance: Optional[str] = None
+    # Whether this activation domain option is recommended.
+    recommended: Optional[bool] = None
+    # The trust concerns value for this activation domain option.
+    trust_concerns: Optional[str] = None
+    # The why it fits value for this activation domain option.
+    why_it_fits: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ActivationDomainOption:
+        """
+        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: ActivationDomainOption
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ActivationDomainOption()
+    
+    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]] = {
+            "availabilityStatus": lambda n : setattr(self, 'availability_status', n.get_str_value()),
+            "domainName": lambda n : setattr(self, 'domain_name', n.get_str_value()),
+            "industryRelevance": lambda n : setattr(self, 'industry_relevance', n.get_str_value()),
+            "recommended": lambda n : setattr(self, 'recommended', n.get_bool_value()),
+            "trustConcerns": lambda n : setattr(self, 'trust_concerns', n.get_str_value()),
+            "whyItFits": lambda n : setattr(self, 'why_it_fits', 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("availabilityStatus", self.availability_status)
+        writer.write_str_value("domainName", self.domain_name)
+        writer.write_str_value("industryRelevance", self.industry_relevance)
+        writer.write_bool_value("recommended", self.recommended)
+        writer.write_str_value("trustConcerns", self.trust_concerns)
+        writer.write_str_value("whyItFits", self.why_it_fits)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/activation_launch_review_status.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class ActivationLaunchReviewStatus(str, Enum):
+    NotReady = "NotReady",
+    Pending = "Pending",
+    Approved = "Approved",
+    NotRequired = "NotRequired",
+    Blocked = "Blocked",
+

leadping/models/activation_onboarding_status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class ActivationOnboardingStatus(str, Enum):
+    Draft = "Draft",
+    Submitted = "Submitted",
+    Failed = "Failed",
+

leadping/models/activation_payment_status.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+class ActivationPaymentStatus(str, Enum):
+    PaymentMethodPending = "PaymentMethodPending",
+    PaymentMethodConfirmed = "PaymentMethodConfirmed",
+    Failed = "Failed",
+

leadping/models/activation_subscription_status.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class ActivationSubscriptionStatus(str, Enum):
+    Pending = "Pending",
+    Active = "Active",
+    Failed = "Failed",
+    Canceled = "Canceled",
+

leadping/models/activation_telephony_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class ActivationTelephonyStatus(str, Enum):
+    NotStarted = "NotStarted",
+    ProvisioningPending = "ProvisioningPending",
+    PartiallyProvisioned = "PartiallyProvisioned",
+    Ready = "Ready",
+    Failed = "Failed",
+    BlockedRequiresOperatorAction = "BlockedRequiresOperatorAction",
+

leadping/models/activation_timeline_event.py

@@ -0,0 +1,79 @@
+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 ActivationTimelineEvent(AdditionalDataHolder, Parsable):
+    """
+    API DTO containing activation timeline event 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 actor name value for this activation timeline event.
+    actor_name: Optional[str] = None
+    # The date and time for the created at value on this activation timeline event.
+    created_at: Optional[datetime.datetime] = None
+    # The details value for this activation timeline event.
+    details: Optional[str] = None
+    # The human-readable failure reason explaining this activation timeline event.
+    failure_reason: Optional[str] = None
+    # The unique ID for this activation timeline event.
+    id: Optional[str] = None
+    # The current status for this activation timeline event.
+    status: Optional[str] = None
+    # The title value for this activation timeline event.
+    title: Optional[str] = None
+    # The type classification for this activation timeline event.
+    type: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ActivationTimelineEvent:
+        """
+        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: ActivationTimelineEvent
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ActivationTimelineEvent()
+    
+    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]] = {
+            "actorName": lambda n : setattr(self, 'actor_name', n.get_str_value()),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "details": lambda n : setattr(self, 'details', n.get_str_value()),
+            "failureReason": lambda n : setattr(self, 'failure_reason', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "status": lambda n : setattr(self, 'status', n.get_str_value()),
+            "title": lambda n : setattr(self, 'title', n.get_str_value()),
+            "type": lambda n : setattr(self, 'type', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("actorName", self.actor_name)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_str_value("details", self.details)
+        writer.write_str_value("failureReason", self.failure_reason)
+        writer.write_str_value("id", self.id)
+        writer.write_str_value("status", self.status)
+        writer.write_str_value("title", self.title)
+        writer.write_str_value("type", self.type)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/admin_enablement_override.py

@@ -0,0 +1,60 @@
+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 AdminEnablementOverride(AdditionalDataHolder, Parsable):
+    # 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 enabled property
+    enabled: Optional[bool] = None
+    # The reason property
+    reason: Optional[str] = None
+    # The updatedAt property
+    updated_at: Optional[datetime.datetime] = None
+    # The updatedByUserId property
+    updated_by_user_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> 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: AdminEnablementOverride
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AdminEnablementOverride()
+    
+    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]] = {
+            "enabled": lambda n : setattr(self, 'enabled', n.get_bool_value()),
+            "reason": lambda n : setattr(self, 'reason', n.get_str_value()),
+            "updatedAt": lambda n : setattr(self, 'updated_at', n.get_datetime_value()),
+            "updatedByUserId": lambda n : setattr(self, 'updated_by_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_bool_value("enabled", self.enabled)
+        writer.write_str_value("reason", self.reason)
+        writer.write_datetime_value("updatedAt", self.updated_at)
+        writer.write_str_value("updatedByUserId", self.updated_by_user_id)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/analytics_comparison.py

@@ -0,0 +1,55 @@
+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 AnalyticsComparison(AdditionalDataHolder, Parsable):
+    # 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 current property
+    current: Optional[float] = None
+    # The direction property
+    direction: Optional[str] = None
+    # The previous property
+    previous: Optional[float] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AnalyticsComparison:
+        """
+        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: AnalyticsComparison
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AnalyticsComparison()
+    
+    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]] = {
+            "current": lambda n : setattr(self, 'current', n.get_float_value()),
+            "direction": lambda n : setattr(self, 'direction', n.get_str_value()),
+            "previous": lambda n : setattr(self, 'previous', n.get_float_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_float_value("current", self.current)
+        writer.write_str_value("direction", self.direction)
+        writer.write_float_value("previous", self.previous)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/analytics_date_range.py

@@ -0,0 +1,56 @@
+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 AnalyticsDateRange(AdditionalDataHolder, Parsable):
+    # 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 bucketSize property
+    bucket_size: Optional[int] = None
+    # The endAt property
+    end_at: Optional[datetime.datetime] = None
+    # The startAt property
+    start_at: Optional[datetime.datetime] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AnalyticsDateRange:
+        """
+        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: AnalyticsDateRange
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AnalyticsDateRange()
+    
+    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]] = {
+            "bucketSize": lambda n : setattr(self, 'bucket_size', n.get_int_value()),
+            "endAt": lambda n : setattr(self, 'end_at', n.get_datetime_value()),
+            "startAt": lambda n : setattr(self, 'start_at', n.get_datetime_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_int_value("bucketSize", self.bucket_size)
+        writer.write_datetime_value("endAt", self.end_at)
+        writer.write_datetime_value("startAt", self.start_at)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/analytics_trend_point_ofdecimal.py

@@ -0,0 +1,60 @@
+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 AnalyticsTrendPointOfdecimal(AdditionalDataHolder, Parsable):
+    # 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 endAt property
+    end_at: Optional[datetime.datetime] = None
+    # The label property
+    label: Optional[str] = None
+    # The startAt property
+    start_at: Optional[datetime.datetime] = None
+    # The value property
+    value: Optional[float] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AnalyticsTrendPointOfdecimal:
+        """
+        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: AnalyticsTrendPointOfdecimal
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AnalyticsTrendPointOfdecimal()
+    
+    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]] = {
+            "endAt": lambda n : setattr(self, 'end_at', n.get_datetime_value()),
+            "label": lambda n : setattr(self, 'label', n.get_str_value()),
+            "startAt": lambda n : setattr(self, 'start_at', n.get_datetime_value()),
+            "value": lambda n : setattr(self, 'value', n.get_float_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("endAt", self.end_at)
+        writer.write_str_value("label", self.label)
+        writer.write_datetime_value("startAt", self.start_at)
+        writer.write_float_value("value", self.value)
+        writer.write_additional_data_value(self.additional_data)
+    
+