connect-sdk-python3 3.47.0__zip → 4.0.1__zip

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/api_error.py

@@ -0,0 +1,156 @@
+# -*- 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 APIError(DataObject):
+
+    __category: Optional[str] = None
+    __code: Optional[str] = None
+    __http_status_code: Optional[int] = None
+    __id: Optional[str] = None
+    __message: Optional[str] = None
+    __property_name: Optional[str] = None
+    __request_id: Optional[str] = None
+
+    @property
+    def category(self) -> Optional[str]:
+        """
+        | Category the error belongs to. The category should give an indication of the type of error you are dealing with.Possible values:
+        
+        * CONNECT_PLATFORM_ERROR - indicating that a functional error has occurred in the Connect platform.
+        * PAYMENT_PLATFORM_ERROR - indicating that a functional error has occurred in the Payment platform.
+        * IO_ERROR - indicating that a technical error has occurred within the Connect platform or between Connect and any of the payment platforms or third party systems.
+
+        Type: str
+        """
+        return self.__category
+
+    @category.setter
+    def category(self, value: Optional[str]) -> None:
+        self.__category = value
+
+    @property
+    def code(self) -> Optional[str]:
+        """
+        | Error code
+
+        Type: str
+        """
+        return self.__code
+
+    @code.setter
+    def code(self, value: Optional[str]) -> None:
+        self.__code = value
+
+    @property
+    def http_status_code(self) -> Optional[int]:
+        """
+        | HTTP status code for this error that can be used to determine the type of error
+
+        Type: int
+        """
+        return self.__http_status_code
+
+    @http_status_code.setter
+    def http_status_code(self, value: Optional[int]) -> None:
+        self.__http_status_code = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | ID of the error. This is a short human-readable message that briefly describes the error.
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def message(self) -> Optional[str]:
+        """
+        | Human-readable error message that is not meant to be relayed to customer as it might tip off people who are trying to commit fraud
+
+        Type: str
+        """
+        return self.__message
+
+    @message.setter
+    def message(self, value: Optional[str]) -> None:
+        self.__message = value
+
+    @property
+    def property_name(self) -> Optional[str]:
+        """
+        | Returned only if the error relates to a value that was missing or incorrect.
+        | Contains a location path to the value as a JSonata query <http://docs.jsonata.org/basic.html>.
+        | Some common examples:
+        
+        * a.b selects the value of property b of root property a,
+        * a[1] selects the first element of the array in root property a,
+        * a[b='some value'] selects all elements of the array in root property a that have a property b with value 'some value'.
+
+        Type: str
+        """
+        return self.__property_name
+
+    @property_name.setter
+    def property_name(self, value: Optional[str]) -> None:
+        self.__property_name = value
+
+    @property
+    def request_id(self) -> Optional[str]:
+        """
+        | ID of the request that can be used for debugging purposes
+
+        Type: str
+        """
+        return self.__request_id
+
+    @request_id.setter
+    def request_id(self, value: Optional[str]) -> None:
+        self.__request_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(APIError, self).to_dictionary()
+        if self.category is not None:
+            dictionary['category'] = self.category
+        if self.code is not None:
+            dictionary['code'] = self.code
+        if self.http_status_code is not None:
+            dictionary['httpStatusCode'] = self.http_status_code
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.message is not None:
+            dictionary['message'] = self.message
+        if self.property_name is not None:
+            dictionary['propertyName'] = self.property_name
+        if self.request_id is not None:
+            dictionary['requestId'] = self.request_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'APIError':
+        super(APIError, self).from_dictionary(dictionary)
+        if 'category' in dictionary:
+            self.category = dictionary['category']
+        if 'code' in dictionary:
+            self.code = dictionary['code']
+        if 'httpStatusCode' in dictionary:
+            self.http_status_code = dictionary['httpStatusCode']
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'message' in dictionary:
+            self.message = dictionary['message']
+        if 'propertyName' in dictionary:
+            self.property_name = dictionary['propertyName']
+        if 'requestId' in dictionary:
+            self.request_id = dictionary['requestId']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/approve_payment_card_payment_method_specific_output.py

