Payment requests

PaymentRequestClient

Bases: BaseAPIClient

Provides a wrapper for paystack Payment Requests API

The Payment Requests API allows you to manage requests for payment of goods and services. https://paystack.com/docs/api/payment-request/

Source code in src/pypaystack2/sub_clients/sync_clients/payment_requests.py

class PaymentRequestClient(BaseAPIClient):
    """Provides a wrapper for paystack Payment Requests API

    The Payment Requests API allows you to manage requests for payment of goods and services.
    https://paystack.com/docs/api/payment-request/
    """

    def create(
        self,
        customer: int | str,
        amount: int,
        due_date: str | None = None,
        description: str | None = None,
        line_items: list[LineItem] | None = None,
        tax: list[Tax] | None = None,
        currency: Currency | None = None,
        send_notification: bool | None = None,
        draft: bool | None = None,
        has_invoice: bool | None = None,
        invoice_number: int | None = None,
        split_code: str | None = None,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
        """Create a payment request for a transaction on your integration

        Args:
            customer: Customer id or code
            amount: Payment request amount. It should be used when line items and tax values aren't specified.
            due_date: ISO 8601 representation of request due date
            description: A short description of the payment request
            line_items: List of line items int the format [{"name":"item 1", "amount":2000, "quantity": 1}]
            tax: List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]
            currency: Any value from Currency enum. default ``Currency.NGN``
            send_notification: Indicates whether Paystack sends an email notification to customer. Defaults to ``True``
            draft: Indicate if request should be saved as draft. Defaults to ``False`` and overrides send_notification
            has_invoice: Set to ``True`` to create a draft invoice (adds an auto-incrementing invoice number
                if none is provided) even if there are no line_items or tax passed
            invoice_number: Numeric value of invoice. Invoice will start from 1 and auto increment from there.
                This field is to help override whatever value Paystack decides. Auto increment for
                subsequent invoices continue from this point.
            split_code: The split code of the transaction split. e.g. SPL_98WF13Eb3w
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """
        _line_items: list[dict[str, Any]] | None = None
        _tax: list[dict[str, Any]] | None = None
        if line_items:
            _line_items = [item.model_dump() for item in line_items]
        if tax:
            _tax = [unit_tax.model_dump() for unit_tax in tax]

        url = self._full_url("/paymentrequest")

        payload = {"customer": customer, "amount": amount}
        optional_params = [
            ("due_date", due_date),
            ("description", description),
            ("line_items", _line_items),
            ("tax", _tax),
            ("currency", currency),
            ("send_notification", send_notification),
            ("draft", draft),
            ("has_invoice", has_invoice),
            ("invoice_number", invoice_number),
            ("split_code", split_code),
        ]
        payload = add_to_payload(optional_params, payload)
        return self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    def get_payment_requests(
        self,
        customer: str | int | None = None,
        status: Status | None = None,
        currency: Currency | None = None,
        include_archive: bool = False,
        page: int = 1,
        pagination: int = 50,
        start_date: str | None = None,
        end_date: str | None = None,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[list[PaymentRequest]] | Response[PaystackDataModel]:
        """Fetches the payment requests available on your integration.

        Args:
            customer: Filter by customer ID
            status: Filter by payment request status. Any value from enum of ``Status``
            currency: Filter by currency. Any value from enum of ``Currency``
            include_archive: Show archived payment requests.
            page: Specify exactly what payment request you want to page. If not specified, we use a default value of 1.
            pagination: Specifies how many records you want to retrieve per page. If not specified,
                we use a default value of 50.
            start_date: A timestamp from which to start listing payment requests
                e.g. 2016-09-24T00:00:05.000Z, 2016-09-21
            end_date: A timestamp at which to stop listing payment requests e.g. 2016-09-24T00:00:05.000Z, 2016-09-21
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest?perPage={pagination}")
        query_params = [
            ("customer", customer),
            ("status", status),
            ("currency", currency),
            ("include_archive", include_archive),
            ("page", page),
            ("start_date", start_date),
            ("end_date", end_date),
        ]
        url = append_query_params(query_params, url)
        return self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    def get_payment_request(
        self,
        id_or_code: int | str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
        """Get details of a payment request on your integration

        Args:
            id_or_code: The payment request ID or code you want to fetch
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest/{id_or_code}")
        return self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    def verify(
        self,
        id_or_code: int | str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
        """Verify details of a payment request on your integration.

        Args:
            id_or_code: Payment Request id or code
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest/verify/{id_or_code}")
        return self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    def send_notification(
        self,
        id_or_code: int | str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[None] | Response[PaystackDataModel]:
        """Send notification of a payment request to your customers

        Args:
            id_or_code: Payment Request id or code
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest/notify/{id_or_code}")
        return self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            response_data_model_class=alternate_model_class,
        )

    def get_total(
        self,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequestStat] | Response[PaystackDataModel]:
        """Get payment requests metric

        Args:
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url("/paymentrequest/totals")
        return self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or PaymentRequestStat,
        )

    def finalize(
        self,
        id_or_code: int | str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
        """Finalize a draft payment request

        Args:
            id_or_code: Payment Request id or code
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest/finalize/{id_or_code}")
        return self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    def update(
        self,
        id_or_code: int | str,
        customer: int | str,
        amount: int,
        due_date: str | None = None,
        description: str | None = None,
        line_items: list[LineItem] | None = None,
        tax: list[Tax] | None = None,
        currency: Currency | None = None,
        send_notification: bool | None = None,
        draft: bool | None = None,
        invoice_number: int | None = None,
        split_code: str | None = None,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
        """Update the payment request details on your integration

        Args:
            id_or_code: Payment Request id or code
            customer: Customer id or code
            amount: Payment request amount. Only useful if line items and tax values are ignored.
                method will throw a friendly warning in the response if neither is available.
            due_date: ISO 8601 representation of request due date
            description: A short description of the payment request
            line_items: List of line items in the format [{"name":"item 1", "amount":2000}]
            tax: List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]
            currency: Specify the currency of the Payment Request id or code. Any value from the ``Currency`` enum
            send_notification: Indicates whether Paystack sends an email notification to customer. Defaults to ``True``
            draft: Indicate if request should be saved as draft. Defaults to false and overrides send_notification
            invoice_number: Numeric value of invoice. Invoice will start from 1 and auto increment from there.
                This field is to help override whatever value Paystack decides. Auto increment for
                subsequent invoices continue from this point.
            split_code: The split code of the transaction split. e.g. SPL_98WF13Eb3w
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        _line_items: list[dict[str, Any]] | None = None
        _tax: list[dict[str, Any]] | None = None

        if line_items:
            _line_items = [item.model_dump() for item in line_items]
        if tax:
            _tax = [unit_tax.model_dump() for unit_tax in tax]

        url = self._full_url(f"/paymentrequest/{id_or_code}")
        payload = {
            "customer": customer,
            "amount": amount,
        }
        optional_params = [
            ("due_date", due_date),
            ("description", description),
            ("line_items", _line_items),
            ("tax", _tax),
            ("currency", currency),
            ("send_notification", send_notification),
            ("draft", draft),
            ("invoice_number", invoice_number),
            ("split_code", split_code),
        ]
        payload = add_to_payload(optional_params, payload)
        return self._handle_request(  # type: ignore
            HTTPMethod.PUT,
            url,
            payload,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    def archive(
        self,
        id_or_code: int | str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[None] | Response[PaystackDataModel]:
        """Used to archive a payment request. A payment request will no longer be fetched on list or returned on verify.

        Args:
            id_or_code: Payment Request id or code
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

         Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest/archive/{id_or_code}")
        return self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            response_data_model_class=alternate_model_class,
        )

archive(id_or_code, alternate_model_class=None)

Used to archive a payment request. A payment request will no longer be fetched on list or returned on verify.

Parameters:

Name	Type	Description	Default
id_or_code	int | str	Payment Request id or code	required
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns: A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/sync_clients/payment_requests.py

def archive(
    self,
    id_or_code: int | str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[None] | Response[PaystackDataModel]:
    """Used to archive a payment request. A payment request will no longer be fetched on list or returned on verify.

    Args:
        id_or_code: Payment Request id or code
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

     Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest/archive/{id_or_code}")
    return self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        response_data_model_class=alternate_model_class,
    )

create(customer, amount, due_date=None, description=None, line_items=None, tax=None, currency=None, send_notification=None, draft=None, has_invoice=None, invoice_number=None, split_code=None, alternate_model_class=None)

Create a payment request for a transaction on your integration

Parameters:

Name	Type	Description	Default
customer	int | str	Customer id or code	required
amount	int	Payment request amount. It should be used when line items and tax values aren't specified.	required
due_date	str | None	ISO 8601 representation of request due date	None
description	str | None	A short description of the payment request	None
line_items	list[LineItem] | None	List of line items int the format [{"name":"item 1", "amount":2000, "quantity": 1}]	None
tax	list[Tax] | None	List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]	None
currency	Currency | None	Any value from Currency enum. default Currency.NGN	None
send_notification	bool | None	Indicates whether Paystack sends an email notification to customer. Defaults to True	None
draft	bool | None	Indicate if request should be saved as draft. Defaults to False and overrides send_notification	None
has_invoice	bool | None	Set to True to create a draft invoice (adds an auto-incrementing invoice number if none is provided) even if there are no line_items or tax passed	None
invoice_number	int | None	Numeric value of invoice. Invoice will start from 1 and auto increment from there. This field is to help override whatever value Paystack decides. Auto increment for subsequent invoices continue from this point.	None
split_code	str | None	The split code of the transaction split. e.g. SPL_98WF13Eb3w	None
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequest] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/sync_clients/payment_requests.py

def create(
    self,
    customer: int | str,
    amount: int,
    due_date: str | None = None,
    description: str | None = None,
    line_items: list[LineItem] | None = None,
    tax: list[Tax] | None = None,
    currency: Currency | None = None,
    send_notification: bool | None = None,
    draft: bool | None = None,
    has_invoice: bool | None = None,
    invoice_number: int | None = None,
    split_code: str | None = None,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequest] | Response[PaystackDataModel]:
    """Create a payment request for a transaction on your integration

    Args:
        customer: Customer id or code
        amount: Payment request amount. It should be used when line items and tax values aren't specified.
        due_date: ISO 8601 representation of request due date
        description: A short description of the payment request
        line_items: List of line items int the format [{"name":"item 1", "amount":2000, "quantity": 1}]
        tax: List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]
        currency: Any value from Currency enum. default ``Currency.NGN``
        send_notification: Indicates whether Paystack sends an email notification to customer. Defaults to ``True``
        draft: Indicate if request should be saved as draft. Defaults to ``False`` and overrides send_notification
        has_invoice: Set to ``True`` to create a draft invoice (adds an auto-incrementing invoice number
            if none is provided) even if there are no line_items or tax passed
        invoice_number: Numeric value of invoice. Invoice will start from 1 and auto increment from there.
            This field is to help override whatever value Paystack decides. Auto increment for
            subsequent invoices continue from this point.
        split_code: The split code of the transaction split. e.g. SPL_98WF13Eb3w
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """
    _line_items: list[dict[str, Any]] | None = None
    _tax: list[dict[str, Any]] | None = None
    if line_items:
        _line_items = [item.model_dump() for item in line_items]
    if tax:
        _tax = [unit_tax.model_dump() for unit_tax in tax]

    url = self._full_url("/paymentrequest")

    payload = {"customer": customer, "amount": amount}
    optional_params = [
        ("due_date", due_date),
        ("description", description),
        ("line_items", _line_items),
        ("tax", _tax),
        ("currency", currency),
        ("send_notification", send_notification),
        ("draft", draft),
        ("has_invoice", has_invoice),
        ("invoice_number", invoice_number),
        ("split_code", split_code),
    ]
    payload = add_to_payload(optional_params, payload)
    return self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )

finalize(id_or_code, alternate_model_class=None)

Finalize a draft payment request

Parameters:

Name	Type	Description	Default
id_or_code	int | str	Payment Request id or code	required
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequest] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/sync_clients/payment_requests.py

def finalize(
    self,
    id_or_code: int | str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequest] | Response[PaystackDataModel]:
    """Finalize a draft payment request

    Args:
        id_or_code: Payment Request id or code
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest/finalize/{id_or_code}")
    return self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )

get_payment_request(id_or_code, alternate_model_class=None)

Get details of a payment request on your integration

Parameters:

Name	Type	Description	Default
id_or_code	int | str	The payment request ID or code you want to fetch	required
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequest] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/sync_clients/payment_requests.py

