```python
import pm4py
from pm4py.objects.powl.obj import StrictPartialOrder, OperatorPOWL, Transition
from pm4py.objects.process_tree.obj import Operator

# Define the activities as transitions
create_purchase_requisition = Transition(label="Create Purchase Requisition")
approve_purchase_requisition = Transition(label="Approve Purchase Requisition")
create_purchase_order = Transition(label="Create Purchase Order")
receive_goods = Transition(label="Receive Goods")
create_invoice = Transition(label="Create Invoice")
approve_invoice = Transition(label="Approve Invoice")
make_payment = Transition(label="Make Payment")

# Define the optional rework loop for invoice approval
rework_invoice = OperatorPOWL(operator=Operator.LOOP, children=[approve_invoice, create_invoice])

# Define the main process flow as a strict partial order
purchase_to_pay_process = StrictPartialOrder(nodes=[
    create_purchase_requisition,
    approve_purchase_requisition,
    create_purchase_order,
    receive_goods,
    rework_invoice,
    make_payment
])

# Add the order constraints
purchase_to_pay_process.order.add_edge(create_purchase_requisition, approve_purchase_requisition)
purchase_to_pay_process.order.add_edge(approve_purchase_requisition, create_purchase_order)
purchase_to_pay_process.order.add_edge(create_purchase_order, receive_goods)
purchase_to_pay_process.order.add_edge(receive_goods, rework_invoice)
purchase_to_pay_process.order.add_edge(rework_invoice, make_payment)

# The 'purchase_to_pay_process' variable now holds the POWL model

# You can visualize the POWL model (requires graphviz)
# pm4py.view_powl(purchase_to_pay_process)

# You can also export the POWL model to a .pnml file
# pm4py.write_pnml(purchase_to_pay_process, "purchase_to_pay_process.pnml")
```

**Explanation:**

1. **Define Activities:** Each activity in the Purchase-to-Pay process is defined as a `Transition` object with a descriptive label.
2. **Define Rework Loop:** The optional rework loop for invoice approval is modeled using an `OperatorPOWL` with the `LOOP` operator. This loop iterates between `approve_invoice` and `create_invoice` until the invoice is approved.
3. **Define Main Process Flow:** The overall process flow is defined as a `StrictPartialOrder` containing all the activities and the rework loop.
4. **Add Order Constraints:** The `order.add_edge()` method is used to define the execution order between the nodes. For example, `purchase_to_pay_process.order.add_edge(create_purchase_requisition, approve_purchase_requisition)` specifies that the purchase requisition must be created before it can be approved.
5. **Visualization and Export (Optional):** The code includes commented-out lines for visualizing the POWL model using `pm4py.view_powl()` and exporting it to a .pnml file using `pm4py.write_pnml()`.

**This code provides a basic implementation of the Purchase-to-Pay process as a POWL model. You can further extend this model by adding more activities, loops, or choices as needed.**
