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

onlinepayments/sdk/domain/redirect_payment_product840_specific_input.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class RedirectPaymentProduct840SpecificInput(DataObject):
+
+    __java_script_sdk_flow: Optional[bool] = None
+    __address_selection_at_pay_pal: Optional[bool] = None
+    __custom: Optional[str] = None
+    __pay_later: Optional[bool] = None
+
+    @property
+    def java_script_sdk_flow(self) -> Optional[bool]:
+        """
+        | To be enabled when Javascript SDK integration is implemented on S2S flow
+        
+        * false = When this flag is disabled the field RedirectionURL is returned by CreatePayment call and should be used in merchant implementation to redirect buyer to PayPal.
+        * true = When this flag is enabled the field orderID is returned by CreatePayment call and should be utilized in case merchant has integrated JS SDK button on their S2S implementation Default value is false.
+
+        Type: bool
+        """
+        return self.__java_script_sdk_flow
+
+    @java_script_sdk_flow.setter
+    def java_script_sdk_flow(self, value: Optional[bool]) -> None:
+        self.__java_script_sdk_flow = value
+
+    @property
+    def address_selection_at_pay_pal(self) -> Optional[bool]:
+        """
+        | Indicates whether to use PayPal Express Checkout Shortcut.
+        
+        * true = When shortcut is enabled, the consumer can select a shipping address during PayPal checkout.
+        * false = When shortcut is disabled, the consumer cannot change the shipping address. Default value is false. Please note that this field is ignored when order.additionalInput.typeInformation.purchaseType is set to "digital"
+
+        Type: bool
+        """
+        return self.__address_selection_at_pay_pal
+
+    @address_selection_at_pay_pal.setter
+    def address_selection_at_pay_pal(self, value: Optional[bool]) -> None:
+        self.__address_selection_at_pay_pal = value
+
+    @property
+    def custom(self) -> Optional[str]:
+        """
+        | Free text field that you can use to support reconciliation flow.
+
+        Type: str
+        """
+        return self.__custom
+
+    @custom.setter
+    def custom(self, value: Optional[str]) -> None:
+        self.__custom = value
+
+    @property
+    def pay_later(self) -> Optional[bool]:
+        """
+        | Indicates whether to allow PayPal Pay Later option.
+        
+        * true = When option is enabled, the consumer can select the PayPal PayLater button given that the merchant meets the eligibility criteria from PayPal.
+        * false = When option is disabled, the consumer cannot select the PayPal PayLater button. Default value is true.
+
+        Type: bool
+        """
+        return self.__pay_later
+
+    @pay_later.setter
+    def pay_later(self, value: Optional[bool]) -> None:
+        self.__pay_later = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectPaymentProduct840SpecificInput, self).to_dictionary()
+        if self.java_script_sdk_flow is not None:
+            dictionary['JavaScriptSdkFlow'] = self.java_script_sdk_flow
+        if self.address_selection_at_pay_pal is not None:
+            dictionary['addressSelectionAtPayPal'] = self.address_selection_at_pay_pal
+        if self.custom is not None:
+            dictionary['custom'] = self.custom
+        if self.pay_later is not None:
+            dictionary['payLater'] = self.pay_later
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentProduct840SpecificInput':
+        super(RedirectPaymentProduct840SpecificInput, self).from_dictionary(dictionary)
+        if 'JavaScriptSdkFlow' in dictionary:
+            self.java_script_sdk_flow = dictionary['JavaScriptSdkFlow']
+        if 'addressSelectionAtPayPal' in dictionary:
+            self.address_selection_at_pay_pal = dictionary['addressSelectionAtPayPal']
+        if 'custom' in dictionary:
+            self.custom = dictionary['custom']
+        if 'payLater' in dictionary:
+            self.pay_later = dictionary['payLater']
+        return self

onlinepayments/sdk/domain/redirection_data.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class RedirectionData(DataObject):
+
+    __return_url: Optional[str] = None
+
+    @property
+    def return_url(self) -> Optional[str]:
+        """
+        | The URL that the customer is redirected to after the payment flow has finished. You can add any number of key value pairs in the query string that, for instance help you to identify the customer when they return to your site. Please note that we will also append some additional key value pairs that will also help you with this identification process. Note: The provided URL should be absolute and contain the protocol to use, e.g. http:// or https://. For use on mobile devices a custom protocol can be used in the form of protocol://. This protocol must be registered on the device first. URLs without a protocol will be rejected.
+
+        Type: str
+        """
+        return self.__return_url
+
+    @return_url.setter
+    def return_url(self, value: Optional[str]) -> None:
+        self.__return_url = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectionData, self).to_dictionary()
+        if self.return_url is not None:
+            dictionary['returnUrl'] = self.return_url
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectionData':
+        super(RedirectionData, self).from_dictionary(dictionary)
+        if 'returnUrl' in dictionary:
+            self.return_url = dictionary['returnUrl']
+        return self

