onlinepayments-sdk-python3 4.22.0__zip → 5.0.0__zip

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/payment_product_field_display_hints.py

@@ -1,44 +1,43 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from onlinepayments.sdk.data_object import DataObject
-from onlinepayments.sdk.domain.payment_product_field_form_element import PaymentProductFieldFormElement
-from onlinepayments.sdk.domain.payment_product_field_tooltip import PaymentProductFieldTooltip
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_product_field_form_element import PaymentProductFieldFormElement
+from .payment_product_field_tooltip import PaymentProductFieldTooltip
 
 
 class PaymentProductFieldDisplayHints(DataObject):
-    """
-    | Object containing display hints for this field, like the order, mask, preferred keyboard
-    """
-
-    __always_show = None
-    __display_order = None
-    __form_element = None
-    __label = None
-    __link = None
-    __mask = None
-    __obfuscate = None
-    __placeholder_label = None
-    __preferred_input_type = None
-    __tooltip = None
+
+    __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) -> bool:
+    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.
+        * 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: bool):
+    def always_show(self, value: Optional[bool]) -> None:
         self.__always_show = value
 
     @property
-    def display_order(self) -> int:
+    def display_order(self) -> Optional[int]:
         """
         | The order in which the fields should be shown (ascending)
 
@@ -47,11 +46,11 @@ class PaymentProductFieldDisplayHints(DataObject):
         return self.__display_order
 
     @display_order.setter
-    def display_order(self, value: int):
+    def display_order(self, value: Optional[int]) -> None:
         self.__display_order = value
 
     @property
-    def form_element(self) -> PaymentProductFieldFormElement:
+    def form_element(self) -> Optional[PaymentProductFieldFormElement]:
         """
         | Object detailing the type of form element that should be used to present the field
 
@@ -60,11 +59,11 @@ class PaymentProductFieldDisplayHints(DataObject):
         return self.__form_element
 
     @form_element.setter
-    def form_element(self, value: PaymentProductFieldFormElement):
+    def form_element(self, value: Optional[PaymentProductFieldFormElement]) -> None:
         self.__form_element = value
 
     @property
-    def label(self) -> str:
+    def label(self) -> Optional[str]:
         """
         | Label/Name of the field to be used in the user interface
 
@@ -73,55 +72,55 @@ class PaymentProductFieldDisplayHints(DataObject):
         return self.__label
 
     @label.setter
-    def label(self, value: str):
+    def label(self, value: Optional[str]) -> None:
         self.__label = value
 
     @property
-    def link(self) -> str:
+    def link(self) -> Optional[str]:
         """
-        | Deprecated: This field is not used by any payment product
-        | Link that should be used to replace the '{link}' variable in the label.
+        | Deprecated: This field is not used by any payment product Link that should be used to replace the '{link}' variable in the label.
 
         Type: str
+
+        Deprecated; Deprecated
         """
         return self.__link
 
     @link.setter
-    def link(self, value: str):
+    def link(self, value: Optional[str]) -> None:
         self.__link = value
 
     @property
-    def mask(self) -> str:
+    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 will be ignored during typing).
-        | * is used for wildcards (and also chars)
-        | 9 is used for numbers
-        | Everything outside {{ and }} is used as-is.
+        
+        * 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: str):
+    def mask(self, value: Optional[str]) -> None:
         self.__mask = value
 
     @property
-    def obfuscate(self) -> bool:
+    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
+        * 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: bool):
+    def obfuscate(self, value: Optional[bool]) -> None:
         self.__obfuscate = value
 
     @property
-    def placeholder_label(self) -> str:
+    def placeholder_label(self) -> Optional[str]:
         """
         | A placeholder value for the form element
 
@@ -130,28 +129,29 @@ class PaymentProductFieldDisplayHints(DataObject):
         return self.__placeholder_label
 
     @placeholder_label.setter
-    def placeholder_label(self, value: str):
+    def placeholder_label(self, value: Optional[str]) -> None:
         self.__placeholder_label = value
 
     @property
-    def preferred_input_type(self) -> str:
+    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
+        
+        * 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: str):
+    def preferred_input_type(self, value: Optional[str]) -> None:
         self.__preferred_input_type = value
 
     @property
