Skip to content

Payment Drafts Pydantic Models

In order to simplify and standardize the data that is passed between the client and the Revolut Business API, PyRevolut uses Pydantic models to define the structure of the data. Below are the Pydantic models used by the Payment Drafts endpoint.

RetrieveAllPaymentDrafts

Get a list of all the payment drafts that aren't processed.

Source code in pyrevolut/api/payment_drafts/get/retrieve_all_payment_drafts.py 
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
class RetrieveAllPaymentDrafts:
    """
    Get a list of all the payment drafts that aren't processed.
    """

    ROUTE = "/1.0/payment-drafts"

    class Params(BaseModel):
        """
        The parameters for the endpoint.
        """

        pass

    class Response(BaseModel):
        """
        The response model for the endpoint.
        """

        class ModelPaymentOrder(BaseModel):
            """A payment draft."""

            id: Annotated[UUID, Field(description="The ID of the payment draft.")]
            scheduled_for: Annotated[
                Date | None,
                Field(
                    description="The scheduled date of the payment draft in ISO 8601 format."
                ),
            ] = None
            title: Annotated[
                str | None,
                Field(description="The title of the payment draft."),
            ] = None
            payment_counts: Annotated[
                int,
                Field(description="The number of payments in the payment draft.", ge=0),
            ]

        payment_orders: Annotated[
            list[ModelPaymentOrder],
            Field(description="The list of payment drafts."),
        ]

Params

Bases: BaseModel

The parameters for the endpoint.

Source code in pyrevolut/api/payment_drafts/get/retrieve_all_payment_drafts.py 
16
17
18
19
20
21
class Params(BaseModel):
    """
    The parameters for the endpoint.
    """

    pass

Response

Bases: BaseModel

The response model for the endpoint.

Source code in pyrevolut/api/payment_drafts/get/retrieve_all_payment_drafts.py 
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
class Response(BaseModel):
    """
    The response model for the endpoint.
    """

    class ModelPaymentOrder(BaseModel):
        """A payment draft."""

        id: Annotated[UUID, Field(description="The ID of the payment draft.")]
        scheduled_for: Annotated[
            Date | None,
            Field(
                description="The scheduled date of the payment draft in ISO 8601 format."
            ),
        ] = None
        title: Annotated[
            str | None,
            Field(description="The title of the payment draft."),
        ] = None
        payment_counts: Annotated[
            int,
            Field(description="The number of payments in the payment draft.", ge=0),
        ]

    payment_orders: Annotated[
        list[ModelPaymentOrder],
        Field(description="The list of payment drafts."),
    ]

ModelPaymentOrder

Bases: BaseModel

A payment draft.

Source code in pyrevolut/api/payment_drafts/get/retrieve_all_payment_drafts.py 
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class ModelPaymentOrder(BaseModel):
    """A payment draft."""

    id: Annotated[UUID, Field(description="The ID of the payment draft.")]
    scheduled_for: Annotated[
        Date | None,
        Field(
            description="The scheduled date of the payment draft in ISO 8601 format."
        ),
    ] = None
    title: Annotated[
        str | None,
        Field(description="The title of the payment draft."),
    ] = None
    payment_counts: Annotated[
        int,
        Field(description="The number of payments in the payment draft.", ge=0),
    ]

RetrievePaymentDraft

Get the information about a specific payment draft by ID.

