connect-sdk-python3 3.47.0__zip → 4.0.1__zip

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

@@ -0,0 +1,210 @@
+# -*- 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.abstract_payment_method_specific_output import AbstractPaymentMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.bank_account_bban import BankAccountBban
+from worldline.connect.sdk.v1.domain.bank_account_iban import BankAccountIban
+from worldline.connect.sdk.v1.domain.fraud_results import FraudResults
+from worldline.connect.sdk.v1.domain.payment_product3201_specific_output import PaymentProduct3201SpecificOutput
+from worldline.connect.sdk.v1.domain.payment_product806_specific_output import PaymentProduct806SpecificOutput
+from worldline.connect.sdk.v1.domain.payment_product836_specific_output import PaymentProduct836SpecificOutput
+from worldline.connect.sdk.v1.domain.payment_product840_specific_output import PaymentProduct840SpecificOutput
+
+
+class RedirectPaymentMethodSpecificOutput(AbstractPaymentMethodSpecificOutput):
+
+    __bank_account_bban: Optional[BankAccountBban] = None
+    __bank_account_iban: Optional[BankAccountIban] = None
+    __bic: Optional[str] = None
+    __fraud_results: Optional[FraudResults] = None
+    __payment_product3201_specific_output: Optional[PaymentProduct3201SpecificOutput] = None
+    __payment_product806_specific_output: Optional[PaymentProduct806SpecificOutput] = None
+    __payment_product836_specific_output: Optional[PaymentProduct836SpecificOutput] = None
+    __payment_product840_specific_output: Optional[PaymentProduct840SpecificOutput] = None
+    __token: Optional[str] = None
+
+    @property
+    def bank_account_bban(self) -> Optional[BankAccountBban]:
+        """
+        | Object that holds the Basic Bank Account Number (BBAN) data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_bban.BankAccountBban`
+        """
+        return self.__bank_account_bban
+
+    @bank_account_bban.setter
+    def bank_account_bban(self, value: Optional[BankAccountBban]) -> None:
+        self.__bank_account_bban = value
+
+    @property
+    def bank_account_iban(self) -> Optional[BankAccountIban]:
+        """
+        | Object containing account holder name and IBAN information
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_iban.BankAccountIban`
+        """
+        return self.__bank_account_iban
+
+    @bank_account_iban.setter
+    def bank_account_iban(self, value: Optional[BankAccountIban]) -> None:
+        self.__bank_account_iban = value
+
+    @property
+    def bic(self) -> Optional[str]:
+        """
+        | The BIC is the Business Identifier Code, also known as SWIFT or Bank Identifier code. It is a code with an internationally agreed format to Identify a specific bank or even branch. The BIC contains 8 or 11 positions: the first 4 contain the bank code, followed by the country code and location code.
+
+        Type: str
+        """
+        return self.__bic
+
+    @bic.setter
+    def bic(self, value: Optional[str]) -> None:
+        self.__bic = value
+
+    @property
+    def fraud_results(self) -> Optional[FraudResults]:
+        """
+        | Object containing the results of the fraud screening
+
+        Type: :class:`worldline.connect.sdk.v1.domain.fraud_results.FraudResults`
+        """
+        return self.__fraud_results
+
+    @fraud_results.setter
+    def fraud_results(self, value: Optional[FraudResults]) -> None:
+        self.__fraud_results = value
+
+    @property
+    def payment_product3201_specific_output(self) -> Optional[PaymentProduct3201SpecificOutput]:
+        """
+        | PostFinance Card (payment product 3201) specific details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_product3201_specific_output.PaymentProduct3201SpecificOutput`
+        """
+        return self.__payment_product3201_specific_output
+
+    @payment_product3201_specific_output.setter
+    def payment_product3201_specific_output(self, value: Optional[PaymentProduct3201SpecificOutput]) -> None:
+        self.__payment_product3201_specific_output = value
+
+    @property
+    def payment_product806_specific_output(self) -> Optional[PaymentProduct806SpecificOutput]:
+        """
+        | Trustly (payment product 806) specific details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_product806_specific_output.PaymentProduct806SpecificOutput`
+        """
+        return self.__payment_product806_specific_output
+
+    @payment_product806_specific_output.setter
+    def payment_product806_specific_output(self, value: Optional[PaymentProduct806SpecificOutput]) -> None:
+        self.__payment_product806_specific_output = value
+
+    @property
+    def payment_product836_specific_output(self) -> Optional[PaymentProduct836SpecificOutput]:
+        """
+        | Sofort (payment product 836) specific details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_product836_specific_output.PaymentProduct836SpecificOutput`
+        """
+        return self.__payment_product836_specific_output
+
+    @payment_product836_specific_output.setter
+    def payment_product836_specific_output(self, value: Optional[PaymentProduct836SpecificOutput]) -> None:
+        self.__payment_product836_specific_output = value
+
+    @property
+    def payment_product840_specific_output(self) -> Optional[PaymentProduct840SpecificOutput]:
+        """
+        | PayPal (payment product 840) specific details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_product840_specific_output.PaymentProduct840SpecificOutput`
+        """
+        return self.__payment_product840_specific_output
+
+    @payment_product840_specific_output.setter
+    def payment_product840_specific_output(self, value: Optional[PaymentProduct840SpecificOutput]) -> None:
+        self.__payment_product840_specific_output = value
+
+    @property
+    def token(self) -> Optional[str]:
+        """
+        | ID of the token. This property is populated when the payment was done with a token or when the payment was tokenized.
+
+        Type: str
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value: Optional[str]) -> None:
+        self.__token = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectPaymentMethodSpecificOutput, self).to_dictionary()
+        if self.bank_account_bban is not None:
+            dictionary['bankAccountBban'] = self.bank_account_bban.to_dictionary()
+        if self.bank_account_iban is not None:
+            dictionary['bankAccountIban'] = self.bank_account_iban.to_dictionary()
+        if self.bic is not None:
+            dictionary['bic'] = self.bic
+        if self.fraud_results is not None:
+            dictionary['fraudResults'] = self.fraud_results.to_dictionary()
+        if self.payment_product3201_specific_output is not None:
+            dictionary['paymentProduct3201SpecificOutput'] = self.payment_product3201_specific_output.to_dictionary()
+        if self.payment_product806_specific_output is not None:
+            dictionary['paymentProduct806SpecificOutput'] = self.payment_product806_specific_output.to_dictionary()
+        if self.payment_product836_specific_output is not None:
+            dictionary['paymentProduct836SpecificOutput'] = self.payment_product836_specific_output.to_dictionary()
+        if self.payment_product840_specific_output is not None:
+            dictionary['paymentProduct840SpecificOutput'] = self.payment_product840_specific_output.to_dictionary()
+        if self.token is not None:
+            dictionary['token'] = self.token
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentMethodSpecificOutput':
+        super(RedirectPaymentMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'bankAccountBban' in dictionary:
+            if not isinstance(dictionary['bankAccountBban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountBban']))
+            value = BankAccountBban()
+            self.bank_account_bban = value.from_dictionary(dictionary['bankAccountBban'])
+        if 'bankAccountIban' in dictionary:
+            if not isinstance(dictionary['bankAccountIban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountIban']))
+            value = BankAccountIban()
+            self.bank_account_iban = value.from_dictionary(dictionary['bankAccountIban'])
+        if 'bic' in dictionary:
+            self.bic = dictionary['bic']
+        if 'fraudResults' in dictionary:
+            if not isinstance(dictionary['fraudResults'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraudResults']))
+            value = FraudResults()
+            self.fraud_results = value.from_dictionary(dictionary['fraudResults'])
+        if 'paymentProduct3201SpecificOutput' in dictionary:
+            if not isinstance(dictionary['paymentProduct3201SpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct3201SpecificOutput']))
+            value = PaymentProduct3201SpecificOutput()
+            self.payment_product3201_specific_output = value.from_dictionary(dictionary['paymentProduct3201SpecificOutput'])
+        if 'paymentProduct806SpecificOutput' in dictionary:
+            if not isinstance(dictionary['paymentProduct806SpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct806SpecificOutput']))
+            value = PaymentProduct806SpecificOutput()
+            self.payment_product806_specific_output = value.from_dictionary(dictionary['paymentProduct806SpecificOutput'])
+        if 'paymentProduct836SpecificOutput' in dictionary:
+            if not isinstance(dictionary['paymentProduct836SpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct836SpecificOutput']))
+            value = PaymentProduct836SpecificOutput()
+            self.payment_product836_specific_output = value.from_dictionary(dictionary['paymentProduct836SpecificOutput'])
+        if 'paymentProduct840SpecificOutput' in dictionary:
+            if not isinstance(dictionary['paymentProduct840SpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct840SpecificOutput']))
+            value = PaymentProduct840SpecificOutput()
+            self.payment_product840_specific_output = value.from_dictionary(dictionary['paymentProduct840SpecificOutput'])
+        if 'token' in dictionary:
+            self.token = dictionary['token']
+        return self

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

@@ -0,0 +1,77 @@
+# -*- 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 RedirectPaymentProduct4101SpecificInput(DataObject):
+    """
+    | Please find below specific input fields for payment product 4101 (UPI)
+    """
+
+    __display_name: Optional[str] = None
+    __integration_type: Optional[str] = None
+    __virtual_payment_address: Optional[str] = None
+
+    @property
+    def display_name(self) -> Optional[str]:
+        """
+        | The merchant name as shown to the customer in some payment applications.
+
+        Type: str
+        """
+        return self.__display_name
+
+    @display_name.setter
+    def display_name(self, value: Optional[str]) -> None:
+        self.__display_name = value
+
+    @property
+    def integration_type(self) -> Optional[str]:
+        """
+        | The value of this property must be 'vpa', 'desktopQRCode', or 'urlIntent'.
+
+        Type: str
+        """
+        return self.__integration_type
+
+    @integration_type.setter
+    def integration_type(self, value: Optional[str]) -> None:
+        self.__integration_type = value
+
+    @property
+    def virtual_payment_address(self) -> Optional[str]:
+        """
+        | The Virtual Payment Address (VPA) of the customer. The '+' character is not allowed in this property for transactions that are processed by TechProcess Payment Platform.
+
+        Type: str
+        """
+        return self.__virtual_payment_address
+
+    @virtual_payment_address.setter
+    def virtual_payment_address(self, value: Optional[str]) -> None:
+        self.__virtual_payment_address = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectPaymentProduct4101SpecificInput, self).to_dictionary()
+        if self.display_name is not None:
+            dictionary['displayName'] = self.display_name
+        if self.integration_type is not None:
+            dictionary['integrationType'] = self.integration_type
+        if self.virtual_payment_address is not None:
+            dictionary['virtualPaymentAddress'] = self.virtual_payment_address
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentProduct4101SpecificInput':
+        super(RedirectPaymentProduct4101SpecificInput, self).from_dictionary(dictionary)
+        if 'displayName' in dictionary:
+            self.display_name = dictionary['displayName']
+        if 'integrationType' in dictionary:
+            self.integration_type = dictionary['integrationType']
+        if 'virtualPaymentAddress' in dictionary:
+            self.virtual_payment_address = dictionary['virtualPaymentAddress']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/redirect_payment_product4101_specific_input_base.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.v1.domain.abstract_redirect_payment_product4101_specific_input import AbstractRedirectPaymentProduct4101SpecificInput
+
+
+class RedirectPaymentProduct4101SpecificInputBase(AbstractRedirectPaymentProduct4101SpecificInput):
+    """
+    | Please find below specific input fields for payment product 4101 (UPI)
+    """
+
+    __display_name: Optional[str] = None
+
+    @property
+    def display_name(self) -> Optional[str]:
+        """
+        | The merchant name as shown to the customer in some payment applications.
+
+        Type: str
+        """
+        return self.__display_name
+
+    @display_name.setter
+    def display_name(self, value: Optional[str]) -> None:
+        self.__display_name = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectPaymentProduct4101SpecificInputBase, self).to_dictionary()
+        if self.display_name is not None:
+            dictionary['displayName'] = self.display_name
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentProduct4101SpecificInputBase':
+        super(RedirectPaymentProduct4101SpecificInputBase, self).from_dictionary(dictionary)
+        if 'displayName' in dictionary:
+            self.display_name = dictionary['displayName']
+        return self

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

@@ -0,0 +1,62 @@
+# -*- 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 RedirectPaymentProduct809SpecificInput(DataObject):
+    """
+    | Please find below specific input fields for payment product 809 (iDeal)
+    """
+
+    __expiration_period: Optional[str] = None
+    __issuer_id: Optional[str] = None
+
+    @property
+    def expiration_period(self) -> Optional[str]:
+        """
+        | This sets the maximum amount of minutes a customer has to complete the payment at the bank. After this period has expired it is impossible for the customer to make a payment and in case no payment has been made the transaction will be marked as unsuccessful and expired by the bank. Setting the expirationPeriod is convenient if you want to maximise the time a customer has to complete the payment. Please note that it is normal for a customer to take up to 5 minutes to complete a payment. Setting this value below 10 minutes is not advised.
+        | You can set this value in minutes with a maximum value of 60 minutes. If no input is provided the default value of 60 is used for the transaction.
+
+        Type: str
+
+        Deprecated; Use RedirectPaymentMethodSpecificInput.expirationPeriod instead
+        """
+        return self.__expiration_period
+
+    @expiration_period.setter
+    def expiration_period(self, value: Optional[str]) -> None:
+        self.__expiration_period = value
+
+    @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(RedirectPaymentProduct809SpecificInput, self).to_dictionary()
+        if self.expiration_period is not None:
+            dictionary['expirationPeriod'] = self.expiration_period
+        if self.issuer_id is not None:
+            dictionary['issuerId'] = self.issuer_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentProduct809SpecificInput':
+        super(RedirectPaymentProduct809SpecificInput, self).from_dictionary(dictionary)
+        if 'expirationPeriod' in dictionary:
+            self.expiration_period = dictionary['expirationPeriod']
+        if 'issuerId' in dictionary:
+            self.issuer_id = dictionary['issuerId']
+        return self

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

@@ -0,0 +1,45 @@
+# -*- 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.bank_account_iban import BankAccountIban
+
+
+class RedirectPaymentProduct816SpecificInput(DataObject):
+    """
+    | Please find below specific input fields for payment product 816 (giropay)
+    """
+
+    __bank_account_iban: Optional[BankAccountIban] = None
+
+    @property
+    def bank_account_iban(self) -> Optional[BankAccountIban]:
+        """
+        | Object containing the bank account details of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_iban.BankAccountIban`
+        """
+        return self.__bank_account_iban
+
+    @bank_account_iban.setter
+    def bank_account_iban(self, value: Optional[BankAccountIban]) -> None:
+        self.__bank_account_iban = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectPaymentProduct816SpecificInput, self).to_dictionary()
+        if self.bank_account_iban is not None:
+            dictionary['bankAccountIban'] = self.bank_account_iban.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentProduct816SpecificInput':
+        super(RedirectPaymentProduct816SpecificInput, self).from_dictionary(dictionary)
+        if 'bankAccountIban' in dictionary:
+            if not isinstance(dictionary['bankAccountIban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountIban']))
+            value = BankAccountIban()
+            self.bank_account_iban = value.from_dictionary(dictionary['bankAccountIban'])
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/redirect_payment_product840_specific_input.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.v1.domain.abstract_redirect_payment_product840_specific_input import AbstractRedirectPaymentProduct840SpecificInput
+
+
+class RedirectPaymentProduct840SpecificInput(AbstractRedirectPaymentProduct840SpecificInput):
+    """
+    | Please find below specific input fields for payment product 840 (PayPal)
+    """
+
+    __custom: Optional[str] = None
+    __is_shortcut: Optional[bool] = None
+
+    @property
+    def custom(self) -> Optional[str]:
+        """
+        | A free text string that you can send to PayPal. With a special agreement between PayPal and you, PayPal uses the data in that property, for custom services they offer to you.
+
+        Type: str
+
+        Deprecated; Use Order.references.descriptor instead
+        """
+        return self.__custom
+
+    @custom.setter
+    def custom(self, value: Optional[str]) -> None:
+        self.__custom = value
+
+    @property
+    def is_shortcut(self) -> Optional[bool]:
+        """
+        | Deprecated: If your PayPal payments are processed by Worldline's Ogone Payment Platform, please use the property addressSelectionAtPayPal instead.
+        | Indicates whether to use PayPal Express Checkout for payments processed by Worldline's GlobalCollect Payment Platform. 
+        
+        * true = PayPal Express Checkout 
+        * false = Regular PayPal payment 
+        
+        | For payments processed by Worldline's Ogone Payment Platform, please see the addressSelectionAtPayPal property for more information.
+
+        Type: bool
+        """
+        return self.__is_shortcut
+
+    @is_shortcut.setter
+    def is_shortcut(self, value: Optional[bool]) -> None:
+        self.__is_shortcut = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectPaymentProduct840SpecificInput, self).to_dictionary()
+        if self.custom is not None:
+            dictionary['custom'] = self.custom
+        if self.is_shortcut is not None:
+            dictionary['isShortcut'] = self.is_shortcut
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentProduct840SpecificInput':
+        super(RedirectPaymentProduct840SpecificInput, self).from_dictionary(dictionary)
+        if 'custom' in dictionary:
+            self.custom = dictionary['custom']
+        if 'isShortcut' in dictionary:
+            self.is_shortcut = dictionary['isShortcut']
+        return self

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

@@ -0,0 +1,20 @@
+# -*- 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.abstract_redirect_payment_product840_specific_input import AbstractRedirectPaymentProduct840SpecificInput
+
+
+class RedirectPaymentProduct840SpecificInputBase(AbstractRedirectPaymentProduct840SpecificInput):
+    """
+    | Please find below the specific input field for payment product 840 (PayPal)
+    """
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectPaymentProduct840SpecificInputBase, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentProduct840SpecificInputBase':
+        super(RedirectPaymentProduct840SpecificInputBase, self).from_dictionary(dictionary)
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/redirect_payment_product861_specific_input.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.domain.data_object import DataObject
+
+
+class RedirectPaymentProduct861SpecificInput(DataObject):
+
+    __mobile_device: Optional[bool] = None
+
+    @property
+    def mobile_device(self) -> Optional[bool]:
+        """
+        | This indicates that a customer is on a mobile device and it is used to distinguish whether a customer should be redirected to AliPay Desktop or Mobile. Alternatively, if you cannot determine whether a customer is on a mobile device or not, a customer can be redirected to AliPay Mobile if the property CreatePaymentRequest.order.customer.device.userAgent is supplied.
+
+        Type: bool
+        """
+        return self.__mobile_device
+
+    @mobile_device.setter
+    def mobile_device(self, value: Optional[bool]) -> None:
+        self.__mobile_device = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectPaymentProduct861SpecificInput, self).to_dictionary()
+        if self.mobile_device is not None:
+            dictionary['mobileDevice'] = self.mobile_device
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentProduct861SpecificInput':
+        super(RedirectPaymentProduct861SpecificInput, self).from_dictionary(dictionary)
+        if 'mobileDevice' in dictionary:
+            self.mobile_device = dictionary['mobileDevice']
+        return self

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

@@ -0,0 +1,62 @@
+# -*- 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 RedirectPaymentProduct863SpecificInput(DataObject):
+
+    __integration_type: Optional[str] = None
+    __open_id: Optional[str] = None
+
+    @property
+    def integration_type(self) -> Optional[str]:
+        """
+        | The type of integration with WeChat. Possible values:
+        
+        * desktopQRCode - used on desktops, the customer opens the WeChat app by scanning a QR code.
+        * urlIntent - used in mobile apps or on mobile web pages, the customer opens the WeChat app using a URL intent.
+        * nativeInApp - used in mobile apps that use the WeChat Pay SDK.
+        * javaScriptAPI - used for WeChat official accounts. Requires the QQ browser to function.
+        * miniProgram - used for Mini Programs.
+
+        Type: str
+        """
+        return self.__integration_type
+
+    @integration_type.setter
+    def integration_type(self, value: Optional[str]) -> None:
+        self.__integration_type = value
+
+    @property
+    def open_id(self) -> Optional[str]:
+        """
+        | An openId of a customer.
+
+        Type: str
+        """
+        return self.__open_id
+
+    @open_id.setter
+    def open_id(self, value: Optional[str]) -> None:
+        self.__open_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectPaymentProduct863SpecificInput, self).to_dictionary()
+        if self.integration_type is not None:
+            dictionary['integrationType'] = self.integration_type
+        if self.open_id is not None:
+            dictionary['openId'] = self.open_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectPaymentProduct863SpecificInput':
+        super(RedirectPaymentProduct863SpecificInput, self).from_dictionary(dictionary)
+        if 'integrationType' in dictionary:
+            self.integration_type = dictionary['integrationType']
+        if 'openId' in dictionary:
+            self.open_id = dictionary['openId']
+        return self