-    def tooltip(self) -> PaymentProductFieldTooltip:
+    def tooltip(self) -> Optional[PaymentProductFieldTooltip]:
         """
         | Object that contains an optional tooltip to assist the customer
 
@@ -160,10 +160,10 @@ class PaymentProductFieldDisplayHints(DataObject):
         return self.__tooltip
 
     @tooltip.setter
-    def tooltip(self, value: PaymentProductFieldTooltip):
+    def tooltip(self, value: Optional[PaymentProductFieldTooltip]) -> None:
         self.__tooltip = value
 
-    def to_dictionary(self):
+    def to_dictionary(self) -> dict:
         dictionary = super(PaymentProductFieldDisplayHints, self).to_dictionary()
         if self.always_show is not None:
             dictionary['alwaysShow'] = self.always_show
@@ -187,7 +187,7 @@ class PaymentProductFieldDisplayHints(DataObject):
             dictionary['tooltip'] = self.tooltip.to_dictionary()
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldDisplayHints':
         super(PaymentProductFieldDisplayHints, self).from_dictionary(dictionary)
         if 'alwaysShow' in dictionary:
             self.always_show = dictionary['alwaysShow']

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/payment_product_field_form_element.py

@@ -1,53 +1,53 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from typing import List
+from typing import List, Optional
 
-from onlinepayments.sdk.data_object import DataObject
-from onlinepayments.sdk.domain.value_mapping_element import ValueMappingElement
+from .data_object import DataObject
+from .value_mapping_element import ValueMappingElement
 
 
 class PaymentProductFieldFormElement(DataObject):
-    """
-    | Object detailing the type of form element that should be used to present the field
-    """
 
-    __type = None
-    __value_mapping = None
+    __type: Optional[str] = None
+    __value_mapping: Optional[List[ValueMappingElement]] = None
 
     @property
-    def type(self) -> str:
+    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.
+        
+        * 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: str):
+    def type(self, value: Optional[str]) -> None:
         self.__type = value
 
     @property
-    def value_mapping(self) -> List[ValueMappingElement]:
+    def value_mapping(self) -> Optional[List[ValueMappingElement]]:
         """
         | Deprecated: This field is not used by any payment product
 
         Type: list[:class:`onlinepayments.sdk.domain.value_mapping_element.ValueMappingElement`]
+
+        Deprecated; This field is not used by any payment product
         """
         return self.__value_mapping
 
     @value_mapping.setter
-    def value_mapping(self, value: List[ValueMappingElement]):
+    def value_mapping(self, value: Optional[List[ValueMappingElement]]) -> None:
         self.__value_mapping = value
 
-    def to_dictionary(self):
+    def to_dictionary(self) -> dict:
         dictionary = super(PaymentProductFieldFormElement, self).to_dictionary()
         if self.type is not None:
             dictionary['type'] = self.type
@@ -58,7 +58,7 @@ class PaymentProductFieldFormElement(DataObject):
                     dictionary['valueMapping'].append(element.to_dictionary())
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldFormElement':
         super(PaymentProductFieldFormElement, self).from_dictionary(dictionary)
         if 'type' in dictionary:
             self.type = dictionary['type']

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/payment_product_field_tooltip.py

@@ -1,34 +1,34 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from onlinepayments.sdk.data_object import DataObject
+from typing import Optional
+
+from .data_object import DataObject
 
 
 class PaymentProductFieldTooltip(DataObject):
-    """
-    | Object that contains an optional tooltip to assist the customer
-    """
 
-    __image = None
-    __label = None
+    __image: Optional[str] = None
+    __label: Optional[str] = None
 
     @property
-    def image(self) -> str:
+    def image(self) -> Optional[str]:
         """
-        | Deprecated: This field is not used by any payment product
-        | Relative URL that can be used to retrieve an image for the tooltip image.
+        | Deprecated: This field is not used by any payment product Relative URL that can be used to retrieve an image for the tooltip image.
 
         Type: str
+
+        Deprecated; This field is not used by any payment product Relative URL that can be used to retrieve an image for the tooltip image.
         """
         return self.__image
 
     @image.setter
-    def image(self, value: str):
+    def image(self, value: Optional[str]) -> None:
         self.__image = value
 
     @property
-    def label(self) -> str:
+    def label(self) -> Optional[str]:
         """
         | A text explaining the field in more detail. This is meant to be used for displaying to the customer.
 
