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

onlinepayments/sdk/domain/account_on_file_attribute.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class AccountOnFileAttribute(DataObject):
+
+    __key: Optional[str] = None
+    __must_write_reason: Optional[str] = None
+    __status: Optional[str] = None
+    __value: Optional[str] = None
+
+    @property
+    def key(self) -> Optional[str]:
+        """
+        | Name of the key or property
+
+        Type: str
+        """
+        return self.__key
+
+    @key.setter
+    def key(self, value: Optional[str]) -> None:
+        self.__key = value
+
+    @property
+    def must_write_reason(self) -> Optional[str]:
+        """
+        | Deprecated: This field is not used by any payment product The reason why the status is MUST_WRITE. Currently only "IN_THE_PAST" is possible as value (for expiry date), but this can be extended with new values in the future.
+
+        Type: str
+
+        Deprecated; Deprecated
+        """
+        return self.__must_write_reason
+
+    @must_write_reason.setter
+    def must_write_reason(self, value: Optional[str]) -> None:
+        self.__must_write_reason = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | Possible values:
+        
+        * READ_ONLY - attribute cannot be updated and should be presented in that way to the user
+        * CAN_WRITE - attribute can be updated and should be presented as an editable field, for example an expiration date that will expire very soon
+        * MUST_WRITE - attribute should be updated and must be presented as an editable field, for example an expiration date that has already expired Any updated values that are entered for CAN_WRITE or MUST_WRITE will be used to update the values stored in the token.
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    @property
+    def value(self) -> Optional[str]:
+        """
+        | Value of the key or property
+
+        Type: str
+        """
+        return self.__value
+
+    @value.setter
+    def value(self, value: Optional[str]) -> None:
+        self.__value = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(AccountOnFileAttribute, self).to_dictionary()
+        if self.key is not None:
+            dictionary['key'] = self.key
+        if self.must_write_reason is not None:
+            dictionary['mustWriteReason'] = self.must_write_reason
+        if self.status is not None:
+            dictionary['status'] = self.status
+        if self.value is not None:
+            dictionary['value'] = self.value
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AccountOnFileAttribute':
+        super(AccountOnFileAttribute, self).from_dictionary(dictionary)
+        if 'key' in dictionary:
+            self.key = dictionary['key']
+        if 'mustWriteReason' in dictionary:
+            self.must_write_reason = dictionary['mustWriteReason']
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        if 'value' in dictionary:
+            self.value = dictionary['value']
+        return self

onlinepayments/sdk/domain/account_on_file_display_hints.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+from .label_template_element import LabelTemplateElement
+
+
+class AccountOnFileDisplayHints(DataObject):
+
+    __label_template: Optional[List[LabelTemplateElement]] = None
+    __logo: Optional[str] = None
+
+    @property
+    def label_template(self) -> Optional[List[LabelTemplateElement]]:
+        """
+        | Array of attribute keys and their mask
+
+        Type: list[:class:`onlinepayments.sdk.domain.label_template_element.LabelTemplateElement`]
+        """
+        return self.__label_template
+
+    @label_template.setter
+    def label_template(self, value: Optional[List[LabelTemplateElement]]) -> None:
+        self.__label_template = value
+
+    @property
+    def logo(self) -> Optional[str]:
+        """
+        | Partial URL that you can reference for the image of this payment product. 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.__logo
+
+    @logo.setter
+    def logo(self, value: Optional[str]) -> None:
+        self.__logo = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(AccountOnFileDisplayHints, self).to_dictionary()
+        if self.label_template is not None:
+            dictionary['labelTemplate'] = []
+            for element in self.label_template:
+                if element is not None:
+                    dictionary['labelTemplate'].append(element.to_dictionary())
+        if self.logo is not None:
+            dictionary['logo'] = self.logo
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AccountOnFileDisplayHints':
+        super(AccountOnFileDisplayHints, self).from_dictionary(dictionary)
+        if 'labelTemplate' in dictionary:
+            if not isinstance(dictionary['labelTemplate'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['labelTemplate']))
+            self.label_template = []
+            for element in dictionary['labelTemplate']:
+                value = LabelTemplateElement()
+                self.label_template.append(value.from_dictionary(element))
+        if 'logo' in dictionary:
+            self.logo = dictionary['logo']
+        return self

onlinepayments/sdk/domain/acquirer_information.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .acquirer_selection_information import AcquirerSelectionInformation
+from .data_object import DataObject
+
+
+class AcquirerInformation(DataObject):
+
+    __acquirer_selection_information: Optional[AcquirerSelectionInformation] = None
+    __name: Optional[str] = None
+
+    @property
+    def acquirer_selection_information(self) -> Optional[AcquirerSelectionInformation]:
+        """
+        | Information about the acquirer selection
+
+        Type: :class:`onlinepayments.sdk.domain.acquirer_selection_information.AcquirerSelectionInformation`
+        """
+        return self.__acquirer_selection_information
+
+    @acquirer_selection_information.setter
+    def acquirer_selection_information(self, value: Optional[AcquirerSelectionInformation]) -> None:
+        self.__acquirer_selection_information = value
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        | Name of the acquirer used to process the transaction
+
+        Type: str
+        """
+        return self.__name
+
+    @name.setter
+    def name(self, value: Optional[str]) -> None:
+        self.__name = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(AcquirerInformation, self).to_dictionary()
+        if self.acquirer_selection_information is not None:
+            dictionary['acquirerSelectionInformation'] = self.acquirer_selection_information.to_dictionary()
+        if self.name is not None:
+            dictionary['name'] = self.name
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AcquirerInformation':
+        super(AcquirerInformation, self).from_dictionary(dictionary)
+        if 'acquirerSelectionInformation' in dictionary:
+            if not isinstance(dictionary['acquirerSelectionInformation'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['acquirerSelectionInformation']))
+            value = AcquirerSelectionInformation()
+            self.acquirer_selection_information = value.from_dictionary(dictionary['acquirerSelectionInformation'])
+        if 'name' in dictionary:
+            self.name = dictionary['name']
+        return self