def get_payment_request(
    self,
    id_or_code: int | str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequest] | Response[PaystackDataModel]:
    """Get details of a payment request on your integration

    Args:
        id_or_code: The payment request ID or code you want to fetch
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest/{id_or_code}")
    return self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )

get_payment_requests(customer=None, status=None, currency=None, include_archive=False, page=1, pagination=50, start_date=None, end_date=None, alternate_model_class=None)

Fetches the payment requests available on your integration.

Parameters:

Name	Type	Description	Default
customer	str | int | None	Filter by customer ID	None
status	Status | None	Filter by payment request status. Any value from enum of Status	None
currency	Currency | None	Filter by currency. Any value from enum of Currency	None
include_archive	bool	Show archived payment requests.	False
page	int	Specify exactly what payment request you want to page. If not specified, we use a default value of 1.	1
pagination	int	Specifies how many records you want to retrieve per page. If not specified, we use a default value of 50.	50
start_date	str | None	A timestamp from which to start listing payment requests e.g. 2016-09-24T00:00:05.000Z, 2016-09-21	None
end_date	str | None	A timestamp at which to stop listing payment requests e.g. 2016-09-24T00:00:05.000Z, 2016-09-21	None
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[list[PaymentRequest]] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/sync_clients/payment_requests.py

def get_payment_requests(
    self,
    customer: str | int | None = None,
    status: Status | None = None,
    currency: Currency | None = None,
    include_archive: bool = False,
    page: int = 1,
    pagination: int = 50,
    start_date: str | None = None,
    end_date: str | None = None,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[list[PaymentRequest]] | Response[PaystackDataModel]:
    """Fetches the payment requests available on your integration.

    Args:
        customer: Filter by customer ID
        status: Filter by payment request status. Any value from enum of ``Status``
        currency: Filter by currency. Any value from enum of ``Currency``
        include_archive: Show archived payment requests.
        page: Specify exactly what payment request you want to page. If not specified, we use a default value of 1.
        pagination: Specifies how many records you want to retrieve per page. If not specified,
            we use a default value of 50.
        start_date: A timestamp from which to start listing payment requests
            e.g. 2016-09-24T00:00:05.000Z, 2016-09-21
        end_date: A timestamp at which to stop listing payment requests e.g. 2016-09-24T00:00:05.000Z, 2016-09-21
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest?perPage={pagination}")
    query_params = [
        ("customer", customer),
        ("status", status),
        ("currency", currency),
        ("include_archive", include_archive),
        ("page", page),
        ("start_date", start_date),
        ("end_date", end_date),
    ]
    url = append_query_params(query_params, url)
    return self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )

