connect-sdk-python3 4.0.0__zip → 4.1.0__zip

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

@@ -1,218 +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_field_form_element import PaymentProductFieldFormElement
-from worldline.connect.sdk.v1.domain.payment_product_field_tooltip import PaymentProductFieldTooltip
-
-
-class PaymentProductFieldDisplayHints(DataObject):
-
-    __always_show: Optional[bool] = None
-    __display_order: Optional[int] = None
-    __form_element: Optional[PaymentProductFieldFormElement] = None
-    __label: Optional[str] = None
-    __link: Optional[str] = None
-    __mask: Optional[str] = None
-    __obfuscate: Optional[bool] = None
-    __placeholder_label: Optional[str] = None
-    __preferred_input_type: Optional[str] = None
-    __tooltip: Optional[PaymentProductFieldTooltip] = None
-
-    @property
-    def always_show(self) -> Optional[bool]:
-        """
-        * true - Indicates that this field is advised to be captured to increase the success rates even though it isn't marked as required. Please note that making the field required could hurt the success rates negatively. This boolean only indicates our advise to always show this field to the customer.
-        * false - Indicates that this field is not to be shown unless it is a required field.
-        
-        Type: bool
-        """
-        return self.__always_show
-
-    @always_show.setter
-    def always_show(self, value: Optional[bool]) -> None:
-        self.__always_show = value
-
-    @property
-    def display_order(self) -> Optional[int]:
-        """
-        | The order in which the fields should be shown (ascending)
-        
-        Type: int
-        """
-        return self.__display_order
-
-    @display_order.setter
-    def display_order(self, value: Optional[int]) -> None:
-        self.__display_order = value
-
-    @property
-    def form_element(self) -> Optional[PaymentProductFieldFormElement]:
-        """
-        | Object detailing the type of form element that should be used to present the field
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_field_form_element.PaymentProductFieldFormElement`
-        """
-        return self.__form_element
-
-    @form_element.setter
-    def form_element(self, value: Optional[PaymentProductFieldFormElement]) -> None:
-        self.__form_element = value
-
-    @property
-    def label(self) -> Optional[str]:
-        """
-        | Label/Name of the field to be used in the user interface
-        
-        Type: str
-        """
-        return self.__label
-
-    @label.setter
-    def label(self, value: Optional[str]) -> None:
-        self.__label = value
-
-    @property
-    def link(self) -> Optional[str]:
-        """
-        | Link that should be used to replace the '{link}' variable in the label.
-        
-        Type: str
-        """
-        return self.__link
-
-    @link.setter
-    def link(self, value: Optional[str]) -> None:
-        self.__link = value
-
-    @property
-    def mask(self) -> Optional[str]:
-        """
-        | A mask that can be used in the input field. You can use it to inject additional characters to provide a better user experience and to restrict the accepted character set (illegal characters to be ignored during typing).
-        | * is used for wildcards (and also chars)
-        | 9 is used for numbers
-        | Everything outside {{ and }} is used as-is.
-        
-        Type: str
-        """
-        return self.__mask
-
-    @mask.setter
-    def mask(self, value: Optional[str]) -> None:
-        self.__mask = value
-
-    @property
-    def obfuscate(self) -> Optional[bool]:
-        """
-        * true - The data in this field should be obfuscated as it is entered, just like a password field
-        * false - The data in this field does not need to be obfuscated
-        
-        Type: bool
-        """
-        return self.__obfuscate
-
-    @obfuscate.setter
-    def obfuscate(self, value: Optional[bool]) -> None:
-        self.__obfuscate = value
-
-    @property
-    def placeholder_label(self) -> Optional[str]:
-        """
-        | A placeholder value for the form element
-        
-        Type: str
-        """
-        return self.__placeholder_label
-
-    @placeholder_label.setter
-    def placeholder_label(self, value: Optional[str]) -> None:
-        self.__placeholder_label = value
-
-    @property
-    def preferred_input_type(self) -> Optional[str]:
-        """
-        | The type of keyboard that can best be used to fill out the value of this field. Possible values are:
-        
-        * PhoneNumberKeyboard - Keyboard that is normally used to enter phone numbers
-        * StringKeyboard - Keyboard that is used to enter strings
-        * IntegerKeyboard - Keyboard that is used to enter only numerical values
-        * EmailAddressKeyboard - Keyboard that allows easier entry of email addresses
-        
-        Type: str
-        """
-        return self.__preferred_input_type
-
-    @preferred_input_type.setter
-    def preferred_input_type(self, value: Optional[str]) -> None:
-        self.__preferred_input_type = value
-
-    @property
-    def tooltip(self) -> Optional[PaymentProductFieldTooltip]:
-        """
-        | Object that contains an optional tooltip to assist the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_field_tooltip.PaymentProductFieldTooltip`
-        """
-        return self.__tooltip
-
-    @tooltip.setter
-    def tooltip(self, value: Optional[PaymentProductFieldTooltip]) -> None:
-        self.__tooltip = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProductFieldDisplayHints, self).to_dictionary()
-        if self.always_show is not None:
-            dictionary['alwaysShow'] = self.always_show
-        if self.display_order is not None:
-            dictionary['displayOrder'] = self.display_order
-        if self.form_element is not None:
-            dictionary['formElement'] = self.form_element.to_dictionary()
-        if self.label is not None:
-            dictionary['label'] = self.label
-        if self.link is not None:
-            dictionary['link'] = self.link
-        if self.mask is not None:
-            dictionary['mask'] = self.mask
-        if self.obfuscate is not None:
-            dictionary['obfuscate'] = self.obfuscate
-        if self.placeholder_label is not None:
-            dictionary['placeholderLabel'] = self.placeholder_label
-        if self.preferred_input_type is not None:
-            dictionary['preferredInputType'] = self.preferred_input_type
-        if self.tooltip is not None:
-            dictionary['tooltip'] = self.tooltip.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldDisplayHints':
-        super(PaymentProductFieldDisplayHints, self).from_dictionary(dictionary)
-        if 'alwaysShow' in dictionary:
-            self.always_show = dictionary['alwaysShow']
-        if 'displayOrder' in dictionary:
-            self.display_order = dictionary['displayOrder']
-        if 'formElement' in dictionary:
-            if not isinstance(dictionary['formElement'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['formElement']))
-            value = PaymentProductFieldFormElement()
-            self.form_element = value.from_dictionary(dictionary['formElement'])
-        if 'label' in dictionary:
-            self.label = dictionary['label']
-        if 'link' in dictionary:
-            self.link = dictionary['link']
-        if 'mask' in dictionary:
-            self.mask = dictionary['mask']
-        if 'obfuscate' in dictionary:
-            self.obfuscate = dictionary['obfuscate']
-        if 'placeholderLabel' in dictionary:
-            self.placeholder_label = dictionary['placeholderLabel']
-        if 'preferredInputType' in dictionary:
-            self.preferred_input_type = dictionary['preferredInputType']
-        if 'tooltip' in dictionary:
-            if not isinstance(dictionary['tooltip'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['tooltip']))
-            value = PaymentProductFieldTooltip()
-            self.tooltip = value.from_dictionary(dictionary['tooltip'])
-        return self

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

