leadping 1.0.0__py3-none-any.whl

leadping/models/user_stripe_info_dunning.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 .user_dunning_info import UserDunningInfo
+
+from .user_dunning_info import UserDunningInfo
+
+@dataclass
+class UserStripeInfo_dunning(UserDunningInfo, Parsable):
+    """
+    The active dunning state after a failed recurring payment.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserStripeInfo_dunning:
+        """
+        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: UserStripeInfo_dunning
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserStripeInfo_dunning()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .user_dunning_info import UserDunningInfo
+
+        from .user_dunning_info import UserDunningInfo
+
+        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/user_subscription_cancellation_info.py

@@ -0,0 +1,83 @@
+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 UserSubscriptionCancellationInfo(AdditionalDataHolder, Parsable):
+    """
+    Captured subscription cancellation feedback for retention and churn analysis.
+    """
+    # 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)
+
+    # Whether the cancellation was scheduled for period end.
+    cancel_at_period_end: Optional[bool] = None
+    # The competitor named by the user, when applicable.
+    competitor: Optional[str] = None
+    # The missing feature named by the user, when applicable.
+    missing_feature: Optional[str] = None
+    # Additional cancellation notes supplied by the user.
+    notes: Optional[str] = None
+    # The human-readable cancellation reason selected by the user.
+    reason: Optional[str] = None
+    # The normalized cancellation reason code selected by the user.
+    reason_code: Optional[str] = None
+    # The date and time when cancellation was requested.
+    requested_at: Optional[datetime.datetime] = None
+    # The user who requested cancellation.
+    requested_by_user_id: Optional[str] = None
+    # The technical issue details supplied by the user, when applicable.
+    technical_issues: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> UserSubscriptionCancellationInfo:
+        """
+        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: UserSubscriptionCancellationInfo
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return UserSubscriptionCancellationInfo()
+    
+    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]] = {
+            "cancelAtPeriodEnd": lambda n : setattr(self, 'cancel_at_period_end', n.get_bool_value()),
+            "competitor": lambda n : setattr(self, 'competitor', n.get_str_value()),
+            "missingFeature": lambda n : setattr(self, 'missing_feature', n.get_str_value()),
+            "notes": lambda n : setattr(self, 'notes', n.get_str_value()),
+            "reason": lambda n : setattr(self, 'reason', n.get_str_value()),
+            "reasonCode": lambda n : setattr(self, 'reason_code', n.get_str_value()),
+            "requestedAt": lambda n : setattr(self, 'requested_at', n.get_datetime_value()),
+            "requestedByUserId": lambda n : setattr(self, 'requested_by_user_id', n.get_str_value()),
+            "technicalIssues": lambda n : setattr(self, 'technical_issues', 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("cancelAtPeriodEnd", self.cancel_at_period_end)
+        writer.write_str_value("competitor", self.competitor)
+        writer.write_str_value("missingFeature", self.missing_feature)
+        writer.write_str_value("notes", self.notes)
+        writer.write_str_value("reason", self.reason)
+        writer.write_str_value("reasonCode", self.reason_code)
+        writer.write_datetime_value("requestedAt", self.requested_at)
+        writer.write_str_value("requestedByUserId", self.requested_by_user_id)
+        writer.write_str_value("technicalIssues", self.technical_issues)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/wallet_response.py

@@ -0,0 +1,121 @@
+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 .wallet_response_credit_status import WalletResponse_creditStatus
+    from .wallet_response_source_type import WalletResponse_sourceType
+
+@dataclass
+class WalletResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing wallet data returned to callers.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The date and time for the balance calculated at value on this wallet.
+    balance_calculated_at: Optional[datetime.datetime] = None
+    # The businessId property
+    business_id: Optional[str] = None
+    # The date and time when the entity was created.
+    created_at: Optional[datetime.datetime] = None
+    # Defines the lifecycle state for a wallet credit lot.
+    credit_status: Optional[WalletResponse_creditStatus] = None
+    # The currency property
+    currency: Optional[str] = None
+    # The expiresAt property
+    expires_at: Optional[datetime.datetime] = None
+    # The unique identifier for the entity.
+    id: Optional[str] = None
+    # The date and time when the entity was last modified, if applicable.
+    modified_at: Optional[datetime.datetime] = None
+    # The display name for the entity.
+    name: Optional[str] = None
+    # The nextCreditExpirationAt property
+    next_credit_expiration_at: Optional[datetime.datetime] = None
+    # The originalTransactionId property
+    original_transaction_id: Optional[str] = None
+    # The purchasedAt property
+    purchased_at: Optional[datetime.datetime] = None
+    # Defines the source that created a wallet credit lot.
+    source_type: Optional[WalletResponse_sourceType] = None
+    # The stripeChargeId property
+    stripe_charge_id: Optional[str] = None
+    # The stripeInvoiceId property
+    stripe_invoice_id: Optional[str] = None
+    # The stripePaymentIntentId property
+    stripe_payment_intent_id: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> WalletResponse:
+        """
+        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: WalletResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return WalletResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .wallet_response_credit_status import WalletResponse_creditStatus
+        from .wallet_response_source_type import WalletResponse_sourceType
+
+        from .wallet_response_credit_status import WalletResponse_creditStatus
+        from .wallet_response_source_type import WalletResponse_sourceType
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "balanceCalculatedAt": lambda n : setattr(self, 'balance_calculated_at', n.get_datetime_value()),
+            "businessId": lambda n : setattr(self, 'business_id', n.get_str_value()),
+            "createdAt": lambda n : setattr(self, 'created_at', n.get_datetime_value()),
+            "creditStatus": lambda n : setattr(self, 'credit_status', n.get_enum_value(WalletResponse_creditStatus)),
+            "currency": lambda n : setattr(self, 'currency', n.get_str_value()),
+            "expiresAt": lambda n : setattr(self, 'expires_at', n.get_datetime_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "modifiedAt": lambda n : setattr(self, 'modified_at', n.get_datetime_value()),
+            "name": lambda n : setattr(self, 'name', n.get_str_value()),
+            "nextCreditExpirationAt": lambda n : setattr(self, 'next_credit_expiration_at', n.get_datetime_value()),
+            "originalTransactionId": lambda n : setattr(self, 'original_transaction_id', n.get_str_value()),
+            "purchasedAt": lambda n : setattr(self, 'purchased_at', n.get_datetime_value()),
+            "sourceType": lambda n : setattr(self, 'source_type', n.get_enum_value(WalletResponse_sourceType)),
+            "stripeChargeId": lambda n : setattr(self, 'stripe_charge_id', n.get_str_value()),
+            "stripeInvoiceId": lambda n : setattr(self, 'stripe_invoice_id', n.get_str_value()),
+            "stripePaymentIntentId": lambda n : setattr(self, 'stripe_payment_intent_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_datetime_value("balanceCalculatedAt", self.balance_calculated_at)
+        writer.write_str_value("businessId", self.business_id)
+        writer.write_datetime_value("createdAt", self.created_at)
+        writer.write_enum_value("creditStatus", self.credit_status)
+        writer.write_str_value("currency", self.currency)
+        writer.write_datetime_value("expiresAt", self.expires_at)
+        writer.write_str_value("id", self.id)
+        writer.write_datetime_value("modifiedAt", self.modified_at)
+        writer.write_str_value("name", self.name)
+        writer.write_datetime_value("nextCreditExpirationAt", self.next_credit_expiration_at)
+        writer.write_str_value("originalTransactionId", self.original_transaction_id)
+        writer.write_datetime_value("purchasedAt", self.purchased_at)
+        writer.write_enum_value("sourceType", self.source_type)
+        writer.write_str_value("stripeChargeId", self.stripe_charge_id)
+        writer.write_str_value("stripeInvoiceId", self.stripe_invoice_id)
+        writer.write_str_value("stripePaymentIntentId", self.stripe_payment_intent_id)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/wallet_response_credit_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class WalletResponse_creditStatus(str, Enum):
+    Active = "active",
+    Consumed = "consumed",
+    Expired = "expired",
+    Refunded = "refunded",
+    Voided = "voided",
+    Disputed = "disputed",
+

leadping/models/wallet_response_source_type.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class WalletResponse_sourceType(str, Enum):
+    Purchase = "purchase",
+    Promo = "promo",
+    Admin_adjustment = "admin_adjustment",
+    Refund_adjustment = "refund_adjustment",
+    Migration = "migration",
+    Chargeback_reversal = "chargeback_reversal",
+    Compromise_restoration = "compromise_restoration",
+

leadping/models/website_lifecycle_status.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class WebsiteLifecycleStatus(str, Enum):
+    NotStarted = "NotStarted",
+    DomainSuggestionsPending = "DomainSuggestionsPending",
+    DomainSelectionPending = "DomainSelectionPending",
+    DomainPurchasePending = "DomainPurchasePending",
+    DomainPurchased = "DomainPurchased",
+    WebsiteGenerationQueued = "WebsiteGenerationQueued",
+    WebsiteGenerating = "WebsiteGenerating",
+    WebsiteDeploymentQueued = "WebsiteDeploymentQueued",
+    WebsiteDeploying = "WebsiteDeploying",
+    WebsiteLive = "WebsiteLive",
+    WebsiteFailed = "WebsiteFailed",
+    ManuallyBypassed = "ManuallyBypassed",
+

leadping/notifications/announcements/announcements_request_builder.py

@@ -0,0 +1,90 @@
+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.paged_result_of_notification_table_row import PagedResultOfNotificationTableRow
+    from ...models.problem_details import ProblemDetails
+    from ...models.request_data_options import RequestDataOptions
+
+class AnnouncementsRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /notifications/announcements
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None:
+        """
+        Instantiates a new AnnouncementsRequestBuilder 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}/notifications/announcements", path_parameters)
+    
+    async def post(self,body: RequestDataOptions, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[PagedResultOfNotificationTableRow]:
+        """
+        Lists announcement notifications for the current user with paging and filters for release notes, notices, and operational updates.
+        param body: Options for flexible, efficient, and explicit querying in Cosmos DB or similar repositories.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: Optional[PagedResultOfNotificationTableRow]
+        """
+        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,
+            "500": ProblemDetails,
+        }
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        from ...models.paged_result_of_notification_table_row import PagedResultOfNotificationTableRow
+
+        return await self.request_adapter.send_async(request_info, PagedResultOfNotificationTableRow, error_mapping)
+    
+    def to_post_request_information(self,body: RequestDataOptions, request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation:
+        """
+        Lists announcement notifications for the current user with paging and filters for release notes, notices, and operational updates.
+        param body: Options for flexible, efficient, and explicit querying in Cosmos DB or similar repositories.
+        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) -> AnnouncementsRequestBuilder:
+        """
+        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: AnnouncementsRequestBuilder
+        """
+        if raw_url is None:
+            raise TypeError("raw_url cannot be null.")
+        return AnnouncementsRequestBuilder(self.request_adapter, raw_url)
+    
+    @dataclass
+    class AnnouncementsRequestBuilderPostRequestConfiguration(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/notifications/item/mark_read/mark_read_request_builder.py

@@ -0,0 +1,80 @@
+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 MarkReadRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /notifications/{id}/mark-read
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None:
+        """
+        Instantiates a new MarkReadRequestBuilder 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}/notifications/{id}/mark-read", path_parameters)
+    
+    async def post(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[bool]:
+        """
+        Marks one current-user notification as read so it no longer contributes to unread counts or active notification lists.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: Optional[bool]
+        """
+        request_info = self.to_post_request_information(
+            request_configuration
+        )
+        from ....models.problem_details import ProblemDetails
+
+        error_mapping: dict[str, type[ParsableFactory]] = {
+            "400": ProblemDetails,
+            "404": ProblemDetails,
+            "500": ProblemDetails,
+        }
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        return await self.request_adapter.send_primitive_async(request_info, "bool", error_mapping)
+    
+    def to_post_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation:
+        """
+        Marks one current-user notification as read so it no longer contributes to unread counts or active notification lists.
+        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/json")
+        return request_info
+    
+    def with_url(self,raw_url: str) -> MarkReadRequestBuilder:
+        """
+        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: MarkReadRequestBuilder
+        """
+        if raw_url is None:
+            raise TypeError("raw_url cannot be null.")
+        return MarkReadRequestBuilder(self.request_adapter, raw_url)
+    
+    @dataclass
+    class MarkReadRequestBuilderPostRequestConfiguration(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/notifications/item/notifications_item_request_builder.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+from collections.abc import Callable
+from kiota_abstractions.base_request_builder import BaseRequestBuilder
+from kiota_abstractions.get_path_parameters import get_path_parameters
+from kiota_abstractions.request_adapter import RequestAdapter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .mark_read.mark_read_request_builder import MarkReadRequestBuilder
+
+class NotificationsItemRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /notifications/{id}
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None:
+        """
+        Instantiates a new NotificationsItemRequestBuilder 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}/notifications/{id}", path_parameters)
+    
+    @property
+    def mark_read(self) -> MarkReadRequestBuilder:
+        """
+        The markRead property
+        """
+        from .mark_read.mark_read_request_builder import MarkReadRequestBuilder
+
+        return MarkReadRequestBuilder(self.request_adapter, self.path_parameters)
+    
+

leadping/notifications/mark_all_read/mark_all_read_request_builder.py

@@ -0,0 +1,79 @@
+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 MarkAllReadRequestBuilder(BaseRequestBuilder):
+    """
+    Builds and executes requests for operations under /notifications/mark-all-read
+    """
+    def __init__(self,request_adapter: RequestAdapter, path_parameters: Union[str, dict[str, Any]]) -> None:
+        """
+        Instantiates a new MarkAllReadRequestBuilder 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}/notifications/mark-all-read", path_parameters)
+    
+    async def post(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> Optional[int]:
+        """
+        Marks all notifications for the current user as read and returns the number updated for notification center refreshes.
+        param request_configuration: Configuration for the request such as headers, query parameters, and middleware options.
+        Returns: Optional[int]
+        """
+        request_info = self.to_post_request_information(
+            request_configuration
+        )
+        from ...models.problem_details import ProblemDetails
+
+        error_mapping: dict[str, type[ParsableFactory]] = {
+            "400": ProblemDetails,
+            "500": ProblemDetails,
+        }
+        if not self.request_adapter:
+            raise Exception("Http core is null") 
+        return await self.request_adapter.send_primitive_async(request_info, "int", error_mapping)
+    
+    def to_post_request_information(self,request_configuration: Optional[RequestConfiguration[QueryParameters]] = None) -> RequestInformation:
+        """
+        Marks all notifications for the current user as read and returns the number updated for notification center refreshes.
+        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/json")
+        return request_info
+    
+    def with_url(self,raw_url: str) -> MarkAllReadRequestBuilder:
+        """
+        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: MarkAllReadRequestBuilder
+        """
+        if raw_url is None:
+            raise TypeError("raw_url cannot be null.")
+        return MarkAllReadRequestBuilder(self.request_adapter, raw_url)
+    
+    @dataclass
+    class MarkAllReadRequestBuilderPostRequestConfiguration(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)
+    
+