Source code in pyrevolut/api/payment_drafts/get/retrieve_payment_draft.py 
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
class RetrievePaymentDraft:
    """
    Get the information about a specific payment draft by ID.
    """

    ROUTE = "/1.0/payment-drafts/{payment_draft_id}"

    class Params(BaseModel):
        """
        The parameters for the endpoint.
        """

        pass

    class Response(BaseModel):
        """
        The response model for the endpoint.
        """

        class ModelPayment(BaseModel):
            """A payment draft."""

            class ModelAmount(ModelBaseAmount):
                """The amount of the payment draft."""

                pass

            class ModelReceiver(BaseModel):
                """The details of the transfer recipient.

                If the counterparty has multiple payment methods available
                (e.g. 2 accounts, or 1 account and 1 card), you must specify the
                account (account_id) or card (card_id) to which you want to transfer the money.
                """

                counterparty_id: Annotated[
                    UUID,
                    Field(description="The ID of the receiving counterparty."),
                ]
                account_id: Annotated[
                    UUID | None,
                    Field(
                        description="""
                        The ID of the receiving counterparty's account, which can be own account. 
                        Used for bank transfers.

                        If the counterparty has multiple payment methods available, use it to 
                        specify the account to which you want to send the money.
                        """
                    ),
                ] = None
                card_id: Annotated[
                    UUID | None,
                    Field(
                        description="""
                        The ID of the receiving counterparty's card. Used for card transfers.

                        If the counterparty has multiple payment methods available, use it to 
                        specify the card to which you want to send the money.
                        """
                    ),
                ] = None

            class ModelCurrentChargeOptions(BaseModel):
                """The explanation of conversion process"""

                model_config = ConfigDict(
                    populate_by_name=True,
                    from_attributes=True,
                )

                class ModelFrom(ModelBaseAmount):
                    """The source of the conversion"""

                    pass

                class ModelTo(ModelBaseAmount):
                    """The target of the conversion"""

                    pass

                class ModelFee(ModelBaseAmount):
                    """The fee of the conversion"""

                    pass

                from_: Annotated[
                    ModelFrom,
                    Field(alias="from", description="The source of the conversion."),
                ]
                to: Annotated[
                    ModelTo,
                    Field(description="The target of the conversion."),
                ]
                rate: Annotated[
                    float | None,
                    Field(description="The exchange rate used for the conversion."),
                ] = None
                fee: Annotated[
                    ModelFee | None,
                    Field(description="The fee of the conversion."),
                ] = None

            id: Annotated[UUID, Field(description="The ID of the payment draft.")]
            amount: Annotated[
                ModelAmount,
                Field(description="The amount of the payment draft."),
            ]
            currency: Annotated[
                Currency | None,
                Field(description="The currency of the payment draft."),
            ] = None
            account_id: Annotated[
                UUID,
                Field(description="The ID of the account to pay from."),
            ]
            receiver: Annotated[
                ModelReceiver,
                Field(
                    description="""
                    The details of the transfer recipient.

                    If the counterparty has multiple payment methods available 
                    (e.g. 2 accounts, or 1 account and 1 card), you must specify the 
                    account (account_id) or card (card_id) to which you want to transfer the money.
                    """
                ),
            ]
            state: Annotated[
                EnumPaymentDraftState,
                Field(description="The state of the payment draft."),
            ]
            reason: Annotated[
                str | None,
                Field(description="The reason for the payment draft state."),
            ] = None
            error_message: Annotated[
                str | None,
                Field(description="The description of the error message."),
            ] = None
            current_charge_options: Annotated[
                ModelCurrentChargeOptions,
                Field(description="The explanation of conversion process."),
            ]
            reference: Annotated[
                str | None,
                Field(description="The description of the transaction."),
            ] = None

        scheduled_for: Annotated[
            Date | None,
            Field(
                description="The scheduled date of the payment draft in ISO 8601 format."
            ),
        ] = None
        title: Annotated[
            str | None,
            Field(description="The title of the payment draft."),
        ] = None
        payments: Annotated[
            list[ModelPayment],
            Field(description="The list of payment drafts."),
        ]

Params

Bases: BaseModel

The parameters for the endpoint.

Source code in pyrevolut/api/payment_drafts/get/retrieve_payment_draft.py 
18
19
20
21
22
23
class Params(BaseModel):
    """
    The parameters for the endpoint.
    """

    pass

Response

Bases: BaseModel

The response model for the endpoint.