get_total(alternate_model_class=None)

Get payment requests metric

Parameters:

Name	Type	Description	Default
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequestStat] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/sync_clients/payment_requests.py

def get_total(
    self,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequestStat] | Response[PaystackDataModel]:
    """Get payment requests metric

    Args:
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url("/paymentrequest/totals")
    return self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or PaymentRequestStat,
    )

send_notification(id_or_code, alternate_model_class=None)

Send notification of a payment request to your customers

Parameters:

Name	Type	Description	Default
id_or_code	int | str	Payment Request id or code	required
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[None] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/sync_clients/payment_requests.py

def send_notification(
    self,
    id_or_code: int | str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[None] | Response[PaystackDataModel]:
    """Send notification of a payment request to your customers

    Args:
        id_or_code: Payment Request id or code
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest/notify/{id_or_code}")
    return self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        response_data_model_class=alternate_model_class,
    )

update(id_or_code, customer, amount, due_date=None, description=None, line_items=None, tax=None, currency=None, send_notification=None, draft=None, invoice_number=None, split_code=None, alternate_model_class=None)

Update the payment request details on your integration

Parameters:

Name	Type	Description	Default
id_or_code	int | str	Payment Request id or code	required
customer	int | str	Customer id or code	required
amount	int	Payment request amount. Only useful if line items and tax values are ignored. method will throw a friendly warning in the response if neither is available.	required
due_date	str | None	ISO 8601 representation of request due date	None
description	str | None	A short description of the payment request	None
line_items	list[LineItem] | None	List of line items in the format [{"name":"item 1", "amount":2000}]	None
tax	list[Tax] | None	List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]	None
currency	Currency | None	Specify the currency of the Payment Request id or code. Any value from the Currency enum	None
send_notification	bool | None	Indicates whether Paystack sends an email notification to customer. Defaults to True	None
draft	bool | None	Indicate if request should be saved as draft. Defaults to false and overrides send_notification	None
invoice_number	int | None	Numeric value of invoice. Invoice will start from 1 and auto increment from there. This field is to help override whatever value Paystack decides. Auto increment for subsequent invoices continue from this point.	None
split_code	str | None	The split code of the transaction split. e.g. SPL_98WF13Eb3w	None
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequest] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/sync_clients/payment_requests.py

