connect-sdk-python3 4.0.0__zip → 4.1.0__zip

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/card_fraud_results.py

@@ -0,0 +1,136 @@
+# -*- 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.fraud_results import FraudResults
+from worldline.connect.sdk.v1.domain.fraud_results_retail_decisions import FraudResultsRetailDecisions
+from worldline.connect.sdk.v1.domain.fraugster_results import FraugsterResults
+
+
+class CardFraudResults(FraudResults):
+    """
+    | Details of the card payment fraud checks that were performed
+    """
+
+    __avs_result: Optional[str] = None
+    __cvv_result: Optional[str] = None
+    __fraugster: Optional[FraugsterResults] = None
+    __retail_decisions: Optional[FraudResultsRetailDecisions] = None
+
+    @property
+    def avs_result(self) -> Optional[str]:
+        """
+        | Result of the Address Verification Service checks. Possible values are:
+        
+        * A - Address (Street) matches, Zip does not
+        * B - Street address match for international transactions—Postal code not verified due to incompatible formats
+        * C - Street address and postal code not verified for international transaction due to incompatible formats
+        * D - Street address and postal code match for international transaction, cardholder name is incorrect
+        * E - AVS error
+        * F - Address does match and five digit ZIP code does match (UK only)
+        * G - Address information is unavailable; international transaction; non-AVS participant
+        * H - Billing address and postal code match, cardholder name is incorrect (Amex)
+        * I - Address information not verified for international transaction
+        * K - Cardholder name matches (Amex)
+        * L - Cardholder name and postal code match (Amex)
+        * M - Cardholder name, street address, and postal code match for international transaction
+        * N - No Match on Address (Street) or Zip
+        * O - Cardholder name and address match (Amex)
+        * P - Postal codes match for international transaction—Street address not verified due to incompatible formats
+        * Q - Billing address matches, cardholder is incorrect (Amex)
+        * R - Retry, System unavailable or Timed out
+        * S - Service not supported by issuer
+        * U - Address information is unavailable
+        * W - 9 digit Zip matches, Address (Street) does not
+        * X - Exact AVS Match
+        * Y - Address (Street) and 5 digit Zip match
+        * Z - 5 digit Zip matches, Address (Street) does not
+        * 0 - No service available
+
+        Type: str
+        """
+        return self.__avs_result
+
+    @avs_result.setter
+    def avs_result(self, value: Optional[str]) -> None:
+        self.__avs_result = value
+
+    @property
+    def cvv_result(self) -> Optional[str]:
+        """
+        | Result of the Card Verification Value checks. Possible values are:
+        
+        * M - CVV check performed and valid value
+        * N - CVV checked and no match
+        * P - CVV check not performed, not requested
+        * S - Cardholder claims no CVV code on card, issuer states CVV-code should be on card
+        * U - Issuer not certified for CVV2
+        * Y - Server provider did not respond
+        * 0 - No service available
+
+        Type: str
+        """
+        return self.__cvv_result
+
+    @cvv_result.setter
+    def cvv_result(self, value: Optional[str]) -> None:
+        self.__cvv_result = value
+
+    @property
+    def fraugster(self) -> Optional[FraugsterResults]:
+        """
+        | Results of Fraugster fraud prevention check. Fraugster collects transaction data points such as name, email address, billing, etc. to analyze whether or not the transaction is fraudulent.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.fraugster_results.FraugsterResults`
+        """
+        return self.__fraugster
+
+    @fraugster.setter
+    def fraugster(self, value: Optional[FraugsterResults]) -> None:
+        self.__fraugster = value
+
+    @property
+    def retail_decisions(self) -> Optional[FraudResultsRetailDecisions]:
+        """
+        | Additional response data returned by RetailDecisions
+
+        Type: :class:`worldline.connect.sdk.v1.domain.fraud_results_retail_decisions.FraudResultsRetailDecisions`
+        """
+        return self.__retail_decisions
+
+    @retail_decisions.setter
+    def retail_decisions(self, value: Optional[FraudResultsRetailDecisions]) -> None:
+        self.__retail_decisions = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CardFraudResults, self).to_dictionary()
+        if self.avs_result is not None:
+            dictionary['avsResult'] = self.avs_result
+        if self.cvv_result is not None:
+            dictionary['cvvResult'] = self.cvv_result
+        if self.fraugster is not None:
+            dictionary['fraugster'] = self.fraugster.to_dictionary()
+        if self.retail_decisions is not None:
+            dictionary['retailDecisions'] = self.retail_decisions.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CardFraudResults':
+        super(CardFraudResults, self).from_dictionary(dictionary)
+        if 'avsResult' in dictionary:
+            self.avs_result = dictionary['avsResult']
+        if 'cvvResult' in dictionary:
+            self.cvv_result = dictionary['cvvResult']
+        if 'fraugster' in dictionary:
+            if not isinstance(dictionary['fraugster'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraugster']))
+            value = FraugsterResults()
+            self.fraugster = value.from_dictionary(dictionary['fraugster'])
+        if 'retailDecisions' in dictionary:
+            if not isinstance(dictionary['retailDecisions'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['retailDecisions']))
+            value = FraudResultsRetailDecisions()
+            self.retail_decisions = value.from_dictionary(dictionary['retailDecisions'])
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/card_payment_method_specific_input.py

@@ -0,0 +1,175 @@
+# -*- 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_card_payment_method_specific_input import AbstractCardPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.card import Card
+from worldline.connect.sdk.v1.domain.external_cardholder_authentication_data import ExternalCardholderAuthenticationData
+from worldline.connect.sdk.v1.domain.scheme_token_data import SchemeTokenData
+from worldline.connect.sdk.v1.domain.three_d_secure import ThreeDSecure
+
+
+class CardPaymentMethodSpecificInput(AbstractCardPaymentMethodSpecificInput):
+
+    __card: Optional[Card] = None
+    __external_cardholder_authentication_data: Optional[ExternalCardholderAuthenticationData] = None
+    __is_recurring: Optional[bool] = None
+    __merchant_initiated_reason_indicator: Optional[str] = None
+    __network_token_data: Optional[SchemeTokenData] = None
+    __return_url: Optional[str] = None
+    __three_d_secure: Optional[ThreeDSecure] = None
+
+    @property
+    def card(self) -> Optional[Card]:
+        """
+        | Object containing card details. The card details will be ignored in case the property networkTokenData is present.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.card.Card`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value: Optional[Card]) -> None:
+        self.__card = value
+
+    @property
+    def external_cardholder_authentication_data(self) -> Optional[ExternalCardholderAuthenticationData]:
+        """
+        | Object containing 3D secure details.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.external_cardholder_authentication_data.ExternalCardholderAuthenticationData`
+
+        Deprecated; Use threeDSecure.externalCardholderAuthenticationData instead
+        """
+        return self.__external_cardholder_authentication_data
+
+    @external_cardholder_authentication_data.setter
+    def external_cardholder_authentication_data(self, value: Optional[ExternalCardholderAuthenticationData]) -> None:
+        self.__external_cardholder_authentication_data = value
+
+    @property
+    def is_recurring(self) -> Optional[bool]:
+        """
+        | Indicates if this transaction is of a one-off or a recurring type
+        
+        * true - This is recurring
+        * false - This is one-off
+
+        Type: bool
+        """
+        return self.__is_recurring
+
+    @is_recurring.setter
+    def is_recurring(self, value: Optional[bool]) -> None:
+        self.__is_recurring = value
+
+    @property
+    def merchant_initiated_reason_indicator(self) -> Optional[str]:
+        """
+        | Indicates reason behind the merchant initiated transaction. These are industry specific.
+        | Possible values:
+        
+        * delayedCharges - Delayed charges are performed to process a supplemental account charge after original services have been rendered and respective payment has been processed. This is typically used in hotel, cruise lines and vehicle rental environments to perform a supplemental payment after the original services are rendered.
+        * noShow - Cardholders can use their cards to make a guaranteed reservation with certain merchant segments. A guaranteed reservation ensures that the reservation will be honored and allows a merchant to perform a No Show transaction to charge the cardholder a penalty according to the merchant’s cancellation policy. For merchants that accept token-based payment credentials to guarantee a reservation, it is necessary to perform a customer initiated (Account Verification) at the time of reservation to be able perform a No Show transaction later.
+
+        Type: str
+        """
+        return self.__merchant_initiated_reason_indicator
+
+    @merchant_initiated_reason_indicator.setter
+    def merchant_initiated_reason_indicator(self, value: Optional[str]) -> None:
+        self.__merchant_initiated_reason_indicator = value
+
+    @property
+    def network_token_data(self) -> Optional[SchemeTokenData]:
+        """
+        | Object holding data that describes a network token
+
+        Type: :class:`worldline.connect.sdk.v1.domain.scheme_token_data.SchemeTokenData`
+        """
+        return self.__network_token_data
+
+    @network_token_data.setter
+    def network_token_data(self, value: Optional[SchemeTokenData]) -> None:
+        self.__network_token_data = value
+
+    @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
+
+        Deprecated; Use threeDSecure.redirectionData.returnUrl instead
+        """
+        return self.__return_url
+
+    @return_url.setter
+    def return_url(self, value: Optional[str]) -> None:
+        self.__return_url = value
+
+    @property
+    def three_d_secure(self) -> Optional[ThreeDSecure]:
+        """
+        | Object containing specific data regarding 3-D Secure
+
+        Type: :class:`worldline.connect.sdk.v1.domain.three_d_secure.ThreeDSecure`
+        """
+        return self.__three_d_secure
+
+    @three_d_secure.setter
+    def three_d_secure(self, value: Optional[ThreeDSecure]) -> None:
+        self.__three_d_secure = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CardPaymentMethodSpecificInput, self).to_dictionary()
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        if self.external_cardholder_authentication_data is not None:
+            dictionary['externalCardholderAuthenticationData'] = self.external_cardholder_authentication_data.to_dictionary()
+        if self.is_recurring is not None:
+            dictionary['isRecurring'] = self.is_recurring
+        if self.merchant_initiated_reason_indicator is not None:
+            dictionary['merchantInitiatedReasonIndicator'] = self.merchant_initiated_reason_indicator
+        if self.network_token_data is not None:
+            dictionary['networkTokenData'] = self.network_token_data.to_dictionary()
+        if self.return_url is not None:
+            dictionary['returnUrl'] = self.return_url
+        if self.three_d_secure is not None:
+            dictionary['threeDSecure'] = self.three_d_secure.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CardPaymentMethodSpecificInput':
+        super(CardPaymentMethodSpecificInput, self).from_dictionary(dictionary)
+        if 'card' in dictionary:
+            if not isinstance(dictionary['card'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['card']))
+            value = Card()
+            self.card = value.from_dictionary(dictionary['card'])
+        if 'externalCardholderAuthenticationData' in dictionary:
+            if not isinstance(dictionary['externalCardholderAuthenticationData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['externalCardholderAuthenticationData']))
+            value = ExternalCardholderAuthenticationData()
+            self.external_cardholder_authentication_data = value.from_dictionary(dictionary['externalCardholderAuthenticationData'])
+        if 'isRecurring' in dictionary:
+            self.is_recurring = dictionary['isRecurring']
+        if 'merchantInitiatedReasonIndicator' in dictionary:
+            self.merchant_initiated_reason_indicator = dictionary['merchantInitiatedReasonIndicator']
+        if 'networkTokenData' in dictionary:
+            if not isinstance(dictionary['networkTokenData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['networkTokenData']))
+            value = SchemeTokenData()
+            self.network_token_data = value.from_dictionary(dictionary['networkTokenData'])
+        if 'returnUrl' in dictionary:
+            self.return_url = dictionary['returnUrl']
+        if 'threeDSecure' in dictionary:
+            if not isinstance(dictionary['threeDSecure'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['threeDSecure']))
+            value = ThreeDSecure()
+            self.three_d_secure = value.from_dictionary(dictionary['threeDSecure'])
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/card_payment_method_specific_input_base.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.abstract_card_payment_method_specific_input import AbstractCardPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.three_d_secure_base import ThreeDSecureBase
+
+
+class CardPaymentMethodSpecificInputBase(AbstractCardPaymentMethodSpecificInput):
+
+    __three_d_secure: Optional[ThreeDSecureBase] = None
+
+    @property
+    def three_d_secure(self) -> Optional[ThreeDSecureBase]:
+        """
+        | Object containing specific data regarding 3-D Secure
+
+        Type: :class:`worldline.connect.sdk.v1.domain.three_d_secure_base.ThreeDSecureBase`
+        """
+        return self.__three_d_secure
+
+    @three_d_secure.setter
+    def three_d_secure(self, value: Optional[ThreeDSecureBase]) -> None:
+        self.__three_d_secure = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CardPaymentMethodSpecificInputBase, self).to_dictionary()
+        if self.three_d_secure is not None:
+            dictionary['threeDSecure'] = self.three_d_secure.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CardPaymentMethodSpecificInputBase':
+        super(CardPaymentMethodSpecificInputBase, self).from_dictionary(dictionary)
+        if 'threeDSecure' in dictionary:
+            if not isinstance(dictionary['threeDSecure'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['threeDSecure']))
+            value = ThreeDSecureBase()
+            self.three_d_secure = value.from_dictionary(dictionary['threeDSecure'])
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/card_payment_method_specific_output.py

@@ -0,0 +1,181 @@
+# -*- 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.card_essentials import CardEssentials
+from worldline.connect.sdk.v1.domain.card_fraud_results import CardFraudResults
+from worldline.connect.sdk.v1.domain.three_d_secure_results import ThreeDSecureResults
+
+
+class CardPaymentMethodSpecificOutput(AbstractPaymentMethodSpecificOutput):
+    """
+    | Card payment specific response data
+    """
+
+    __authorisation_code: Optional[str] = None
+    __card: Optional[CardEssentials] = None
+    __fraud_results: Optional[CardFraudResults] = None
+    __initial_scheme_transaction_id: Optional[str] = None
+    __network_token_used: Optional[bool] = None
+    __scheme_transaction_id: Optional[str] = None
+    __three_d_secure_results: Optional[ThreeDSecureResults] = None
+    __token: Optional[str] = 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
+
+    @property
+    def fraud_results(self) -> Optional[CardFraudResults]:
+        """
+        | Fraud results contained in the CardFraudResults object
+
+        Type: :class:`worldline.connect.sdk.v1.domain.card_fraud_results.CardFraudResults`
+        """
+        return self.__fraud_results
+
+    @fraud_results.setter
+    def fraud_results(self, value: Optional[CardFraudResults]) -> None:
+        self.__fraud_results = value
+
+    @property
+    def initial_scheme_transaction_id(self) -> Optional[str]:
+        """
+        | The unique scheme transactionId of the initial transaction that was performed with SCA.
+        | Should be stored by the merchant to allow it to be submitted in future transactions.
+
+        Type: str
+        """
+        return self.__initial_scheme_transaction_id
+
+    @initial_scheme_transaction_id.setter
+    def initial_scheme_transaction_id(self, value: Optional[str]) -> None:
+        self.__initial_scheme_transaction_id = value
+
+    @property
+    def network_token_used(self) -> Optional[bool]:
+        """
+        | Indicates if a network token was used during the payment.
+
+        Type: bool
+        """
+        return self.__network_token_used
+
+    @network_token_used.setter
+    def network_token_used(self, value: Optional[bool]) -> None:
+        self.__network_token_used = value
+
+    @property
+    def scheme_transaction_id(self) -> Optional[str]:
+        """
+        | The unique scheme transactionId of this transaction.
+        | Should be stored by the merchant to allow it to be submitted in future transactions. Use this value in case the initialSchemeTransactionId property is empty.
+
+        Type: str
+        """
+        return self.__scheme_transaction_id
+
+    @scheme_transaction_id.setter
+    def scheme_transaction_id(self, value: Optional[str]) -> None:
+        self.__scheme_transaction_id = value
+
+    @property
+    def three_d_secure_results(self) -> Optional[ThreeDSecureResults]:
+        """
+        | 3D Secure results object
+
+        Type: :class:`worldline.connect.sdk.v1.domain.three_d_secure_results.ThreeDSecureResults`
+        """
+        return self.__three_d_secure_results
+
+    @three_d_secure_results.setter
+    def three_d_secure_results(self, value: Optional[ThreeDSecureResults]) -> None:
+        self.__three_d_secure_results = value
+
+    @property
+    def token(self) -> Optional[str]:
+        """
+        | If a token was used for or created during the payment, then the ID of that token.
+
+        Type: str
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value: Optional[str]) -> None:
+        self.__token = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CardPaymentMethodSpecificOutput, 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()
+        if self.fraud_results is not None:
+            dictionary['fraudResults'] = self.fraud_results.to_dictionary()
+        if self.initial_scheme_transaction_id is not None:
+            dictionary['initialSchemeTransactionId'] = self.initial_scheme_transaction_id
+        if self.network_token_used is not None:
+            dictionary['networkTokenUsed'] = self.network_token_used
+        if self.scheme_transaction_id is not None:
+            dictionary['schemeTransactionId'] = self.scheme_transaction_id
+        if self.three_d_secure_results is not None:
+            dictionary['threeDSecureResults'] = self.three_d_secure_results.to_dictionary()
+        if self.token is not None:
+            dictionary['token'] = self.token
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CardPaymentMethodSpecificOutput':
+        super(CardPaymentMethodSpecificOutput, 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'])
+        if 'fraudResults' in dictionary:
+            if not isinstance(dictionary['fraudResults'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraudResults']))
+            value = CardFraudResults()
+            self.fraud_results = value.from_dictionary(dictionary['fraudResults'])
+        if 'initialSchemeTransactionId' in dictionary:
+            self.initial_scheme_transaction_id = dictionary['initialSchemeTransactionId']
+        if 'networkTokenUsed' in dictionary:
+            self.network_token_used = dictionary['networkTokenUsed']
+        if 'schemeTransactionId' in dictionary:
+            self.scheme_transaction_id = dictionary['schemeTransactionId']
+        if 'threeDSecureResults' in dictionary:
+            if not isinstance(dictionary['threeDSecureResults'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['threeDSecureResults']))
+            value = ThreeDSecureResults()
+            self.three_d_secure_results = value.from_dictionary(dictionary['threeDSecureResults'])
+        if 'token' in dictionary:
+            self.token = dictionary['token']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/card_payout_method_specific_input.py

@@ -0,0 +1,102 @@
+# -*- 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_payout_method_specific_input import AbstractPayoutMethodSpecificInput
+from worldline.connect.sdk.v1.domain.card import Card
+from worldline.connect.sdk.v1.domain.payout_recipient import PayoutRecipient
+
+
+class CardPayoutMethodSpecificInput(AbstractPayoutMethodSpecificInput):
+
+    __card: Optional[Card] = None
+    __payment_product_id: Optional[int] = None
+    __recipient: Optional[PayoutRecipient] = None
+    __token: Optional[str] = None
+
+    @property
+    def card(self) -> Optional[Card]:
+        """
+        | Object containing the card details.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.card.Card`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value: Optional[Card]) -> None:
+        self.__card = value
+
+    @property
+    def payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier
+        | Please see payment products <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/paymentproducts.html> for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__payment_product_id
+
+    @payment_product_id.setter
+    def payment_product_id(self, value: Optional[int]) -> None:
+        self.__payment_product_id = value
+
+    @property
+    def recipient(self) -> Optional[PayoutRecipient]:
+        """
+        | Object containing the details of the recipient of the payout
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payout_recipient.PayoutRecipient`
+        """
+        return self.__recipient
+
+    @recipient.setter
+    def recipient(self, value: Optional[PayoutRecipient]) -> None:
+        self.__recipient = value
+
+    @property
+    def token(self) -> Optional[str]:
+        """
+        | ID of the token that holds previously stored card data.
+        |  If both the token and card are provided, then the card takes precedence over the token.
+
+        Type: str
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value: Optional[str]) -> None:
+        self.__token = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CardPayoutMethodSpecificInput, self).to_dictionary()
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        if self.recipient is not None:
+            dictionary['recipient'] = self.recipient.to_dictionary()
+        if self.token is not None:
+            dictionary['token'] = self.token
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CardPayoutMethodSpecificInput':
+        super(CardPayoutMethodSpecificInput, self).from_dictionary(dictionary)
+        if 'card' in dictionary:
+            if not isinstance(dictionary['card'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['card']))
+            value = Card()
+            self.card = value.from_dictionary(dictionary['card'])
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        if 'recipient' in dictionary:
+            if not isinstance(dictionary['recipient'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['recipient']))
+            value = PayoutRecipient()
+            self.recipient = value.from_dictionary(dictionary['recipient'])
+        if 'token' in dictionary:
+            self.token = dictionary['token']
+        return self