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

onlinepayments/sdk/domain/regular_expression_validator.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class RegularExpressionValidator(DataObject):
+
+    __regular_expression: Optional[str] = None
+
+    @property
+    def regular_expression(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__regular_expression
+
+    @regular_expression.setter
+    def regular_expression(self, value: Optional[str]) -> None:
+        self.__regular_expression = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RegularExpressionValidator, self).to_dictionary()
+        if self.regular_expression is not None:
+            dictionary['regularExpression'] = self.regular_expression
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RegularExpressionValidator':
+        super(RegularExpressionValidator, self).from_dictionary(dictionary)
+        if 'regularExpression' in dictionary:
+            self.regular_expression = dictionary['regularExpression']
+        return self

onlinepayments/sdk/domain/revoke_mandate_request.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class RevokeMandateRequest(DataObject):
+
+    __revocation_reason: Optional[str] = None
+
+    @property
+    def revocation_reason(self) -> Optional[str]:
+        """
+        | The reason for revoking the mandate. Possible values are:
+        
+        * receivedFinal
+        * userAction
+        * obsolescence
+        * refused
+        * revocationAskedByDebitor
+        * revocationAskedByCreditor
+        * deletionAskedByDebitor
+        * deletionAskedByCreditor
+        
+        | Refer to the support page to determine if the property is applicable.
+
+        Type: str
+        """
+        return self.__revocation_reason
+
+    @revocation_reason.setter
+    def revocation_reason(self, value: Optional[str]) -> None:
+        self.__revocation_reason = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RevokeMandateRequest, self).to_dictionary()
+        if self.revocation_reason is not None:
+            dictionary['revocationReason'] = self.revocation_reason
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RevokeMandateRequest':
+        super(RevokeMandateRequest, self).from_dictionary(dictionary)
+        if 'revocationReason' in dictionary:
+            self.revocation_reason = dictionary['revocationReason']
+        return self

onlinepayments/sdk/domain/send_test_request.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class SendTestRequest(DataObject):
+
+    __url: Optional[str] = None
+
+    @property
+    def url(self) -> Optional[str]:
+        """
+        | Url to which the dummy webhook would be sent. If the parameter is not sent, It will be sent as default to the webhook url configured in the backoffice.
+
+        Type: str
+        """
+        return self.__url
+
+    @url.setter
+    def url(self, value: Optional[str]) -> None:
+        self.__url = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SendTestRequest, self).to_dictionary()
+        if self.url is not None:
+            dictionary['url'] = self.url
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SendTestRequest':
+        super(SendTestRequest, self).from_dictionary(dictionary)
+        if 'url' in dictionary:
+            self.url = dictionary['url']
+        return self

onlinepayments/sdk/domain/sepa_direct_debit_payment_method_specific_input.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .sepa_direct_debit_payment_product771_specific_input import SepaDirectDebitPaymentProduct771SpecificInput
+
+
+class SepaDirectDebitPaymentMethodSpecificInput(DataObject):
+
+    __payment_product771_specific_input: Optional[SepaDirectDebitPaymentProduct771SpecificInput] = None
+    __payment_product_id: Optional[int] = None
+
+    @property
+    def payment_product771_specific_input(self) -> Optional[SepaDirectDebitPaymentProduct771SpecificInput]:
+        """
+        | Object containing information specific to SEPA Direct Debit
+
+        Type: :class:`onlinepayments.sdk.domain.sepa_direct_debit_payment_product771_specific_input.SepaDirectDebitPaymentProduct771SpecificInput`
+        """
+        return self.__payment_product771_specific_input
+
+    @payment_product771_specific_input.setter
+    def payment_product771_specific_input(self, value: Optional[SepaDirectDebitPaymentProduct771SpecificInput]) -> None:
+        self.__payment_product771_specific_input = value
+
+    @property
+    def payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier - Please see Products documentation for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__payment_product_id
+
+    @payment_product_id.setter
+    def payment_product_id(self, value: Optional[int]) -> None:
+        self.__payment_product_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SepaDirectDebitPaymentMethodSpecificInput, self).to_dictionary()
+        if self.payment_product771_specific_input is not None:
+            dictionary['paymentProduct771SpecificInput'] = self.payment_product771_specific_input.to_dictionary()
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SepaDirectDebitPaymentMethodSpecificInput':
+        super(SepaDirectDebitPaymentMethodSpecificInput, self).from_dictionary(dictionary)
+        if 'paymentProduct771SpecificInput' in dictionary:
+            if not isinstance(dictionary['paymentProduct771SpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct771SpecificInput']))
+            value = SepaDirectDebitPaymentProduct771SpecificInput()
+            self.payment_product771_specific_input = value.from_dictionary(dictionary['paymentProduct771SpecificInput'])
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        return self