@@ -37,10 +37,10 @@ class PaymentProductFieldTooltip(DataObject):
         return self.__label
 
     @label.setter
-    def label(self, value: str):
+    def label(self, value: Optional[str]) -> None:
         self.__label = value
 
-    def to_dictionary(self):
+    def to_dictionary(self) -> dict:
         dictionary = super(PaymentProductFieldTooltip, self).to_dictionary()
         if self.image is not None:
             dictionary['image'] = self.image
@@ -48,7 +48,7 @@ class PaymentProductFieldTooltip(DataObject):
             dictionary['label'] = self.label
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldTooltip':
         super(PaymentProductFieldTooltip, self).from_dictionary(dictionary)
         if 'image' in dictionary:
             self.image = dictionary['image']

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/payment_product_field_validators.py

@@ -1,130 +1,129 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from onlinepayments.sdk.data_object import DataObject
-from onlinepayments.sdk.domain.empty_validator import EmptyValidator
-from onlinepayments.sdk.domain.fixed_list_validator import FixedListValidator
-from onlinepayments.sdk.domain.length_validator import LengthValidator
-from onlinepayments.sdk.domain.range_validator import RangeValidator
-from onlinepayments.sdk.domain.regular_expression_validator import RegularExpressionValidator
+from typing import Optional
+
+from .data_object import DataObject
+from .empty_validator import EmptyValidator
+from .fixed_list_validator import FixedListValidator
+from .length_validator import LengthValidator
+from .range_validator import RangeValidator
+from .regular_expression_validator import RegularExpressionValidator
 
 
 class PaymentProductFieldValidators(DataObject):
-    """
-    | Object containing the details of the validations on the field
-    """
-
-    __email_address = None
-    __expiration_date = None
-    __fixed_list = None
-    __iban = None
-    __length = None
-    __luhn = None
-    __range = None
-    __regular_expression = None
-    __terms_and_conditions = 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
+    __terms_and_conditions: Optional[EmptyValidator] = None
 
     @property
-    def email_address(self) -> EmptyValidator:
+    def email_address(self) -> Optional[EmptyValidator]:
         """
         Type: :class:`onlinepayments.sdk.domain.empty_validator.EmptyValidator`
         """
         return self.__email_address
 
     @email_address.setter
-    def email_address(self, value: EmptyValidator):
+    def email_address(self, value: Optional[EmptyValidator]) -> None:
         self.__email_address = value
 
     @property
-    def expiration_date(self) -> EmptyValidator:
+    def expiration_date(self) -> Optional[EmptyValidator]:
         """
         Type: :class:`onlinepayments.sdk.domain.empty_validator.EmptyValidator`
         """
         return self.__expiration_date
 
     @expiration_date.setter
-    def expiration_date(self, value: EmptyValidator):
+    def expiration_date(self, value: Optional[EmptyValidator]) -> None:
         self.__expiration_date = value
 
     @property
-    def fixed_list(self) -> FixedListValidator:
+    def fixed_list(self) -> Optional[FixedListValidator]:
         """
         Type: :class:`onlinepayments.sdk.domain.fixed_list_validator.FixedListValidator`
         """
         return self.__fixed_list
 
     @fixed_list.setter
-    def fixed_list(self, value: FixedListValidator):
+    def fixed_list(self, value: Optional[FixedListValidator]) -> None:
         self.__fixed_list = value
 
     @property
-    def iban(self) -> EmptyValidator:
+    def iban(self) -> Optional[EmptyValidator]:
         """
         Type: :class:`onlinepayments.sdk.domain.empty_validator.EmptyValidator`
         """
         return self.__iban
 
     @iban.setter
-    def iban(self, value: EmptyValidator):
+    def iban(self, value: Optional[EmptyValidator]) -> None:
         self.__iban = value
 
     @property
-    def length(self) -> LengthValidator:
+    def length(self) -> Optional[LengthValidator]:
         """
         Type: :class:`onlinepayments.sdk.domain.length_validator.LengthValidator`
         """
         return self.__length
 
     @length.setter
