leadping 1.0.87__tar.gz → 1.0.89__tar.gz

{leadping-1.0.87/leadping.egg-info → leadping-1.0.89}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leadping
-Version: 1.0.87
+Version: 1.0.89
 Summary: Typed Python client for the Leadping API, generated from the Leadping OpenAPI document with Microsoft Kiota.
 Home-page: https://github.com/leadpingai/leadping-python
 Author: Leadping

{leadping-1.0.87 → leadping-1.0.89/leadping.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: leadping
-Version: 1.0.87
+Version: 1.0.89
 Summary: Typed Python client for the Leadping API, generated from the Leadping OpenAPI document with Microsoft Kiota.
 Home-page: https://github.com/leadpingai/leadping-python
 Author: Leadping

{leadping-1.0.87 → leadping-1.0.89}/leadping.egg-info/SOURCES.txt

@@ -92,6 +92,7 @@ setup.py
 ./models/activation_telephony_status.py
 ./models/activation_timeline_event.py
 ./models/activation_timeline_event_actor.py
+./models/admin_demo_preferences.py
 ./models/analytics_comparison.py
 ./models/analytics_coverage.py
 ./models/analytics_date_range.py
@@ -482,6 +483,7 @@ setup.py
 ./models/user_request.py
 ./models/user_request_notification_preferences.py
 ./models/user_response.py
+./models/user_response_admin_demo_preferences.py
 ./models/user_response_billing_plan.py
 ./models/user_response_billing_state.py
 ./models/user_response_compliance.py
@@ -570,6 +572,9 @@ setup.py
 ./tags/tags_request_builder.py
 ./tags/item/tags_item_request_builder.py
 ./telephony/telephony_request_builder.py
+./telephony/availability/availability_request_builder.py
+./telephony/availability/item/with_device_item_request_builder.py
+./telephony/incoming_caller/incoming_caller_request_builder.py
 ./telephony/login/login_request_builder.py
 ./transactions/transactions_request_builder.py
 ./transactions/all/all_request_builder.py
@@ -682,6 +687,7 @@ models/activation_subscription_status.py
 models/activation_telephony_status.py
 models/activation_timeline_event.py
 models/activation_timeline_event_actor.py
+models/admin_demo_preferences.py
 models/analytics_comparison.py
 models/analytics_coverage.py
 models/analytics_date_range.py
@@ -1072,6 +1078,7 @@ models/user_notification_preferences_sms_consent_certificate.py
 models/user_request.py
 models/user_request_notification_preferences.py
 models/user_response.py
+models/user_response_admin_demo_preferences.py
 models/user_response_billing_plan.py
 models/user_response_billing_state.py
 models/user_response_compliance.py
@@ -1160,6 +1167,9 @@ suppressions/release/release_request_builder.py
 tags/tags_request_builder.py
 tags/item/tags_item_request_builder.py
 telephony/telephony_request_builder.py
+telephony/availability/availability_request_builder.py
+telephony/availability/item/with_device_item_request_builder.py
+telephony/incoming_caller/incoming_caller_request_builder.py
 telephony/login/login_request_builder.py
 transactions/transactions_request_builder.py
 transactions/all/all_request_builder.py

leadping-1.0.89/models/admin_demo_preferences.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 AdminDemoPreferences(AdditionalDataHolder, Parsable):
+    """
+    Controls demo presentation for an individual platform admin.
+    """
+    # 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 showDemoData property
+    show_demo_data: Optional[bool] = None
+    # The showDemoMarkers property
+    show_demo_markers: Optional[bool] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> AdminDemoPreferences:
+        """
+        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: AdminDemoPreferences
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return AdminDemoPreferences()
+    
+    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]] = {
+            "showDemoData": lambda n : setattr(self, 'show_demo_data', n.get_bool_value()),
+            "showDemoMarkers": lambda n : setattr(self, 'show_demo_markers', 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_bool_value("showDemoData", self.show_demo_data)
+        writer.write_bool_value("showDemoMarkers", self.show_demo_markers)
+        writer.write_additional_data_value(self.additional_data)
+    
+

{leadping-1.0.87 → leadping-1.0.89}/models/phone_call_response.py

@@ -27,6 +27,8 @@ class PhoneCallResponse(AdditionalDataHolder, Parsable):
     billing_status: Optional[str] = None
     # Server-approved parameters for one outbound browser call.
     browser_call_approval: Optional[PhoneCallResponse_browserCallApproval] = None
+    # Provider session identity used to correlate device invitations and server lifecycle events.
+    call_session_id: Optional[str] = None
     # Caller ID phone number presented during the outbound call.
     caller_id: Optional[str] = None
     # Messaging campaign identifier associated with this phone call.
@@ -53,6 +55,8 @@ class PhoneCallResponse(AdditionalDataHolder, Parsable):
     is_demo: Optional[bool] = None
     # Lead ID associated with the call conversation or outreach attempt.
     lead_id: Optional[str] = None
+    # The matched lead's display name, when the caller belongs to a known lead.
+    lead_name: Optional[str] = None
     # UTC timestamp when the resource was last modified, or null when it has not been updated.
     modified_at: Optional[datetime.datetime] = None
     # The organization context required to handle this call on a mobile device.
@@ -109,6 +113,7 @@ class PhoneCallResponse(AdditionalDataHolder, Parsable):
             "billableAmount": lambda n : setattr(self, 'billable_amount', n.get_float_value()),
             "billingStatus": lambda n : setattr(self, 'billing_status', n.get_str_value()),
             "browserCallApproval": lambda n : setattr(self, 'browser_call_approval', n.get_object_value(PhoneCallResponse_browserCallApproval)),
+            "callSessionId": lambda n : setattr(self, 'call_session_id', n.get_str_value()),
             "callerId": lambda n : setattr(self, 'caller_id', n.get_str_value()),
             "campaignId": lambda n : setattr(self, 'campaign_id', n.get_str_value()),
             "consoleEntries": lambda n : setattr(self, 'console_entries', n.get_collection_of_object_values(CommunicationConsoleEntry)),
@@ -122,6 +127,7 @@ class PhoneCallResponse(AdditionalDataHolder, Parsable):
             "id": lambda n : setattr(self, 'id', n.get_str_value()),
             "isDemo": lambda n : setattr(self, 'is_demo', n.get_bool_value()),
             "leadId": lambda n : setattr(self, 'lead_id', n.get_str_value()),
+            "leadName": lambda n : setattr(self, 'lead_name', n.get_str_value()),
             "modifiedAt": lambda n : setattr(self, 'modified_at', n.get_datetime_value()),
             "organizationId": lambda n : setattr(self, 'organization_id', n.get_str_value()),
             "phoneNumber": lambda n : setattr(self, 'phone_number', n.get_str_value()),
@@ -149,6 +155,7 @@ class PhoneCallResponse(AdditionalDataHolder, Parsable):
         writer.write_float_value("billableAmount", self.billable_amount)
         writer.write_str_value("billingStatus", self.billing_status)
         writer.write_object_value("browserCallApproval", self.browser_call_approval)
+        writer.write_str_value("callSessionId", self.call_session_id)
         writer.write_str_value("callerId", self.caller_id)
         writer.write_str_value("campaignId", self.campaign_id)
         writer.write_collection_of_object_values("consoleEntries", self.console_entries)
@@ -162,6 +169,7 @@ class PhoneCallResponse(AdditionalDataHolder, Parsable):
         writer.write_str_value("id", self.id)
         writer.write_bool_value("isDemo", self.is_demo)
         writer.write_str_value("leadId", self.lead_id)
+        writer.write_str_value("leadName", self.lead_name)
         writer.write_datetime_value("modifiedAt", self.modified_at)
         writer.write_str_value("organizationId", self.organization_id)
         writer.write_str_value("phoneNumber", self.phone_number)

{leadping-1.0.87 → leadping-1.0.89}/models/telephony_login_request.py

@@ -17,6 +17,8 @@ class TelephonyLoginRequest(AdditionalDataHolder, Parsable):
 
     # Provides a compact API reference to another resource using its stable identifier and human-readable display name.
     device: Optional[TelephonyLoginRequest_device] = None
+    # Includes credentials for receiving calls to the authenticated organization.
+    include_incoming: Optional[bool] = None
     
     @staticmethod
     def create_from_discriminator_value(parse_node: ParseNode) -> TelephonyLoginRequest:
@@ -40,6 +42,7 @@ class TelephonyLoginRequest(AdditionalDataHolder, Parsable):
 
         fields: dict[str, Callable[[Any], None]] = {
             "device": lambda n : setattr(self, 'device', n.get_object_value(TelephonyLoginRequest_device)),
+            "includeIncoming": lambda n : setattr(self, 'include_incoming', n.get_bool_value()),
         }
         return fields
     
@@ -52,6 +55,7 @@ class TelephonyLoginRequest(AdditionalDataHolder, Parsable):
         if writer is None:
             raise TypeError("writer cannot be null.")
         writer.write_object_value("device", self.device)
+        writer.write_bool_value("includeIncoming", self.include_incoming)
         writer.write_additional_data_value(self.additional_data)
     
 

{leadping-1.0.87 → leadping-1.0.89}/models/telephony_login_response.py

@@ -17,6 +17,10 @@ class TelephonyLoginResponse(AdditionalDataHolder, Parsable):
     callback_token: Optional[str] = None
     # UTC timestamp for expires at on this telephony login.
     expires_at: Optional[datetime.datetime] = None
+    # Password for the organization's incoming SIP connection, when requested and configured.
+    incoming_password: Optional[str] = None
+    # Username for the organization's incoming SIP connection, when requested and configured.
+    incoming_username: Optional[str] = None
     # Password for this telephony login.
     password: Optional[str] = None
     # Username for this telephony login.
@@ -41,6 +45,8 @@ class TelephonyLoginResponse(AdditionalDataHolder, Parsable):
         fields: dict[str, Callable[[Any], None]] = {
             "callbackToken": lambda n : setattr(self, 'callback_token', n.get_str_value()),
             "expiresAt": lambda n : setattr(self, 'expires_at', n.get_datetime_value()),
+            "incomingPassword": lambda n : setattr(self, 'incoming_password', n.get_str_value()),
+            "incomingUsername": lambda n : setattr(self, 'incoming_username', n.get_str_value()),
             "password": lambda n : setattr(self, 'password', n.get_str_value()),
             "username": lambda n : setattr(self, 'username', n.get_str_value()),
         }
@@ -56,6 +62,8 @@ class TelephonyLoginResponse(AdditionalDataHolder, Parsable):
             raise TypeError("writer cannot be null.")
         writer.write_str_value("callbackToken", self.callback_token)
         writer.write_datetime_value("expiresAt", self.expires_at)
+        writer.write_str_value("incomingPassword", self.incoming_password)
+        writer.write_str_value("incomingUsername", self.incoming_username)
         writer.write_str_value("password", self.password)
         writer.write_str_value("username", self.username)
         writer.write_additional_data_value(self.additional_data)

{leadping-1.0.87 → leadping-1.0.89}/models/user_response.py

@@ -7,6 +7,7 @@ from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
     from .mobile_device_preferences import MobileDevicePreferences
+    from .user_response_admin_demo_preferences import UserResponse_adminDemoPreferences
     from .user_response_billing_plan import UserResponse_billingPlan
     from .user_response_billing_state import UserResponse_billingState
     from .user_response_compliance import UserResponse_compliance
@@ -22,6 +23,8 @@ class UserResponse(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)
 
+    # Controls demo presentation for an individual platform admin.
+    admin_demo_preferences: Optional[UserResponse_adminDemoPreferences] = None
     # Identifies the Leadping subscription plan that determines organization features, allowances, and billing behavior.
     billing_plan: Optional[UserResponse_billingPlan] = None
     # Customer-safe billing state for a Leadping organization.
@@ -86,6 +89,7 @@ class UserResponse(AdditionalDataHolder, Parsable):
         Returns: dict[str, Callable[[ParseNode], None]]
         """
         from .mobile_device_preferences import MobileDevicePreferences
+        from .user_response_admin_demo_preferences import UserResponse_adminDemoPreferences
         from .user_response_billing_plan import UserResponse_billingPlan
         from .user_response_billing_state import UserResponse_billingState
         from .user_response_compliance import UserResponse_compliance
@@ -94,6 +98,7 @@ class UserResponse(AdditionalDataHolder, Parsable):
         from .user_response_subscription_status import UserResponse_subscriptionStatus
 
         from .mobile_device_preferences import MobileDevicePreferences
+        from .user_response_admin_demo_preferences import UserResponse_adminDemoPreferences
         from .user_response_billing_plan import UserResponse_billingPlan
         from .user_response_billing_state import UserResponse_billingState
         from .user_response_compliance import UserResponse_compliance
@@ -102,6 +107,7 @@ class UserResponse(AdditionalDataHolder, Parsable):
         from .user_response_subscription_status import UserResponse_subscriptionStatus
 
         fields: dict[str, Callable[[Any], None]] = {
+            "adminDemoPreferences": lambda n : setattr(self, 'admin_demo_preferences', n.get_object_value(UserResponse_adminDemoPreferences)),
             "billingPlan": lambda n : setattr(self, 'billing_plan', n.get_enum_value(UserResponse_billingPlan)),
             "billingState": lambda n : setattr(self, 'billing_state', n.get_object_value(UserResponse_billingState)),
             "compliance": lambda n : setattr(self, 'compliance', n.get_object_value(UserResponse_compliance)),
@@ -136,6 +142,7 @@ class UserResponse(AdditionalDataHolder, Parsable):
         """
         if writer is None:
             raise TypeError("writer cannot be null.")
+        writer.write_object_value("adminDemoPreferences", self.admin_demo_preferences)
         writer.write_enum_value("billingPlan", self.billing_plan)
         writer.write_object_value("billingState", self.billing_state)
         writer.write_object_value("compliance", self.compliance)

leadping-1.0.89/models/user_response_admin_demo_preferences.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .admin_demo_preferences import AdminDemoPreferences
+
+from .admin_demo_preferences import AdminDemoPreferences
+
+@dataclass
+class UserResponse_adminDemoPreferences(AdminDemoPreferences, Parsable):
+    """
+    Controls demo presentation for an individual platform admin.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserResponse_adminDemoPreferences:
+        """
+        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: UserResponse_adminDemoPreferences
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserResponse_adminDemoPreferences()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .admin_demo_preferences import AdminDemoPreferences
+
+        from .admin_demo_preferences import AdminDemoPreferences
+
+        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-1.0.89/telephony/availability/availability_request_builder.py

@@ -0,0 +1,95 @@
+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.problem_details import ProblemDetails
+    from .item.with_device_item_request_builder import WithDeviceItemRequestBuilder
+
+class AvailabilityRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /telephony/availability
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None:
+        """
+        Instantiates a new AvailabilityRequestBuilder 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}/telephony/availability", path_parameters)
+    
+    def by_device_id(self,device_id: str) -> WithDeviceItemRequestBuilder:
+        """
+        Gets an item from the leadping.telephony.availability.item collection
+        param device_id: The GUID identifying the calling device.
+        Returns: WithDeviceItemRequestBuilder
+        """
+        if device_id is None:
+            raise TypeError("device_id cannot be null.")
+        from .item.with_device_item_request_builder import WithDeviceItemRequestBuilder
+
+        url_tpl_params = get_path_parameters(self.path_parameters)
+        url_tpl_params["deviceId"] = device_id
+        return WithDeviceItemRequestBuilder(self.request_adapter, url_tpl_params)
+    
+    async def get(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bytes]:
+        """
+        Returns whether the authenticated user can currently receive an incoming call.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: bytes
+        """
+        request_info = self.to_get_request_information(
+            request_configuration
+        )
+        from ...models.problem_details import ProblemDetails
+
+        error_mapping: dict[str, type[ParsableFactory]] = {
+            "401": ProblemDetails,
+            "403": ProblemDetails,
+            "429": ProblemDetails,
+        }
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping)
+    
+    def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation:
+        """
+        Returns whether the authenticated user can currently receive an incoming call.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: RequestInformation
+        """
+        request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters)
+        request_info.configure(request_configuration)
+        request_info.headers.try_add("Accept", "application/problem+json")
+        return request_info
+    
+    def with_url(self,raw_url: str) -> AvailabilityRequestBuilder:
+        """
+        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: AvailabilityRequestBuilder
+        """
+        if raw_url is None:
+            raise TypeError("raw_url cannot be null.")
+        return AvailabilityRequestBuilder(self.request_adapter, raw_url)
+    
+    @dataclass
+    class AvailabilityRequestBuilderGetRequestConfiguration(RequestConfiguration[QueryParameters]):
+        """
+        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-1.0.89/telephony/availability/item/with_device_item_request_builder.py

@@ -0,0 +1,89 @@
+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.problem_details import ProblemDetails
+
+class WithDeviceItemRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /telephony/availability/{deviceId}
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None:
+        """
+        Instantiates a new WithDeviceItemRequestBuilder 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}/telephony/availability/{deviceId}{?busy*}", path_parameters)
+    
+    async def post(self,request_configuration: Optional[RequestConfiguration[WithDeviceItemRequestBuilderPostQueryParameters]] = None) -> Optional[bytes]:
+        """
+        Updates the busy state of a calling device for the authenticated user and returns whether the update succeeded.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: bytes
+        """
+        request_info = self.to_post_request_information(
+            request_configuration
+        )
+        from ....models.problem_details import ProblemDetails
+
+        error_mapping: dict[str, type[ParsableFactory]] = {
+            "401": ProblemDetails,
+            "403": ProblemDetails,
+            "429": ProblemDetails,
+        }
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping)
+    
+    def to_post_request_information(self,request_configuration: Optional[RequestConfiguration[WithDeviceItemRequestBuilderPostQueryParameters]] = None) -> RequestInformation:
+        """
+        Updates the busy state of a calling device for the authenticated user and returns whether the update succeeded.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: RequestInformation
+        """
+        request_info = RequestInformation(Method.POST, self.url_template, self.path_parameters)
+        request_info.configure(request_configuration)
+        request_info.headers.try_add("Accept", "application/problem+json")
+        return request_info
+    
+    def with_url(self,raw_url: str) -> WithDeviceItemRequestBuilder:
+        """
+        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: WithDeviceItemRequestBuilder
+        """
+        if raw_url is None:
+            raise TypeError("raw_url cannot be null.")
+        return WithDeviceItemRequestBuilder(self.request_adapter, raw_url)
+    
+    @dataclass
+    class WithDeviceItemRequestBuilderPostQueryParameters():
+        """
+        Updates the busy state of a calling device for the authenticated user and returns whether the update succeeded.
+        """
+        # Whether the device is currently busy with a call.
+        busy: Optional[bool] = None
+
+    
+    @dataclass
+    class WithDeviceItemRequestBuilderPostRequestConfiguration(RequestConfiguration[WithDeviceItemRequestBuilderPostQueryParameters]):
+        """
+        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-1.0.89/telephony/incoming_caller/incoming_caller_request_builder.py

@@ -0,0 +1,101 @@
+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.problem_details import ProblemDetails
+
+class IncomingCallerRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /telephony/incoming-caller
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None:
+        """
+        Instantiates a new IncomingCallerRequestBuilder 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}/telephony/incoming-caller{?phoneNumber*}", path_parameters)
+    
+    async def get(self,request_configuration: Optional[RequestConfiguration[IncomingCallerRequestBuilderGetQueryParameters]] = None) -> Optional[bytes]:
+        """
+        Finds a lead in the current organization by the caller's normalized primary phone number. Returns an empty lead identity when no matching lead exists.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: bytes
+        """
+        request_info = self.to_get_request_information(
+            request_configuration
+        )
+        from ...models.problem_details import ProblemDetails
+
+        error_mapping: dict[str, type[ParsableFactory]] = {
+            "401": ProblemDetails,
+            "403": ProblemDetails,
+            "429": ProblemDetails,
+        }
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        return await self.request_adapter.send_primitive_async(request_info, "bytes", error_mapping)
+    
+    def to_get_request_information(self,request_configuration: Optional[RequestConfiguration[IncomingCallerRequestBuilderGetQueryParameters]] = None) -> RequestInformation:
+        """
+        Finds a lead in the current organization by the caller's normalized primary phone number. Returns an empty lead identity when no matching lead exists.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: RequestInformation
+        """
+        request_info = RequestInformation(Method.GET, self.url_template, self.path_parameters)
+        request_info.configure(request_configuration)
+        request_info.headers.try_add("Accept", "application/problem+json")
+        return request_info
+    
+    def with_url(self,raw_url: str) -> IncomingCallerRequestBuilder:
+        """
+        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: IncomingCallerRequestBuilder
+        """
+        if raw_url is None:
+            raise TypeError("raw_url cannot be null.")
+        return IncomingCallerRequestBuilder(self.request_adapter, raw_url)
+    
+    @dataclass
+    class IncomingCallerRequestBuilderGetQueryParameters():
+        """
+        Finds a lead in the current organization by the caller's normalized primary phone number. Returns an empty lead identity when no matching lead exists.
+        """
+        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 == "phone_number":
+                return "phoneNumber"
+            return original_name
+        
+        # The incoming caller's phone number to normalize and match against organization leads.
+        phone_number: Optional[str] = None
+
+    
+    @dataclass
+    class IncomingCallerRequestBuilderGetRequestConfiguration(RequestConfiguration[IncomingCallerRequestBuilderGetQueryParameters]):
+        """
+        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-1.0.87 → leadping-1.0.89}/telephony/telephony_request_builder.py

@@ -6,6 +6,8 @@ from kiota_abstractions.request_adapter import RequestAdapter
 from typing import Any, Optional, TYPE_CHECKING, Union
 
 if TYPE_CHECKING:
+    from .availability.availability_request_builder import AvailabilityRequestBuilder
+    from .incoming_caller.incoming_caller_request_builder import IncomingCallerRequestBuilder
     from .login.login_request_builder import LoginRequestBuilder
 
 class TelephonyRequestBuilder(BaseRequestBuilder):
@@ -21,6 +23,24 @@ class TelephonyRequestBuilder(BaseRequestBuilder):
         """
         super().__init__(request_adapter, "{+baseurl}/telephony", path_parameters)
     
+    @property
+    def availability(self) -> AvailabilityRequestBuilder:
+        """
+        The availability property
+        """
+        from .availability.availability_request_builder import AvailabilityRequestBuilder
+
+        return AvailabilityRequestBuilder(self.request_adapter, self.path_parameters)
+    
+    @property
+    def incoming_caller(self) -> IncomingCallerRequestBuilder:
+        """
+        The incomingCaller property
+        """
+        from .incoming_caller.incoming_caller_request_builder import IncomingCallerRequestBuilder
+
+        return IncomingCallerRequestBuilder(self.request_adapter, self.path_parameters)
+    
     @property
     def login(self) -> LoginRequestBuilder:
         """