Source code in pyrevolut/api/payment_drafts/get/retrieve_payment_draft.py 
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
class Response(BaseModel):
    """
    The response model for the endpoint.
    """

    class ModelPayment(BaseModel):
        """A payment draft."""

        class ModelAmount(ModelBaseAmount):
            """The amount of the payment draft."""

            pass

        class ModelReceiver(BaseModel):
            """The details of the transfer recipient.

            If the counterparty has multiple payment methods available
            (e.g. 2 accounts, or 1 account and 1 card), you must specify the
            account (account_id) or card (card_id) to which you want to transfer the money.
            """

            counterparty_id: Annotated[
                UUID,
                Field(description="The ID of the receiving counterparty."),
            ]
            account_id: Annotated[
                UUID | None,
                Field(
                    description="""
                    The ID of the receiving counterparty's account, which can be own account. 
                    Used for bank transfers.

                    If the counterparty has multiple payment methods available, use it to 
                    specify the account to which you want to send the money.
                    """
                ),
            ] = None
            card_id: Annotated[
                UUID | None,
                Field(
                    description="""
                    The ID of the receiving counterparty's card. Used for card transfers.

                    If the counterparty has multiple payment methods available, use it to 
                    specify the card to which you want to send the money.
                    """
                ),
            ] = None

        class ModelCurrentChargeOptions(BaseModel):
            """The explanation of conversion process"""

            model_config = ConfigDict(
                populate_by_name=True,
                from_attributes=True,
            )

            class ModelFrom(ModelBaseAmount):
                """The source of the conversion"""

                pass

            class ModelTo(ModelBaseAmount):
                """The target of the conversion"""

                pass

            class ModelFee(ModelBaseAmount):
                """The fee of the conversion"""

                pass

            from_: Annotated[
                ModelFrom,
                Field(alias="from", description="The source of the conversion."),
            ]
            to: Annotated[
                ModelTo,
                Field(description="The target of the conversion."),
            ]
            rate: Annotated[
                float | None,
                Field(description="The exchange rate used for the conversion."),
            ] = None
            fee: Annotated[
                ModelFee | None,
                Field(description="The fee of the conversion."),
            ] = None

        id: Annotated[UUID, Field(description="The ID of the payment draft.")]
        amount: Annotated[
            ModelAmount,
            Field(description="The amount of the payment draft."),
        ]
        currency: Annotated[
            Currency | None,
            Field(description="The currency of the payment draft."),
        ] = None
        account_id: Annotated[
            UUID,
            Field(description="The ID of the account to pay from."),
        ]
        receiver: Annotated[
            ModelReceiver,
            Field(
                description="""
                The details of the transfer recipient.

                If the counterparty has multiple payment methods available 
                (e.g. 2 accounts, or 1 account and 1 card), you must specify the 
                account (account_id) or card (card_id) to which you want to transfer the money.
                """
            ),
        ]
        state: Annotated[
            EnumPaymentDraftState,
            Field(description="The state of the payment draft."),
        ]
        reason: Annotated[
            str | None,
            Field(description="The reason for the payment draft state."),
        ] = None
        error_message: Annotated[
            str | None,
            Field(description="The description of the error message."),
        ] = None
        current_charge_options: Annotated[
            ModelCurrentChargeOptions,
            Field(description="The explanation of conversion process."),
        ]
        reference: Annotated[
            str | None,
            Field(description="The description of the transaction."),
        ] = None

    scheduled_for: Annotated[
        Date | None,
        Field(
            description="The scheduled date of the payment draft in ISO 8601 format."
        ),
    ] = None
    title: Annotated[
        str | None,
        Field(description="The title of the payment draft."),
    ] = None
    payments: Annotated[
        list[ModelPayment],
        Field(description="The list of payment drafts."),
    ]

ModelPayment

Bases: BaseModel

A payment draft.

