connect-sdk-python3 4.0.0__zip → 4.1.0__zip

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/get_iin_details_request.py

@@ -1,63 +0,0 @@
-# -*- 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.payment_context import PaymentContext
-
-
-class GetIINDetailsRequest(DataObject):
-    """
-    | Input for the retrieval of the IIN details request.
-    """
-
-    __bin: Optional[str] = None
-    __payment_context: Optional[PaymentContext] = None
-
-    @property
-    def bin(self) -> Optional[str]:
-        """
-        | The first digits of the credit card number from left to right with a minimum of 6 digits. Providing additional digits can result in more co-brands being returned.
-        
-        Type: str
-        """
-        return self.__bin
-
-    @bin.setter
-    def bin(self, value: Optional[str]) -> None:
-        self.__bin = value
-
-    @property
-    def payment_context(self) -> Optional[PaymentContext]:
-        """
-        | Optional payment context to refine the IIN lookup to filter out payment products not applicable to your payment.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_context.PaymentContext`
-        """
-        return self.__payment_context
-
-    @payment_context.setter
-    def payment_context(self, value: Optional[PaymentContext]) -> None:
-        self.__payment_context = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(GetIINDetailsRequest, self).to_dictionary()
-        if self.bin is not None:
-            dictionary['bin'] = self.bin
-        if self.payment_context is not None:
-            dictionary['paymentContext'] = self.payment_context.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'GetIINDetailsRequest':
-        super(GetIINDetailsRequest, self).from_dictionary(dictionary)
-        if 'bin' in dictionary:
-            self.bin = dictionary['bin']
-        if 'paymentContext' in dictionary:
-            if not isinstance(dictionary['paymentContext'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentContext']))
-            value = PaymentContext()
-            self.payment_context = value.from_dictionary(dictionary['paymentContext'])
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/get_iin_details_response.py

@@ -1,109 +0,0 @@
-# -*- 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.iin_detail import IINDetail
-
-
-class GetIINDetailsResponse(DataObject):
-    """
-    | Output of the retrieval of the IIN details request
-    """
-
-    __co_brands: Optional[List[IINDetail]] = None
-    __country_code: Optional[str] = None
-    __is_allowed_in_context: Optional[bool] = None
-    __payment_product_id: Optional[int] = None
-
-    @property
-    def co_brands(self) -> Optional[List[IINDetail]]:
-        """
-        | Populated only if the card has multiple brands.
-        | A list with for every brand of the card, the payment product identifier associated with that brand, and if you submitted a payment context, whether that payment product is allowed in the context.
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.iin_detail.IINDetail`]
-        """
-        return self.__co_brands
-
-    @co_brands.setter
-    def co_brands(self, value: Optional[List[IINDetail]]) -> None:
-        self.__co_brands = value
-
-    @property
-    def country_code(self) -> Optional[str]:
-        """
-        | The ISO 3166-1 alpha-2 country code of the country where the card was issued. If we don't know where the card was issued, then the countryCode will return the value '99'.
-        
-        Type: str
-        """
-        return self.__country_code
-
-    @country_code.setter
-    def country_code(self, value: Optional[str]) -> None:
-        self.__country_code = value
-
-    @property
-    def is_allowed_in_context(self) -> Optional[bool]:
-        """
-        | Populated only if you submitted a payment context.
-        
-        * true - The payment product is allowed in the submitted context.
-        * false - The payment product is not allowed in the submitted context. Note that in this case, none of the brands of the card will be allowed in the submitted context.
-        
-        Type: bool
-        """
-        return self.__is_allowed_in_context
-
-    @is_allowed_in_context.setter
-    def is_allowed_in_context(self, value: Optional[bool]) -> None:
-        self.__is_allowed_in_context = value
-
-    @property
-    def payment_product_id(self) -> Optional[int]:
-        """
-        | The payment product identifier associated with the card. If the card has multiple brands, then we select the most appropriate payment product based on your configuration and the payment context, if you submitted one.
-        | 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
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(GetIINDetailsResponse, self).to_dictionary()
-        if self.co_brands is not None:
-            dictionary['coBrands'] = []
-            for element in self.co_brands:
-                if element is not None:
-                    dictionary['coBrands'].append(element.to_dictionary())
-        if self.country_code is not None:
-            dictionary['countryCode'] = self.country_code
-        if self.is_allowed_in_context is not None:
-            dictionary['isAllowedInContext'] = self.is_allowed_in_context
-        if self.payment_product_id is not None:
-            dictionary['paymentProductId'] = self.payment_product_id
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'GetIINDetailsResponse':
-        super(GetIINDetailsResponse, self).from_dictionary(dictionary)
-        if 'coBrands' in dictionary:
-            if not isinstance(dictionary['coBrands'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['coBrands']))
-            self.co_brands = []
-            for element in dictionary['coBrands']:
-                value = IINDetail()
-                self.co_brands.append(value.from_dictionary(element))
-        if 'countryCode' in dictionary:
-            self.country_code = dictionary['countryCode']
-        if 'isAllowedInContext' in dictionary:
-            self.is_allowed_in_context = dictionary['isAllowedInContext']
-        if 'paymentProductId' in dictionary:
-            self.payment_product_id = dictionary['paymentProductId']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/get_installment_request.py

@@ -1,100 +0,0 @@
-# -*- 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.amount_of_money import AmountOfMoney
-
-
-class GetInstallmentRequest(DataObject):
-    """
-    | Using the Installment Service API you can ask us to provide you with information related to the available installment options, based on the country, amount and optionally payment productId and bin number.  
-    """
-
-    __amount_of_money: Optional[AmountOfMoney] = None
-    __bin: Optional[str] = None
-    __country_code: Optional[str] = None
-    __payment_product_id: Optional[int] = None
-
-    @property
-    def amount_of_money(self) -> Optional[AmountOfMoney]:
-        """
-        | Object containing amount and ISO currency code attributes
-        
-        Type: :class:`worldline.connect.sdk.v1.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 bin(self) -> Optional[str]:
-        """
-        | The first digits of the card number from left to right with a minimum of 6 digits
-        
-        Type: str
-        """
-        return self.__bin
-
-    @bin.setter
-    def bin(self, value: Optional[str]) -> None:
-        self.__bin = value
-
-    @property
-    def country_code(self) -> Optional[str]:
-        """
-        | ISO 3166-1 alpha-2 country code
-        
-        Type: str
-        """
-        return self.__country_code
-
-    @country_code.setter
-    def country_code(self, value: Optional[str]) -> None:
-        self.__country_code = 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
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(GetInstallmentRequest, self).to_dictionary()
-        if self.amount_of_money is not None:
-            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
-        if self.bin is not None:
-            dictionary['bin'] = self.bin
-        if self.country_code is not None:
-            dictionary['countryCode'] = self.country_code
-        if self.payment_product_id is not None:
-            dictionary['paymentProductId'] = self.payment_product_id
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'GetInstallmentRequest':
-        super(GetInstallmentRequest, 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 'bin' in dictionary:
-            self.bin = dictionary['bin']
-        if 'countryCode' in dictionary:
-            self.country_code = dictionary['countryCode']
-        if 'paymentProductId' in dictionary:
-            self.payment_product_id = dictionary['paymentProductId']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/get_mandate_response.py

@@ -1,42 +0,0 @@
-# -*- 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.mandate_response import MandateResponse
-
-
-class GetMandateResponse(DataObject):
-
-    __mandate: Optional[MandateResponse] = None
-
-    @property
-    def mandate(self) -> Optional[MandateResponse]:
-        """
-        | Object containing information on a mandate.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.mandate_response.MandateResponse`
-        """
-        return self.__mandate
-
-    @mandate.setter
-    def mandate(self, value: Optional[MandateResponse]) -> None:
-        self.__mandate = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(GetMandateResponse, self).to_dictionary()
-        if self.mandate is not None:
-            dictionary['mandate'] = self.mandate.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'GetMandateResponse':
-        super(GetMandateResponse, self).from_dictionary(dictionary)
-        if 'mandate' in dictionary:
-            if not isinstance(dictionary['mandate'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mandate']))
-            value = MandateResponse()
-            self.mandate = value.from_dictionary(dictionary['mandate'])
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/get_privacy_policy_response.py

@@ -1,41 +0,0 @@
-# -*- 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 GetPrivacyPolicyResponse(DataObject):
-    """
-    | Output of the retrieval of the privacy policy
-    """
-
-    __html_content: Optional[str] = None
-
-    @property
-    def html_content(self) -> Optional[str]:
-        """
-        | HTML content to be displayed to the user
-        
-        Type: str
-        """
-        return self.__html_content
-
-    @html_content.setter
-    def html_content(self, value: Optional[str]) -> None:
-        self.__html_content = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(GetPrivacyPolicyResponse, self).to_dictionary()
-        if self.html_content is not None:
-            dictionary['htmlContent'] = self.html_content
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'GetPrivacyPolicyResponse':
-        super(GetPrivacyPolicyResponse, self).from_dictionary(dictionary)
-        if 'htmlContent' in dictionary:
-            self.html_content = dictionary['htmlContent']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/gift_card_purchase.py

@@ -1,63 +0,0 @@
-# -*- 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.amount_of_money import AmountOfMoney
-
-
-class GiftCardPurchase(DataObject):
-    """
-    | Object containing information on purchased gift card(s)
-    """
-
-    __amount_of_money: Optional[AmountOfMoney] = None
-    __number_of_gift_cards: Optional[int] = None
-
-    @property
-    def amount_of_money(self) -> Optional[AmountOfMoney]:
-        """
-        | Object containing information on an amount of money
-        
-        Type: :class:`worldline.connect.sdk.v1.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 number_of_gift_cards(self) -> Optional[int]:
-        """
-        | Number of gift cards that are purchased through this transaction
-        
-        Type: int
-        """
-        return self.__number_of_gift_cards
-
-    @number_of_gift_cards.setter
-    def number_of_gift_cards(self, value: Optional[int]) -> None:
-        self.__number_of_gift_cards = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(GiftCardPurchase, self).to_dictionary()
-        if self.amount_of_money is not None:
-            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
-        if self.number_of_gift_cards is not None:
-            dictionary['numberOfGiftCards'] = self.number_of_gift_cards
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'GiftCardPurchase':
-        super(GiftCardPurchase, 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 'numberOfGiftCards' in dictionary:
-            self.number_of_gift_cards = dictionary['numberOfGiftCards']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/hosted_checkout_specific_input.py

@@ -1,223 +0,0 @@
-# -*- 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.payment_product_filters_hosted_checkout import PaymentProductFiltersHostedCheckout
-from worldline.connect.sdk.v1.domain.recurring_payments_data import RecurringPaymentsData
-
-
-class HostedCheckoutSpecificInput(DataObject):
-
-    __is_recurring: Optional[bool] = None
-    __locale: Optional[str] = None
-    __payment_product_filters: Optional[PaymentProductFiltersHostedCheckout] = None
-    __recurring_payments_data: Optional[RecurringPaymentsData] = None
-    __return_cancel_state: Optional[bool] = None
-    __return_url: Optional[str] = None
-    __show_result_page: Optional[bool] = None
-    __tokens: Optional[str] = None
-    __validate_shopping_cart: Optional[bool] = None
-    __variant: Optional[str] = None
-
-    @property
-    def is_recurring(self) -> Optional[bool]:
-        """
-        * true - Only payment products that support recurring payments will be shown. Any transactions created will also be tagged as being a first of a recurring sequence.
-        * false - Only payment products that support one-off payments will be shown.
-        
-        | The default value for this property is false.
-        
-        Type: bool
-        """
-        return self.__is_recurring
-
-    @is_recurring.setter
-    def is_recurring(self, value: Optional[bool]) -> None:
-        self.__is_recurring = value
-
-    @property
-    def locale(self) -> Optional[str]:
-        """
-        | Locale to use to present the MyCheckout payment pages to the customer. Please make sure that a language pack is configured for the locale you are submitting. If you submit a locale that is not setup on your account we will use the default language pack for your account. You can easily upload additional language packs and set the default language pack in the Configuration Center.
-        
-        Type: str
-        """
-        return self.__locale
-
-    @locale.setter
-    def locale(self, value: Optional[str]) -> None:
-        self.__locale = value
-
-    @property
-    def payment_product_filters(self) -> Optional[PaymentProductFiltersHostedCheckout]:
-        """
-        | Contains the payment product ids and payment product groups that will be used for manipulating the payment products available for the payment to the customer.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_filters_hosted_checkout.PaymentProductFiltersHostedCheckout`
-        """
-        return self.__payment_product_filters
-
-    @payment_product_filters.setter
-    def payment_product_filters(self, value: Optional[PaymentProductFiltersHostedCheckout]) -> None:
-        self.__payment_product_filters = value
-
-    @property
-    def recurring_payments_data(self) -> Optional[RecurringPaymentsData]:
-        """
-        | The object containing reference data for the text that can be displayed on MyCheckout hosted payment page with subscription information.
-        
-        | Note:
-        
-        | The data in this object is only meant for displaying recurring payments-related data on your checkout page.
-        | You still need to submit all the recurring payment-related data in the corresponding payment product-specific input. (example: cardPaymentMethodSpecificInput.recurring and cardPaymentMethodSpecificInput.isRecurring)
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.recurring_payments_data.RecurringPaymentsData`
-        """
-        return self.__recurring_payments_data
-
-    @recurring_payments_data.setter
-    def recurring_payments_data(self, value: Optional[RecurringPaymentsData]) -> None:
-        self.__recurring_payments_data = value
-
-    @property
-    def return_cancel_state(self) -> Optional[bool]:
-        """
-        | This flag affects the status of a Hosted Checkout when a customer presses the cancel button and is returned to you as a result.
-        | If set to true, then the status will be CANCELLED_BY_CONSUMER. If set to false, then the status will be IN_PROGRESS.
-        | The default value is false. This flag was added to introduce the additional CANCELLED_BY_CONSUMER state as a non-breaking change.
-        
-        Type: bool
-        """
-        return self.__return_cancel_state
-
-    @return_cancel_state.setter
-    def return_cancel_state(self, value: Optional[bool]) -> None:
-        self.__return_cancel_state = 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
-        """
-        return self.__return_url
-
-    @return_url.setter
-    def return_url(self, value: Optional[str]) -> None:
-        self.__return_url = value
-
-    @property
-    def show_result_page(self) -> Optional[bool]:
-        """
-        * true - MyCheckout will show a result page to the customer when applicable. Default.
-        * false - MyCheckout will redirect the customer back to the provided returnUrl when this is possible.
-        
-        | The default value for this property is true.
-        
-        Type: bool
-        """
-        return self.__show_result_page
-
-    @show_result_page.setter
-    def show_result_page(self, value: Optional[bool]) -> None:
-        self.__show_result_page = value
-
-    @property
-    def tokens(self) -> Optional[str]:
-        """
-        | String containing comma separated tokens (no spaces) associated with the customer of this hosted checkout. Valid tokens will be used to present the customer the option to re-use previously used payment details. This means the customer for instance does not have to re-enter their card details again, which a big plus when the customer is using their mobile phone to complete the checkout.
-        
-        Type: str
-        """
-        return self.__tokens
-
-    @tokens.setter
-    def tokens(self, value: Optional[str]) -> None:
-        self.__tokens = value
-
-    @property
-    def validate_shopping_cart(self) -> Optional[bool]:
-        """
-        | By default, validation is done for all the information required to display the shopping cart. Set this value to false if you would like to turn that feature off for a hosted checkout on the Ogone Payment Platform, in which case the rendering of the shopping cart will be skipped if any required information is missing. Use this when you want fraud-checks to be performed on the shopping cart, but do not want to suply all data needed for displaying it in the hosted checkout. The default value for this property is true.
-        
-        Type: bool
-        """
-        return self.__validate_shopping_cart
-
-    @validate_shopping_cart.setter
-    def validate_shopping_cart(self, value: Optional[bool]) -> None:
-        self.__validate_shopping_cart = value
-
-    @property
-    def variant(self) -> Optional[str]:
-        """
-        | Using the Configuration Center it is possible to create multiple variations of your MyCheckout payment pages. By specifying a specific variant you can force the use of another variant then 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 of the variant.
-        
-        Type: str
-        """
-        return self.__variant
-
-    @variant.setter
-    def variant(self, value: Optional[str]) -> None:
-        self.__variant = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(HostedCheckoutSpecificInput, self).to_dictionary()
-        if self.is_recurring is not None:
-            dictionary['isRecurring'] = self.is_recurring
-        if self.locale is not None:
-            dictionary['locale'] = self.locale
-        if self.payment_product_filters is not None:
-            dictionary['paymentProductFilters'] = self.payment_product_filters.to_dictionary()
-        if self.recurring_payments_data is not None:
-            dictionary['recurringPaymentsData'] = self.recurring_payments_data.to_dictionary()
-        if self.return_cancel_state is not None:
-            dictionary['returnCancelState'] = self.return_cancel_state
-        if self.return_url is not None:
-            dictionary['returnUrl'] = self.return_url
-        if self.show_result_page is not None:
-            dictionary['showResultPage'] = self.show_result_page
-        if self.tokens is not None:
-            dictionary['tokens'] = self.tokens
-        if self.validate_shopping_cart is not None:
-            dictionary['validateShoppingCart'] = self.validate_shopping_cart
-        if self.variant is not None:
-            dictionary['variant'] = self.variant
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'HostedCheckoutSpecificInput':
-        super(HostedCheckoutSpecificInput, self).from_dictionary(dictionary)
-        if 'isRecurring' in dictionary:
-            self.is_recurring = dictionary['isRecurring']
-        if 'locale' in dictionary:
-            self.locale = dictionary['locale']
-        if 'paymentProductFilters' in dictionary:
-            if not isinstance(dictionary['paymentProductFilters'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProductFilters']))
-            value = PaymentProductFiltersHostedCheckout()
-            self.payment_product_filters = value.from_dictionary(dictionary['paymentProductFilters'])
-        if 'recurringPaymentsData' in dictionary:
-            if not isinstance(dictionary['recurringPaymentsData'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['recurringPaymentsData']))
-            value = RecurringPaymentsData()
-            self.recurring_payments_data = value.from_dictionary(dictionary['recurringPaymentsData'])
-        if 'returnCancelState' in dictionary:
-            self.return_cancel_state = dictionary['returnCancelState']
-        if 'returnUrl' in dictionary:
-            self.return_url = dictionary['returnUrl']
-        if 'showResultPage' in dictionary:
-            self.show_result_page = dictionary['showResultPage']
-        if 'tokens' in dictionary:
-            self.tokens = dictionary['tokens']
-        if 'validateShoppingCart' in dictionary:
-            self.validate_shopping_cart = dictionary['validateShoppingCart']
-        if 'variant' in dictionary:
-            self.variant = dictionary['variant']
-        return self