def update(
    self,
    id_or_code: int | str,
    customer: int | str,
    amount: int,
    due_date: str | None = None,
    description: str | None = None,
    line_items: list[LineItem] | None = None,
    tax: list[Tax] | None = None,
    currency: Currency | None = None,
    send_notification: bool | None = None,
    draft: bool | None = None,
    invoice_number: int | None = None,
    split_code: str | None = None,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequest] | Response[PaystackDataModel]:
    """Update the payment request details on your integration

    Args:
        id_or_code: Payment Request id or code
        customer: Customer id or code
        amount: Payment request amount. Only useful if line items and tax values are ignored.
            method will throw a friendly warning in the response if neither is available.
        due_date: ISO 8601 representation of request due date
        description: A short description of the payment request
        line_items: List of line items in the format [{"name":"item 1", "amount":2000}]
        tax: List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]
        currency: Specify the currency of the Payment Request id or code. Any value from the ``Currency`` enum
        send_notification: Indicates whether Paystack sends an email notification to customer. Defaults to ``True``
        draft: Indicate if request should be saved as draft. Defaults to false and overrides send_notification
        invoice_number: Numeric value of invoice. Invoice will start from 1 and auto increment from there.
            This field is to help override whatever value Paystack decides. Auto increment for
            subsequent invoices continue from this point.
        split_code: The split code of the transaction split. e.g. SPL_98WF13Eb3w
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    _line_items: list[dict[str, Any]] | None = None
    _tax: list[dict[str, Any]] | None = None

    if line_items:
        _line_items = [item.model_dump() for item in line_items]
    if tax:
        _tax = [unit_tax.model_dump() for unit_tax in tax]

    url = self._full_url(f"/paymentrequest/{id_or_code}")
    payload = {
        "customer": customer,
        "amount": amount,
    }
    optional_params = [
        ("due_date", due_date),
        ("description", description),
        ("line_items", _line_items),
        ("tax", _tax),
        ("currency", currency),
        ("send_notification", send_notification),
        ("draft", draft),
        ("invoice_number", invoice_number),
        ("split_code", split_code),
    ]
    payload = add_to_payload(optional_params, payload)
    return self._handle_request(  # type: ignore
        HTTPMethod.PUT,
        url,
        payload,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )

verify(id_or_code, alternate_model_class=None)

Verify details of a payment request on your integration.

Parameters:

Name	Type	Description	Default
id_or_code	int | str	Payment Request id or code	required
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequest] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/sync_clients/payment_requests.py

def verify(
    self,
    id_or_code: int | str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequest] | Response[PaystackDataModel]:
    """Verify details of a payment request on your integration.

    Args:
        id_or_code: Payment Request id or code
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest/verify/{id_or_code}")
    return self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )

AsyncPaymentRequestClient

Bases: BaseAsyncAPIClient

Provides a wrapper for paystack Payment Requests API

The Payment Requests API allows you to manage requests for payment of goods and services. https://paystack.com/docs/api/payment-request/

Source code in src/pypaystack2/sub_clients/async_clients/payment_requests.py

