onlinepayments-sdk-python3 7.4.1__py3-none-any.whl

onlinepayments/sdk/domain/shopping_cart_extension.py

@@ -0,0 +1,77 @@
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ShoppingCartExtension(DataObject):
+    def __init__(self, creator: str, name: str, version: str, extension_id: Optional[str] = None):
+        if not creator:
+            raise ValueError("creator is required")
+        if not name:
+            raise ValueError("name is required")
+        if not version:
+            raise ValueError("version is required")
+        self.__creator = creator
+        self.__name = name
+        self.__version = version
+        self.__extension_id = extension_id
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ShoppingCartExtension, self).to_dictionary()
+        if self.__creator is not None:
+            dictionary['creator'] = self.__creator
+        if self.__name is not None:
+            dictionary['name'] = self.__name
+        if self.__version is not None:
+            dictionary['version'] = self.__version
+        if self.__extension_id is not None:
+            dictionary['extensionId'] = self.__extension_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ShoppingCartExtension':
+        super(ShoppingCartExtension, self).from_dictionary(dictionary)
+        if 'creator' in dictionary:
+            self.__creator = dictionary['creator']
+        if 'name' in dictionary:
+            self.__name = dictionary['name']
+        if 'version' in dictionary:
+            self.__version = dictionary['version']
+        if 'extensionId' in dictionary:
+            self.__extension_id = dictionary['extensionId']
+        return self
+
+    @staticmethod
+    def create_from_dictionary(dictionary: dict) -> 'ShoppingCartExtension':
+        if 'creator' in dictionary:
+            creator = dictionary['creator']
+        else:
+            raise ValueError("creator is required")
+        if 'name' in dictionary:
+            name = dictionary['name']
+        else:
+            raise ValueError("name is required")
+        if 'version' in dictionary:
+            version = dictionary['version']
+        else:
+            raise ValueError("version is required")
+        if 'extensionId' in dictionary:
+            extension_id = dictionary['extensionId']
+        else:
+            extension_id = None
+        return ShoppingCartExtension(creator, name, version, extension_id)
+
+    @property
+    def creator(self) -> str:
+        return self.__creator
+
+    @property
+    def name(self) -> str:
+        return self.__name
+
+    @property
+    def version(self) -> str:
+        return self.__version
+
+    @property
+    def extension_id(self) -> Optional[str]:
+        return self.__extension_id

