dime-python-sdk 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

dime_payments/client.py

@@ -3,8 +3,10 @@ from .http.transport import Transport
 from .resources.addresses import Addresses
 from .resources.customers import Customers
 from .resources.deposits import Deposits
+from .resources.invoices import Invoices
 from .resources.merchants import Merchants
 from .resources.payment_methods import PaymentMethods
+from .resources.recurring_invoices import RecurringInvoices
 from .resources.recurring_payments import RecurringPayments
 from .resources.transactions import Transactions
 
@@ -25,6 +27,8 @@ class Client:
         self.addresses = Addresses(transport)
         self.deposits = Deposits(transport)
         self.recurring_payments = RecurringPayments(transport)
+        self.invoices = Invoices(transport)
+        self.recurring_invoices = RecurringInvoices(transport)
 
     def config(self) -> Config:
         return self._config

dime_payments/config.py

@@ -8,7 +8,7 @@ if TYPE_CHECKING:
 
 class Config:
     DEFAULT_BASE_URL = 'https://app.dimepayments.com'
-    VERSION = '1.0.0'
+    VERSION = '1.2.0'
 
     def __init__(
         self,

dime_payments/data_objects/__init__.py

@@ -4,9 +4,17 @@ from .deposit import Deposit
 from .deposit_group import DepositGroup
 from .deposit_with_transactions import DepositWithTransactions
 from .form_link import FormLink
+from .invoice import Invoice
+from .invoice_customer import InvoiceCustomer
+from .invoice_event import InvoiceEvent
+from .invoice_item import InvoiceItem
+from .invoice_link import InvoiceLink
+from .invoice_payment import InvoicePayment
+from .line_item import LineItem
 from .merchant import Merchant
 from .message_result import MessageResult
 from .payment_method import PaymentMethod
+from .recurring_invoice import RecurringInvoice, RecurringInvoiceRun
 from .recurring_payment import RecurringPayment
 from .recurring_payment_method import RecurringPaymentMethod
 from .tokenize_result import TokenizeResult
@@ -28,4 +36,13 @@ __all__ = [
     'TokenizeResult',
     'MessageResult',
     'FormLink',
+    'Invoice',
+    'InvoiceCustomer',
+    'InvoiceEvent',
+    'InvoiceItem',
+    'InvoiceLink',
+    'InvoicePayment',
+    'LineItem',
+    'RecurringInvoice',
+    'RecurringInvoiceRun',
 ]

dime_payments/data_objects/invoice.py

@@ -0,0 +1,62 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_array, arr_bool, arr_int, arr_object, arr_string
+from .invoice_customer import InvoiceCustomer
+from .invoice_event import InvoiceEvent
+from .invoice_payment import InvoicePayment
+from .line_item import LineItem
+
+
+@dataclass
+class Invoice:
+    """
+    A full invoice as returned by the show, create, update and action endpoints.
+
+    Money fields arrive as dollar amounts and are kept as strings, consistent
+    with the rest of the SDK, to avoid float rounding.
+    """
+
+    id: int | None = None
+    token: str | None = None
+    invoice_number: str | None = None
+    status: str | None = None
+    payment_terms: str | None = None
+    issue_date: str | None = None
+    due_date: str | None = None
+    is_overdue: bool = False
+    subtotal: str | None = None
+    total: str | None = None
+    amount_paid: str | None = None
+    balance: str | None = None
+    allow_partial_payment: bool = False
+    thank_you_note: str | None = None
+    public_url: str | None = None
+    customer: InvoiceCustomer = field(default_factory=InvoiceCustomer)
+    items: list[LineItem] = field(default_factory=list)
+    payments: list[InvoicePayment] = field(default_factory=list)
+    events: list[InvoiceEvent] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'Invoice':
+        return cls(
+            id=arr_int(data, 'id'),
+            token=arr_string(data, 'token'),
+            invoice_number=arr_string(data, 'invoice_number'),
+            status=arr_string(data, 'status'),
+            payment_terms=arr_string(data, 'payment_terms'),
+            issue_date=arr_string(data, 'issue_date'),
+            due_date=arr_string(data, 'due_date'),
+            is_overdue=arr_bool(data, 'is_overdue'),
+            subtotal=arr_string(data, 'subtotal'),
+            total=arr_string(data, 'total'),
+            amount_paid=arr_string(data, 'amount_paid'),
+            balance=arr_string(data, 'balance'),
+            allow_partial_payment=arr_bool(data, 'allow_partial_payment'),
+            thank_you_note=arr_string(data, 'thank_you_note'),
+            public_url=arr_string(data, 'public_url'),
+            customer=InvoiceCustomer.from_dict(arr_object(data, 'customer')),
+            items=[LineItem.from_dict(i) for i in arr_array(data, 'items') if isinstance(i, dict)],
+            payments=[InvoicePayment.from_dict(p) for p in arr_array(data, 'payments') if isinstance(p, dict)],
+            events=[InvoiceEvent.from_dict(e) for e in arr_array(data, 'events') if isinstance(e, dict)],
+        )

dime_payments/data_objects/invoice_customer.py

@@ -0,0 +1,21 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+
+
+@dataclass
+class InvoiceCustomer:
+    """The customer snapshot embedded in an invoice response."""
+
+    id: int | None = None
+    name: str | None = None
+    email: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'InvoiceCustomer':
+        return cls(
+            id=arr_int(data, 'id'),
+            name=arr_string(data, 'name'),
+            email=arr_string(data, 'email'),
+        )

dime_payments/data_objects/invoice_event.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_string
+
+
+@dataclass
+class InvoiceEvent:
+    """An entry in an invoice's history (created, sent, paid, voided, ...)."""
+
+    type: str | None = None
+    label: str | None = None
+    description: str | None = None
+    created_at: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'InvoiceEvent':
+        return cls(
+            type=arr_string(data, 'type'),
+            label=arr_string(data, 'label'),
+            description=arr_string(data, 'description'),
+            created_at=arr_string(data, 'created_at'),
+        )

dime_payments/data_objects/invoice_item.py

@@ -0,0 +1,29 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_bool, arr_int, arr_string
+
+
+@dataclass
+class InvoiceItem:
+    """
+    A Merchant item (fund or designation) that invoice line items reference by
+    ``item_id``. This is the catalog entry, not a line on an invoice — for that,
+    see :class:`LineItem`.
+    """
+
+    id: int | None = None
+    name: str | None = None
+    description: str | None = None
+    price: str | None = None
+    tax_deductible: bool = False
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'InvoiceItem':
+        return cls(
+            id=arr_int(data, 'id'),
+            name=arr_string(data, 'name'),
+            description=arr_string(data, 'description'),
+            price=arr_string(data, 'price'),
+            tax_deductible=arr_bool(data, 'tax_deductible'),
+        )

dime_payments/data_objects/invoice_link.py

@@ -0,0 +1,19 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_string
+
+
+@dataclass
+class InvoiceLink:
+    """The public payment link for an invoice."""
+
+    public_url: str | None = None
+    token: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'InvoiceLink':
+        return cls(
+            public_url=arr_string(data, 'public_url'),
+            token=arr_string(data, 'token'),
+        )

dime_payments/data_objects/invoice_payment.py

@@ -0,0 +1,23 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+
+
+@dataclass
+class InvoicePayment:
+    """A payment recorded against an invoice."""
+
+    amount: str | None = None
+    paid_at: str | None = None
+    method: str | None = None
+    transaction_id: int | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'InvoicePayment':
+        return cls(
+            amount=arr_string(data, 'amount'),
+            paid_at=arr_string(data, 'paid_at'),
+            method=arr_string(data, 'method'),
+            transaction_id=arr_int(data, 'transaction_id'),
+        )

dime_payments/data_objects/line_item.py

@@ -0,0 +1,33 @@
+from dataclasses import dataclass
+from typing import Any
+
+from ..support.arr import arr_int, arr_string
+
+
+@dataclass
+class LineItem:
+    """
+    A single line on an invoice. ``item_id`` points at the Merchant item the line
+    was sourced from; ``name`` and ``unit_price`` are snapshotted at creation so
+    later edits to the item do not rewrite history.
+    """
+
+    id: int | None = None
+    item_id: int | None = None
+    name: str | None = None
+    description: str | None = None
+    quantity: str | None = None
+    unit_price: str | None = None
+    amount: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'LineItem':
+        return cls(
+            id=arr_int(data, 'id'),
+            item_id=arr_int(data, 'item_id'),
+            name=arr_string(data, 'name'),
+            description=arr_string(data, 'description'),
+            quantity=arr_string(data, 'quantity'),
+            unit_price=arr_string(data, 'unit_price'),
+            amount=arr_string(data, 'amount'),
+        )

dime_payments/data_objects/recurring_invoice.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from ..support.arr import arr_array, arr_int, arr_object, arr_string
+from .invoice_customer import InvoiceCustomer
+from .line_item import LineItem
+
+
+@dataclass
+class RecurringInvoiceRun:
+    """A summary of one invoice already emitted by a recurring template."""
+
+    id: int | None = None
+    invoice_number: str | None = None
+    status: str | None = None
+    total: str | None = None
+    issue_date: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'RecurringInvoiceRun':
+        return cls(
+            id=arr_int(data, 'id'),
+            invoice_number=arr_string(data, 'invoice_number'),
+            status=arr_string(data, 'status'),
+            total=arr_string(data, 'total'),
+            issue_date=arr_string(data, 'issue_date'),
+        )
+
+
+@dataclass
+class RecurringInvoice:
+    """
+    A recurring-invoice template. ``recurrence_schedule`` is one of Weekly,
+    Biweekly, FirstFifteenth, Monthly or Yearly.
+    """
+
+    id: int | None = None
+    status: str | None = None
+    recurrence_schedule: str | None = None
+    payment_terms: str | None = None
+    start_date: str | None = None
+    end_date: str | None = None
+    next_run_date: str | None = None
+    last_run_date: str | None = None
+    thank_you_note: str | None = None
+    customer: InvoiceCustomer = field(default_factory=InvoiceCustomer)
+    items: list[LineItem] = field(default_factory=list)
+    upcoming_run_dates: list[str] = field(default_factory=list)
+    invoices: list[RecurringInvoiceRun] = field(default_factory=list)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> 'RecurringInvoice':
+        return cls(
+            id=arr_int(data, 'id'),
+            status=arr_string(data, 'status'),
+            recurrence_schedule=arr_string(data, 'recurrence_schedule'),
+            payment_terms=arr_string(data, 'payment_terms'),
+            start_date=arr_string(data, 'start_date'),
+            end_date=arr_string(data, 'end_date'),
+            next_run_date=arr_string(data, 'next_run_date'),
+            last_run_date=arr_string(data, 'last_run_date'),
+            thank_you_note=arr_string(data, 'thank_you_note'),
+            customer=InvoiceCustomer.from_dict(arr_object(data, 'customer')),
+            items=[LineItem.from_dict(i) for i in arr_array(data, 'items') if isinstance(i, dict)],
+            upcoming_run_dates=[str(d) for d in arr_array(data, 'upcoming_run_dates')],
+            invoices=[RecurringInvoiceRun.from_dict(i) for i in arr_array(data, 'invoices') if isinstance(i, dict)],
+        )

dime_payments/http/transport.py

@@ -11,7 +11,7 @@ from .error_handler import ErrorHandler
 if TYPE_CHECKING:
     from ..config import Config
 
-SDK_VERSION = '1.0.0'
+SDK_VERSION = '1.2.0'
 
 
 class Transport:

dime_payments/resources/invoices.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..data_objects.invoice import Invoice
+from ..data_objects.invoice_item import InvoiceItem
+from ..data_objects.invoice_link import InvoiceLink
+from ..data_objects.message_result import MessageResult
+from ..pagination.cursor_page import CursorPage
+from .abstract_resource import AbstractResource
+
+
+class Invoices(AbstractResource):
+    """
+    Invoice endpoints.
+
+    Every method takes the merchant ``sid`` explicitly; remaining fields go in an
+    ``attributes`` dict. Identify the customer with ``customer_uuid`` — the same
+    identifier the customer, payment-method and address endpoints use, and the
+    only one :class:`Customer` exposes. ``customer_id`` is still accepted for
+    integrations written against the original contract; supply exactly one.
+
+    Line-item and invoice mutations return the refreshed invoice, so the caller
+    always sees recalculated totals rather than a detached fragment.
+    """
+
+    def list(self, sid: str, filters: dict[str, Any] | None = None) -> CursorPage[Invoice]:
+        body = self._envelope({'sid': sid}, filters or {})
+        return self._paginate('GET', 'invoices', body, Invoice.from_dict)
+
+    def show(self, sid: str, invoice_id: int | str) -> Invoice:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('GET', 'invoice', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def create(self, sid: str, attributes: dict[str, Any]) -> Invoice:
+        """
+        Create a draft invoice. Requires ``customer_uuid`` (or ``customer_id``),
+        ``customer_name``, ``customer_email``, ``payment_terms``
+        (``due_on_receipt`` | ``net_15`` | ``net_30`` | ``net_60``) and at least
+        one entry in ``lines``, each referencing a Merchant ``item_id``.
+        """
+        body = self._envelope({'sid': sid} | attributes)
+        raw = self._transport.request('POST', 'invoice/create', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def update(self, sid: str, invoice_id: int | str, attributes: dict[str, Any]) -> Invoice:
+        """Update a draft invoice. Passing ``lines`` replaces the existing lines."""
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id} | attributes)
+        raw = self._transport.request('PATCH', 'invoice/update', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def delete(self, sid: str, invoice_id: int | str) -> MessageResult:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('POST', 'invoice/delete', body)
+        return MessageResult.from_dict(raw.get('data') or raw)
+
+    def send(self, sid: str, invoice_id: int | str) -> Invoice:
+        """Email the invoice and advance it to Sent."""
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('POST', 'invoice/send', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def mark_sent(self, sid: str, invoice_id: int | str) -> Invoice:
+        """Activate a draft for payment without emailing it."""
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('POST', 'invoice/mark-sent', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def void(self, sid: str, invoice_id: int | str) -> Invoice:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('PATCH', 'invoice/void', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def duplicate(self, sid: str, invoice_id: int | str) -> Invoice:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('POST', 'invoice/duplicate', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def pay(self, sid: str, invoice_id: int | str, attributes: dict[str, Any]) -> Invoice:
+        """
+        Record a merchant-initiated (MOTO) payment against an open invoice.
+
+        ``payment_type`` is required and is either ``cc`` or ``ach``. For a card,
+        pass a stored ``token`` or raw ``cardholder_name`` / ``card_number`` /
+        ``expiration_date``; for ACH, pass ``routing_number`` /
+        ``account_number`` / ``account_type`` / ``account_name``. Omit ``amount``
+        to pay the full balance.
+        """
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id} | attributes)
+        raw = self._transport.request('POST', 'invoice/pay', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def get_link(self, sid: str, invoice_id: int | str) -> InvoiceLink:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id})
+        raw = self._transport.request('GET', 'invoice/link', body)
+        return InvoiceLink.from_dict(raw.get('data') or {})
+
+    def list_items(self, sid: str) -> list[InvoiceItem]:
+        """
+        List the Merchant's items (funds/designations) that line items can
+        reference. Scoped to the merchant, not to a single invoice — an
+        invoice's own lines are on :attr:`Invoice.items`.
+        """
+        body = self._envelope({'sid': sid})
+        raw = self._transport.request('GET', 'invoice/items', body)
+        items = raw.get('data', [])
+        if isinstance(items, dict):
+            items = list(items.values())
+        return [InvoiceItem.from_dict(item) for item in items if isinstance(item, dict)]
+
+    def create_item(self, sid: str, attributes: dict[str, Any]) -> InvoiceItem:
+        """
+        Create an invoicing-only Merchant item. ``name`` is required;
+        ``description``, ``price`` and ``tax_deductible`` are optional.
+        """
+        body = self._envelope({'sid': sid} | attributes)
+        raw = self._transport.request('POST', 'invoice/item/create', body)
+        return InvoiceItem.from_dict(raw.get('data') or {})
+
+    def add_line_item(self, sid: str, invoice_id: int | str, attributes: dict[str, Any]) -> Invoice:
+        body = self._envelope({'sid': sid, 'invoice_id': invoice_id} | attributes)
+        raw = self._transport.request('POST', 'invoice/line-item/add', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def update_line_item(
+        self,
+        sid: str,
+        invoice_id: int | str,
+        line_item_id: int | str,
+        attributes: dict[str, Any],
+    ) -> Invoice:
+        body = self._envelope(
+            {'sid': sid, 'invoice_id': invoice_id, 'line_item_id': line_item_id} | attributes
+        )
+        raw = self._transport.request('PATCH', 'invoice/line-item/update', body)
+        return Invoice.from_dict(raw.get('data') or {})
+
+    def delete_line_item(self, sid: str, invoice_id: int | str, line_item_id: int | str) -> Invoice:
+        body = self._envelope(
+            {'sid': sid, 'invoice_id': invoice_id, 'line_item_id': line_item_id}
+        )
+        raw = self._transport.request('POST', 'invoice/line-item/delete', body)
+        return Invoice.from_dict(raw.get('data') or {})

dime_payments/resources/recurring_invoices.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ..data_objects.recurring_invoice import RecurringInvoice
+from ..pagination.cursor_page import CursorPage
+from .abstract_resource import AbstractResource
+
+
+class RecurringInvoices(AbstractResource):
+    def list(self, sid: str, filters: dict[str, Any] | None = None) -> CursorPage[RecurringInvoice]:
+        body = self._envelope({'sid': sid}, filters or {})
+        return self._paginate('GET', 'recurring-invoices', body, RecurringInvoice.from_dict)
+
+    def show(self, sid: str, recurring_invoice_id: int | str) -> RecurringInvoice:
+        body = self._envelope({'sid': sid, 'recurring_invoice_id': recurring_invoice_id})
+        raw = self._transport.request('GET', 'recurring-invoice', body)
+        return RecurringInvoice.from_dict(raw.get('data') or {})
+
+    def create(self, sid: str, attributes: dict[str, Any]) -> RecurringInvoice:
+        body = self._envelope({'sid': sid} | attributes)
+        raw = self._transport.request('POST', 'recurring-invoice/create', body)
+        return RecurringInvoice.from_dict(raw.get('data') or {})
+
+    def cancel(self, sid: str, recurring_invoice_id: int | str) -> RecurringInvoice:
+        body = self._envelope({'sid': sid, 'recurring_invoice_id': recurring_invoice_id})
+        raw = self._transport.request('POST', 'recurring-invoice/cancel', body)
+        return RecurringInvoice.from_dict(raw.get('data') or {})

{dime_python_sdk-1.0.0.dist-info → dime_python_sdk-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dime-python-sdk
-Version: 1.0.0
+Version: 1.2.0
 Summary: Python client for the Dime Payments API
 Author: Dime Technology
 License: MIT License
@@ -118,6 +118,8 @@ returned as strings to avoid float rounding.
 | `dime.addresses`                | list, show, create, update, delete                                    |
 | `dime.deposits`                 | list, list_with_transactions, show                                    |
 | `dime.recurring_payments`       | list, show, create, edit, pause, cancel, activate, delete             |
+| `dime.invoices`                 | list, show, create, update, delete, send, mark_sent, void, duplicate, pay, get_link, list_items, add_line_item, update_line_item, delete_line_item, create_item |
+| `dime.recurring_invoices`       | list, show, create, cancel                                            |
 
 ### Transactions
 
@@ -208,6 +210,83 @@ dime.recurring_payments.activate('000010', rp.id)
 dime.recurring_payments.cancel('000010', rp.id)
 ```
 
+### Invoices
+
+Invoices are scoped to a merchant `sid` and built from line items that each reference a merchant
+item (a fund or designation). Draft invoices can be edited; once sent they are locked.
+
+Identify the customer with `customer_uuid` — the same uuid every other resource uses, and the only
+identifier the customer endpoints return. `customer_id` is still accepted for older integrations.
+
+```python
+# Look up (or create) the merchant items a line can reference
+items = dime.invoices.list_items('000010')
+item = dime.invoices.create_item('000010', {
+    'name': 'Consulting',
+    'description': 'Professional services',
+    'price': 125,
+    'tax_deductible': False,
+})
+
+# Create a draft invoice with one or more line items
+invoice = dime.invoices.create('000010', {
+    'customer_uuid': customer.uuid,
+    'customer_name': 'Jane Doe',
+    'customer_email': 'jane@example.com',
+    'payment_terms': 'net_15',  # due_on_receipt | net_15 | net_30 | net_60
+    'lines': [
+        {'item_id': item.id, 'name': 'Consulting', 'description': '2 hours',
+         'quantity': 2, 'unit_price': 125},
+    ],
+})
+
+# Line-item edits return the refreshed invoice, with totals recalculated
+invoice = dime.invoices.add_line_item('000010', invoice.id, {
+    'item_id': item.id, 'name': 'Setup', 'quantity': 1, 'unit_price': 50,
+})
+invoice = dime.invoices.update_line_item('000010', invoice.id, invoice.items[0].id, {'quantity': 3})
+invoice = dime.invoices.delete_line_item('000010', invoice.id, invoice.items[0].id)
+
+# Email it to the customer, or activate the pay link without emailing
+dime.invoices.send('000010', invoice.id)
+dime.invoices.mark_sent('000010', invoice.id)
+
+# Share the public pay link
+link = dime.invoices.get_link('000010', invoice.id)
+print(link.public_url)
+
+# Take a merchant-initiated payment. payment_type is required; omit amount to
+# pay the full balance.
+dime.invoices.pay('000010', invoice.id, {
+    'payment_type': 'cc',  # cc | ach
+    'token': pm.token,
+    'amount': 125,
+})
+
+dime.invoices.void('000010', invoice.id)
+dime.invoices.duplicate('000010', invoice.id)
+```
+
+### Recurring invoices
+
+Templates that emit an invoice on a schedule.
+
+```python
+ri = dime.recurring_invoices.create('000010', {
+    'customer_uuid': customer.uuid,
+    'payment_terms': 'net_30',
+    'recurring_frequency': 'Monthly',  # Weekly | Biweekly | FirstFifteenth | Monthly | Yearly
+    'recurring_start_date': '2026-09-01',
+    'lines': [
+        {'item_id': item.id, 'name': 'Retainer', 'quantity': 1, 'unit_price': 500},
+    ],
+})
+
+print(ri.next_run_date, ri.upcoming_run_dates)
+
+dime.recurring_invoices.cancel('000010', ri.id)
+```
+
 ## Pagination
 
 List endpoints return a `CursorPage`. Iterate one page, walk pages manually, or stream every
@@ -271,7 +350,9 @@ except DimeException as e:
 ## Notes
 
 - **GET requests carry a JSON body.** The Dime API expects read parameters in the request body
-  even for `GET` endpoints; the SDK handles this transparently.
+  even for `GET` endpoints; the SDK handles this transparently. Point `base_url` at an `https://`
+  origin — an `http://` URL that 301-redirects to `https` will have its request body dropped by the
+  redirect, which surfaces as a `403` "You do not have access to this company." from the API.
 - **No API versioning.** Endpoints live under `/api` with no version prefix.
 
 ## Development

{dime_python_sdk-1.0.0.dist-info → dime_python_sdk-1.2.0.dist-info}/RECORD

@@ -1,16 +1,24 @@
 dime_payments/__init__.py,sha256=nJGtKtehbZMxar3wgdk8RIG_nNPSb6G9rmMyC2PnjqM,638
-dime_payments/client.py,sha256=K4riOAzgJJvZUfICZxuh34fD0q5oUDeqRExNH51xhRA,1120
-dime_payments/config.py,sha256=io97prwhlASHBRl0nm_YwckMuJxXFP2ylpsfbT7Bys8,847
-dime_payments/data_objects/__init__.py,sha256=1t2xoZ5rX7RoAO9r-rAsTHoyHBNsK8_sEzHQ_8o1pWY,888
+dime_payments/client.py,sha256=dX_mH2q_hBZrC2s8B3Y3EYy3AWAvUYgTDNf1M0i9aFM,1328
+dime_payments/config.py,sha256=uRmAy2Pon8Uz1CzVPQp47Gk1VQl5aRsQRXf-FA9xSPY,847
+dime_payments/data_objects/__init__.py,sha256=fuavK4aZ-IFM_PyMpJ8fIZlip7-V5m5LOHTCr2XnZng,1409
 dime_payments/data_objects/address.py,sha256=ocnxRM3JDLr4mDtlnVgsnUb6Hy5u6vNQlWVRFHzuMIw,950
 dime_payments/data_objects/customer.py,sha256=fSUPB9PynX_R3Jntnjr130ExeZtgrmRZSVfds54rmV0,1141
 dime_payments/data_objects/deposit.py,sha256=b0rQdNgdprMtP0pdMrepsWG3jBt7fJ4FGZ1EuHTRQhA,1139
 dime_payments/data_objects/deposit_group.py,sha256=kmfwnDO0YgmvmlSvIakb4cMFYOMfYDDnXMR4eiabSKA,813
 dime_payments/data_objects/deposit_with_transactions.py,sha256=HjmWB5v2R67z5xgqoZt1rlV5nxvixrTmySS-zzUFA0c,1420
 dime_payments/data_objects/form_link.py,sha256=rPU7cJynsrfb_1QjT8DkZ8ShvXVXUScBqJNZVASeJCI,280
+dime_payments/data_objects/invoice.py,sha256=x2_UplLFnmj2_BwTI2tgzflQJbCXdCk9jmmAoOlrWxg,2622
+dime_payments/data_objects/invoice_customer.py,sha256=GtnomaFO8xlpRuElMPPAAtlT5DwJLyp3NB5wGqdW9Bc,528
+dime_payments/data_objects/invoice_event.py,sha256=dvKOfcB9sxE6ehFQyB_lsfpA6iMFX3oK5WAUjSIpgDk,646
+dime_payments/data_objects/invoice_item.py,sha256=aVgO0UM7vqJB2VjvtYMBpLsCWXKHus0r7pA9I7UHwxo,856
+dime_payments/data_objects/invoice_link.py,sha256=kiWSXkl4jtsCZ-ODsEaFU12mTk3soe0qZ7ICDJ2MiEE,452
+dime_payments/data_objects/invoice_payment.py,sha256=jDllzFpRdaWAa0s89iNPdQG0dy61S47hvEMIbnKEpv8,635
+dime_payments/data_objects/line_item.py,sha256=EJtpxnSOoCOlZJcrq8jDarieICPHtQK-g6jipTDMDAg,1024
 dime_payments/data_objects/merchant.py,sha256=U6RbP3QJACjOtrSExyodfz9zOzeU2hThXwGD6M0XATI,1900
 dime_payments/data_objects/message_result.py,sha256=2gZYbokwPRdlBUz_vGgYzrJpxMnjMuzwtTdjXhUv1GM,299
 dime_payments/data_objects/payment_method.py,sha256=-3kcHBGoXD12mzHocMoKU0aBwoNJ_9GJFx5eldXUJxA,2460
+dime_payments/data_objects/recurring_invoice.py,sha256=r5Qf656ByedP0LhmoEg9KVsIpC_svaPGEu231Mqqiy8,2612
 dime_payments/data_objects/recurring_payment.py,sha256=E6F3oX6aqWeE2Ek4ePqDDbZ79APdIKKXVip4bTcFU-g,2209
 dime_payments/data_objects/recurring_payment_method.py,sha256=P22ITvvxAUJ4NaEc7MH2ItCFm6wk1mEuxRs4ffSUDrg,402
 dime_payments/data_objects/tokenize_result.py,sha256=i27Hc0A-dFM8cX8s9A71yM95kd48ih25fvnb3SEml54,295
@@ -28,7 +36,7 @@ dime_payments/exceptions/server_exception.py,sha256=SCUubaM1wTwFMW3E9mBSxry4A-0Q
 dime_payments/exceptions/validation_exception.py,sha256=_HGMPN-5iFq6RWJY-06Oaak565MeD-yRf6GnbXp7Sog,689
 dime_payments/http/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dime_payments/http/error_handler.py,sha256=dqClsyDIcCPS6CtiqtGvEwTnORj24m2muXThXfHdhX0,2873
-dime_payments/http/transport.py,sha256=G2dPpXckNBUKjc0MwmzopF8YfACMR3LR3M9RROyX_Nw,2642
+dime_payments/http/transport.py,sha256=xYJ1OWHDTuTGuZgZPCLsV75AXEHUDyH1enBoIwwurac,2642
 dime_payments/pagination/__init__.py,sha256=J2k8htn29Nu92KQh4wtEeN0StyMc8cWxVY8jQydF-dQ,62
 dime_payments/pagination/cursor_page.py,sha256=Xpbt33ceBy_HQlqe3wFbxA93bUfx3rHcqXfhVAkOQJ0,2263
 dime_payments/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -36,13 +44,15 @@ dime_payments/resources/abstract_resource.py,sha256=-XmnqJvk2tVNe44JeY_TTAzD4UiU
 dime_payments/resources/addresses.py,sha256=sg0q3YCnkdGlGM0onbBh_UsatrIu4VyzAA1BdZ1QRZ0,1713
 dime_payments/resources/customers.py,sha256=6_9gG9tc2uHN-onhzNFP0NO67NxGOYqbwZmF96vU4bo,1545
 dime_payments/resources/deposits.py,sha256=k8wE7kT_baHjXmXxzN9v6_2BqDb0GSUlINPRVtjmyUI,1213
+dime_payments/resources/invoices.py,sha256=_n2MPmBgn4IvQ9nhq9q8gSuVrxDDjfs5251S9PpywwA,7062
 dime_payments/resources/merchants.py,sha256=blVx7JIAps9ktdpLjjQofEnVkK_KgXOQP8beBPkHrkg,1370
 dime_payments/resources/payment_methods.py,sha256=KJWryjnZadyohG1r6pmULjwPIjPIjScSK7ekQYamvYA,1775
+dime_payments/resources/recurring_invoices.py,sha256=mn-I-0o_uac6w-8HiwIWS2y0ptCZpVLZm3F60cyhl8w,1431
 dime_payments/resources/recurring_payments.py,sha256=DPihjc-C7oLLfPrP5UveNpEKHmUxayv4k3hFpguJ35c,2940
 dime_payments/resources/transactions.py,sha256=Q0VwYDicdGuM1WQXqxPX_KS313A0KZVCeuVCyKS_G7k,2742
 dime_payments/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dime_payments/support/arr.py,sha256=_mboi_q3HGn_Sx_MgU2exkbl-fnP2gdDY8yeSC8hkNc,1722
-dime_python_sdk-1.0.0.dist-info/METADATA,sha256=YdWerOwvU8IBJOFjpxJg3HuuEbrDW-oC19Mp9SJJeBo,9553
-dime_python_sdk-1.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
-dime_python_sdk-1.0.0.dist-info/licenses/LICENSE,sha256=-Xc5dLgfuFLVQLsSKNYmJKtNZCUU1_9ErffdGiwH-DU,1072
-dime_python_sdk-1.0.0.dist-info/RECORD,,
+dime_python_sdk-1.2.0.dist-info/METADATA,sha256=RwVXCQEwsDl3sm2uRGyIORwqFTAIP-o_6lQMuDVsGhk,12723
+dime_python_sdk-1.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+dime_python_sdk-1.2.0.dist-info/licenses/LICENSE,sha256=-Xc5dLgfuFLVQLsSKNYmJKtNZCUU1_9ErffdGiwH-DU,1072
+dime_python_sdk-1.2.0.dist-info/RECORD,,

{dime_python_sdk-1.0.0.dist-info → dime_python_sdk-1.2.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.30.1
+Generator: hatchling 1.31.0
 Root-Is-Purelib: true
 Tag: py3-none-any