class AsyncPaymentRequestClient(BaseAsyncAPIClient):
    """Provides a wrapper for paystack Payment Requests API

    The Payment Requests API allows you to manage requests for payment of goods and services.
    https://paystack.com/docs/api/payment-request/
    """

    async def create(
        self,
        customer: int | str,
        amount: int,
        due_date: str | None = None,
        description: str | None = None,
        line_items: list[LineItem] | None = None,
        tax: list[Tax] | None = None,
        currency: Currency | None = None,
        send_notification: bool | None = None,
        draft: bool | None = None,
        has_invoice: bool | None = None,
        invoice_number: int | None = None,
        split_code: str | None = None,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
        """Create a payment request for a transaction on your integration

        Args:
            customer: Customer id or code
            amount: Payment request amount. It should be used when line items and tax values aren't specified.
            due_date: ISO 8601 representation of request due date
            description: A short description of the payment request
            line_items: List of line items int the format [{"name":"item 1", "amount":2000, "quantity": 1}]
            tax: List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]
            currency: Any value from Currency enum. default ``Currency.NGN``
            send_notification: Indicates whether Paystack sends an email notification to customer. Defaults to ``True``
            draft: Indicate if request should be saved as draft. Defaults to ``False`` and overrides send_notification
            has_invoice: Set to ``True`` to create a draft invoice (adds an auto incrementing invoice number
                if none is provided) even if there are no line_items or tax passed
            invoice_number: Numeric value of invoice. Invoice will start from 1 and auto increment from there.
                This field is to help override whatever value Paystack decides. Auto increment for
                subsequent invoices continue from this point.
            split_code: The split code of the transaction split. e.g. SPL_98WF13Eb3w
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """
        _line_items: list[dict[str, Any]] | None = None
        _tax: list[dict[str, Any]] | None = None
        if line_items:
            _line_items = [item.model_dump() for item in line_items]
        if tax:
            _tax = [unit_tax.model_dump() for unit_tax in tax]

        url = self._full_url("/paymentrequest")

        payload = {"customer": customer, "amount": amount}
        optional_params = [
            ("due_date", due_date),
            ("description", description),
            ("line_items", _line_items),
            ("tax", _tax),
            ("currency", currency),
            ("send_notification", send_notification),
            ("draft", draft),
            ("has_invoice", has_invoice),
            ("invoice_number", invoice_number),
            ("split_code", split_code),
        ]
        payload = add_to_payload(optional_params, payload)
        return await self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            payload,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    async def get_payment_requests(
        self,
        customer: str | int | None = None,
        status: Status | None = None,
        currency: Currency | None = None,
        include_archive: bool = False,
        page: int = 1,
        pagination: int = 50,
        start_date: str | None = None,
        end_date: str | None = None,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[list[PaymentRequest]] | Response[PaystackDataModel]:
        """Fetches the payment requests available on your integration.

        Args:
            customer: Filter by customer ID
            status: Filter by payment request status. Any value from enum of ``Status``
            currency: Filter by currency. Any value from enum of ``Currency``
            include_archive: Show archived payment requests.
            page: Specify exactly what payment request you want to page. If not specify we use a default value of 1.
            pagination: Specifies how many records you want to retrieve per page. If not specified
                we use a default value of 50.
            start_date: A timestamp from which to start listing payment request
                e.g. 2016-09-24T00:00:05.000Z, 2016-09-21
            end_date: A timestamp at which to stop listing payment request e.g. 2016-09-24T00:00:05.000Z, 2016-09-21
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest?perPage={pagination}")
        query_params = [
            ("customer", customer),
            ("status", status),
            ("currency", currency),
            ("include_archive", include_archive),
            ("page", page),
            ("start_date", start_date),
            ("end_date", end_date),
        ]
        url = append_query_params(query_params, url)
        return await self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    async def get_payment_request(
        self,
        id_or_code: int | str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
        """Get details of a payment request on your integration.

        Args:
            id_or_code: Payment Request id or code
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest/{id_or_code}")
        return await self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    async def verify(
        self,
        id_or_code: int | str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
        """Verify details of a payment request on your integration.

        Args:
            id_or_code: Payment Request id or code
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest/verify/{id_or_code}")
        return await self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    async def send_notification(
        self,
        id_or_code: int | str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[None] | Response[PaystackDataModel]:
        """Send notification of a payment request to your customers

        Args:
            id_or_code: Payment Request id or code
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest/notify/{id_or_code}")
        return await self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            response_data_model_class=alternate_model_class,
        )

    async def get_total(
        self,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequestStat] | Response[PaystackDataModel]:
        """Get payment requests metric

        Args:
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url("/paymentrequest/totals")
        return await self._handle_request(  # type: ignore
            HTTPMethod.GET,
            url,
            response_data_model_class=alternate_model_class or PaymentRequestStat,
        )

    async def finalize(
        self,
        id_or_code: int | str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
        """Finalize a draft payment request

        Args:
            id_or_code: Payment Request id or code
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest/finalize/{id_or_code}")
        return await self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    async def update(
        self,
        id_or_code: int | str,
        customer: int | str,
        amount: int,
        due_date: str | None = None,
        description: str | None = None,
        line_items: list[LineItem] | None = None,
        tax: list[Tax] | None = None,
        currency: Currency | None = None,
        send_notification: bool | None = None,
        draft: bool | None = None,
        invoice_number: int | None = None,
        split_code: str | None = None,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[PaymentRequest] | Response[PaystackDataModel]:
        """Update a payment request details on your integration

        Args:
            id_or_code: Payment Request id or code
            customer: Customer id or code
            amount: Payment request amount. Only useful if line items and tax values are ignored.
                method will throw a friendly warning in the response if neither is available.
            due_date: ISO 8601 representation of request due date
            description: A short description of the payment request
            line_items: List of line items in the format [{"name":"item 1", "amount":2000}]
            tax: List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]
            currency: Specify the currency of the payment request. Any value from the ``Currency`` enum
            send_notification: Indicates whether Paystack sends an email notification to customer. Defaults to ``True``
            draft: Indicate if request should be saved as draft. Defaults to false and overrides send_notification
            invoice_number: Numeric value of invoice. Invoice will start from 1 and auto increment from there.
                This field is to help override whatever value Paystack decides. Auto increment for
                subsequent invoices continue from this point.
            split_code: The split code of the transaction split. e.g. SPL_98WF13Eb3w
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

        Returns:
            A pydantic model containing the response gotten from paystack's server.
        """
        _line_items: list[dict[str, Any]] | None = None
        _tax: list[dict[str, Any]] | None = None

        if line_items:
            _line_items = [item.model_dump() for item in line_items]
        if tax:
            _tax = [unit_tax.model_dump() for unit_tax in tax]

        url = self._full_url(f"/paymentrequest/{id_or_code}")
        payload = {
            "customer": customer,
            "amount": amount,
        }
        optional_params = [
            ("due_date", due_date),
            ("description", description),
            ("line_items", _line_items),
            ("tax", _tax),
            ("currency", currency),
            ("send_notification", send_notification),
            ("draft", draft),
            ("invoice_number", invoice_number),
            ("split_code", split_code),
        ]
        payload = add_to_payload(optional_params, payload)
        return await self._handle_request(  # type: ignore
            HTTPMethod.PUT,
            url,
            payload,
            response_data_model_class=alternate_model_class or PaymentRequest,
        )

    async def archive(
        self,
        id_or_code: int | str,
        alternate_model_class: type[PaystackDataModel] | None = None,
    ) -> Response[None] | Response[PaystackDataModel]:
        """Used to archive a payment request. A payment request will no longer be fetched on list or returned on verify.

        Args:
            id_or_code: Payment Request id or code
            alternate_model_class: A pydantic model class to use instead of the
                default pydantic model used by the library to present the data in
                the `Response.data`. The default behaviour of the library is to
                set  `Response.data` to `None` if it fails to serialize the data
                returned from paystack with the model provided in the library.
                Providing a pydantic model class via this parameter overrides
                the library default model with the model class you provide.
                This can come in handy when the models in the library do not
                accurately represent the data returned, and you prefer working with the
                data as a pydantic model instead of as a dict of the response returned
                by  paystack before it is serialized with pydantic models, The original
                data can be accessed via `Response.raw`.

         Returns:
            A pydantic model containing the response gotten from paystack's server.
        """

        url = self._full_url(f"/paymentrequest/archive/{id_or_code}")
        return await self._handle_request(  # type: ignore
            HTTPMethod.POST,
            url,
            response_data_model_class=alternate_model_class,
        )

archive(id_or_code, alternate_model_class=None) async

Used to archive a payment request. A payment request will no longer be fetched on list or returned on verify.

Parameters:

Name	Type	Description	Default
id_or_code	int | str	Payment Request id or code	required
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns: A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/async_clients/payment_requests.py

async def archive(
    self,
    id_or_code: int | str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[None] | Response[PaystackDataModel]:
    """Used to archive a payment request. A payment request will no longer be fetched on list or returned on verify.

    Args:
        id_or_code: Payment Request id or code
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

     Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest/archive/{id_or_code}")
    return await self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        response_data_model_class=alternate_model_class,
    )

create(customer, amount, due_date=None, description=None, line_items=None, tax=None, currency=None, send_notification=None, draft=None, has_invoice=None, invoice_number=None, split_code=None, alternate_model_class=None) async

Create a payment request for a transaction on your integration

Parameters:

Name	Type	Description	Default
customer	int | str	Customer id or code	required
amount	int	Payment request amount. It should be used when line items and tax values aren't specified.	required
due_date	str | None	ISO 8601 representation of request due date	None
description	str | None	A short description of the payment request	None
line_items	list[LineItem] | None	List of line items int the format [{"name":"item 1", "amount":2000, "quantity": 1}]	None
tax	list[Tax] | None	List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]	None
currency	Currency | None	Any value from Currency enum. default Currency.NGN	None
send_notification	bool | None	Indicates whether Paystack sends an email notification to customer. Defaults to True	None
draft	bool | None	Indicate if request should be saved as draft. Defaults to False and overrides send_notification	None
has_invoice	bool | None	Set to True to create a draft invoice (adds an auto incrementing invoice number if none is provided) even if there are no line_items or tax passed	None
invoice_number	int | None	Numeric value of invoice. Invoice will start from 1 and auto increment from there. This field is to help override whatever value Paystack decides. Auto increment for subsequent invoices continue from this point.	None
split_code	str | None	The split code of the transaction split. e.g. SPL_98WF13Eb3w	None
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequest] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/async_clients/payment_requests.py

async def create(
    self,
    customer: int | str,
    amount: int,
    due_date: str | None = None,
    description: str | None = None,
    line_items: list[LineItem] | None = None,
    tax: list[Tax] | None = None,
    currency: Currency | None = None,
    send_notification: bool | None = None,
    draft: bool | None = None,
    has_invoice: bool | None = None,
    invoice_number: int | None = None,
    split_code: str | None = None,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequest] | Response[PaystackDataModel]:
    """Create a payment request for a transaction on your integration

    Args:
        customer: Customer id or code
        amount: Payment request amount. It should be used when line items and tax values aren't specified.
        due_date: ISO 8601 representation of request due date
        description: A short description of the payment request
        line_items: List of line items int the format [{"name":"item 1", "amount":2000, "quantity": 1}]
        tax: List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]
        currency: Any value from Currency enum. default ``Currency.NGN``
        send_notification: Indicates whether Paystack sends an email notification to customer. Defaults to ``True``
        draft: Indicate if request should be saved as draft. Defaults to ``False`` and overrides send_notification
        has_invoice: Set to ``True`` to create a draft invoice (adds an auto incrementing invoice number
            if none is provided) even if there are no line_items or tax passed
        invoice_number: Numeric value of invoice. Invoice will start from 1 and auto increment from there.
            This field is to help override whatever value Paystack decides. Auto increment for
            subsequent invoices continue from this point.
        split_code: The split code of the transaction split. e.g. SPL_98WF13Eb3w
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """
    _line_items: list[dict[str, Any]] | None = None
    _tax: list[dict[str, Any]] | None = None
    if line_items:
        _line_items = [item.model_dump() for item in line_items]
    if tax:
        _tax = [unit_tax.model_dump() for unit_tax in tax]

    url = self._full_url("/paymentrequest")

    payload = {"customer": customer, "amount": amount}
    optional_params = [
        ("due_date", due_date),
        ("description", description),
        ("line_items", _line_items),
        ("tax", _tax),
        ("currency", currency),
        ("send_notification", send_notification),
        ("draft", draft),
        ("has_invoice", has_invoice),
        ("invoice_number", invoice_number),
        ("split_code", split_code),
    ]
    payload = add_to_payload(optional_params, payload)
    return await self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        payload,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )

finalize(id_or_code, alternate_model_class=None) async

Finalize a draft payment request

Parameters:

Name	Type	Description	Default
id_or_code	int | str	Payment Request id or code	required
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequest] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/async_clients/payment_requests.py

async def finalize(
    self,
    id_or_code: int | str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequest] | Response[PaystackDataModel]:
    """Finalize a draft payment request

    Args:
        id_or_code: Payment Request id or code
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest/finalize/{id_or_code}")
    return await self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )

get_payment_request(id_or_code, alternate_model_class=None) async

Get details of a payment request on your integration.

Parameters:

Name	Type	Description	Default
id_or_code	int | str	Payment Request id or code	required
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequest] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/async_clients/payment_requests.py

async def get_payment_request(
    self,
    id_or_code: int | str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequest] | Response[PaystackDataModel]:
    """Get details of a payment request on your integration.

    Args:
        id_or_code: Payment Request id or code
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest/{id_or_code}")
    return await self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )

get_payment_requests(customer=None, status=None, currency=None, include_archive=False, page=1, pagination=50, start_date=None, end_date=None, alternate_model_class=None) async

Fetches the payment requests available on your integration.

Parameters:

Name	Type	Description	Default
customer	str | int | None	Filter by customer ID	None
status	Status | None	Filter by payment request status. Any value from enum of Status	None
currency	Currency | None	Filter by currency. Any value from enum of Currency	None
include_archive	bool	Show archived payment requests.	False
page	int	Specify exactly what payment request you want to page. If not specify we use a default value of 1.	1
pagination	int	Specifies how many records you want to retrieve per page. If not specified we use a default value of 50.	50
start_date	str | None	A timestamp from which to start listing payment request e.g. 2016-09-24T00:00:05.000Z, 2016-09-21	None
end_date	str | None	A timestamp at which to stop listing payment request e.g. 2016-09-24T00:00:05.000Z, 2016-09-21	None
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[list[PaymentRequest]] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/async_clients/payment_requests.py

async def get_payment_requests(
    self,
    customer: str | int | None = None,
    status: Status | None = None,
    currency: Currency | None = None,
    include_archive: bool = False,
    page: int = 1,
    pagination: int = 50,
    start_date: str | None = None,
    end_date: str | None = None,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[list[PaymentRequest]] | Response[PaystackDataModel]:
    """Fetches the payment requests available on your integration.

    Args:
        customer: Filter by customer ID
        status: Filter by payment request status. Any value from enum of ``Status``
        currency: Filter by currency. Any value from enum of ``Currency``
        include_archive: Show archived payment requests.
        page: Specify exactly what payment request you want to page. If not specify we use a default value of 1.
        pagination: Specifies how many records you want to retrieve per page. If not specified
            we use a default value of 50.
        start_date: A timestamp from which to start listing payment request
            e.g. 2016-09-24T00:00:05.000Z, 2016-09-21
        end_date: A timestamp at which to stop listing payment request e.g. 2016-09-24T00:00:05.000Z, 2016-09-21
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest?perPage={pagination}")
    query_params = [
        ("customer", customer),
        ("status", status),
        ("currency", currency),
        ("include_archive", include_archive),
        ("page", page),
        ("start_date", start_date),
        ("end_date", end_date),
    ]
    url = append_query_params(query_params, url)
    return await self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )

get_total(alternate_model_class=None) async

Get payment requests metric

Parameters:

Name	Type	Description	Default
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequestStat] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/async_clients/payment_requests.py

async def get_total(
    self,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequestStat] | Response[PaystackDataModel]:
    """Get payment requests metric

    Args:
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url("/paymentrequest/totals")
    return await self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or PaymentRequestStat,
    )

send_notification(id_or_code, alternate_model_class=None) async

Send notification of a payment request to your customers

Parameters:

Name	Type	Description	Default
id_or_code	int | str	Payment Request id or code	required
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[None] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/async_clients/payment_requests.py

async def send_notification(
    self,
    id_or_code: int | str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[None] | Response[PaystackDataModel]:
    """Send notification of a payment request to your customers

    Args:
        id_or_code: Payment Request id or code
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest/notify/{id_or_code}")
    return await self._handle_request(  # type: ignore
        HTTPMethod.POST,
        url,
        response_data_model_class=alternate_model_class,
    )

update(id_or_code, customer, amount, due_date=None, description=None, line_items=None, tax=None, currency=None, send_notification=None, draft=None, invoice_number=None, split_code=None, alternate_model_class=None) async

Update a payment request details on your integration

Parameters:

Name	Type	Description	Default
id_or_code	int | str	Payment Request id or code	required
customer	int | str	Customer id or code	required
amount	int	Payment request amount. Only useful if line items and tax values are ignored. method will throw a friendly warning in the response if neither is available.	required
due_date	str | None	ISO 8601 representation of request due date	None
description	str | None	A short description of the payment request	None
line_items	list[LineItem] | None	List of line items in the format [{"name":"item 1", "amount":2000}]	None
tax	list[Tax] | None	List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]	None
currency	Currency | None	Specify the currency of the payment request. Any value from the Currency enum	None
send_notification	bool | None	Indicates whether Paystack sends an email notification to customer. Defaults to True	None
draft	bool | None	Indicate if request should be saved as draft. Defaults to false and overrides send_notification	None
invoice_number	int | None	Numeric value of invoice. Invoice will start from 1 and auto increment from there. This field is to help override whatever value Paystack decides. Auto increment for subsequent invoices continue from this point.	None
split_code	str | None	The split code of the transaction split. e.g. SPL_98WF13Eb3w	None
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequest] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/async_clients/payment_requests.py

