connect-sdk-python3 3.47.0__zip → 4.0.1__zip

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/redirect_payment_product869_specific_input.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class RedirectPaymentProduct869SpecificInput(DataObject):
+
+    __issuer_id: Optional[str] = None
+    __resident_id_name: Optional[str] = None
+    __resident_id_number: Optional[str] = None
+
+    @property
+    def issuer_id(self) -> Optional[str]:
+        """
+        | ID of the issuing bank of the customer. A list of available issuerIDs can be obtained by using the retrieve payment product directory API.
+
+        Type: str
+        """
+        return self.__issuer_id
+
+    @issuer_id.setter
+    def issuer_id(self, value: Optional[str]) -> None:
+        self.__issuer_id = value
+
+    @property
+    def resident_id_name(self) -> Optional[str]:
+        """
+        | The name as described on the Resident Identity Card of the People's Republic of China.
+
+        Type: str
+        """
+        return self.__resident_id_name
+
+    @resident_id_name.setter
+    def resident_id_name(self, value: Optional[str]) -> None:
+        self.__resident_id_name = value
+
+    @property
+    def resident_id_number(self) -> Optional[str]:
+        """
+        | The identification number as described on the Resident Identity Card of the People's Republic of China.
+
+        Type: str
+        """
+        return self.__resident_id_number
+
+    @resident_id_number.setter
+    def resident_id_number(self, value: Optional[str]) -> None:
+        self.__resident_id_number = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectPaymentProduct869SpecificInput, self).to_dictionary()
+        if self.issuer_id is not None:
+            dictionary['issuerId'] = self.issuer_id
+        if self.resident_id_name is not None:
+            dictionary['residentIdName'] = self.resident_id_name
+        if self.resident_id_number is not None:
+            dictionary['residentIdNumber'] = self.resident_id_number
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentProduct869SpecificInput':
+        super(RedirectPaymentProduct869SpecificInput, self).from_dictionary(dictionary)
+        if 'issuerId' in dictionary:
+            self.issuer_id = dictionary['issuerId']
+        if 'residentIdName' in dictionary:
+            self.resident_id_name = dictionary['residentIdName']
+        if 'residentIdNumber' in dictionary:
+            self.resident_id_number = dictionary['residentIdNumber']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/redirect_payment_product882_specific_input.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class RedirectPaymentProduct882SpecificInput(DataObject):
+    """
+    | Please find below specific input fields for payment product 882 (Net Banking)
+    """
+
+    __issuer_id: Optional[str] = None
+
+    @property
+    def issuer_id(self) -> Optional[str]:
+        """
+        | ID of the issuing bank of the customer. A list of available issuerIDs can be obtained by using the retrieve payment product directory API.
+
+        Type: str
+        """
+        return self.__issuer_id
+
+    @issuer_id.setter
+    def issuer_id(self, value: Optional[str]) -> None:
+        self.__issuer_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectPaymentProduct882SpecificInput, self).to_dictionary()
+        if self.issuer_id is not None:
+            dictionary['issuerId'] = self.issuer_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentProduct882SpecificInput':
+        super(RedirectPaymentProduct882SpecificInput, self).from_dictionary(dictionary)
+        if 'issuerId' in dictionary:
+            self.issuer_id = dictionary['issuerId']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/redirection_data.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class RedirectionData(DataObject):
+    """
+    | Object containing browser specific redirection related data
+    """
+
+    __return_url: Optional[str] = None
+    __variant: Optional[str] = None
+
+    @property
+    def return_url(self) -> Optional[str]:
+        """
+        | The URL that the customer is redirect 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
+
+    @property
+    def variant(self) -> Optional[str]:
+        """
+        | Using the Configuration Center it is possible to create multiple variations of your MyCheckout payment pages. The redirection flow for 3-D Secure uses the MyCheckout payment pages to display the following types of pages:
+        
+        * Redirection page - All redirection using a POST method will load a page in the browser of the customer that performs the actual redirection. This page contains a message to the customer explaining what is happening.
+        * MethodURL page - Certain Issuers will use a specific flow in case of 3-D Secure version 2 to directly collect information from the customer browser. This page contains a spinner indicating that this process is going on in.
+        
+        | By specifying a specific variant you can force the use of another variant than the default. This allows you to test out the effect of certain changes to your MyCheckout payment pages in a controlled manner. Please note that you need to specify the ID instead of the name of the variant.
+        | Note: In case you have defined a Dynamic 3D Secure rule that takes the variant into account this will only work if you explicitly specify the ID using this property.
+
+        Type: str
+        """
+        return self.__variant
+
+    @variant.setter
+    def variant(self, value: Optional[str]) -> None:
+        self.__variant = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectionData, self).to_dictionary()
+        if self.return_url is not None:
+            dictionary['returnUrl'] = self.return_url
+        if self.variant is not None:
+            dictionary['variant'] = self.variant
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectionData':
+        super(RedirectionData, self).from_dictionary(dictionary)
+        if 'returnUrl' in dictionary:
+            self.return_url = dictionary['returnUrl']
+        if 'variant' in dictionary:
+            self.variant = dictionary['variant']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_bank_method_specific_output.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.refund_method_specific_output import RefundMethodSpecificOutput
+
+
+class RefundBankMethodSpecificOutput(RefundMethodSpecificOutput):
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundBankMethodSpecificOutput, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundBankMethodSpecificOutput':
+        super(RefundBankMethodSpecificOutput, self).from_dictionary(dictionary)
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_card_method_specific_output.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.v1.domain.card_essentials import CardEssentials
+from worldline.connect.sdk.v1.domain.refund_method_specific_output import RefundMethodSpecificOutput
+
+
+class RefundCardMethodSpecificOutput(RefundMethodSpecificOutput):
+
+    __authorisation_code: Optional[str] = None
+    __card: Optional[CardEssentials] = None
+
+    @property
+    def authorisation_code(self) -> Optional[str]:
+        """
+        | Card Authorization code as returned by the acquirer
+
+        Type: str
+        """
+        return self.__authorisation_code
+
+    @authorisation_code.setter
+    def authorisation_code(self, value: Optional[str]) -> None:
+        self.__authorisation_code = value
+
+    @property
+    def card(self) -> Optional[CardEssentials]:
+        """
+        | Object containing card details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.card_essentials.CardEssentials`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value: Optional[CardEssentials]) -> None:
+        self.__card = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundCardMethodSpecificOutput, self).to_dictionary()
+        if self.authorisation_code is not None:
+            dictionary['authorisationCode'] = self.authorisation_code
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundCardMethodSpecificOutput':
+        super(RefundCardMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'authorisationCode' in dictionary:
+            self.authorisation_code = dictionary['authorisationCode']
+        if 'card' in dictionary:
+            if not isinstance(dictionary['card'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['card']))
+            value = CardEssentials()
+            self.card = value.from_dictionary(dictionary['card'])
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_cash_method_specific_output.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.refund_method_specific_output import RefundMethodSpecificOutput
+
+
+class RefundCashMethodSpecificOutput(RefundMethodSpecificOutput):
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundCashMethodSpecificOutput, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundCashMethodSpecificOutput':
+        super(RefundCashMethodSpecificOutput, self).from_dictionary(dictionary)
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_customer.py

@@ -0,0 +1,123 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.address_personal import AddressPersonal
+from worldline.connect.sdk.v1.domain.company_information import CompanyInformation
+from worldline.connect.sdk.v1.domain.contact_details_base import ContactDetailsBase
+
+
+class RefundCustomer(DataObject):
+
+    __address: Optional[AddressPersonal] = None
+    __company_information: Optional[CompanyInformation] = None
+    __contact_details: Optional[ContactDetailsBase] = None
+    __fiscal_number: Optional[str] = None
+
+    @property
+    def address(self) -> Optional[AddressPersonal]:
+        """
+        | Object containing address details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.address_personal.AddressPersonal`
+        """
+        return self.__address
+
+    @address.setter
+    def address(self, value: Optional[AddressPersonal]) -> None:
+        self.__address = value
+
+    @property
+    def company_information(self) -> Optional[CompanyInformation]:
+        """
+        | Object containing company information
+
+        Type: :class:`worldline.connect.sdk.v1.domain.company_information.CompanyInformation`
+        """
+        return self.__company_information
+
+    @company_information.setter
+    def company_information(self, value: Optional[CompanyInformation]) -> None:
+        self.__company_information = value
+
+    @property
+    def contact_details(self) -> Optional[ContactDetailsBase]:
+        """
+        | Object containing contact details like email address and phone number
+
+        Type: :class:`worldline.connect.sdk.v1.domain.contact_details_base.ContactDetailsBase`
+        """
+        return self.__contact_details
+
+    @contact_details.setter
+    def contact_details(self, value: Optional[ContactDetailsBase]) -> None:
+        self.__contact_details = value
+
+    @property
+    def fiscal_number(self) -> Optional[str]:
+        """
+        | The fiscal registration number of the customer or the tax registration number of the company in case of a business customer. Please find below specifics per country:
+        
+        * Argentina - Consumer (DNI) with a length of 7 or 8 digits
+        * Argentina - Company (CUIT) with a length of 11 digits
+        * Brazil - Consumer (CPF) with a length of 11 digits
+        * Brazil - Company (CNPJ) with a length of 14 digits
+        * Chile - Consumer (RUT) with a length of 9 digits
+        * Colombia - Consumer (NIT) with a length of 8, 9 or 10 digits
+        * Denmark - Consumer (CPR-nummer or personnummer) with a length of 10 digits
+        * Dominican Republic - Consumer (RNC) with a length of 11 digits
+        * Finland - Consumer (Finnish: henkilötunnus (abbreviated as HETU)) with a length of 11 characters
+        * India - Consumer (PAN) with a length of 10 characters
+        * Mexico - Consumer (RFC) with a length of 13 digits
+        * Mexico - Company (RFC) with a length of 12 digits
+        * Norway - Consumer (fødselsnummer) with a length of 11 digits
+        * Peru - Consumer (RUC) with a length of 11 digits
+        * Sweden - Consumer (personnummer) with a length of 10 or 12 digits
+        * Uruguay - Consumer (CI) with a length of 8 digits
+        * Uruguay - Consumer (NIE) with a length of 9 digits
+        * Uruguay - Company (RUT) with a length of 12 digits
+
+        Type: str
+        """
+        return self.__fiscal_number
+
+    @fiscal_number.setter
+    def fiscal_number(self, value: Optional[str]) -> None:
+        self.__fiscal_number = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundCustomer, self).to_dictionary()
+        if self.address is not None:
+            dictionary['address'] = self.address.to_dictionary()
+        if self.company_information is not None:
+            dictionary['companyInformation'] = self.company_information.to_dictionary()
+        if self.contact_details is not None:
+            dictionary['contactDetails'] = self.contact_details.to_dictionary()
+        if self.fiscal_number is not None:
+            dictionary['fiscalNumber'] = self.fiscal_number
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundCustomer':
+        super(RefundCustomer, self).from_dictionary(dictionary)
+        if 'address' in dictionary:
+            if not isinstance(dictionary['address'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['address']))
+            value = AddressPersonal()
+            self.address = value.from_dictionary(dictionary['address'])
+        if 'companyInformation' in dictionary:
+            if not isinstance(dictionary['companyInformation'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['companyInformation']))
+            value = CompanyInformation()
+            self.company_information = value.from_dictionary(dictionary['companyInformation'])
+        if 'contactDetails' in dictionary:
+            if not isinstance(dictionary['contactDetails'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['contactDetails']))
+            value = ContactDetailsBase()
+            self.contact_details = value.from_dictionary(dictionary['contactDetails'])
+        if 'fiscalNumber' in dictionary:
+            self.fiscal_number = dictionary['fiscalNumber']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_e_invoice_method_specific_output.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.refund_method_specific_output import RefundMethodSpecificOutput
+
+
+class RefundEInvoiceMethodSpecificOutput(RefundMethodSpecificOutput):
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundEInvoiceMethodSpecificOutput, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundEInvoiceMethodSpecificOutput':
+        super(RefundEInvoiceMethodSpecificOutput, self).from_dictionary(dictionary)
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_e_wallet_method_specific_output.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.v1.domain.refund_method_specific_output import RefundMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.refund_payment_product840_specific_output import RefundPaymentProduct840SpecificOutput
+
+
+class RefundEWalletMethodSpecificOutput(RefundMethodSpecificOutput):
+
+    __payment_product840_specific_output: Optional[RefundPaymentProduct840SpecificOutput] = None
+
+    @property
+    def payment_product840_specific_output(self) -> Optional[RefundPaymentProduct840SpecificOutput]:
+        """
+        | PayPal (payment product 840) specific details
+
+        Type: :class:`worldline.connect.sdk.v1.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
+
+    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()
+        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'])
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_error_response.py

@@ -0,0 +1,87 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import List, Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.api_error import APIError
+from worldline.connect.sdk.v1.domain.refund_result import RefundResult
+
+
+class RefundErrorResponse(DataObject):
+
+    __error_id: Optional[str] = None
+    __errors: Optional[List[APIError]] = None
+    __refund_result: Optional[RefundResult] = None
+
+    @property
+    def error_id(self) -> Optional[str]:
+        """
+        | Unique reference, for debugging purposes, of this error response
+
+        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]]:
+        """
+        | List of one or more errors
+
+        Type: list[:class:`worldline.connect.sdk.v1.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[RefundResult]:
+        """
+        | Object that contains details on the created refund in case one has been created
+
+        Type: :class:`worldline.connect.sdk.v1.domain.refund_result.RefundResult`
+        """
+        return self.__refund_result
+
+    @refund_result.setter
+    def refund_result(self, value: Optional[RefundResult]) -> 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 = RefundResult()
+            self.refund_result = value.from_dictionary(dictionary['refundResult'])
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_method_specific_output.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class RefundMethodSpecificOutput(DataObject):
+
+    __refund_product_id: Optional[int] = None
+    __total_amount_paid: Optional[int] = None
+    __total_amount_refunded: Optional[int] = None
+
+    @property
+    def refund_product_id(self) -> Optional[int]:
+        """
+        | Refund product identifier
+        | Please see refund products <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/refundproducts.html> for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__refund_product_id
+
+    @refund_product_id.setter
+    def refund_product_id(self, value: Optional[int]) -> None:
+        self.__refund_product_id = value
+
+    @property
+    def total_amount_paid(self) -> Optional[int]:
+        """
+        | Total paid amount (in cents and always with 2 decimals)
+
+        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(RefundMethodSpecificOutput, self).to_dictionary()
+        if self.refund_product_id is not None:
+            dictionary['refundProductId'] = self.refund_product_id
+        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) -> 'RefundMethodSpecificOutput':
+        super(RefundMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'refundProductId' in dictionary:
+            self.refund_product_id = dictionary['refundProductId']
+        if 'totalAmountPaid' in dictionary:
+            self.total_amount_paid = dictionary['totalAmountPaid']
+        if 'totalAmountRefunded' in dictionary:
+            self.total_amount_refunded = dictionary['totalAmountRefunded']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/refund_mobile_method_specific_output.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import Optional
+
+from worldline.connect.sdk.v1.domain.refund_method_specific_output import RefundMethodSpecificOutput
+
+
+class RefundMobileMethodSpecificOutput(RefundMethodSpecificOutput):
+
+    __network: Optional[str] = None
+
+    @property
+    def network(self) -> Optional[str]:
+        """
+        | The network that was used for the refund. The string that represents the network is identical to the strings that the payment product vendors use in their documentation.For instance: "Visa" for Google Pay <https://developer.apple.com/reference/passkit/pkpaymentnetwork>.
+
+        Type: str
+        """
+        return self.__network
+
+    @network.setter
+    def network(self, value: Optional[str]) -> None:
+        self.__network = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RefundMobileMethodSpecificOutput, self).to_dictionary()
+        if self.network is not None:
+            dictionary['network'] = self.network
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RefundMobileMethodSpecificOutput':
+        super(RefundMobileMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'network' in dictionary:
+            self.network = dictionary['network']
+        return self