onlinepayments/sdk/domain/sepa_direct_debit_payment_method_specific_input_base.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .sepa_direct_debit_payment_product771_specific_input_base import SepaDirectDebitPaymentProduct771SpecificInputBase
+
+
+class SepaDirectDebitPaymentMethodSpecificInputBase(DataObject):
+
+    __payment_product771_specific_input: Optional[SepaDirectDebitPaymentProduct771SpecificInputBase] = None
+    __payment_product_id: Optional[int] = None
+
+    @property
+    def payment_product771_specific_input(self) -> Optional[SepaDirectDebitPaymentProduct771SpecificInputBase]:
+        """
+        | Object containing information specific to SEPA Direct Debit
+
+        Type: :class:`onlinepayments.sdk.domain.sepa_direct_debit_payment_product771_specific_input_base.SepaDirectDebitPaymentProduct771SpecificInputBase`
+        """
+        return self.__payment_product771_specific_input
+
+    @payment_product771_specific_input.setter
+    def payment_product771_specific_input(self, value: Optional[SepaDirectDebitPaymentProduct771SpecificInputBase]) -> None:
+        self.__payment_product771_specific_input = value
+
+    @property
+    def payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier - Please see Products documentation for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__payment_product_id
+
+    @payment_product_id.setter
+    def payment_product_id(self, value: Optional[int]) -> None:
+        self.__payment_product_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SepaDirectDebitPaymentMethodSpecificInputBase, self).to_dictionary()
+        if self.payment_product771_specific_input is not None:
+            dictionary['paymentProduct771SpecificInput'] = self.payment_product771_specific_input.to_dictionary()
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SepaDirectDebitPaymentMethodSpecificInputBase':
+        super(SepaDirectDebitPaymentMethodSpecificInputBase, self).from_dictionary(dictionary)
+        if 'paymentProduct771SpecificInput' in dictionary:
+            if not isinstance(dictionary['paymentProduct771SpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct771SpecificInput']))
+            value = SepaDirectDebitPaymentProduct771SpecificInputBase()
+            self.payment_product771_specific_input = value.from_dictionary(dictionary['paymentProduct771SpecificInput'])
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        return self