onlinepayments/sdk/domain/shopping_cart_output.py

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+from .line_item_detail import LineItemDetail
+
+
+class ShoppingCartOutput(DataObject):
+
+    __line_item_details: Optional[List[LineItemDetail]] = None
+
+    @property
+    def line_item_details(self) -> Optional[List[LineItemDetail]]:
+        """
+        | List of lineItemIds and quantities for capture/refund/cancellation.
+
+        Type: list[:class:`onlinepayments.sdk.domain.line_item_detail.LineItemDetail`]
+        """
+        return self.__line_item_details
+
+    @line_item_details.setter
+    def line_item_details(self, value: Optional[List[LineItemDetail]]) -> None:
+        self.__line_item_details = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ShoppingCartOutput, self).to_dictionary()
+        if self.line_item_details is not None:
+            dictionary['lineItemDetails'] = []
+            for element in self.line_item_details:
+                if element is not None:
+                    dictionary['lineItemDetails'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ShoppingCartOutput':
+        super(ShoppingCartOutput, self).from_dictionary(dictionary)
+        if 'lineItemDetails' in dictionary:
+            if not isinstance(dictionary['lineItemDetails'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['lineItemDetails']))
+            self.line_item_details = []
+            for element in dictionary['lineItemDetails']:
+                value = LineItemDetail()
+                self.line_item_details.append(value.from_dictionary(element))
+        return self

onlinepayments/sdk/domain/show_form_data.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_product3012 import PaymentProduct3012
+from .payment_product350 import PaymentProduct350
+from .payment_product5001 import PaymentProduct5001
+from .payment_product5404 import PaymentProduct5404
+from .payment_product5407 import PaymentProduct5407
+from .payment_product840 import PaymentProduct840
+from .pending_authentication import PendingAuthentication
+
+
+class ShowFormData(DataObject):
+
+    __payment_product3012: Optional[PaymentProduct3012] = None
+    __payment_product350: Optional[PaymentProduct350] = None
+    __payment_product5001: Optional[PaymentProduct5001] = None
+    __payment_product5404: Optional[PaymentProduct5404] = None
+    __payment_product5407: Optional[PaymentProduct5407] = None
+    __payment_product840: Optional[PaymentProduct840] = None
+    __pending_authentication: Optional[PendingAuthentication] = None
+
+    @property
+    def payment_product3012(self) -> Optional[PaymentProduct3012]:
+        """
+        | Contains the third party data for payment product 3012 (Bancontact)
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product3012.PaymentProduct3012`
+        """
+        return self.__payment_product3012
+
+    @payment_product3012.setter
+    def payment_product3012(self, value: Optional[PaymentProduct3012]) -> None:
+        self.__payment_product3012 = value
+
+    @property
+    def payment_product350(self) -> Optional[PaymentProduct350]:
+        """
+        | Contains the third party data for payment product 350 (Swish)
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product350.PaymentProduct350`
+        """
+        return self.__payment_product350
+
+    @payment_product350.setter
+    def payment_product350(self, value: Optional[PaymentProduct350]) -> None:
+        self.__payment_product350 = value
+
+    @property
+    def payment_product5001(self) -> Optional[PaymentProduct5001]:
+        """
+        | Deprecated by pendingAuthentication. Contains the third party data for payment product 5001 (Bizum)
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product5001.PaymentProduct5001`
+        """
+        return self.__payment_product5001
+
+    @payment_product5001.setter
+    def payment_product5001(self, value: Optional[PaymentProduct5001]) -> None:
+        self.__payment_product5001 = value
+
+    @property
+    def payment_product5404(self) -> Optional[PaymentProduct5404]:
+        """
+        | Contains the third party data for payment product 5404 (WeChat Pay)
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product5404.PaymentProduct5404`
+        """
+        return self.__payment_product5404
+
+    @payment_product5404.setter
+    def payment_product5404(self, value: Optional[PaymentProduct5404]) -> None:
+        self.__payment_product5404 = value
+
+    @property
+    def payment_product5407(self) -> Optional[PaymentProduct5407]:
+        """
+        | Contains the third party data for payment product 5407 (Twint)
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product5407.PaymentProduct5407`
+        """
+        return self.__payment_product5407
+
+    @payment_product5407.setter
+    def payment_product5407(self, value: Optional[PaymentProduct5407]) -> None:
+        self.__payment_product5407 = value
+
+    @property
+    def payment_product840(self) -> Optional[PaymentProduct840]:
+        """
+        | Contains the third party data for payment product 840 (PayPal)
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product840.PaymentProduct840`
+        """
+        return self.__payment_product840
+
+    @payment_product840.setter
+    def payment_product840(self, value: Optional[PaymentProduct840]) -> None:
+        self.__payment_product840 = value
+
+    @property
+    def pending_authentication(self) -> Optional[PendingAuthentication]:
+        """
+        | Contains the third party data for payment product requiring an external authentication (e.g., Bizum, CV Connect)
+
+        Type: :class:`onlinepayments.sdk.domain.pending_authentication.PendingAuthentication`
+        """
+        return self.__pending_authentication
+
+    @pending_authentication.setter
+    def pending_authentication(self, value: Optional[PendingAuthentication]) -> None:
+        self.__pending_authentication = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ShowFormData, self).to_dictionary()
+        if self.payment_product3012 is not None:
+            dictionary['paymentProduct3012'] = self.payment_product3012.to_dictionary()
+        if self.payment_product350 is not None:
+            dictionary['paymentProduct350'] = self.payment_product350.to_dictionary()
+        if self.payment_product5001 is not None:
+            dictionary['paymentProduct5001'] = self.payment_product5001.to_dictionary()
+        if self.payment_product5404 is not None:
+            dictionary['paymentProduct5404'] = self.payment_product5404.to_dictionary()
+        if self.payment_product5407 is not None:
+            dictionary['paymentProduct5407'] = self.payment_product5407.to_dictionary()
+        if self.payment_product840 is not None:
+            dictionary['paymentProduct840'] = self.payment_product840.to_dictionary()
+        if self.pending_authentication is not None:
+            dictionary['pendingAuthentication'] = self.pending_authentication.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ShowFormData':
+        super(ShowFormData, self).from_dictionary(dictionary)
+        if 'paymentProduct3012' in dictionary:
+            if not isinstance(dictionary['paymentProduct3012'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct3012']))
+            value = PaymentProduct3012()
+            self.payment_product3012 = value.from_dictionary(dictionary['paymentProduct3012'])
+        if 'paymentProduct350' in dictionary:
+            if not isinstance(dictionary['paymentProduct350'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct350']))
+            value = PaymentProduct350()
+            self.payment_product350 = value.from_dictionary(dictionary['paymentProduct350'])
+        if 'paymentProduct5001' in dictionary:
+            if not isinstance(dictionary['paymentProduct5001'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct5001']))
+            value = PaymentProduct5001()
+            self.payment_product5001 = value.from_dictionary(dictionary['paymentProduct5001'])
+        if 'paymentProduct5404' in dictionary:
+            if not isinstance(dictionary['paymentProduct5404'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct5404']))
+            value = PaymentProduct5404()
+            self.payment_product5404 = value.from_dictionary(dictionary['paymentProduct5404'])
+        if 'paymentProduct5407' in dictionary:
+            if not isinstance(dictionary['paymentProduct5407'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct5407']))
+            value = PaymentProduct5407()
+            self.payment_product5407 = value.from_dictionary(dictionary['paymentProduct5407'])
+        if 'paymentProduct840' in dictionary:
+            if not isinstance(dictionary['paymentProduct840'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct840']))
+            value = PaymentProduct840()
+            self.payment_product840 = value.from_dictionary(dictionary['paymentProduct840'])
+        if 'pendingAuthentication' in dictionary:
+            if not isinstance(dictionary['pendingAuthentication'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['pendingAuthentication']))
+            value = PendingAuthentication()
+            self.pending_authentication = value.from_dictionary(dictionary['pendingAuthentication'])
+        return self

onlinepayments/sdk/domain/show_instructions_data.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ShowInstructionsData(DataObject):
+
+    __show_data: Optional[str] = None
+
+    @property
+    def show_data(self) -> Optional[str]:
+        """
+        | The data that should be shown to the customer that can be used to render the instructions in your own application or website.
+
+        Type: str
+        """
+        return self.__show_data
+
+    @show_data.setter
+    def show_data(self, value: Optional[str]) -> None:
+        self.__show_data = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ShowInstructionsData, self).to_dictionary()
+        if self.show_data is not None:
+            dictionary['showData'] = self.show_data
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ShowInstructionsData':
+        super(ShowInstructionsData, self).from_dictionary(dictionary)
+        if 'showData' in dictionary:
+            self.show_data = dictionary['showData']
+        return self

onlinepayments/sdk/domain/split_payment_product_filter.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+
+
+class SplitPaymentProductFilter(DataObject):
+
+    __products: Optional[List[int]] = None
+
+    @property
+    def products(self) -> Optional[List[int]]:
+        """
+        Type: list[int]
+        """
+        return self.__products
+
+    @products.setter
+    def products(self, value: Optional[List[int]]) -> None:
+        self.__products = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SplitPaymentProductFilter, self).to_dictionary()
+        if self.products is not None:
+            dictionary['products'] = []
+            for element in self.products:
+                if element is not None:
+                    dictionary['products'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SplitPaymentProductFilter':
+        super(SplitPaymentProductFilter, self).from_dictionary(dictionary)
+        if 'products' in dictionary:
+            if not isinstance(dictionary['products'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['products']))
+            self.products = []
+            for element in dictionary['products']:
+                self.products.append(element)
+        return self

onlinepayments/sdk/domain/split_payment_product_filters_hosted_checkout.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .split_payment_product_filter import SplitPaymentProductFilter
+
+
+class SplitPaymentProductFiltersHostedCheckout(DataObject):
+
+    __exclude: Optional[SplitPaymentProductFilter] = None
+    __restrict_to: Optional[SplitPaymentProductFilter] = None
+
+    @property
+    def exclude(self) -> Optional[SplitPaymentProductFilter]:
+        """
+        | The payment product IDs to be excluded or restricted for the payment products available for the following payments in a split payment. Note that you can add exclusions on top of the 'restrictTo' filter.
+
+        Type: :class:`onlinepayments.sdk.domain.split_payment_product_filter.SplitPaymentProductFilter`
+        """
+        return self.__exclude
+
+    @exclude.setter
+    def exclude(self, value: Optional[SplitPaymentProductFilter]) -> None:
+        self.__exclude = value
+
+    @property
+    def restrict_to(self) -> Optional[SplitPaymentProductFilter]:
+        """
+        | The payment product IDs to be excluded or restricted for the payment products available for the following payments in a split payment. Note that you can add exclusions on top of the 'restrictTo' filter.
+
+        Type: :class:`onlinepayments.sdk.domain.split_payment_product_filter.SplitPaymentProductFilter`
+        """
+        return self.__restrict_to
+
+    @restrict_to.setter
+    def restrict_to(self, value: Optional[SplitPaymentProductFilter]) -> None:
+        self.__restrict_to = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SplitPaymentProductFiltersHostedCheckout, self).to_dictionary()
+        if self.exclude is not None:
+            dictionary['exclude'] = self.exclude.to_dictionary()
+        if self.restrict_to is not None:
+            dictionary['restrictTo'] = self.restrict_to.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SplitPaymentProductFiltersHostedCheckout':
+        super(SplitPaymentProductFiltersHostedCheckout, self).from_dictionary(dictionary)
+        if 'exclude' in dictionary:
+            if not isinstance(dictionary['exclude'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['exclude']))
+            value = SplitPaymentProductFilter()
+            self.exclude = value.from_dictionary(dictionary['exclude'])
+        if 'restrictTo' in dictionary:
+            if not isinstance(dictionary['restrictTo'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['restrictTo']))
+            value = SplitPaymentProductFilter()
+            self.restrict_to = value.from_dictionary(dictionary['restrictTo'])
+        return self

onlinepayments/sdk/domain/submit_batch_request_body.py

@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .batch_metadata import BatchMetadata
+from .cancel_payment_batch_request import CancelPaymentBatchRequest
+from .capture_payment_batch_request import CapturePaymentBatchRequest
+from .create_payment_link_request import CreatePaymentLinkRequest
+from .create_payment_request import CreatePaymentRequest
+from .create_payout_request import CreatePayoutRequest
+from .data_object import DataObject
+from .refund_payment_batch_request import RefundPaymentBatchRequest
+from .subsequent_payment_batch_request import SubsequentPaymentBatchRequest
+
+
+class SubmitBatchRequestBody(DataObject):
+
+    __cancel_payments: Optional[List[CancelPaymentBatchRequest]] = None
+    __capture_payments: Optional[List[CapturePaymentBatchRequest]] = None
+    __create_payment_links: Optional[List[CreatePaymentLinkRequest]] = None
+    __create_payments: Optional[List[CreatePaymentRequest]] = None
+    __create_payouts: Optional[List[CreatePayoutRequest]] = None
+    __header: Optional[BatchMetadata] = None
+    __refund_payments: Optional[List[RefundPaymentBatchRequest]] = None
+    __subsequent_payments: Optional[List[SubsequentPaymentBatchRequest]] = None
+
+    @property
+    def cancel_payments(self) -> Optional[List[CancelPaymentBatchRequest]]:
+        """
+        | Array of cancel payment requests to be submitted in batch.
+
+        Type: list[:class:`onlinepayments.sdk.domain.cancel_payment_batch_request.CancelPaymentBatchRequest`]
+        """
+        return self.__cancel_payments
+
+    @cancel_payments.setter
+    def cancel_payments(self, value: Optional[List[CancelPaymentBatchRequest]]) -> None:
+        self.__cancel_payments = value
+
+    @property
+    def capture_payments(self) -> Optional[List[CapturePaymentBatchRequest]]:
+        """
+        | Array of capture payment requests to be submitted in batch.
+
+        Type: list[:class:`onlinepayments.sdk.domain.capture_payment_batch_request.CapturePaymentBatchRequest`]
+        """
+        return self.__capture_payments
+
+    @capture_payments.setter
+    def capture_payments(self, value: Optional[List[CapturePaymentBatchRequest]]) -> None:
+        self.__capture_payments = value
+
+    @property
+    def create_payment_links(self) -> Optional[List[CreatePaymentLinkRequest]]:
+        """
+        | An array containing multiple payment link generation requests that will be processed as a batch. Each item represents an individual payment link to be created.
+
+        Type: list[:class:`onlinepayments.sdk.domain.create_payment_link_request.CreatePaymentLinkRequest`]
+        """
+        return self.__create_payment_links
+
+    @create_payment_links.setter
+    def create_payment_links(self, value: Optional[List[CreatePaymentLinkRequest]]) -> None:
+        self.__create_payment_links = value
+
+    @property
+    def create_payments(self) -> Optional[List[CreatePaymentRequest]]:
+        """
+        | Array of payment creation requests to be submitted in batch.
+
+        Type: list[:class:`onlinepayments.sdk.domain.create_payment_request.CreatePaymentRequest`]
+        """
+        return self.__create_payments
+
+    @create_payments.setter
+    def create_payments(self, value: Optional[List[CreatePaymentRequest]]) -> None:
+        self.__create_payments = value
+
+    @property
+    def create_payouts(self) -> Optional[List[CreatePayoutRequest]]:
+        """
+        | Array of payout creation requests to be submitted in batch.
+
+        Type: list[:class:`onlinepayments.sdk.domain.create_payout_request.CreatePayoutRequest`]
+        """
+        return self.__create_payouts
+
+    @create_payouts.setter
+    def create_payouts(self, value: Optional[List[CreatePayoutRequest]]) -> None:
+        self.__create_payouts = value
+
+    @property
+    def header(self) -> Optional[BatchMetadata]:
+        """
+        | Details about the batch, including the type of operation, the merchant batch reference, and the number of items in the batch.
+
+        Type: :class:`onlinepayments.sdk.domain.batch_metadata.BatchMetadata`
+        """
+        return self.__header
+
+    @header.setter
+    def header(self, value: Optional[BatchMetadata]) -> None:
+        self.__header = value
+
+    @property
+    def refund_payments(self) -> Optional[List[RefundPaymentBatchRequest]]:
+        """
+        | Array of refund payment requests to be submitted in batch.
+
+        Type: list[:class:`onlinepayments.sdk.domain.refund_payment_batch_request.RefundPaymentBatchRequest`]
+        """
+        return self.__refund_payments
+
+    @refund_payments.setter
+    def refund_payments(self, value: Optional[List[RefundPaymentBatchRequest]]) -> None:
+        self.__refund_payments = value
+
+    @property
+    def subsequent_payments(self) -> Optional[List[SubsequentPaymentBatchRequest]]:
+        """
+        | Array of subsequent payment requests to be submitted in batch.
+
+        Type: list[:class:`onlinepayments.sdk.domain.subsequent_payment_batch_request.SubsequentPaymentBatchRequest`]
+        """
+        return self.__subsequent_payments
+
+    @subsequent_payments.setter
+    def subsequent_payments(self, value: Optional[List[SubsequentPaymentBatchRequest]]) -> None:
+        self.__subsequent_payments = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SubmitBatchRequestBody, self).to_dictionary()
+        if self.cancel_payments is not None:
+            dictionary['cancelPayments'] = []
+            for element in self.cancel_payments:
+                if element is not None:
+                    dictionary['cancelPayments'].append(element.to_dictionary())
+        if self.capture_payments is not None:
+            dictionary['capturePayments'] = []
+            for element in self.capture_payments:
+                if element is not None:
+                    dictionary['capturePayments'].append(element.to_dictionary())
+        if self.create_payment_links is not None:
+            dictionary['createPaymentLinks'] = []
+            for element in self.create_payment_links:
+                if element is not None:
+                    dictionary['createPaymentLinks'].append(element.to_dictionary())
+        if self.create_payments is not None:
+            dictionary['createPayments'] = []
+            for element in self.create_payments:
+                if element is not None:
+                    dictionary['createPayments'].append(element.to_dictionary())
+        if self.create_payouts is not None:
+            dictionary['createPayouts'] = []
+            for element in self.create_payouts:
+                if element is not None:
+                    dictionary['createPayouts'].append(element.to_dictionary())
+        if self.header is not None:
+            dictionary['header'] = self.header.to_dictionary()
+        if self.refund_payments is not None:
+            dictionary['refundPayments'] = []
+            for element in self.refund_payments:
+                if element is not None:
+                    dictionary['refundPayments'].append(element.to_dictionary())
+        if self.subsequent_payments is not None:
+            dictionary['subsequentPayments'] = []
+            for element in self.subsequent_payments:
+                if element is not None:
+                    dictionary['subsequentPayments'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SubmitBatchRequestBody':
+        super(SubmitBatchRequestBody, self).from_dictionary(dictionary)
+        if 'cancelPayments' in dictionary:
+            if not isinstance(dictionary['cancelPayments'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['cancelPayments']))
+            self.cancel_payments = []
+            for element in dictionary['cancelPayments']:
+                value = CancelPaymentBatchRequest()
+                self.cancel_payments.append(value.from_dictionary(element))
+        if 'capturePayments' in dictionary:
+            if not isinstance(dictionary['capturePayments'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['capturePayments']))
+            self.capture_payments = []
+            for element in dictionary['capturePayments']:
+                value = CapturePaymentBatchRequest()
+                self.capture_payments.append(value.from_dictionary(element))
+        if 'createPaymentLinks' in dictionary:
+            if not isinstance(dictionary['createPaymentLinks'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['createPaymentLinks']))
+            self.create_payment_links = []
+            for element in dictionary['createPaymentLinks']:
+                value = CreatePaymentLinkRequest()
+                self.create_payment_links.append(value.from_dictionary(element))
+        if 'createPayments' in dictionary:
+            if not isinstance(dictionary['createPayments'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['createPayments']))
+            self.create_payments = []
+            for element in dictionary['createPayments']:
+                value = CreatePaymentRequest()
+                self.create_payments.append(value.from_dictionary(element))
+        if 'createPayouts' in dictionary:
+            if not isinstance(dictionary['createPayouts'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['createPayouts']))
+            self.create_payouts = []
+            for element in dictionary['createPayouts']:
+                value = CreatePayoutRequest()
+                self.create_payouts.append(value.from_dictionary(element))
+        if 'header' in dictionary:
+            if not isinstance(dictionary['header'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['header']))
+            value = BatchMetadata()
+            self.header = value.from_dictionary(dictionary['header'])
+        if 'refundPayments' in dictionary:
+            if not isinstance(dictionary['refundPayments'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['refundPayments']))
+            self.refund_payments = []
+            for element in dictionary['refundPayments']:
+                value = RefundPaymentBatchRequest()
+                self.refund_payments.append(value.from_dictionary(element))
+        if 'subsequentPayments' in dictionary:
+            if not isinstance(dictionary['subsequentPayments'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['subsequentPayments']))
+            self.subsequent_payments = []
+            for element in dictionary['subsequentPayments']:
+                value = SubsequentPaymentBatchRequest()
+                self.subsequent_payments.append(value.from_dictionary(element))
+        return self