onlinepayments/sdk/domain/acquirer_selection_information.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class AcquirerSelectionInformation(DataObject):
+
+    __fallback_level: Optional[int] = None
+    __result: Optional[str] = None
+    __rule_name: Optional[str] = None
+
+    @property
+    def fallback_level(self) -> Optional[int]:
+        """
+        | Specifies whether a fallback occurred from the primary choice of the acquirer selection service.
+
+        Type: int
+        """
+        return self.__fallback_level
+
+    @fallback_level.setter
+    def fallback_level(self, value: Optional[int]) -> None:
+        self.__fallback_level = value
+
+    @property
+    def result(self) -> Optional[str]:
+        """
+        | Result of the acquirer selection operation
+
+        Type: str
+        """
+        return self.__result
+
+    @result.setter
+    def result(self, value: Optional[str]) -> None:
+        self.__result = value
+
+    @property
+    def rule_name(self) -> Optional[str]:
+        """
+        | Name of the rule used to select the acquirer
+
+        Type: str
+        """
+        return self.__rule_name
+
+    @rule_name.setter
+    def rule_name(self, value: Optional[str]) -> None:
+        self.__rule_name = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(AcquirerSelectionInformation, self).to_dictionary()
+        if self.fallback_level is not None:
+            dictionary['fallbackLevel'] = self.fallback_level
+        if self.result is not None:
+            dictionary['result'] = self.result
+        if self.rule_name is not None:
+            dictionary['ruleName'] = self.rule_name
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AcquirerSelectionInformation':
+        super(AcquirerSelectionInformation, self).from_dictionary(dictionary)
+        if 'fallbackLevel' in dictionary:
+            self.fallback_level = dictionary['fallbackLevel']
+        if 'result' in dictionary:
+            self.result = dictionary['result']
+        if 'ruleName' in dictionary:
+            self.rule_name = dictionary['ruleName']
+        return self

