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

onlinepayments/sdk/domain/create_payment_response.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .merchant_action import MerchantAction
+from .payment_creation_output import PaymentCreationOutput
+from .payment_response import PaymentResponse
+
+
+class CreatePaymentResponse(DataObject):
+
+    __creation_output: Optional[PaymentCreationOutput] = None
+    __merchant_action: Optional[MerchantAction] = None
+    __payment: Optional[PaymentResponse] = None
+
+    @property
+    def creation_output(self) -> Optional[PaymentCreationOutput]:
+        """
+        | This object contains the details of the created payment.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_creation_output.PaymentCreationOutput`
+        """
+        return self.__creation_output
+
+    @creation_output.setter
+    def creation_output(self, value: Optional[PaymentCreationOutput]) -> None:
+        self.__creation_output = value
+
+    @property
+    def merchant_action(self) -> Optional[MerchantAction]:
+        """
+        | This object contains the action, including the needed data, that you should perform next. This could involve showing instructions, displaying the transaction results, or redirecting to a third party to complete the payment.
+
+        Type: :class:`onlinepayments.sdk.domain.merchant_action.MerchantAction`
+        """
+        return self.__merchant_action
+
+    @merchant_action.setter
+    def merchant_action(self, value: Optional[MerchantAction]) -> None:
+        self.__merchant_action = value
+
+    @property
+    def payment(self) -> Optional[PaymentResponse]:
+        """
+        | This object holds the properties related to the payment.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_response.PaymentResponse`
+        """
+        return self.__payment
+
+    @payment.setter
+    def payment(self, value: Optional[PaymentResponse]) -> None:
+        self.__payment = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreatePaymentResponse, self).to_dictionary()
+        if self.creation_output is not None:
+            dictionary['creationOutput'] = self.creation_output.to_dictionary()
+        if self.merchant_action is not None:
+            dictionary['merchantAction'] = self.merchant_action.to_dictionary()
+        if self.payment is not None:
+            dictionary['payment'] = self.payment.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreatePaymentResponse':
+        super(CreatePaymentResponse, self).from_dictionary(dictionary)
+        if 'creationOutput' in dictionary:
+            if not isinstance(dictionary['creationOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['creationOutput']))
+            value = PaymentCreationOutput()
+            self.creation_output = value.from_dictionary(dictionary['creationOutput'])
+        if 'merchantAction' in dictionary:
+            if not isinstance(dictionary['merchantAction'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['merchantAction']))
+            value = MerchantAction()
+            self.merchant_action = value.from_dictionary(dictionary['merchantAction'])
+        if 'payment' in dictionary:
+            if not isinstance(dictionary['payment'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payment']))
+            value = PaymentResponse()
+            self.payment = value.from_dictionary(dictionary['payment'])
+        return self

onlinepayments/sdk/domain/create_payout_request.py

@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .card_payout_method_specific_input import CardPayoutMethodSpecificInput
+from .data_object import DataObject
+from .feedbacks import Feedbacks
+from .omnichannel_payout_specific_input import OmnichannelPayoutSpecificInput
+from .payment_references import PaymentReferences
+
+
+class CreatePayoutRequest(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __card_payout_method_specific_input: Optional[CardPayoutMethodSpecificInput] = None
+    __descriptor: Optional[str] = None
+    __feedbacks: Optional[Feedbacks] = None
+    __omnichannel_payout_specific_input: Optional[OmnichannelPayoutSpecificInput] = 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 card_payout_method_specific_input(self) -> Optional[CardPayoutMethodSpecificInput]:
+        """
+        | Object containing the payout details for a card
+
+        Type: :class:`onlinepayments.sdk.domain.card_payout_method_specific_input.CardPayoutMethodSpecificInput`
+        """
+        return self.__card_payout_method_specific_input
+
+    @card_payout_method_specific_input.setter
+    def card_payout_method_specific_input(self, value: Optional[CardPayoutMethodSpecificInput]) -> None:
+        self.__card_payout_method_specific_input = value
+
+    @property
+    def descriptor(self) -> Optional[str]:
+        """
+        | Descriptive text that is used towards to customer, either during an online checkout at a third party and/or on the statement of the customer. For card transactions this is usually referred to as a Soft Descriptor. The maximum allowed length varies per card acquirer:
+        
+        * AIB - 22 characters
+        * American Express - 25 characters
+        * Atos Origin BNP - 15 characters
+        * Barclays - 25 characters
+        * Catella - 22 characters
+        * CBA - 20 characters
+        * Elavon - 25 characters
+        * First Data - 25 characters
+        * INICIS (INIPAY) - 22-30 characters
+        * JCB - 25 characters
+        * Merchant Solutions - 22-25 characters
+        * Payvision (EU & HK) - 25 characters
+        * SEB Euroline - 22 characters
+        * Sub1 Argentina - 15 characters
+        * Wells Fargo - 25 characters Note that we advise you to use 22 characters as the max length as beyond this our experience is that issuers will start to truncate. We currently also only allow per API call overrides for AIB and Barclays For alternative payment products the maximum allowed length varies per payment product:
+        * 402 e-Przelewy - 30 characters
+        * 404 INICIS - 80 characters
+        * 802 Nordea ePayment Finland - 234 characters
+        * 809 iDeal - 32 characters
+        * 836 SOFORT - 42 characters
+        * 840 PayPal - 127 characters
+        * 841 WebMoney - 175 characters
+        * 849 Yandex - 64 characters
+        * 861 Alipay - 256 characters
+        * 863 WeChat Pay - 32 characters
+        * 880 BOKU - 20 characters
+        * 8580 Qiwi - 255 characters
+        * 1504 Konbini - 80 characters All other payment products do not support a descriptor.
+
+        Type: str
+        """
+        return self.__descriptor
+
+    @descriptor.setter
+    def descriptor(self, value: Optional[str]) -> None:
+        self.__descriptor = value
+
+    @property
+    def feedbacks(self) -> Optional[Feedbacks]:
+        """
+        | This section will contain feedback Urls to provide feedback on the payment.
+
+        Type: :class:`onlinepayments.sdk.domain.feedbacks.Feedbacks`
+        """
+        return self.__feedbacks
+
+    @feedbacks.setter
+    def feedbacks(self, value: Optional[Feedbacks]) -> None:
+        self.__feedbacks = value
+
+    @property
+    def omnichannel_payout_specific_input(self) -> Optional[OmnichannelPayoutSpecificInput]:
+        """
+        | Object containing the additional payout details for an Omnichannel merchant
+
+        Type: :class:`onlinepayments.sdk.domain.omnichannel_payout_specific_input.OmnichannelPayoutSpecificInput`
+        """
+        return self.__omnichannel_payout_specific_input
+
+    @omnichannel_payout_specific_input.setter
+    def omnichannel_payout_specific_input(self, value: Optional[OmnichannelPayoutSpecificInput]) -> None:
+        self.__omnichannel_payout_specific_input = 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(CreatePayoutRequest, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.card_payout_method_specific_input is not None:
+            dictionary['cardPayoutMethodSpecificInput'] = self.card_payout_method_specific_input.to_dictionary()
+        if self.descriptor is not None:
+            dictionary['descriptor'] = self.descriptor
+        if self.feedbacks is not None:
+            dictionary['feedbacks'] = self.feedbacks.to_dictionary()
+        if self.omnichannel_payout_specific_input is not None:
+            dictionary['omnichannelPayoutSpecificInput'] = self.omnichannel_payout_specific_input.to_dictionary()
+        if self.references is not None:
+            dictionary['references'] = self.references.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreatePayoutRequest':
+        super(CreatePayoutRequest, 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 'cardPayoutMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['cardPayoutMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardPayoutMethodSpecificInput']))
+            value = CardPayoutMethodSpecificInput()
+            self.card_payout_method_specific_input = value.from_dictionary(dictionary['cardPayoutMethodSpecificInput'])
+        if 'descriptor' in dictionary:
+            self.descriptor = dictionary['descriptor']
+        if 'feedbacks' in dictionary:
+            if not isinstance(dictionary['feedbacks'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['feedbacks']))
+            value = Feedbacks()
+            self.feedbacks = value.from_dictionary(dictionary['feedbacks'])
+        if 'omnichannelPayoutSpecificInput' in dictionary:
+            if not isinstance(dictionary['omnichannelPayoutSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['omnichannelPayoutSpecificInput']))
+            value = OmnichannelPayoutSpecificInput()
+            self.omnichannel_payout_specific_input = value.from_dictionary(dictionary['omnichannelPayoutSpecificInput'])
+        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

onlinepayments/sdk/domain/create_token_request.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .token_card_specific_input import TokenCardSpecificInput
+
+
+class CreateTokenRequest(DataObject):
+
+    __card: Optional[TokenCardSpecificInput] = None
+    __encrypted_customer_input: Optional[str] = None
+    __payment_product_id: Optional[int] = None
+
+    @property
+    def card(self) -> Optional[TokenCardSpecificInput]:
+        """
+        | Object containing the token details for a card
+
+        Type: :class:`onlinepayments.sdk.domain.token_card_specific_input.TokenCardSpecificInput`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value: Optional[TokenCardSpecificInput]) -> None:
+        self.__card = value
+
+    @property
+    def encrypted_customer_input(self) -> Optional[str]:
+        """
+        | Data that was encrypted client side containing all customer entered data elements like card data. Note: Because this data can only be submitted once to our system and contains encrypted card data you should not store it. As the data was captured within the context of a client session you also need to submit it to us before the session has expired.
+
+        Type: str
+        """
+        return self.__encrypted_customer_input
+
+    @encrypted_customer_input.setter
+    def encrypted_customer_input(self, value: Optional[str]) -> None:
+        self.__encrypted_customer_input = value
+
+    @property
+    def payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier - Please see Products documentation 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
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateTokenRequest, self).to_dictionary()
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        if self.encrypted_customer_input is not None:
+            dictionary['encryptedCustomerInput'] = self.encrypted_customer_input
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateTokenRequest':
+        super(CreateTokenRequest, 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 = TokenCardSpecificInput()
+            self.card = value.from_dictionary(dictionary['card'])
+        if 'encryptedCustomerInput' in dictionary:
+            self.encrypted_customer_input = dictionary['encryptedCustomerInput']
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        return self

onlinepayments/sdk/domain/created_payment_output.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_response import PaymentResponse
+
+
+class CreatedPaymentOutput(DataObject):
+
+    __payment: Optional[PaymentResponse] = None
+    __payment_status_category: Optional[str] = None
+
+    @property
+    def payment(self) -> Optional[PaymentResponse]:
+        """
+        | This object holds the properties related to the payment.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_response.PaymentResponse`
+        """
+        return self.__payment
+
+    @payment.setter
+    def payment(self, value: Optional[PaymentResponse]) -> None:
+        self.__payment = value
+
+    @property
+    def payment_status_category(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__payment_status_category
+
+    @payment_status_category.setter
+    def payment_status_category(self, value: Optional[str]) -> None:
+        self.__payment_status_category = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreatedPaymentOutput, self).to_dictionary()
+        if self.payment is not None:
+            dictionary['payment'] = self.payment.to_dictionary()
+        if self.payment_status_category is not None:
+            dictionary['paymentStatusCategory'] = self.payment_status_category
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreatedPaymentOutput':
+        super(CreatedPaymentOutput, self).from_dictionary(dictionary)
+        if 'payment' in dictionary:
+            if not isinstance(dictionary['payment'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payment']))
+            value = PaymentResponse()
+            self.payment = value.from_dictionary(dictionary['payment'])
+        if 'paymentStatusCategory' in dictionary:
+            self.payment_status_category = dictionary['paymentStatusCategory']
+        return self

onlinepayments/sdk/domain/created_token_response.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .card_without_cvv import CardWithoutCvv
+from .crm_token import CrmToken
+from .data_object import DataObject
+from .external_token_linked import ExternalTokenLinked
+
+
+class CreatedTokenResponse(DataObject):
+
+    __card: Optional[CardWithoutCvv] = None
+    __crm_token: Optional[CrmToken] = None
+    __external_token_linked: Optional[ExternalTokenLinked] = None
+    __is_new_token: Optional[bool] = None
+    __token: Optional[str] = None
+    __token_status: Optional[str] = None
+
+    @property
+    def card(self) -> Optional[CardWithoutCvv]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.card_without_cvv.CardWithoutCvv`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value: Optional[CardWithoutCvv]) -> None:
+        self.__card = value
+
+    @property
+    def crm_token(self) -> Optional[CrmToken]:
+        """
+        | The CRM (Customer Relationship Management) token group. CRM tokens are available to enhance knowledge of a merchant's customers by attempting to identify the customer.
+
+        Type: :class:`onlinepayments.sdk.domain.crm_token.CrmToken`
+        """
+        return self.__crm_token
+
+    @crm_token.setter
+    def crm_token(self, value: Optional[CrmToken]) -> None:
+        self.__crm_token = value
+
+    @property
+    def external_token_linked(self) -> Optional[ExternalTokenLinked]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.external_token_linked.ExternalTokenLinked`
+        """
+        return self.__external_token_linked
+
+    @external_token_linked.setter
+    def external_token_linked(self, value: Optional[ExternalTokenLinked]) -> None:
+        self.__external_token_linked = value
+
+    @property
+    def is_new_token(self) -> Optional[bool]:
+        """
+        | Indicates if a new token was created
+        
+        * true - A new token was created
+        * false - A token with the same card number already exists and is returned. Please note that the existing token has not been updated. When you want to update other data then the card number, you need to update data stored in the token explicitly, as data is never updated during the creation of a token.
+
+        Type: bool
+        """
+        return self.__is_new_token
+
+    @is_new_token.setter
+    def is_new_token(self, value: Optional[bool]) -> None:
+        self.__is_new_token = value
+
+    @property
+    def token(self) -> Optional[str]:
+        """
+        | ID of the token
+
+        Type: str
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value: Optional[str]) -> None:
+        self.__token = value
+
+    @property
+    def token_status(self) -> Optional[str]:
+        """
+        | This is the status of the token in the hosted tokenization session. Possible values are:
+        
+        * UNCHANGED - The token has not changed
+        * CREATED - The token has been created
+        * UPDATED - The token has been updated
+
+        Type: str
+        """
+        return self.__token_status
+
+    @token_status.setter
+    def token_status(self, value: Optional[str]) -> None:
+        self.__token_status = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreatedTokenResponse, self).to_dictionary()
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        if self.crm_token is not None:
+            dictionary['crmToken'] = self.crm_token.to_dictionary()
+        if self.external_token_linked is not None:
+            dictionary['externalTokenLinked'] = self.external_token_linked.to_dictionary()
+        if self.is_new_token is not None:
+            dictionary['isNewToken'] = self.is_new_token
+        if self.token is not None:
+            dictionary['token'] = self.token
+        if self.token_status is not None:
+            dictionary['tokenStatus'] = self.token_status
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreatedTokenResponse':
+        super(CreatedTokenResponse, 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 = CardWithoutCvv()
+            self.card = value.from_dictionary(dictionary['card'])
+        if 'crmToken' in dictionary:
+            if not isinstance(dictionary['crmToken'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['crmToken']))
+            value = CrmToken()
+            self.crm_token = value.from_dictionary(dictionary['crmToken'])
+        if 'externalTokenLinked' in dictionary:
+            if not isinstance(dictionary['externalTokenLinked'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['externalTokenLinked']))
+            value = ExternalTokenLinked()
+            self.external_token_linked = value.from_dictionary(dictionary['externalTokenLinked'])
+        if 'isNewToken' in dictionary:
+            self.is_new_token = dictionary['isNewToken']
+        if 'token' in dictionary:
+            self.token = dictionary['token']
+        if 'tokenStatus' in dictionary:
+            self.token_status = dictionary['tokenStatus']
+        return self

onlinepayments/sdk/domain/credit_card_specific_input_hosted_tokenization.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .credit_card_validation_rules import CreditCardValidationRules
+from .data_object import DataObject
+
+
+class CreditCardSpecificInputHostedTokenization(DataObject):
+
+    __validation_rules: Optional[CreditCardValidationRules] = None
+    __payment_product_preferred_order: Optional[List[int]] = None
+
+    @property
+    def validation_rules(self) -> Optional[CreditCardValidationRules]:
+        """
+        | Object containing specific validation rules for creditCard.
+
+        Type: :class:`onlinepayments.sdk.domain.credit_card_validation_rules.CreditCardValidationRules`
+        """
+        return self.__validation_rules
+
+    @validation_rules.setter
+    def validation_rules(self, value: Optional[CreditCardValidationRules]) -> None:
+        self.__validation_rules = value
+
+    @property
+    def payment_product_preferred_order(self) -> Optional[List[int]]:
+        """
+        | This array contains the payment product identifiers representing the brands. For co-badged cards, this displays their available brands in the order defined by this array.
+
+        Type: list[int]
+        """
+        return self.__payment_product_preferred_order
+
+    @payment_product_preferred_order.setter
+    def payment_product_preferred_order(self, value: Optional[List[int]]) -> None:
+        self.__payment_product_preferred_order = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreditCardSpecificInputHostedTokenization, self).to_dictionary()
+        if self.validation_rules is not None:
+            dictionary['ValidationRules'] = self.validation_rules.to_dictionary()
+        if self.payment_product_preferred_order is not None:
+            dictionary['paymentProductPreferredOrder'] = []
+            for element in self.payment_product_preferred_order:
+                if element is not None:
+                    dictionary['paymentProductPreferredOrder'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreditCardSpecificInputHostedTokenization':
+        super(CreditCardSpecificInputHostedTokenization, self).from_dictionary(dictionary)
+        if 'ValidationRules' in dictionary:
+            if not isinstance(dictionary['ValidationRules'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['ValidationRules']))
+            value = CreditCardValidationRules()
+            self.validation_rules = value.from_dictionary(dictionary['ValidationRules'])
+        if 'paymentProductPreferredOrder' in dictionary:
+            if not isinstance(dictionary['paymentProductPreferredOrder'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['paymentProductPreferredOrder']))
+            self.payment_product_preferred_order = []
+            for element in dictionary['paymentProductPreferredOrder']:
+                self.payment_product_preferred_order.append(element)
+        return self

onlinepayments/sdk/domain/credit_card_validation_rules.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CreditCardValidationRules(DataObject):
+
+    __cvv_mandatory_for_existing_token: Optional[bool] = None
+    __cvv_mandatory_for_new_token: Optional[bool] = None
+
+    @property
+    def cvv_mandatory_for_existing_token(self) -> Optional[bool]:
+        """
+        | Determines whether the Card Verification Value must be provided for existing tokens. This option overrides the payment method configuration for the session.
+
+        Type: bool
+        """
+        return self.__cvv_mandatory_for_existing_token
+
+    @cvv_mandatory_for_existing_token.setter
+    def cvv_mandatory_for_existing_token(self, value: Optional[bool]) -> None:
+        self.__cvv_mandatory_for_existing_token = value
+
+    @property
+    def cvv_mandatory_for_new_token(self) -> Optional[bool]:
+        """
+        | Determines whether the Card Verification Value must be provided for new tokens. This option overrides the payment method configuration for the session.
+
+        Type: bool
+        """
+        return self.__cvv_mandatory_for_new_token
+
+    @cvv_mandatory_for_new_token.setter
+    def cvv_mandatory_for_new_token(self, value: Optional[bool]) -> None:
+        self.__cvv_mandatory_for_new_token = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreditCardValidationRules, self).to_dictionary()
+        if self.cvv_mandatory_for_existing_token is not None:
+            dictionary['cvvMandatoryForExistingToken'] = self.cvv_mandatory_for_existing_token
+        if self.cvv_mandatory_for_new_token is not None:
+            dictionary['cvvMandatoryForNewToken'] = self.cvv_mandatory_for_new_token
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreditCardValidationRules':
+        super(CreditCardValidationRules, self).from_dictionary(dictionary)
+        if 'cvvMandatoryForExistingToken' in dictionary:
+            self.cvv_mandatory_for_existing_token = dictionary['cvvMandatoryForExistingToken']
+        if 'cvvMandatoryForNewToken' in dictionary:
+            self.cvv_mandatory_for_new_token = dictionary['cvvMandatoryForNewToken']
+        return self