async def update(
    self,
    id_or_code: int | str,
    customer: int | str,
    amount: int,
    due_date: str | None = None,
    description: str | None = None,
    line_items: list[LineItem] | None = None,
    tax: list[Tax] | None = None,
    currency: Currency | None = None,
    send_notification: bool | None = None,
    draft: bool | None = None,
    invoice_number: int | None = None,
    split_code: str | None = None,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequest] | Response[PaystackDataModel]:
    """Update a payment request details on your integration

    Args:
        id_or_code: Payment Request id or code
        customer: Customer id or code
        amount: Payment request amount. Only useful if line items and tax values are ignored.
            method will throw a friendly warning in the response if neither is available.
        due_date: ISO 8601 representation of request due date
        description: A short description of the payment request
        line_items: List of line items in the format [{"name":"item 1", "amount":2000}]
        tax: List of taxes to be charged in the format [{"name":"VAT", "amount":2000}]
        currency: Specify the currency of the payment request. Any value from the ``Currency`` enum
        send_notification: Indicates whether Paystack sends an email notification to customer. Defaults to ``True``
        draft: Indicate if request should be saved as draft. Defaults to false and overrides send_notification
        invoice_number: Numeric value of invoice. Invoice will start from 1 and auto increment from there.
            This field is to help override whatever value Paystack decides. Auto increment for
            subsequent invoices continue from this point.
        split_code: The split code of the transaction split. e.g. SPL_98WF13Eb3w
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """
    _line_items: list[dict[str, Any]] | None = None
    _tax: list[dict[str, Any]] | None = None

    if line_items:
        _line_items = [item.model_dump() for item in line_items]
    if tax:
        _tax = [unit_tax.model_dump() for unit_tax in tax]

    url = self._full_url(f"/paymentrequest/{id_or_code}")
    payload = {
        "customer": customer,
        "amount": amount,
    }
    optional_params = [
        ("due_date", due_date),
        ("description", description),
        ("line_items", _line_items),
        ("tax", _tax),
        ("currency", currency),
        ("send_notification", send_notification),
        ("draft", draft),
        ("invoice_number", invoice_number),
        ("split_code", split_code),
    ]
    payload = add_to_payload(optional_params, payload)
    return await self._handle_request(  # type: ignore
        HTTPMethod.PUT,
        url,
        payload,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )

verify(id_or_code, alternate_model_class=None) async

Verify details of a payment request on your integration.

Parameters:

Name	Type	Description	Default
id_or_code	int | str	Payment Request id or code	required
alternate_model_class	type[PaystackDataModel] | None	A pydantic model class to use instead of the default pydantic model used by the library to present the data in the Response.data. The default behaviour of the library is to set Response.data to None if it fails to serialize the data returned from paystack with the model provided in the library. Providing a pydantic model class via this parameter overrides the library default model with the model class you provide. This can come in handy when the models in the library do not accurately represent the data returned, and you prefer working with the data as a pydantic model instead of as a dict of the response returned by paystack before it is serialized with pydantic models, The original data can be accessed via Response.raw.	None

Returns:

Type	Description
Response[PaymentRequest] | Response[PaystackDataModel]	A pydantic model containing the response gotten from paystack's server.

Source code in src/pypaystack2/sub_clients/async_clients/payment_requests.py

async def verify(
    self,
    id_or_code: int | str,
    alternate_model_class: type[PaystackDataModel] | None = None,
) -> Response[PaymentRequest] | Response[PaystackDataModel]:
    """Verify details of a payment request on your integration.

    Args:
        id_or_code: Payment Request id or code
        alternate_model_class: A pydantic model class to use instead of the
            default pydantic model used by the library to present the data in
            the `Response.data`. The default behaviour of the library is to
            set  `Response.data` to `None` if it fails to serialize the data
            returned from paystack with the model provided in the library.
            Providing a pydantic model class via this parameter overrides
            the library default model with the model class you provide.
            This can come in handy when the models in the library do not
            accurately represent the data returned, and you prefer working with the
            data as a pydantic model instead of as a dict of the response returned
            by  paystack before it is serialized with pydantic models, The original
            data can be accessed via `Response.raw`.

    Returns:
        A pydantic model containing the response gotten from paystack's server.
    """

    url = self._full_url(f"/paymentrequest/verify/{id_or_code}")
    return await self._handle_request(  # type: ignore
        HTTPMethod.GET,
        url,
        response_data_model_class=alternate_model_class or PaymentRequest,
    )