@@ -1,71 +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.value_mapping_element import ValueMappingElement
-
-
-class PaymentProductFieldFormElement(DataObject):
-
-    __type: Optional[str] = None
-    __value_mapping: Optional[List[ValueMappingElement]] = None
-
-    @property
-    def type(self) -> Optional[str]:
-        """
-        | Type of form element to be used. The following types can be returned:
-        
-        * text - A normal text input field
-        * list - A list of values that the customer needs to choose from, is detailed in the valueMapping array
-        * currency - Currency fields should be split into two fields, with the second one being specifically for the cents
-        * boolean - Boolean fields should offer the customer a choice, like accepting the terms and conditions of a product.
-        * date - let the customer pick a date.
-        
-        Type: str
-        """
-        return self.__type
-
-    @type.setter
-    def type(self, value: Optional[str]) -> None:
-        self.__type = value
-
-    @property
-    def value_mapping(self) -> Optional[List[ValueMappingElement]]:
-        """
-        | An array of values and displayNames that should be used to populate the list object in the GUI
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.value_mapping_element.ValueMappingElement`]
-        """
-        return self.__value_mapping
-
-    @value_mapping.setter
-    def value_mapping(self, value: Optional[List[ValueMappingElement]]) -> None:
-        self.__value_mapping = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProductFieldFormElement, self).to_dictionary()
-        if self.type is not None:
-            dictionary['type'] = self.type
-        if self.value_mapping is not None:
-            dictionary['valueMapping'] = []
-            for element in self.value_mapping:
-                if element is not None:
-                    dictionary['valueMapping'].append(element.to_dictionary())
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldFormElement':
-        super(PaymentProductFieldFormElement, self).from_dictionary(dictionary)
-        if 'type' in dictionary:
-            self.type = dictionary['type']
-        if 'valueMapping' in dictionary:
-            if not isinstance(dictionary['valueMapping'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['valueMapping']))
-            self.value_mapping = []
-            for element in dictionary['valueMapping']:
-                value = ValueMappingElement()
-                self.value_mapping.append(value.from_dictionary(element))
-        return self

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