Source code in pyrevolut/api/payment_drafts/get/retrieve_payment_draft.py 
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
class ModelPayment(BaseModel):
    """A payment draft."""

    class ModelAmount(ModelBaseAmount):
        """The amount of the payment draft."""

        pass

    class ModelReceiver(BaseModel):
        """The details of the transfer recipient.

        If the counterparty has multiple payment methods available
        (e.g. 2 accounts, or 1 account and 1 card), you must specify the
        account (account_id) or card (card_id) to which you want to transfer the money.
        """

        counterparty_id: Annotated[
            UUID,
            Field(description="The ID of the receiving counterparty."),
        ]
        account_id: Annotated[
            UUID | None,
            Field(
                description="""
                The ID of the receiving counterparty's account, which can be own account. 
                Used for bank transfers.

                If the counterparty has multiple payment methods available, use it to 
                specify the account to which you want to send the money.
                """
            ),
        ] = None
        card_id: Annotated[
            UUID | None,
            Field(
                description="""
                The ID of the receiving counterparty's card. Used for card transfers.

                If the counterparty has multiple payment methods available, use it to 
                specify the card to which you want to send the money.
                """
            ),
        ] = None

    class ModelCurrentChargeOptions(BaseModel):
        """The explanation of conversion process"""

        model_config = ConfigDict(
            populate_by_name=True,
            from_attributes=True,
        )

        class ModelFrom(ModelBaseAmount):
            """The source of the conversion"""

            pass

        class ModelTo(ModelBaseAmount):
            """The target of the conversion"""

            pass

        class ModelFee(ModelBaseAmount):
            """The fee of the conversion"""

            pass

        from_: Annotated[
            ModelFrom,
            Field(alias="from", description="The source of the conversion."),
        ]
        to: Annotated[
            ModelTo,
            Field(description="The target of the conversion."),
        ]
        rate: Annotated[
            float | None,
            Field(description="The exchange rate used for the conversion."),
        ] = None
        fee: Annotated[
            ModelFee | None,
            Field(description="The fee of the conversion."),
        ] = None

    id: Annotated[UUID, Field(description="The ID of the payment draft.")]
    amount: Annotated[
        ModelAmount,
        Field(description="The amount of the payment draft."),
    ]
    currency: Annotated[
        Currency | None,
        Field(description="The currency of the payment draft."),
    ] = None
    account_id: Annotated[
        UUID,
        Field(description="The ID of the account to pay from."),
    ]
    receiver: Annotated[
        ModelReceiver,
        Field(
            description="""
            The details of the transfer recipient.

            If the counterparty has multiple payment methods available 
            (e.g. 2 accounts, or 1 account and 1 card), you must specify the 
            account (account_id) or card (card_id) to which you want to transfer the money.
            """
        ),
    ]
    state: Annotated[
        EnumPaymentDraftState,
        Field(description="The state of the payment draft."),
    ]
    reason: Annotated[
        str | None,
        Field(description="The reason for the payment draft state."),
    ] = None
    error_message: Annotated[
        str | None,
        Field(description="The description of the error message."),
    ] = None
    current_charge_options: Annotated[
        ModelCurrentChargeOptions,
        Field(description="The explanation of conversion process."),
    ]
    reference: Annotated[
        str | None,
        Field(description="The description of the transaction."),
    ] = None
ModelAmount

Bases: ModelBaseAmount

The amount of the payment draft.

Source code in pyrevolut/api/payment_drafts/get/retrieve_payment_draft.py 
33
34
35
36
class ModelAmount(ModelBaseAmount):
    """The amount of the payment draft."""

    pass
ModelCurrentChargeOptions

Bases: BaseModel

The explanation of conversion process

Source code in pyrevolut/api/payment_drafts/get/retrieve_payment_draft.py 
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
class ModelCurrentChargeOptions(BaseModel):
    """The explanation of conversion process"""

    model_config = ConfigDict(
        populate_by_name=True,
        from_attributes=True,
    )

    class ModelFrom(ModelBaseAmount):
        """The source of the conversion"""

        pass

    class ModelTo(ModelBaseAmount):
        """The target of the conversion"""

        pass

    class ModelFee(ModelBaseAmount):
        """The fee of the conversion"""

        pass

    from_: Annotated[
        ModelFrom,
        Field(alias="from", description="The source of the conversion."),
    ]
    to: Annotated[
        ModelTo,
        Field(description="The target of the conversion."),
    ]
    rate: Annotated[
        float | None,
        Field(description="The exchange rate used for the conversion."),
    ] = None
    fee: Annotated[
        ModelFee | None,
        Field(description="The fee of the conversion."),
    ] = None