onlinepayments/sdk/domain/refund_card_method_specific_output.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .currency_conversion import CurrencyConversion
+from .data_object import DataObject
+
+
+class RefundCardMethodSpecificOutput(DataObject):
+
+    __currency_conversion: Optional[CurrencyConversion] = None
+    __total_amount_paid: Optional[int] = None
+    __total_amount_refunded: Optional[int] = None
+
+    @property
+    def currency_conversion(self) -> Optional[CurrencyConversion]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.currency_conversion.CurrencyConversion`
+        """
+        return self.__currency_conversion
+
+    @currency_conversion.setter
+    def currency_conversion(self, value: Optional[CurrencyConversion]) -> None:
+        self.__currency_conversion = value
+
+    @property
+    def total_amount_paid(self) -> Optional[int]:
+        """
+        Type: int
+        """
+        return self.__total_amount_paid
+
+    @total_amount_paid.setter
+    def total_amount_paid(self, value: Optional[int]) -> None:
+        self.__total_amount_paid = value
+
+    @property
+    def total_amount_refunded(self) -> Optional[int]:
+        """
+        Type: int
+        """
+        return self.__total_amount_refunded
+
+    @total_amount_refunded.setter
+    def total_amount_refunded(self, value: Optional[int]) -> None:
+        self.__total_amount_refunded = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundCardMethodSpecificOutput, self).to_dictionary()
+        if self.currency_conversion is not None:
+            dictionary['currencyConversion'] = self.currency_conversion.to_dictionary()
+        if self.total_amount_paid is not None:
+            dictionary['totalAmountPaid'] = self.total_amount_paid
+        if self.total_amount_refunded is not None:
+            dictionary['totalAmountRefunded'] = self.total_amount_refunded
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundCardMethodSpecificOutput':
+        super(RefundCardMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'currencyConversion' in dictionary:
+            if not isinstance(dictionary['currencyConversion'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['currencyConversion']))
+            value = CurrencyConversion()
+            self.currency_conversion = value.from_dictionary(dictionary['currencyConversion'])
+        if 'totalAmountPaid' in dictionary:
+            self.total_amount_paid = dictionary['totalAmountPaid']
+        if 'totalAmountRefunded' in dictionary:
+            self.total_amount_refunded = dictionary['totalAmountRefunded']
+        return self

onlinepayments/sdk/domain/refund_e_wallet_method_specific_output.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .refund_payment_product840_specific_output import RefundPaymentProduct840SpecificOutput
+
+
+class RefundEWalletMethodSpecificOutput(DataObject):
+
+    __payment_product840_specific_output: Optional[RefundPaymentProduct840SpecificOutput] = None
+    __total_amount_paid: Optional[int] = None
+    __total_amount_refunded: Optional[int] = None
+
+    @property
+    def payment_product840_specific_output(self) -> Optional[RefundPaymentProduct840SpecificOutput]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.refund_payment_product840_specific_output.RefundPaymentProduct840SpecificOutput`
+        """
+        return self.__payment_product840_specific_output
+
+    @payment_product840_specific_output.setter
+    def payment_product840_specific_output(self, value: Optional[RefundPaymentProduct840SpecificOutput]) -> None:
+        self.__payment_product840_specific_output = value
+
+    @property
+    def total_amount_paid(self) -> Optional[int]:
+        """
+        Type: int
+        """
+        return self.__total_amount_paid
+
+    @total_amount_paid.setter
+    def total_amount_paid(self, value: Optional[int]) -> None:
+        self.__total_amount_paid = value
+
+    @property
+    def total_amount_refunded(self) -> Optional[int]:
+        """
+        Type: int
+        """
+        return self.__total_amount_refunded
+
+    @total_amount_refunded.setter
+    def total_amount_refunded(self, value: Optional[int]) -> None:
+        self.__total_amount_refunded = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundEWalletMethodSpecificOutput, self).to_dictionary()
+        if self.payment_product840_specific_output is not None:
+            dictionary['paymentProduct840SpecificOutput'] = self.payment_product840_specific_output.to_dictionary()
+        if self.total_amount_paid is not None:
+            dictionary['totalAmountPaid'] = self.total_amount_paid
+        if self.total_amount_refunded is not None:
+            dictionary['totalAmountRefunded'] = self.total_amount_refunded
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundEWalletMethodSpecificOutput':
+        super(RefundEWalletMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'paymentProduct840SpecificOutput' in dictionary:
+            if not isinstance(dictionary['paymentProduct840SpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct840SpecificOutput']))
+            value = RefundPaymentProduct840SpecificOutput()
+            self.payment_product840_specific_output = value.from_dictionary(dictionary['paymentProduct840SpecificOutput'])
+        if 'totalAmountPaid' in dictionary:
+            self.total_amount_paid = dictionary['totalAmountPaid']
+        if 'totalAmountRefunded' in dictionary:
+            self.total_amount_refunded = dictionary['totalAmountRefunded']
+        return self

onlinepayments/sdk/domain/refund_error_response.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .api_error import APIError
+from .data_object import DataObject
+from .refund_response import RefundResponse
+
+
+class RefundErrorResponse(DataObject):
+
+    __error_id: Optional[str] = None
+    __errors: Optional[List[APIError]] = None
+    __refund_result: Optional[RefundResponse] = None
+
+    @property
+    def error_id(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__error_id
+
+    @error_id.setter
+    def error_id(self, value: Optional[str]) -> None:
+        self.__error_id = value
+
+    @property
+    def errors(self) -> Optional[List[APIError]]:
+        """
+        Type: list[:class:`onlinepayments.sdk.domain.api_error.APIError`]
+        """
+        return self.__errors
+
+    @errors.setter
+    def errors(self, value: Optional[List[APIError]]) -> None:
+        self.__errors = value
+
+    @property
+    def refund_result(self) -> Optional[RefundResponse]:
+        """
+        | This object has the numeric representation of the current refund status, timestamp of last status change and performable action on the current refund resource. In case of a rejected refund, detailed error information is listed.
+
+        Type: :class:`onlinepayments.sdk.domain.refund_response.RefundResponse`
+        """
+        return self.__refund_result
+
+    @refund_result.setter
+    def refund_result(self, value: Optional[RefundResponse]) -> None:
+        self.__refund_result = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundErrorResponse, self).to_dictionary()
+        if self.error_id is not None:
+            dictionary['errorId'] = self.error_id
+        if self.errors is not None:
+            dictionary['errors'] = []
+            for element in self.errors:
+                if element is not None:
+                    dictionary['errors'].append(element.to_dictionary())
+        if self.refund_result is not None:
+            dictionary['refundResult'] = self.refund_result.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundErrorResponse':
+        super(RefundErrorResponse, self).from_dictionary(dictionary)
+        if 'errorId' in dictionary:
+            self.error_id = dictionary['errorId']
+        if 'errors' in dictionary:
+            if not isinstance(dictionary['errors'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['errors']))
+            self.errors = []
+            for element in dictionary['errors']:
+                value = APIError()
+                self.errors.append(value.from_dictionary(element))
+        if 'refundResult' in dictionary:
+            if not isinstance(dictionary['refundResult'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['refundResult']))
+            value = RefundResponse()
+            self.refund_result = value.from_dictionary(dictionary['refundResult'])
+        return self

onlinepayments/sdk/domain/refund_mobile_method_specific_output.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class RefundMobileMethodSpecificOutput(DataObject):
+
+    __network: Optional[str] = None
+    __total_amount_paid: Optional[int] = None
+    __total_amount_refunded: Optional[int] = None
+
+    @property
+    def network(self) -> Optional[str]:
+        """
+        | The card network that was used for a mobile payment method operation
+
+        Type: str
+        """
+        return self.__network
+
+    @network.setter
+    def network(self, value: Optional[str]) -> None:
+        self.__network = value
+
+    @property
+    def total_amount_paid(self) -> Optional[int]:
+        """
+        Type: int
+        """
+        return self.__total_amount_paid
+
+    @total_amount_paid.setter
+    def total_amount_paid(self, value: Optional[int]) -> None:
+        self.__total_amount_paid = value
+
+    @property
+    def total_amount_refunded(self) -> Optional[int]:
+        """
+        Type: int
+        """
+        return self.__total_amount_refunded
+
+    @total_amount_refunded.setter
+    def total_amount_refunded(self, value: Optional[int]) -> None:
+        self.__total_amount_refunded = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundMobileMethodSpecificOutput, self).to_dictionary()
+        if self.network is not None:
+            dictionary['network'] = self.network
+        if self.total_amount_paid is not None:
+            dictionary['totalAmountPaid'] = self.total_amount_paid
+        if self.total_amount_refunded is not None:
+            dictionary['totalAmountRefunded'] = self.total_amount_refunded
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundMobileMethodSpecificOutput':
+        super(RefundMobileMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'network' in dictionary:
+            self.network = dictionary['network']
+        if 'totalAmountPaid' in dictionary:
+            self.total_amount_paid = dictionary['totalAmountPaid']
+        if 'totalAmountRefunded' in dictionary:
+            self.total_amount_refunded = dictionary['totalAmountRefunded']
+        return self

onlinepayments/sdk/domain/refund_output.py

@@ -0,0 +1,217 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+from .operation_payment_references import OperationPaymentReferences
+from .payment_references import PaymentReferences
+from .refund_card_method_specific_output import RefundCardMethodSpecificOutput
+from .refund_e_wallet_method_specific_output import RefundEWalletMethodSpecificOutput
+from .refund_mobile_method_specific_output import RefundMobileMethodSpecificOutput
+from .refund_redirect_method_specific_output import RefundRedirectMethodSpecificOutput
+
+
+class RefundOutput(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __amount_paid: Optional[int] = None
+    __card_refund_method_specific_output: Optional[RefundCardMethodSpecificOutput] = None
+    __e_wallet_refund_method_specific_output: Optional[RefundEWalletMethodSpecificOutput] = None
+    __merchant_parameters: Optional[str] = None
+    __mobile_refund_method_specific_output: Optional[RefundMobileMethodSpecificOutput] = None
+    __operation_references: Optional[OperationPaymentReferences] = None
+    __payment_method: Optional[str] = None
+    __redirect_refund_method_specific_output: Optional[RefundRedirectMethodSpecificOutput] = None
+    __references: Optional[PaymentReferences] = None
+
+    @property
+    def amount_of_money(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__amount_of_money
+
+    @amount_of_money.setter
+    def amount_of_money(self, value: Optional[AmountOfMoney]) -> None:
+        self.__amount_of_money = value
+
+    @property
+    def amount_paid(self) -> Optional[int]:
+        """
+        Type: int
+        """
+        return self.__amount_paid
+
+    @amount_paid.setter
+    def amount_paid(self, value: Optional[int]) -> None:
+        self.__amount_paid = value
+
+    @property
+    def card_refund_method_specific_output(self) -> Optional[RefundCardMethodSpecificOutput]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.refund_card_method_specific_output.RefundCardMethodSpecificOutput`
+        """
+        return self.__card_refund_method_specific_output
+
+    @card_refund_method_specific_output.setter
+    def card_refund_method_specific_output(self, value: Optional[RefundCardMethodSpecificOutput]) -> None:
+        self.__card_refund_method_specific_output = value
+
+    @property
+    def e_wallet_refund_method_specific_output(self) -> Optional[RefundEWalletMethodSpecificOutput]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.refund_e_wallet_method_specific_output.RefundEWalletMethodSpecificOutput`
+        """
+        return self.__e_wallet_refund_method_specific_output
+
+    @e_wallet_refund_method_specific_output.setter
+    def e_wallet_refund_method_specific_output(self, value: Optional[RefundEWalletMethodSpecificOutput]) -> None:
+        self.__e_wallet_refund_method_specific_output = value
+
+    @property
+    def merchant_parameters(self) -> Optional[str]:
+        """
+        | It allows you to store additional parameters for the transaction in the format you prefer (e.g.-> key-value query string, JSON, etc.) These parameters are then echoed back to you in API GET calls and Webhook notifications. This field must not contain any personal data.
+
+        Type: str
+        """
+        return self.__merchant_parameters
+
+    @merchant_parameters.setter
+    def merchant_parameters(self, value: Optional[str]) -> None:
+        self.__merchant_parameters = value
+
+    @property
+    def mobile_refund_method_specific_output(self) -> Optional[RefundMobileMethodSpecificOutput]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.refund_mobile_method_specific_output.RefundMobileMethodSpecificOutput`
+        """
+        return self.__mobile_refund_method_specific_output
+
+    @mobile_refund_method_specific_output.setter
+    def mobile_refund_method_specific_output(self, value: Optional[RefundMobileMethodSpecificOutput]) -> None:
+        self.__mobile_refund_method_specific_output = value
+
+    @property
+    def operation_references(self) -> Optional[OperationPaymentReferences]:
+        """
+        | Object that holds all reference properties that are linked to this transaction
+
+        Type: :class:`onlinepayments.sdk.domain.operation_payment_references.OperationPaymentReferences`
+        """
+        return self.__operation_references
+
+    @operation_references.setter
+    def operation_references(self, value: Optional[OperationPaymentReferences]) -> None:
+        self.__operation_references = value
+
+    @property
+    def payment_method(self) -> Optional[str]:
+        """
+        | Payment method identifier used by the our payment engine.
+
+        Type: str
+        """
+        return self.__payment_method
+
+    @payment_method.setter
+    def payment_method(self, value: Optional[str]) -> None:
+        self.__payment_method = value
+
+    @property
+    def redirect_refund_method_specific_output(self) -> Optional[RefundRedirectMethodSpecificOutput]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.refund_redirect_method_specific_output.RefundRedirectMethodSpecificOutput`
+        """
+        return self.__redirect_refund_method_specific_output
+
+    @redirect_refund_method_specific_output.setter
+    def redirect_refund_method_specific_output(self, value: Optional[RefundRedirectMethodSpecificOutput]) -> None:
+        self.__redirect_refund_method_specific_output = value
+
+    @property
+    def references(self) -> Optional[PaymentReferences]:
+        """
+        | Object that holds all reference properties that are linked to this transaction. **Deprecated for capture/refund**: Use operationReferences instead.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_references.PaymentReferences`
+        """
+        return self.__references
+
+    @references.setter
+    def references(self, value: Optional[PaymentReferences]) -> None:
+        self.__references = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundOutput, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.amount_paid is not None:
+            dictionary['amountPaid'] = self.amount_paid
+        if self.card_refund_method_specific_output is not None:
+            dictionary['cardRefundMethodSpecificOutput'] = self.card_refund_method_specific_output.to_dictionary()
+        if self.e_wallet_refund_method_specific_output is not None:
+            dictionary['eWalletRefundMethodSpecificOutput'] = self.e_wallet_refund_method_specific_output.to_dictionary()
+        if self.merchant_parameters is not None:
+            dictionary['merchantParameters'] = self.merchant_parameters
+        if self.mobile_refund_method_specific_output is not None:
+            dictionary['mobileRefundMethodSpecificOutput'] = self.mobile_refund_method_specific_output.to_dictionary()
+        if self.operation_references is not None:
+            dictionary['operationReferences'] = self.operation_references.to_dictionary()
+        if self.payment_method is not None:
+            dictionary['paymentMethod'] = self.payment_method
+        if self.redirect_refund_method_specific_output is not None:
+            dictionary['redirectRefundMethodSpecificOutput'] = self.redirect_refund_method_specific_output.to_dictionary()
+        if self.references is not None:
+            dictionary['references'] = self.references.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundOutput':
+        super(RefundOutput, self).from_dictionary(dictionary)
+        if 'amountOfMoney' in dictionary:
+            if not isinstance(dictionary['amountOfMoney'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amountOfMoney']))
+            value = AmountOfMoney()
+            self.amount_of_money = value.from_dictionary(dictionary['amountOfMoney'])
+        if 'amountPaid' in dictionary:
+            self.amount_paid = dictionary['amountPaid']
+        if 'cardRefundMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['cardRefundMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardRefundMethodSpecificOutput']))
+            value = RefundCardMethodSpecificOutput()
+            self.card_refund_method_specific_output = value.from_dictionary(dictionary['cardRefundMethodSpecificOutput'])
+        if 'eWalletRefundMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['eWalletRefundMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['eWalletRefundMethodSpecificOutput']))
+            value = RefundEWalletMethodSpecificOutput()
+            self.e_wallet_refund_method_specific_output = value.from_dictionary(dictionary['eWalletRefundMethodSpecificOutput'])
+        if 'merchantParameters' in dictionary:
+            self.merchant_parameters = dictionary['merchantParameters']
+        if 'mobileRefundMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['mobileRefundMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mobileRefundMethodSpecificOutput']))
+            value = RefundMobileMethodSpecificOutput()
+            self.mobile_refund_method_specific_output = value.from_dictionary(dictionary['mobileRefundMethodSpecificOutput'])
+        if 'operationReferences' in dictionary:
+            if not isinstance(dictionary['operationReferences'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['operationReferences']))
+            value = OperationPaymentReferences()
+            self.operation_references = value.from_dictionary(dictionary['operationReferences'])
+        if 'paymentMethod' in dictionary:
+            self.payment_method = dictionary['paymentMethod']
+        if 'redirectRefundMethodSpecificOutput' in dictionary:
+            if not isinstance(dictionary['redirectRefundMethodSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectRefundMethodSpecificOutput']))
+            value = RefundRedirectMethodSpecificOutput()
+            self.redirect_refund_method_specific_output = value.from_dictionary(dictionary['redirectRefundMethodSpecificOutput'])
+        if 'references' in dictionary:
+            if not isinstance(dictionary['references'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['references']))
+            value = PaymentReferences()
+            self.references = value.from_dictionary(dictionary['references'])
+        return self