@@ -1,56 +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 PaymentProductFieldTooltip(DataObject):
-
-    __image: Optional[str] = None
-    __label: Optional[str] = None
-
-    @property
-    def image(self) -> Optional[str]:
-        """
-        | Relative URL that can be used to retrieve an image for the tooltip image. You can use our server-side resize functionality by appending '?size={{width}}x{{height}}' to the full URL, where width and height are specified in pixels. The resized image will always keep its correct aspect ratio.
-        
-        Type: str
-        """
-        return self.__image
-
-    @image.setter
-    def image(self, value: Optional[str]) -> None:
-        self.__image = value
-
-    @property
-    def label(self) -> Optional[str]:
-        """
-        | A text explaining the field in more detail. This is meant to be used for displaying to the customer.
-        
-        Type: str
-        """
-        return self.__label
-
-    @label.setter
-    def label(self, value: Optional[str]) -> None:
-        self.__label = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProductFieldTooltip, self).to_dictionary()
-        if self.image is not None:
-            dictionary['image'] = self.image
-        if self.label is not None:
-            dictionary['label'] = self.label
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldTooltip':
-        super(PaymentProductFieldTooltip, self).from_dictionary(dictionary)
-        if 'image' in dictionary:
-            self.image = dictionary['image']
-        if 'label' in dictionary:
-            self.label = dictionary['label']
-        return self

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