ModelFee

Bases: ModelBaseAmount

The fee of the conversion

Source code in pyrevolut/api/payment_drafts/get/retrieve_payment_draft.py 
92
93
94
95
class ModelFee(ModelBaseAmount):
    """The fee of the conversion"""

    pass
ModelFrom

Bases: ModelBaseAmount

The source of the conversion

Source code in pyrevolut/api/payment_drafts/get/retrieve_payment_draft.py 
82
83
84
85
class ModelFrom(ModelBaseAmount):
    """The source of the conversion"""

    pass
ModelTo

Bases: ModelBaseAmount

The target of the conversion

Source code in pyrevolut/api/payment_drafts/get/retrieve_payment_draft.py 
87
88
89
90
class ModelTo(ModelBaseAmount):
    """The target of the conversion"""

    pass
ModelReceiver

Bases: BaseModel

The details of the transfer recipient.

If the counterparty has multiple payment methods available (e.g. 2 accounts, or 1 account and 1 card), you must specify the account (account_id) or card (card_id) to which you want to transfer the money.

Source code in pyrevolut/api/payment_drafts/get/retrieve_payment_draft.py 
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
class ModelReceiver(BaseModel):
    """The details of the transfer recipient.

    If the counterparty has multiple payment methods available
    (e.g. 2 accounts, or 1 account and 1 card), you must specify the
    account (account_id) or card (card_id) to which you want to transfer the money.
    """

    counterparty_id: Annotated[
        UUID,
        Field(description="The ID of the receiving counterparty."),
    ]
    account_id: Annotated[
        UUID | None,
        Field(
            description="""
            The ID of the receiving counterparty's account, which can be own account. 
            Used for bank transfers.

            If the counterparty has multiple payment methods available, use it to 
            specify the account to which you want to send the money.
            """
        ),
    ] = None
    card_id: Annotated[
        UUID | None,
        Field(
            description="""
            The ID of the receiving counterparty's card. Used for card transfers.

            If the counterparty has multiple payment methods available, use it to 
            specify the card to which you want to send the money.
            """
        ),
    ] = None

CreatePaymentDraft

Create a payment draft.

Source code in pyrevolut/api/payment_drafts/post/create_payment_draft.py 
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
class CreatePaymentDraft:
    """
    Create a payment draft.
    """

    ROUTE = "/1.0/payment-drafts"

    class Body(BaseModel):
        """
        The body model for the endpoint.
        """

        class ModelPayment(BaseModel):
            """The details of a payment"""

            class ModelReceiver(BaseModel):
                """The details of the transfer recipient.

                If the counterparty has multiple payment methods available
                (e.g. 2 accounts, or 1 account and 1 card), you must specify the
                account (account_id) or card (card_id) to which you want to transfer the money.
                """

                counterparty_id: Annotated[
                    UUID,
                    Field(description="The ID of the receiving counterparty."),
                ]
                account_id: Annotated[
                    UUID | None,
                    Field(
                        description="""
                        The ID of the receiving counterparty's account, which can be own account. 
                        Used for bank transfers.

                        If the counterparty has multiple payment methods available, use it to 
                        specify the account to which you want to send the money.
                        """
                    ),
                ] = None
                card_id: Annotated[
                    UUID | None,
                    Field(
                        description="""
                        The ID of the receiving counterparty's card. Used for card transfers.

                        If the counterparty has multiple payment methods available, use it to 
                        specify the card to which you want to send the money.
                        """
                    ),
                ] = None

            account_id: Annotated[
                UUID,
                Field(
                    description="""
                    The ID of the account to pay from.
                    You can specify only one account ID for multiple payments in the same payment draft.
                    """
                ),
            ]
            receiver: Annotated[
                ModelReceiver,
                Field(
                    description="""
                    The details of the transfer recipient.

                    If the counterparty has multiple payment methods available 
                    (e.g. 2 accounts, or 1 account and 1 card), you must specify the 
                    account (account_id) or card (card_id) to which you want to transfer the money.
                    """
                ),
            ]
            amount: Annotated[
                float,
                Field(description="The amount of the payment."),
            ]
            currency: Annotated[
                Currency,
                Field(description="ISO 4217 currency code in upper case."),
            ]
            reference: Annotated[
                str,
                Field(description="The reference for the payment."),
            ]

        title: Annotated[
            str | None,
            Field(description="The title of the payment draft."),
        ] = None
        schedule_for: Annotated[
            Date | None,
            Field(
                description="The scheduled date of the payment draft in ISO 8601 format."
            ),
        ] = None
        payments: Annotated[
            list[ModelPayment],
            Field(description="The details of the payments."),
        ]

    class Response(BaseModel):
        """
        The response model for the endpoint.
        """

        id: Annotated[UUID, Field(description="The ID of the payment draft created.")]