@@ -0,0 +1,45 @@
+# -*- 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 ApprovePaymentCardPaymentMethodSpecificOutput(DataObject):
+
+    __void_response_id: Optional[str] = None
+
+    @property
+    def void_response_id(self) -> Optional[str]:
+        """
+        | Result of the authorization reversal request
+        
+        | Possible values are:
+        
+        * 00 - Successful reversal
+        * 0, 8 or 11 - Reversal request submitted
+        * 5 or 55 - Reversal request declined or referred
+        * empty or 98 - The provider did not provide a response
+
+        Type: str
+        """
+        return self.__void_response_id
+
+    @void_response_id.setter
+    def void_response_id(self, value: Optional[str]) -> None:
+        self.__void_response_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApprovePaymentCardPaymentMethodSpecificOutput, self).to_dictionary()
+        if self.void_response_id is not None:
+            dictionary['voidResponseId'] = self.void_response_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApprovePaymentCardPaymentMethodSpecificOutput':
+        super(ApprovePaymentCardPaymentMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'voidResponseId' in dictionary:
+            self.void_response_id = dictionary['voidResponseId']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/approve_payment_direct_debit_payment_method_specific_input.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.approve_payment_payment_method_specific_input import ApprovePaymentPaymentMethodSpecificInput
+
+
+class ApprovePaymentDirectDebitPaymentMethodSpecificInput(ApprovePaymentPaymentMethodSpecificInput):
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApprovePaymentDirectDebitPaymentMethodSpecificInput, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApprovePaymentDirectDebitPaymentMethodSpecificInput':
+        super(ApprovePaymentDirectDebitPaymentMethodSpecificInput, self).from_dictionary(dictionary)
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/approve_payment_mobile_payment_method_specific_output.py

@@ -0,0 +1,48 @@
+# -*- 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 ApprovePaymentMobilePaymentMethodSpecificOutput(DataObject):
+    """
+    | Mobile payment specific response data
+    """
+
+    __void_response_id: Optional[str] = None
+
+    @property
+    def void_response_id(self) -> Optional[str]:
+        """
+        | Result of the authorization reversal request
+        
+        | Possible values are:
+        
+        * 00 - Successful reversal
+        * 0, 8 or 11 - Reversal request submitted
+        * 5 or 55 - Reversal request declined or referred
+        * empty or 98 - The provider did not provide a response
+
+        Type: str
+        """
+        return self.__void_response_id
+
+    @void_response_id.setter
+    def void_response_id(self, value: Optional[str]) -> None:
+        self.__void_response_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApprovePaymentMobilePaymentMethodSpecificOutput, self).to_dictionary()
+        if self.void_response_id is not None:
+            dictionary['voidResponseId'] = self.void_response_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApprovePaymentMobilePaymentMethodSpecificOutput':
+        super(ApprovePaymentMobilePaymentMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'voidResponseId' in dictionary:
+            self.void_response_id = dictionary['voidResponseId']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/approve_payment_non_sepa_direct_debit_payment_method_specific_input.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.approve_payment_direct_debit_payment_method_specific_input import ApprovePaymentDirectDebitPaymentMethodSpecificInput
+
+
+class ApprovePaymentNonSepaDirectDebitPaymentMethodSpecificInput(ApprovePaymentDirectDebitPaymentMethodSpecificInput):
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApprovePaymentNonSepaDirectDebitPaymentMethodSpecificInput, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApprovePaymentNonSepaDirectDebitPaymentMethodSpecificInput':
+        super(ApprovePaymentNonSepaDirectDebitPaymentMethodSpecificInput, self).from_dictionary(dictionary)
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/approve_payment_payment_method_specific_input.py

@@ -0,0 +1,57 @@
+# -*- 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 ApprovePaymentPaymentMethodSpecificInput(DataObject):
+
+    __date_collect: Optional[str] = None
+    __token: Optional[str] = None
+
+    @property
+    def date_collect(self) -> Optional[str]:
+        """
+        | The desired date for the collection
+        | Format: YYYYMMDD
+
+        Type: str
+        """
+        return self.__date_collect
+
+    @date_collect.setter
+    def date_collect(self, value: Optional[str]) -> None:
+        self.__date_collect = value
+
+    @property
+    def token(self) -> Optional[str]:
+        """
+        | Token containing tokenized bank account details
+
+        Type: str
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value: Optional[str]) -> None:
+        self.__token = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApprovePaymentPaymentMethodSpecificInput, self).to_dictionary()
+        if self.date_collect is not None:
+            dictionary['dateCollect'] = self.date_collect
+        if self.token is not None:
+            dictionary['token'] = self.token
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApprovePaymentPaymentMethodSpecificInput':
+        super(ApprovePaymentPaymentMethodSpecificInput, self).from_dictionary(dictionary)
+        if 'dateCollect' in dictionary:
+            self.date_collect = dictionary['dateCollect']
+        if 'token' in dictionary:
+            self.token = dictionary['token']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/approve_payment_request.py

@@ -0,0 +1,104 @@
+# -*- 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.approve_payment_non_sepa_direct_debit_payment_method_specific_input import ApprovePaymentNonSepaDirectDebitPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.approve_payment_sepa_direct_debit_payment_method_specific_input import ApprovePaymentSepaDirectDebitPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.order_approve_payment import OrderApprovePayment
+
+
+class ApprovePaymentRequest(DataObject):
+
+    __amount: Optional[int] = None
+    __direct_debit_payment_method_specific_input: Optional[ApprovePaymentNonSepaDirectDebitPaymentMethodSpecificInput] = None
+    __order: Optional[OrderApprovePayment] = None
+    __sepa_direct_debit_payment_method_specific_input: Optional[ApprovePaymentSepaDirectDebitPaymentMethodSpecificInput] = None
+
+    @property
+    def amount(self) -> Optional[int]:
+        """
+        | In case you want to approve the capture of a different lower amount you can specify this here (specified in cents, where single digit currencies are presumed to have 2 digits)
+
+        Type: int
+        """
+        return self.__amount
+
+    @amount.setter
+    def amount(self, value: Optional[int]) -> None:
+        self.__amount = value
+
+    @property
+    def direct_debit_payment_method_specific_input(self) -> Optional[ApprovePaymentNonSepaDirectDebitPaymentMethodSpecificInput]:
+        """
+        | Object that holds non-SEPA Direct Debit specific input data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.approve_payment_non_sepa_direct_debit_payment_method_specific_input.ApprovePaymentNonSepaDirectDebitPaymentMethodSpecificInput`
+        """
+        return self.__direct_debit_payment_method_specific_input
+
+    @direct_debit_payment_method_specific_input.setter
+    def direct_debit_payment_method_specific_input(self, value: Optional[ApprovePaymentNonSepaDirectDebitPaymentMethodSpecificInput]) -> None:
+        self.__direct_debit_payment_method_specific_input = value
+
+    @property
+    def order(self) -> Optional[OrderApprovePayment]:
+        """
+        | Object that holds the order data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.order_approve_payment.OrderApprovePayment`
+        """
+        return self.__order
+
+    @order.setter
+    def order(self, value: Optional[OrderApprovePayment]) -> None:
+        self.__order = value
+
+    @property
+    def sepa_direct_debit_payment_method_specific_input(self) -> Optional[ApprovePaymentSepaDirectDebitPaymentMethodSpecificInput]:
+        """
+        | Object that holds SEPA Direct Debit specific input data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.approve_payment_sepa_direct_debit_payment_method_specific_input.ApprovePaymentSepaDirectDebitPaymentMethodSpecificInput`
+        """
+        return self.__sepa_direct_debit_payment_method_specific_input
+
+    @sepa_direct_debit_payment_method_specific_input.setter
+    def sepa_direct_debit_payment_method_specific_input(self, value: Optional[ApprovePaymentSepaDirectDebitPaymentMethodSpecificInput]) -> None:
+        self.__sepa_direct_debit_payment_method_specific_input = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApprovePaymentRequest, self).to_dictionary()
+        if self.amount is not None:
+            dictionary['amount'] = self.amount
+        if self.direct_debit_payment_method_specific_input is not None:
+            dictionary['directDebitPaymentMethodSpecificInput'] = self.direct_debit_payment_method_specific_input.to_dictionary()
+        if self.order is not None:
+            dictionary['order'] = self.order.to_dictionary()
+        if self.sepa_direct_debit_payment_method_specific_input is not None:
+            dictionary['sepaDirectDebitPaymentMethodSpecificInput'] = self.sepa_direct_debit_payment_method_specific_input.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApprovePaymentRequest':
+        super(ApprovePaymentRequest, self).from_dictionary(dictionary)
+        if 'amount' in dictionary:
+            self.amount = dictionary['amount']
+        if 'directDebitPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['directDebitPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['directDebitPaymentMethodSpecificInput']))
+            value = ApprovePaymentNonSepaDirectDebitPaymentMethodSpecificInput()
+            self.direct_debit_payment_method_specific_input = value.from_dictionary(dictionary['directDebitPaymentMethodSpecificInput'])
+        if 'order' in dictionary:
+            if not isinstance(dictionary['order'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['order']))
+            value = OrderApprovePayment()
+            self.order = value.from_dictionary(dictionary['order'])
+        if 'sepaDirectDebitPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['sepaDirectDebitPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sepaDirectDebitPaymentMethodSpecificInput']))
+            value = ApprovePaymentSepaDirectDebitPaymentMethodSpecificInput()
+            self.sepa_direct_debit_payment_method_specific_input = value.from_dictionary(dictionary['sepaDirectDebitPaymentMethodSpecificInput'])
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/approve_payment_sepa_direct_debit_payment_method_specific_input.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.approve_payment_direct_debit_payment_method_specific_input import ApprovePaymentDirectDebitPaymentMethodSpecificInput
+
+
+class ApprovePaymentSepaDirectDebitPaymentMethodSpecificInput(ApprovePaymentDirectDebitPaymentMethodSpecificInput):
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApprovePaymentSepaDirectDebitPaymentMethodSpecificInput, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApprovePaymentSepaDirectDebitPaymentMethodSpecificInput':
+        super(ApprovePaymentSepaDirectDebitPaymentMethodSpecificInput, self).from_dictionary(dictionary)
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/approve_payout_request.py

@@ -0,0 +1,39 @@
+# -*- 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 ApprovePayoutRequest(DataObject):
+
+    __date_payout: Optional[str] = None
+
+    @property
+    def date_payout(self) -> Optional[str]:
+        """
+        | The desired date for the payout
+        | Format: YYYYMMDD
+
+        Type: str
+        """
+        return self.__date_payout
+
+    @date_payout.setter
+    def date_payout(self, value: Optional[str]) -> None:
+        self.__date_payout = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApprovePayoutRequest, self).to_dictionary()
+        if self.date_payout is not None:
+            dictionary['datePayout'] = self.date_payout
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApprovePayoutRequest':
+        super(ApprovePayoutRequest, self).from_dictionary(dictionary)
+        if 'datePayout' in dictionary:
+            self.date_payout = dictionary['datePayout']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/approve_refund_request.py

@@ -0,0 +1,38 @@
+# -*- 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 ApproveRefundRequest(DataObject):
+
+    __amount: Optional[int] = None
+
+    @property
+    def amount(self) -> Optional[int]:
+        """
+        | Refund amount to be approved
+
+        Type: int
+        """
+        return self.__amount
+
+    @amount.setter
+    def amount(self, value: Optional[int]) -> None:
+        self.__amount = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApproveRefundRequest, self).to_dictionary()
+        if self.amount is not None:
+            dictionary['amount'] = self.amount
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApproveRefundRequest':
+        super(ApproveRefundRequest, self).from_dictionary(dictionary)
+        if 'amount' in dictionary:
+            self.amount = dictionary['amount']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/approve_token_request.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.mandate_approval import MandateApproval
+
+
+class ApproveTokenRequest(MandateApproval):
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApproveTokenRequest, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApproveTokenRequest':
+        super(ApproveTokenRequest, self).from_dictionary(dictionary)
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/authentication_indicator.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.abstract_indicator import AbstractIndicator
+
+
+class AuthenticationIndicator(AbstractIndicator):
+    """
+    | Indicates if the payment product supports 3D Security (mandatory, optional or not needed).
+    """
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(AuthenticationIndicator, self).to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AuthenticationIndicator':
+        super(AuthenticationIndicator, self).from_dictionary(dictionary)
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/bank_account.py

@@ -0,0 +1,38 @@
+# -*- 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 BankAccount(DataObject):
+
+    __account_holder_name: Optional[str] = None
+
+    @property
+    def account_holder_name(self) -> Optional[str]:
+        """
+        | Name in which the account is held.
+
+        Type: str
+        """
+        return self.__account_holder_name
+
+    @account_holder_name.setter
+    def account_holder_name(self, value: Optional[str]) -> None:
+        self.__account_holder_name = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(BankAccount, self).to_dictionary()
+        if self.account_holder_name is not None:
+            dictionary['accountHolderName'] = self.account_holder_name
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'BankAccount':
+        super(BankAccount, self).from_dictionary(dictionary)
+        if 'accountHolderName' in dictionary:
+            self.account_holder_name = dictionary['accountHolderName']
+        return self