-    def length(self, value: LengthValidator):
+    def length(self, value: Optional[LengthValidator]) -> None:
         self.__length = value
 
     @property
-    def luhn(self) -> EmptyValidator:
+    def luhn(self) -> Optional[EmptyValidator]:
         """
         Type: :class:`onlinepayments.sdk.domain.empty_validator.EmptyValidator`
         """
         return self.__luhn
 
     @luhn.setter
-    def luhn(self, value: EmptyValidator):
+    def luhn(self, value: Optional[EmptyValidator]) -> None:
         self.__luhn = value
 
     @property
-    def range(self) -> RangeValidator:
+    def range(self) -> Optional[RangeValidator]:
         """
         Type: :class:`onlinepayments.sdk.domain.range_validator.RangeValidator`
         """
         return self.__range
 
     @range.setter
-    def range(self, value: RangeValidator):
+    def range(self, value: Optional[RangeValidator]) -> None:
         self.__range = value
 
     @property
-    def regular_expression(self) -> RegularExpressionValidator:
+    def regular_expression(self) -> Optional[RegularExpressionValidator]:
         """
         Type: :class:`onlinepayments.sdk.domain.regular_expression_validator.RegularExpressionValidator`
         """
         return self.__regular_expression
 
     @regular_expression.setter
-    def regular_expression(self, value: RegularExpressionValidator):
+    def regular_expression(self, value: Optional[RegularExpressionValidator]) -> None:
         self.__regular_expression = value
 
     @property
-    def terms_and_conditions(self) -> EmptyValidator:
+    def terms_and_conditions(self) -> Optional[EmptyValidator]:
         """
         Type: :class:`onlinepayments.sdk.domain.empty_validator.EmptyValidator`
         """
         return self.__terms_and_conditions
 
     @terms_and_conditions.setter
-    def terms_and_conditions(self, value: EmptyValidator):
+    def terms_and_conditions(self, value: Optional[EmptyValidator]) -> None:
         self.__terms_and_conditions = value
 
-    def to_dictionary(self):
+    def to_dictionary(self) -> dict:
         dictionary = super(PaymentProductFieldValidators, self).to_dictionary()
         if self.email_address is not None:
             dictionary['emailAddress'] = self.email_address.to_dictionary()
@@ -146,7 +145,7 @@ class PaymentProductFieldValidators(DataObject):
             dictionary['termsAndConditions'] = self.terms_and_conditions.to_dictionary()
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldValidators':
         super(PaymentProductFieldValidators, self).from_dictionary(dictionary)
         if 'emailAddress' in dictionary:
             if not isinstance(dictionary['emailAddress'], dict):

{onlinepayments-sdk-python3-4.22.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/payment_product_filter.py

@@ -1,22 +1,19 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from typing import List
+from typing import List, Optional
 
-from onlinepayments.sdk.data_object import DataObject
+from .data_object import DataObject
 
 
 class PaymentProductFilter(DataObject):
-    """
-    | The payment product ids to be be excluded or restricted to from the payment products available for the payment. Note that you can add exclusions on top of the 'restrictTo' filter.
-    """
 
-    __groups = None
-    __products = None
+    __groups: Optional[List[str]] = None
+    __products: Optional[List[int]] = None
 
     @property
-    def groups(self) -> List[str]:
+    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'.
 
@@ -25,23 +22,21 @@ class PaymentProductFilter(DataObject):
         return self.__groups
 
     @groups.setter
-    def groups(self, value: List[str]):
+    def groups(self, value: Optional[List[str]]) -> None:
         self.__groups = value
 
     @property
-    def products(self) -> List[int]:
+    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: List[int]):
+    def products(self, value: Optional[List[int]]) -> None:
         self.__products = value
 
-    def to_dictionary(self):
+    def to_dictionary(self) -> dict:
         dictionary = super(PaymentProductFilter, self).to_dictionary()
         if self.groups is not None:
             dictionary['groups'] = []
@@ -55,7 +50,7 @@ class PaymentProductFilter(DataObject):
                     dictionary['products'].append(element)
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFilter':
         super(PaymentProductFilter, self).from_dictionary(dictionary)
         if 'groups' in dictionary:
             if not isinstance(dictionary['groups'], list):