Body

Bases: BaseModel

The body model for the endpoint.

Source code in pyrevolut/api/payment_drafts/post/create_payment_draft.py 
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
class Body(BaseModel):
    """
    The body model for the endpoint.
    """

    class ModelPayment(BaseModel):
        """The details of a payment"""

        class ModelReceiver(BaseModel):
            """The details of the transfer recipient.

            If the counterparty has multiple payment methods available
            (e.g. 2 accounts, or 1 account and 1 card), you must specify the
            account (account_id) or card (card_id) to which you want to transfer the money.
            """

            counterparty_id: Annotated[
                UUID,
                Field(description="The ID of the receiving counterparty."),
            ]
            account_id: Annotated[
                UUID | None,
                Field(
                    description="""
                    The ID of the receiving counterparty's account, which can be own account. 
                    Used for bank transfers.

                    If the counterparty has multiple payment methods available, use it to 
                    specify the account to which you want to send the money.
                    """
                ),
            ] = None
            card_id: Annotated[
                UUID | None,
                Field(
                    description="""
                    The ID of the receiving counterparty's card. Used for card transfers.

                    If the counterparty has multiple payment methods available, use it to 
                    specify the card to which you want to send the money.
                    """
                ),
            ] = None

        account_id: Annotated[
            UUID,
            Field(
                description="""
                The ID of the account to pay from.
                You can specify only one account ID for multiple payments in the same payment draft.
                """
            ),
        ]
        receiver: Annotated[
            ModelReceiver,
            Field(
                description="""
                The details of the transfer recipient.

                If the counterparty has multiple payment methods available 
                (e.g. 2 accounts, or 1 account and 1 card), you must specify the 
                account (account_id) or card (card_id) to which you want to transfer the money.
                """
            ),
        ]
        amount: Annotated[
            float,
            Field(description="The amount of the payment."),
        ]
        currency: Annotated[
            Currency,
            Field(description="ISO 4217 currency code in upper case."),
        ]
        reference: Annotated[
            str,
            Field(description="The reference for the payment."),
        ]

    title: Annotated[
        str | None,
        Field(description="The title of the payment draft."),
    ] = None
    schedule_for: Annotated[
        Date | None,
        Field(
            description="The scheduled date of the payment draft in ISO 8601 format."
        ),
    ] = None
    payments: Annotated[
        list[ModelPayment],
        Field(description="The details of the payments."),
    ]

ModelPayment

Bases: BaseModel

The details of a payment