onlinepayments/sdk/domain/sepa_direct_debit_payment_method_specific_output.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .fraud_results import FraudResults
+from .payment_product771_specific_output import PaymentProduct771SpecificOutput
+
+
+class SepaDirectDebitPaymentMethodSpecificOutput(DataObject):
+
+    __fraud_results: Optional[FraudResults] = None
+    __payment_product771_specific_output: Optional[PaymentProduct771SpecificOutput] = None
+    __payment_product_id: Optional[int] = None
+
+    @property
+    def fraud_results(self) -> Optional[FraudResults]:
+        """
+        | Object containing the results of the fraud screening
+
+        Type: :class:`onlinepayments.sdk.domain.fraud_results.FraudResults`
+        """
+        return self.__fraud_results
+
+    @fraud_results.setter
+    def fraud_results(self, value: Optional[FraudResults]) -> None:
+        self.__fraud_results = value
+
+    @property
+    def payment_product771_specific_output(self) -> Optional[PaymentProduct771SpecificOutput]:
+        """
+        | Output that is SEPA Direct Debit specific (i.e. the used mandate)
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product771_specific_output.PaymentProduct771SpecificOutput`
+        """
+        return self.__payment_product771_specific_output
+
+    @payment_product771_specific_output.setter
+    def payment_product771_specific_output(self, value: Optional[PaymentProduct771SpecificOutput]) -> None:
+        self.__payment_product771_specific_output = value
+
+    @property
+    def payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier - Please see Products documentation for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__payment_product_id
+
+    @payment_product_id.setter
+    def payment_product_id(self, value: Optional[int]) -> None:
+        self.__payment_product_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SepaDirectDebitPaymentMethodSpecificOutput, self).to_dictionary()
+        if self.fraud_results is not None:
+            dictionary['fraudResults'] = self.fraud_results.to_dictionary()
+        if self.payment_product771_specific_output is not None:
+            dictionary['paymentProduct771SpecificOutput'] = self.payment_product771_specific_output.to_dictionary()
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SepaDirectDebitPaymentMethodSpecificOutput':
+        super(SepaDirectDebitPaymentMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'fraudResults' in dictionary:
+            if not isinstance(dictionary['fraudResults'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraudResults']))
+            value = FraudResults()
+            self.fraud_results = value.from_dictionary(dictionary['fraudResults'])
+        if 'paymentProduct771SpecificOutput' in dictionary:
+            if not isinstance(dictionary['paymentProduct771SpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct771SpecificOutput']))
+            value = PaymentProduct771SpecificOutput()
+            self.payment_product771_specific_output = value.from_dictionary(dictionary['paymentProduct771SpecificOutput'])
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        return self

onlinepayments/sdk/domain/sepa_direct_debit_payment_product771_specific_input.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .create_mandate_with_return_url import CreateMandateWithReturnUrl
+from .data_object import DataObject
+
+
+class SepaDirectDebitPaymentProduct771SpecificInput(DataObject):
+
+    __existing_unique_mandate_reference: Optional[str] = None
+    __mandate: Optional[CreateMandateWithReturnUrl] = None
+
+    @property
+    def existing_unique_mandate_reference(self) -> Optional[str]:
+        """
+        | The unique reference of the existing mandate to use in this payment.
+
+        Type: str
+        """
+        return self.__existing_unique_mandate_reference
+
+    @existing_unique_mandate_reference.setter
+    def existing_unique_mandate_reference(self, value: Optional[str]) -> None:
+        self.__existing_unique_mandate_reference = value
+
+    @property
+    def mandate(self) -> Optional[CreateMandateWithReturnUrl]:
+        """
+        | Object containing information to create a SEPA Direct Debit mandate.
+
+        Type: :class:`onlinepayments.sdk.domain.create_mandate_with_return_url.CreateMandateWithReturnUrl`
+        """
+        return self.__mandate
+
+    @mandate.setter
+    def mandate(self, value: Optional[CreateMandateWithReturnUrl]) -> None:
+        self.__mandate = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SepaDirectDebitPaymentProduct771SpecificInput, self).to_dictionary()
+        if self.existing_unique_mandate_reference is not None:
+            dictionary['existingUniqueMandateReference'] = self.existing_unique_mandate_reference
+        if self.mandate is not None:
+            dictionary['mandate'] = self.mandate.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SepaDirectDebitPaymentProduct771SpecificInput':
+        super(SepaDirectDebitPaymentProduct771SpecificInput, self).from_dictionary(dictionary)
+        if 'existingUniqueMandateReference' in dictionary:
+            self.existing_unique_mandate_reference = dictionary['existingUniqueMandateReference']
+        if 'mandate' in dictionary:
+            if not isinstance(dictionary['mandate'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mandate']))
+            value = CreateMandateWithReturnUrl()
+            self.mandate = value.from_dictionary(dictionary['mandate'])
+        return self

onlinepayments/sdk/domain/sepa_direct_debit_payment_product771_specific_input_base.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .create_mandate_request import CreateMandateRequest
+from .data_object import DataObject
+
+
+class SepaDirectDebitPaymentProduct771SpecificInputBase(DataObject):
+
+    __existing_unique_mandate_reference: Optional[str] = None
+    __mandate: Optional[CreateMandateRequest] = None
+
+    @property
+    def existing_unique_mandate_reference(self) -> Optional[str]:
+        """
+        | The unique reference of the existing mandate to use in this payment.
+
+        Type: str
+        """
+        return self.__existing_unique_mandate_reference
+
+    @existing_unique_mandate_reference.setter
+    def existing_unique_mandate_reference(self, value: Optional[str]) -> None:
+        self.__existing_unique_mandate_reference = value
+
+    @property
+    def mandate(self) -> Optional[CreateMandateRequest]:
+        """
+        | Object containing information to create a SEPA Direct Debit mandate.
+
+        Type: :class:`onlinepayments.sdk.domain.create_mandate_request.CreateMandateRequest`
+        """
+        return self.__mandate
+
+    @mandate.setter
+    def mandate(self, value: Optional[CreateMandateRequest]) -> None:
+        self.__mandate = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SepaDirectDebitPaymentProduct771SpecificInputBase, self).to_dictionary()
+        if self.existing_unique_mandate_reference is not None:
+            dictionary['existingUniqueMandateReference'] = self.existing_unique_mandate_reference
+        if self.mandate is not None:
+            dictionary['mandate'] = self.mandate.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SepaDirectDebitPaymentProduct771SpecificInputBase':
+        super(SepaDirectDebitPaymentProduct771SpecificInputBase, self).from_dictionary(dictionary)
+        if 'existingUniqueMandateReference' in dictionary:
+            self.existing_unique_mandate_reference = dictionary['existingUniqueMandateReference']
+        if 'mandate' in dictionary:
+            if not isinstance(dictionary['mandate'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mandate']))
+            value = CreateMandateRequest()
+            self.mandate = value.from_dictionary(dictionary['mandate'])
+        return self

onlinepayments/sdk/domain/session_data.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+
+
+class SessionData(DataObject):
+
+    __hosted_fields_session_id: Optional[str] = None
+    __locale: Optional[str] = None
+    __platform_url: Optional[str] = None
+    __session_token: Optional[str] = None
+    __tokens: Optional[List[str]] = None
+
+    @property
+    def hosted_fields_session_id(self) -> Optional[str]:
+        """
+        | Id of the created session
+
+        Type: str
+        """
+        return self.__hosted_fields_session_id
+
+    @hosted_fields_session_id.setter
+    def hosted_fields_session_id(self, value: Optional[str]) -> None:
+        self.__hosted_fields_session_id = value
+
+    @property
+    def locale(self) -> Optional[str]:
+        """
+        | Locale used in the GUI towards the consumer.
+
+        Type: str
+        """
+        return self.__locale
+
+    @locale.setter
+    def locale(self, value: Optional[str]) -> None:
+        self.__locale = value
+
+    @property
+    def platform_url(self) -> Optional[str]:
+        """
+        | This is the URL to Worldline's payment platform.
+
+        Type: str
+        """
+        return self.__platform_url
+
+    @platform_url.setter
+    def platform_url(self, value: Optional[str]) -> None:
+        self.__platform_url = value
+
+    @property
+    def session_token(self) -> Optional[str]:
+        """
+        | The JWT token used to authorize calls between iframes and server
+
+        Type: str
+        """
+        return self.__session_token
+
+    @session_token.setter
+    def session_token(self, value: Optional[str]) -> None:
+        self.__session_token = value
+
+    @property
+    def tokens(self) -> Optional[List[str]]:
+        """
+        | This is a list of validated, previously stored card tokens available for use in this checkout session.
+
+        Type: list[str]
+        """
+        return self.__tokens
+
+    @tokens.setter
+    def tokens(self, value: Optional[List[str]]) -> None:
+        self.__tokens = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SessionData, self).to_dictionary()
+        if self.hosted_fields_session_id is not None:
+            dictionary['hostedFieldsSessionId'] = self.hosted_fields_session_id
+        if self.locale is not None:
+            dictionary['locale'] = self.locale
+        if self.platform_url is not None:
+            dictionary['platformUrl'] = self.platform_url
+        if self.session_token is not None:
+            dictionary['sessionToken'] = self.session_token
+        if self.tokens is not None:
+            dictionary['tokens'] = []
+            for element in self.tokens:
+                if element is not None:
+                    dictionary['tokens'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SessionData':
+        super(SessionData, self).from_dictionary(dictionary)
+        if 'hostedFieldsSessionId' in dictionary:
+            self.hosted_fields_session_id = dictionary['hostedFieldsSessionId']
+        if 'locale' in dictionary:
+            self.locale = dictionary['locale']
+        if 'platformUrl' in dictionary:
+            self.platform_url = dictionary['platformUrl']
+        if 'sessionToken' in dictionary:
+            self.session_token = dictionary['sessionToken']
+        if 'tokens' in dictionary:
+            if not isinstance(dictionary['tokens'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['tokens']))
+            self.tokens = []
+            for element in dictionary['tokens']:
+                self.tokens.append(element)
+        return self

onlinepayments/sdk/domain/session_details.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class SessionDetails(DataObject):
+
+    __id: Optional[str] = None
+    __type: Optional[str] = None
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | Session identifier from where this payment originates from. Depends on the session type: ex: For PayByLink: id is the corresponding paymentLinkId.
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def type(self) -> Optional[str]:
+        """
+        | Session type. This denotes the origin of the session. For example PayByLink, HostedTokenization, etc.
+
+        Type: str
+        """
+        return self.__type
+
+    @type.setter
+    def type(self, value: Optional[str]) -> None:
+        self.__type = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SessionDetails, self).to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.type is not None:
+            dictionary['type'] = self.type
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SessionDetails':
+        super(SessionDetails, self).from_dictionary(dictionary)
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'type' in dictionary:
+            self.type = dictionary['type']
+        return self

onlinepayments/sdk/domain/session_request.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+
+
+class SessionRequest(DataObject):
+
+    __tokens: Optional[List[str]] = None
+
+    @property
+    def tokens(self) -> Optional[List[str]]:
+        """
+        | List of previously stored tokens linked to the customer that wants to checkout.
+
+        Type: list[str]
+        """
+        return self.__tokens
+
+    @tokens.setter
+    def tokens(self, value: Optional[List[str]]) -> None:
+        self.__tokens = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SessionRequest, self).to_dictionary()
+        if self.tokens is not None:
+            dictionary['tokens'] = []
+            for element in self.tokens:
+                if element is not None:
+                    dictionary['tokens'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SessionRequest':
+        super(SessionRequest, self).from_dictionary(dictionary)
+        if 'tokens' in dictionary:
+            if not isinstance(dictionary['tokens'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['tokens']))
+            self.tokens = []
+            for element in dictionary['tokens']:
+                self.tokens.append(element)
+        return self