@@ -1,257 +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.boleto_bancario_requiredness_validator import BoletoBancarioRequirednessValidator
-from worldline.connect.sdk.v1.domain.empty_validator import EmptyValidator
-from worldline.connect.sdk.v1.domain.fixed_list_validator import FixedListValidator
-from worldline.connect.sdk.v1.domain.length_validator import LengthValidator
-from worldline.connect.sdk.v1.domain.range_validator import RangeValidator
-from worldline.connect.sdk.v1.domain.regular_expression_validator import RegularExpressionValidator
-
-
-class PaymentProductFieldValidators(DataObject):
-
-    __boleto_bancario_requiredness: Optional[BoletoBancarioRequirednessValidator] = None
-    __email_address: Optional[EmptyValidator] = None
-    __expiration_date: Optional[EmptyValidator] = None
-    __fixed_list: Optional[FixedListValidator] = None
-    __iban: Optional[EmptyValidator] = None
-    __length: Optional[LengthValidator] = None
-    __luhn: Optional[EmptyValidator] = None
-    __range: Optional[RangeValidator] = None
-    __regular_expression: Optional[RegularExpressionValidator] = None
-    __resident_id_number: Optional[EmptyValidator] = None
-    __terms_and_conditions: Optional[EmptyValidator] = None
-
-    @property
-    def boleto_bancario_requiredness(self) -> Optional[BoletoBancarioRequirednessValidator]:
-        """
-        | Indicates the requiredness of the field based on the fiscalnumber for Boleto Bancario
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.boleto_bancario_requiredness_validator.BoletoBancarioRequirednessValidator`
-        """
-        return self.__boleto_bancario_requiredness
-
-    @boleto_bancario_requiredness.setter
-    def boleto_bancario_requiredness(self, value: Optional[BoletoBancarioRequirednessValidator]) -> None:
-        self.__boleto_bancario_requiredness = value
-
-    @property
-    def email_address(self) -> Optional[EmptyValidator]:
-        """
-        | Indicates that the content should be validated against the rules for an email address
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
-        """
-        return self.__email_address
-
-    @email_address.setter
-    def email_address(self, value: Optional[EmptyValidator]) -> None:
-        self.__email_address = value
-
-    @property
-    def expiration_date(self) -> Optional[EmptyValidator]:
-        """
-        | Indicates that the content should be validated against the rules for an expiration date (it should be in the future)
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
-        """
-        return self.__expiration_date
-
-    @expiration_date.setter
-    def expiration_date(self, value: Optional[EmptyValidator]) -> None:
-        self.__expiration_date = value
-
-    @property
-    def fixed_list(self) -> Optional[FixedListValidator]:
-        """
-        | Indicates that content should be one of the, in this object, listed items
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.fixed_list_validator.FixedListValidator`
-        """
-        return self.__fixed_list
-
-    @fixed_list.setter
-    def fixed_list(self, value: Optional[FixedListValidator]) -> None:
-        self.__fixed_list = value
-
-    @property
-    def iban(self) -> Optional[EmptyValidator]:
-        """
-        | Indicates that the content of this (iban) field needs to validated against format checks and modulo check (as described in ISO 7064)
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
-        """
-        return self.__iban
-
-    @iban.setter
-    def iban(self, value: Optional[EmptyValidator]) -> None:
-        self.__iban = value
-
-    @property
-    def length(self) -> Optional[LengthValidator]:
-        """
-        | Indicates that the content needs to be validated against length criteria defined in this object
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.length_validator.LengthValidator`
-        """
-        return self.__length
-
-    @length.setter
-    def length(self, value: Optional[LengthValidator]) -> None:
-        self.__length = value
-
-    @property
-    def luhn(self) -> Optional[EmptyValidator]:
-        """
-        | Indicates that the content needs to be validated using a LUHN check
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
-        """
-        return self.__luhn
-
-    @luhn.setter
-    def luhn(self, value: Optional[EmptyValidator]) -> None:
-        self.__luhn = value
-
-    @property
-    def range(self) -> Optional[RangeValidator]:
-        """
-        | Indicates that the content needs to be validated against a, in this object, defined range
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.range_validator.RangeValidator`
-        """
-        return self.__range
-
-    @range.setter
-    def range(self, value: Optional[RangeValidator]) -> None:
-        self.__range = value
-
-    @property
-    def regular_expression(self) -> Optional[RegularExpressionValidator]:
-        """
-        | A string representing the regular expression to check
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.regular_expression_validator.RegularExpressionValidator`
-        """
-        return self.__regular_expression
-
-    @regular_expression.setter
-    def regular_expression(self, value: Optional[RegularExpressionValidator]) -> None:
-        self.__regular_expression = value
-
-    @property
-    def resident_id_number(self) -> Optional[EmptyValidator]:
-        """
-        | Indicates that the content needs to be validated as per the Chinese resident identity number format
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
-        """
-        return self.__resident_id_number
-
-    @resident_id_number.setter
-    def resident_id_number(self, value: Optional[EmptyValidator]) -> None:
-        self.__resident_id_number = value
-
-    @property
-    def terms_and_conditions(self) -> Optional[EmptyValidator]:
-        """
-        | Indicates that the content should be validated as such that the customer has accepted the field as if they were terms and conditions of a service
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.empty_validator.EmptyValidator`
-        """
-        return self.__terms_and_conditions
-
-    @terms_and_conditions.setter
-    def terms_and_conditions(self, value: Optional[EmptyValidator]) -> None:
-        self.__terms_and_conditions = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProductFieldValidators, self).to_dictionary()
-        if self.boleto_bancario_requiredness is not None:
-            dictionary['boletoBancarioRequiredness'] = self.boleto_bancario_requiredness.to_dictionary()
-        if self.email_address is not None:
-            dictionary['emailAddress'] = self.email_address.to_dictionary()
-        if self.expiration_date is not None:
-            dictionary['expirationDate'] = self.expiration_date.to_dictionary()
-        if self.fixed_list is not None:
-            dictionary['fixedList'] = self.fixed_list.to_dictionary()
-        if self.iban is not None:
-            dictionary['iban'] = self.iban.to_dictionary()
-        if self.length is not None:
-            dictionary['length'] = self.length.to_dictionary()
-        if self.luhn is not None:
-            dictionary['luhn'] = self.luhn.to_dictionary()
-        if self.range is not None:
-            dictionary['range'] = self.range.to_dictionary()
-        if self.regular_expression is not None:
-            dictionary['regularExpression'] = self.regular_expression.to_dictionary()
-        if self.resident_id_number is not None:
-            dictionary['residentIdNumber'] = self.resident_id_number.to_dictionary()
-        if self.terms_and_conditions is not None:
-            dictionary['termsAndConditions'] = self.terms_and_conditions.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldValidators':
-        super(PaymentProductFieldValidators, self).from_dictionary(dictionary)
-        if 'boletoBancarioRequiredness' in dictionary:
-            if not isinstance(dictionary['boletoBancarioRequiredness'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['boletoBancarioRequiredness']))
-            value = BoletoBancarioRequirednessValidator()
-            self.boleto_bancario_requiredness = value.from_dictionary(dictionary['boletoBancarioRequiredness'])
-        if 'emailAddress' in dictionary:
-            if not isinstance(dictionary['emailAddress'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['emailAddress']))
-            value = EmptyValidator()
-            self.email_address = value.from_dictionary(dictionary['emailAddress'])
-        if 'expirationDate' in dictionary:
-            if not isinstance(dictionary['expirationDate'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['expirationDate']))
-            value = EmptyValidator()
-            self.expiration_date = value.from_dictionary(dictionary['expirationDate'])
-        if 'fixedList' in dictionary:
-            if not isinstance(dictionary['fixedList'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fixedList']))
-            value = FixedListValidator()
-            self.fixed_list = value.from_dictionary(dictionary['fixedList'])
-        if 'iban' in dictionary:
-            if not isinstance(dictionary['iban'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['iban']))
-            value = EmptyValidator()
-            self.iban = value.from_dictionary(dictionary['iban'])
-        if 'length' in dictionary:
-            if not isinstance(dictionary['length'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['length']))
-            value = LengthValidator()
-            self.length = value.from_dictionary(dictionary['length'])
-        if 'luhn' in dictionary:
-            if not isinstance(dictionary['luhn'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['luhn']))
-            value = EmptyValidator()
-            self.luhn = value.from_dictionary(dictionary['luhn'])
-        if 'range' in dictionary:
-            if not isinstance(dictionary['range'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['range']))
-            value = RangeValidator()
-            self.range = value.from_dictionary(dictionary['range'])
-        if 'regularExpression' in dictionary:
-            if not isinstance(dictionary['regularExpression'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['regularExpression']))
-            value = RegularExpressionValidator()
-            self.regular_expression = value.from_dictionary(dictionary['regularExpression'])
-        if 'residentIdNumber' in dictionary:
-            if not isinstance(dictionary['residentIdNumber'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['residentIdNumber']))
-            value = EmptyValidator()
-            self.resident_id_number = value.from_dictionary(dictionary['residentIdNumber'])
-        if 'termsAndConditions' in dictionary:
-            if not isinstance(dictionary['termsAndConditions'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['termsAndConditions']))
-            value = EmptyValidator()
-            self.terms_and_conditions = value.from_dictionary(dictionary['termsAndConditions'])
-        return self

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

@@ -1,70 +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
-
-
-class PaymentProductFilter(DataObject):
-
-    __groups: Optional[List[str]] = None
-    __products: Optional[List[int]] = None
-
-    @property
-    def groups(self) -> Optional[List[str]]:
-        """
-        | List containing all payment product groups that should either be restricted to in or excluded from the payment context. Currently, there is only one group, called 'cards'.
-        
-        Type: list[str]
-        """
-        return self.__groups
-
-    @groups.setter
-    def groups(self, value: Optional[List[str]]) -> None:
-        self.__groups = value
-
-    @property
-    def products(self) -> Optional[List[int]]:
-        """
-        | List containing all payment product ids that should either be restricted to in or excluded from the payment context.
-        
-        Type: list[int]
-        """
-        return self.__products
-
-    @products.setter
-    def products(self, value: Optional[List[int]]) -> None:
-        self.__products = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProductFilter, self).to_dictionary()
-        if self.groups is not None:
-            dictionary['groups'] = []
-            for element in self.groups:
-                if element is not None:
-                    dictionary['groups'].append(element)
-        if self.products is not None:
-            dictionary['products'] = []
-            for element in self.products:
-                if element is not None:
-                    dictionary['products'].append(element)
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFilter':
-        super(PaymentProductFilter, self).from_dictionary(dictionary)
-        if 'groups' in dictionary:
-            if not isinstance(dictionary['groups'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['groups']))
-            self.groups = []
-            for element in dictionary['groups']:
-                self.groups.append(element)
-        if 'products' in dictionary:
-            if not isinstance(dictionary['products'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['products']))
-            self.products = []
-            for element in dictionary['products']:
-                self.products.append(element)
-        return self