Source code in pyrevolut/api/payment_drafts/post/create_payment_draft.py 
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
class ModelPayment(BaseModel):
    """The details of a payment"""

    class ModelReceiver(BaseModel):
        """The details of the transfer recipient.

        If the counterparty has multiple payment methods available
        (e.g. 2 accounts, or 1 account and 1 card), you must specify the
        account (account_id) or card (card_id) to which you want to transfer the money.
        """

        counterparty_id: Annotated[
            UUID,
            Field(description="The ID of the receiving counterparty."),
        ]
        account_id: Annotated[
            UUID | None,
            Field(
                description="""
                The ID of the receiving counterparty's account, which can be own account. 
                Used for bank transfers.

                If the counterparty has multiple payment methods available, use it to 
                specify the account to which you want to send the money.
                """
            ),
        ] = None
        card_id: Annotated[
            UUID | None,
            Field(
                description="""
                The ID of the receiving counterparty's card. Used for card transfers.

                If the counterparty has multiple payment methods available, use it to 
                specify the card to which you want to send the money.
                """
            ),
        ] = None

    account_id: Annotated[
        UUID,
        Field(
            description="""
            The ID of the account to pay from.
            You can specify only one account ID for multiple payments in the same payment draft.
            """
        ),
    ]
    receiver: Annotated[
        ModelReceiver,
        Field(
            description="""
            The details of the transfer recipient.

            If the counterparty has multiple payment methods available 
            (e.g. 2 accounts, or 1 account and 1 card), you must specify the 
            account (account_id) or card (card_id) to which you want to transfer the money.
            """
        ),
    ]
    amount: Annotated[
        float,
        Field(description="The amount of the payment."),
    ]
    currency: Annotated[
        Currency,
        Field(description="ISO 4217 currency code in upper case."),
    ]
    reference: Annotated[
        str,
        Field(description="The reference for the payment."),
    ]
ModelReceiver

Bases: BaseModel

The details of the transfer recipient.

If the counterparty has multiple payment methods available (e.g. 2 accounts, or 1 account and 1 card), you must specify the account (account_id) or card (card_id) to which you want to transfer the money.

Source code in pyrevolut/api/payment_drafts/post/create_payment_draft.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
class ModelReceiver(BaseModel):
    """The details of the transfer recipient.

    If the counterparty has multiple payment methods available
    (e.g. 2 accounts, or 1 account and 1 card), you must specify the
    account (account_id) or card (card_id) to which you want to transfer the money.
    """

    counterparty_id: Annotated[
        UUID,
        Field(description="The ID of the receiving counterparty."),
    ]
    account_id: Annotated[
        UUID | None,
        Field(
            description="""
            The ID of the receiving counterparty's account, which can be own account. 
            Used for bank transfers.

            If the counterparty has multiple payment methods available, use it to 
            specify the account to which you want to send the money.
            """
        ),
    ] = None
    card_id: Annotated[
        UUID | None,
        Field(
            description="""
            The ID of the receiving counterparty's card. Used for card transfers.

            If the counterparty has multiple payment methods available, use it to 
            specify the card to which you want to send the money.
            """
        ),
    ] = None

Response

Bases: BaseModel

The response model for the endpoint.

Source code in pyrevolut/api/payment_drafts/post/create_payment_draft.py 
110
111
112
113
114
115
class Response(BaseModel):
    """
    The response model for the endpoint.
    """

    id: Annotated[UUID, Field(description="The ID of the payment draft created.")]

DeletePaymentDraft

Delete a payment draft with the given ID. You can delete a payment draft only if it isn't processed.

Source code in pyrevolut/api/payment_drafts/delete/delete_payment_draft.py 
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class DeletePaymentDraft:
    """
    Delete a payment draft with the given ID.
    You can delete a payment draft only if it isn't processed.
    """

    ROUTE = "/1.0/payment-drafts/{payment_draft_id}"

    class Params(BaseModel):
        """
        The parameters for the endpoint.
        """

        pass

    class Response(BaseModel):
        """
        The response model for the endpoint.
        """

        pass

Params

Bases: BaseModel

The parameters for the endpoint.

Source code in pyrevolut/api/payment_drafts/delete/delete_payment_draft.py 
12
13
14
15
16
17
class Params(BaseModel):
    """
    The parameters for the endpoint.
    """

    pass

Response

Bases: BaseModel

The response model for the endpoint.

Source code in pyrevolut/api/payment_drafts/delete/delete_payment_draft.py 
19
20
21
22
23
24
class Response(BaseModel):
    """
    The response model for the endpoint.
    """

    pass