onlinepayments/sdk/domain/additional_order_input.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .airline_data import AirlineData
+from .data_object import DataObject
+from .loan_recipient import LoanRecipient
+from .lodging_data import LodgingData
+from .order_type_information import OrderTypeInformation
+
+
+class AdditionalOrderInput(DataObject):
+
+    __airline_data: Optional[AirlineData] = None
+    __loan_recipient: Optional[LoanRecipient] = None
+    __lodging_data: Optional[LodgingData] = None
+    __type_information: Optional[OrderTypeInformation] = None
+
+    @property
+    def airline_data(self) -> Optional[AirlineData]:
+        """
+        | Object that holds airline specific data
+
+        Type: :class:`onlinepayments.sdk.domain.airline_data.AirlineData`
+        """
+        return self.__airline_data
+
+    @airline_data.setter
+    def airline_data(self, value: Optional[AirlineData]) -> None:
+        self.__airline_data = value
+
+    @property
+    def loan_recipient(self) -> Optional[LoanRecipient]:
+        """
+        | Object containing specific data regarding the recipient of a loan in the UK
+
+        Type: :class:`onlinepayments.sdk.domain.loan_recipient.LoanRecipient`
+        """
+        return self.__loan_recipient
+
+    @loan_recipient.setter
+    def loan_recipient(self, value: Optional[LoanRecipient]) -> None:
+        self.__loan_recipient = value
+
+    @property
+    def lodging_data(self) -> Optional[LodgingData]:
+        """
+        | Object that holds lodging specific data
+
+        Type: :class:`onlinepayments.sdk.domain.lodging_data.LodgingData`
+        """
+        return self.__lodging_data
+
+    @lodging_data.setter
+    def lodging_data(self, value: Optional[LodgingData]) -> None:
+        self.__lodging_data = value
+
+    @property
+    def type_information(self) -> Optional[OrderTypeInformation]:
+        """
+        | Object that holds the purchase and usage type indicators
+
+        Type: :class:`onlinepayments.sdk.domain.order_type_information.OrderTypeInformation`
+        """
+        return self.__type_information
+
+    @type_information.setter
+    def type_information(self, value: Optional[OrderTypeInformation]) -> None:
+        self.__type_information = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(AdditionalOrderInput, self).to_dictionary()
+        if self.airline_data is not None:
+            dictionary['airlineData'] = self.airline_data.to_dictionary()
+        if self.loan_recipient is not None:
+            dictionary['loanRecipient'] = self.loan_recipient.to_dictionary()
+        if self.lodging_data is not None:
+            dictionary['lodgingData'] = self.lodging_data.to_dictionary()
+        if self.type_information is not None:
+            dictionary['typeInformation'] = self.type_information.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AdditionalOrderInput':
+        super(AdditionalOrderInput, self).from_dictionary(dictionary)
+        if 'airlineData' in dictionary:
+            if not isinstance(dictionary['airlineData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['airlineData']))
+            value = AirlineData()
+            self.airline_data = value.from_dictionary(dictionary['airlineData'])
+        if 'loanRecipient' in dictionary:
+            if not isinstance(dictionary['loanRecipient'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['loanRecipient']))
+            value = LoanRecipient()
+            self.loan_recipient = value.from_dictionary(dictionary['loanRecipient'])
+        if 'lodgingData' in dictionary:
+            if not isinstance(dictionary['lodgingData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['lodgingData']))
+            value = LodgingData()
+            self.lodging_data = value.from_dictionary(dictionary['lodgingData'])
+        if 'typeInformation' in dictionary:
+            if not isinstance(dictionary['typeInformation'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['typeInformation']))
+            value = OrderTypeInformation()
+            self.type_information = value.from_dictionary(dictionary['typeInformation'])
+        return self

onlinepayments/sdk/domain/address.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class Address(DataObject):
+
+    __additional_info: Optional[str] = None
+    __city: Optional[str] = None
+    __country_code: Optional[str] = None
+    __house_number: Optional[str] = None
+    __state: Optional[str] = None
+    __street: Optional[str] = None
+    __zip: Optional[str] = None
+
+    @property
+    def additional_info(self) -> Optional[str]:
+        """
+        | Second line of street or additional address information
+
+        Type: str
+        """
+        return self.__additional_info
+
+    @additional_info.setter
+    def additional_info(self, value: Optional[str]) -> None:
+        self.__additional_info = value
+
+    @property
+    def city(self) -> Optional[str]:
+        """
+        | City
+
+        Type: str
+        """
+        return self.__city
+
+    @city.setter
+    def city(self, value: Optional[str]) -> None:
+        self.__city = 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 house_number(self) -> Optional[str]:
+        """
+        | House number
+
+        Type: str
+        """
+        return self.__house_number
+
+    @house_number.setter
+    def house_number(self, value: Optional[str]) -> None:
+        self.__house_number = value
+
+    @property
+    def state(self) -> Optional[str]:
+        """
+        | ISO 3166-2 country subdivision code
+
+        Type: str
+        """
+        return self.__state
+
+    @state.setter
+    def state(self, value: Optional[str]) -> None:
+        self.__state = value
+
+    @property
+    def street(self) -> Optional[str]:
+        """
+        | Street name
+
+        Type: str
+        """
+        return self.__street
+
+    @street.setter
+    def street(self, value: Optional[str]) -> None:
+        self.__street = value
+
+    @property
+    def zip(self) -> Optional[str]:
+        """
+        | Zip code
+
+        Type: str
+        """
+        return self.__zip
+
+    @zip.setter
+    def zip(self, value: Optional[str]) -> None:
+        self.__zip = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Address, self).to_dictionary()
+        if self.additional_info is not None:
+            dictionary['additionalInfo'] = self.additional_info
+        if self.city is not None:
+            dictionary['city'] = self.city
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.house_number is not None:
+            dictionary['houseNumber'] = self.house_number
+        if self.state is not None:
+            dictionary['state'] = self.state
+        if self.street is not None:
+            dictionary['street'] = self.street
+        if self.zip is not None:
+            dictionary['zip'] = self.zip
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Address':
+        super(Address, self).from_dictionary(dictionary)
+        if 'additionalInfo' in dictionary:
+            self.additional_info = dictionary['additionalInfo']
+        if 'city' in dictionary:
+            self.city = dictionary['city']
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'houseNumber' in dictionary:
+            self.house_number = dictionary['houseNumber']
+        if 'state' in dictionary:
+            self.state = dictionary['state']
+        if 'street' in dictionary:
+            self.street = dictionary['street']
+        if 'zip' in dictionary:
+            self.zip = dictionary['zip']
+        return self