connect-sdk-python3 3.47.0__zip → 4.0.1__zip

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

@@ -0,0 +1,77 @@
+# -*- 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 ExemptionOutput(DataObject):
+    """
+    | Object containing exemption output
+    """
+
+    __exemption_raised: Optional[str] = None
+    __exemption_rejection_reason: Optional[str] = None
+    __exemption_request: Optional[str] = None
+
+    @property
+    def exemption_raised(self) -> Optional[str]:
+        """
+        | Type of strong customer authentication (SCA) exemption that was raised towards the acquirer for this transaction.
+
+        Type: str
+        """
+        return self.__exemption_raised
+
+    @exemption_raised.setter
+    def exemption_raised(self, value: Optional[str]) -> None:
+        self.__exemption_raised = value
+
+    @property
+    def exemption_rejection_reason(self) -> Optional[str]:
+        """
+        | The request exemption could not be granted. The reason why is returned in this property.
+
+        Type: str
+        """
+        return self.__exemption_rejection_reason
+
+    @exemption_rejection_reason.setter
+    def exemption_rejection_reason(self, value: Optional[str]) -> None:
+        self.__exemption_rejection_reason = value
+
+    @property
+    def exemption_request(self) -> Optional[str]:
+        """
+        | Type of strong customer authentication (SCA) exemption requested by you for this transaction.
+
+        Type: str
+        """
+        return self.__exemption_request
+
+    @exemption_request.setter
+    def exemption_request(self, value: Optional[str]) -> None:
+        self.__exemption_request = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ExemptionOutput, self).to_dictionary()
+        if self.exemption_raised is not None:
+            dictionary['exemptionRaised'] = self.exemption_raised
+        if self.exemption_rejection_reason is not None:
+            dictionary['exemptionRejectionReason'] = self.exemption_rejection_reason
+        if self.exemption_request is not None:
+            dictionary['exemptionRequest'] = self.exemption_request
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ExemptionOutput':
+        super(ExemptionOutput, self).from_dictionary(dictionary)
+        if 'exemptionRaised' in dictionary:
+            self.exemption_raised = dictionary['exemptionRaised']
+        if 'exemptionRejectionReason' in dictionary:
+            self.exemption_rejection_reason = dictionary['exemptionRejectionReason']
+        if 'exemptionRequest' in dictionary:
+            self.exemption_request = dictionary['exemptionRequest']
+        return self

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

@@ -0,0 +1,237 @@
+# -*- 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 ExternalCardholderAuthenticationData(DataObject):
+    """
+    | Object containing 3D secure details.
+    """
+
+    __acs_transaction_id: Optional[str] = None
+    __applied_exemption: Optional[str] = None
+    __cavv: Optional[str] = None
+    __cavv_algorithm: Optional[str] = None
+    __directory_server_transaction_id: Optional[str] = None
+    __eci: Optional[int] = None
+    __scheme_risk_score: Optional[int] = None
+    __three_d_secure_version: Optional[str] = None
+    __three_d_server_transaction_id: Optional[str] = None
+    __validation_result: Optional[str] = None
+    __xid: Optional[str] = None
+
+    @property
+    def acs_transaction_id(self) -> Optional[str]:
+        """
+        | Identifier of the authenticated transaction at the ACS/Issuer.
+
+        Type: str
+        """
+        return self.__acs_transaction_id
+
+    @acs_transaction_id.setter
+    def acs_transaction_id(self, value: Optional[str]) -> None:
+        self.__acs_transaction_id = value
+
+    @property
+    def applied_exemption(self) -> Optional[str]:
+        """
+        | Exemption code from Carte Bancaire (130) (unknown possible values so far -free format).
+
+        Type: str
+        """
+        return self.__applied_exemption
+
+    @applied_exemption.setter
+    def applied_exemption(self, value: Optional[str]) -> None:
+        self.__applied_exemption = value
+
+    @property
+    def cavv(self) -> Optional[str]:
+        """
+        | The CAVV (cardholder authentication verification value) or AAV (accountholder authentication value) provides an authentication validation value.
+
+        Type: str
+        """
+        return self.__cavv
+
+    @cavv.setter
+    def cavv(self, value: Optional[str]) -> None:
+        self.__cavv = value
+
+    @property
+    def cavv_algorithm(self) -> Optional[str]:
+        """
+        | The algorithm, from your 3D Secure provider, used to generate the authentication CAVV.
+
+        Type: str
+        """
+        return self.__cavv_algorithm
+
+    @cavv_algorithm.setter
+    def cavv_algorithm(self, value: Optional[str]) -> None:
+        self.__cavv_algorithm = value
+
+    @property
+    def directory_server_transaction_id(self) -> Optional[str]:
+        """
+        | The 3-D Secure Directory Server transaction ID that is used for the 3D Authentication
+
+        Type: str
+        """
+        return self.__directory_server_transaction_id
+
+    @directory_server_transaction_id.setter
+    def directory_server_transaction_id(self, value: Optional[str]) -> None:
+        self.__directory_server_transaction_id = value
+
+    @property
+    def eci(self) -> Optional[int]:
+        """
+        | Electronic Commerce Indicator provides authentication validation results returned after AUTHENTICATIONVALIDATION
+        
+        * 0 = No authentication, Internet (no liability shift, not a 3D Secure transaction)
+        * 1 = Authentication attempted (MasterCard)
+        * 2 = Successful authentication (MasterCard)
+        * 5 = Successful authentication (Visa, Diners Club, Amex)
+        * 6 = Authentication attempted (Visa, Diners Club, Amex)
+        * 7 = No authentication, Internet (no liability shift, not a 3D Secure transaction)
+        * (empty) = Not checked or not enrolled
+
+        Type: int
+        """
+        return self.__eci
+
+    @eci.setter
+    def eci(self, value: Optional[int]) -> None:
+        self.__eci = value
+
+    @property
+    def scheme_risk_score(self) -> Optional[int]:
+        """
+        | Global score calculated by the Carte Bancaire (130) Scoring platform. Possible values from 0 to 99.
+
+        Type: int
+        """
+        return self.__scheme_risk_score
+
+    @scheme_risk_score.setter
+    def scheme_risk_score(self, value: Optional[int]) -> None:
+        self.__scheme_risk_score = value
+
+    @property
+    def three_d_secure_version(self) -> Optional[str]:
+        """
+        | The 3-D Secure version used for the authentication. Possible values:
+        
+        * v1
+        * v2
+        * 1.0.2
+        * 2.1.0
+        * 2.2.0
+
+        Type: str
+        """
+        return self.__three_d_secure_version
+
+    @three_d_secure_version.setter
+    def three_d_secure_version(self, value: Optional[str]) -> None:
+        self.__three_d_secure_version = value
+
+    @property
+    def three_d_server_transaction_id(self) -> Optional[str]:
+        """
+        | The 3-D Secure Server transaction ID that is used for the 3-D Secure version 2 Authentication.
+
+        Type: str
+
+        Deprecated; No replacement
+        """
+        return self.__three_d_server_transaction_id
+
+    @three_d_server_transaction_id.setter
+    def three_d_server_transaction_id(self, value: Optional[str]) -> None:
+        self.__three_d_server_transaction_id = value
+
+    @property
+    def validation_result(self) -> Optional[str]:
+        """
+        | The 3D Secure authentication result from your 3D Secure provider.
+
+        Type: str
+        """
+        return self.__validation_result
+
+    @validation_result.setter
+    def validation_result(self, value: Optional[str]) -> None:
+        self.__validation_result = value
+
+    @property
+    def xid(self) -> Optional[str]:
+        """
+        | The transaction ID that is used for the 3D Authentication
+
+        Type: str
+        """
+        return self.__xid
+
+    @xid.setter
+    def xid(self, value: Optional[str]) -> None:
+        self.__xid = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ExternalCardholderAuthenticationData, self).to_dictionary()
+        if self.acs_transaction_id is not None:
+            dictionary['acsTransactionId'] = self.acs_transaction_id
+        if self.applied_exemption is not None:
+            dictionary['appliedExemption'] = self.applied_exemption
+        if self.cavv is not None:
+            dictionary['cavv'] = self.cavv
+        if self.cavv_algorithm is not None:
+            dictionary['cavvAlgorithm'] = self.cavv_algorithm
+        if self.directory_server_transaction_id is not None:
+            dictionary['directoryServerTransactionId'] = self.directory_server_transaction_id
+        if self.eci is not None:
+            dictionary['eci'] = self.eci
+        if self.scheme_risk_score is not None:
+            dictionary['schemeRiskScore'] = self.scheme_risk_score
+        if self.three_d_secure_version is not None:
+            dictionary['threeDSecureVersion'] = self.three_d_secure_version
+        if self.three_d_server_transaction_id is not None:
+            dictionary['threeDServerTransactionId'] = self.three_d_server_transaction_id
+        if self.validation_result is not None:
+            dictionary['validationResult'] = self.validation_result
+        if self.xid is not None:
+            dictionary['xid'] = self.xid
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ExternalCardholderAuthenticationData':
+        super(ExternalCardholderAuthenticationData, self).from_dictionary(dictionary)
+        if 'acsTransactionId' in dictionary:
+            self.acs_transaction_id = dictionary['acsTransactionId']
+        if 'appliedExemption' in dictionary:
+            self.applied_exemption = dictionary['appliedExemption']
+        if 'cavv' in dictionary:
+            self.cavv = dictionary['cavv']
+        if 'cavvAlgorithm' in dictionary:
+            self.cavv_algorithm = dictionary['cavvAlgorithm']
+        if 'directoryServerTransactionId' in dictionary:
+            self.directory_server_transaction_id = dictionary['directoryServerTransactionId']
+        if 'eci' in dictionary:
+            self.eci = dictionary['eci']
+        if 'schemeRiskScore' in dictionary:
+            self.scheme_risk_score = dictionary['schemeRiskScore']
+        if 'threeDSecureVersion' in dictionary:
+            self.three_d_secure_version = dictionary['threeDSecureVersion']
+        if 'threeDServerTransactionId' in dictionary:
+            self.three_d_server_transaction_id = dictionary['threeDServerTransactionId']
+        if 'validationResult' in dictionary:
+            self.validation_result = dictionary['validationResult']
+        if 'xid' in dictionary:
+            self.xid = dictionary['xid']
+        return self

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

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import List, Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.payment import Payment
+
+
+class FindPaymentsResponse(DataObject):
+
+    __limit: Optional[int] = None
+    __offset: Optional[int] = None
+    __payments: Optional[List[Payment]] = None
+    __total_count: Optional[int] = None
+
+    @property
+    def limit(self) -> Optional[int]:
+        """
+        | The limit you used in the request.
+
+        Type: int
+        """
+        return self.__limit
+
+    @limit.setter
+    def limit(self, value: Optional[int]) -> None:
+        self.__limit = value
+
+    @property
+    def offset(self) -> Optional[int]:
+        """
+        | The offset you used in the request.
+
+        Type: int
+        """
+        return self.__offset
+
+    @offset.setter
+    def offset(self, value: Optional[int]) -> None:
+        self.__offset = value
+
+    @property
+    def payments(self) -> Optional[List[Payment]]:
+        """
+        | A list of payments that matched your filter, starting at the given offset and limited to the given limit.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.payment.Payment`]
+        """
+        return self.__payments
+
+    @payments.setter
+    def payments(self, value: Optional[List[Payment]]) -> None:
+        self.__payments = value
+
+    @property
+    def total_count(self) -> Optional[int]:
+        """
+        | The total number of payments that matched your filter.
+
+        Type: int
+        """
+        return self.__total_count
+
+    @total_count.setter
+    def total_count(self, value: Optional[int]) -> None:
+        self.__total_count = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(FindPaymentsResponse, self).to_dictionary()
+        if self.limit is not None:
+            dictionary['limit'] = self.limit
+        if self.offset is not None:
+            dictionary['offset'] = self.offset
+        if self.payments is not None:
+            dictionary['payments'] = []
+            for element in self.payments:
+                if element is not None:
+                    dictionary['payments'].append(element.to_dictionary())
+        if self.total_count is not None:
+            dictionary['totalCount'] = self.total_count
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'FindPaymentsResponse':
+        super(FindPaymentsResponse, self).from_dictionary(dictionary)
+        if 'limit' in dictionary:
+            self.limit = dictionary['limit']
+        if 'offset' in dictionary:
+            self.offset = dictionary['offset']
+        if 'payments' in dictionary:
+            if not isinstance(dictionary['payments'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['payments']))
+            self.payments = []
+            for element in dictionary['payments']:
+                value = Payment()
+                self.payments.append(value.from_dictionary(element))
+        if 'totalCount' in dictionary:
+            self.total_count = dictionary['totalCount']
+        return self

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

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import List, Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.payout_result import PayoutResult
+
+
+class FindPayoutsResponse(DataObject):
+
+    __limit: Optional[int] = None
+    __offset: Optional[int] = None
+    __payouts: Optional[List[PayoutResult]] = None
+    __total_count: Optional[int] = None
+
+    @property
+    def limit(self) -> Optional[int]:
+        """
+        | The limit you used in the request.
+
+        Type: int
+        """
+        return self.__limit
+
+    @limit.setter
+    def limit(self, value: Optional[int]) -> None:
+        self.__limit = value
+
+    @property
+    def offset(self) -> Optional[int]:
+        """
+        | The offset you used in the request.
+
+        Type: int
+        """
+        return self.__offset
+
+    @offset.setter
+    def offset(self, value: Optional[int]) -> None:
+        self.__offset = value
+
+    @property
+    def payouts(self) -> Optional[List[PayoutResult]]:
+        """
+        | A list of payouts that matched your filter, starting at the given offset and limited to the given limit.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.payout_result.PayoutResult`]
+        """
+        return self.__payouts
+
+    @payouts.setter
+    def payouts(self, value: Optional[List[PayoutResult]]) -> None:
+        self.__payouts = value
+
+    @property
+    def total_count(self) -> Optional[int]:
+        """
+        | The total number of payouts that matched your filter.
+
+        Type: int
+        """
+        return self.__total_count
+
+    @total_count.setter
+    def total_count(self, value: Optional[int]) -> None:
+        self.__total_count = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(FindPayoutsResponse, self).to_dictionary()
+        if self.limit is not None:
+            dictionary['limit'] = self.limit
+        if self.offset is not None:
+            dictionary['offset'] = self.offset
+        if self.payouts is not None:
+            dictionary['payouts'] = []
+            for element in self.payouts:
+                if element is not None:
+                    dictionary['payouts'].append(element.to_dictionary())
+        if self.total_count is not None:
+            dictionary['totalCount'] = self.total_count
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'FindPayoutsResponse':
+        super(FindPayoutsResponse, self).from_dictionary(dictionary)
+        if 'limit' in dictionary:
+            self.limit = dictionary['limit']
+        if 'offset' in dictionary:
+            self.offset = dictionary['offset']
+        if 'payouts' in dictionary:
+            if not isinstance(dictionary['payouts'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['payouts']))
+            self.payouts = []
+            for element in dictionary['payouts']:
+                value = PayoutResult()
+                self.payouts.append(value.from_dictionary(element))
+        if 'totalCount' in dictionary:
+            self.total_count = dictionary['totalCount']
+        return self

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

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from typing import List, Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.refund_result import RefundResult
+
+
+class FindRefundsResponse(DataObject):
+
+    __limit: Optional[int] = None
+    __offset: Optional[int] = None
+    __refunds: Optional[List[RefundResult]] = None
+    __total_count: Optional[int] = None
+
+    @property
+    def limit(self) -> Optional[int]:
+        """
+        | The limit you used in the request.
+
+        Type: int
+        """
+        return self.__limit
+
+    @limit.setter
+    def limit(self, value: Optional[int]) -> None:
+        self.__limit = value
+
+    @property
+    def offset(self) -> Optional[int]:
+        """
+        | The offset you used in the request.
+
+        Type: int
+        """
+        return self.__offset
+
+    @offset.setter
+    def offset(self, value: Optional[int]) -> None:
+        self.__offset = value
+
+    @property
+    def refunds(self) -> Optional[List[RefundResult]]:
+        """
+        | A list of refunds that matched your filter, starting at the given offset and limited to the given limit.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.refund_result.RefundResult`]
+        """
+        return self.__refunds
+
+    @refunds.setter
+    def refunds(self, value: Optional[List[RefundResult]]) -> None:
+        self.__refunds = value
+
+    @property
+    def total_count(self) -> Optional[int]:
+        """
+        | The total number of refunds that matched your filter.
+
+        Type: int
+        """
+        return self.__total_count
+
+    @total_count.setter
+    def total_count(self, value: Optional[int]) -> None:
+        self.__total_count = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(FindRefundsResponse, self).to_dictionary()
+        if self.limit is not None:
+            dictionary['limit'] = self.limit
+        if self.offset is not None:
+            dictionary['offset'] = self.offset
+        if self.refunds is not None:
+            dictionary['refunds'] = []
+            for element in self.refunds:
+                if element is not None:
+                    dictionary['refunds'].append(element.to_dictionary())
+        if self.total_count is not None:
+            dictionary['totalCount'] = self.total_count
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'FindRefundsResponse':
+        super(FindRefundsResponse, self).from_dictionary(dictionary)
+        if 'limit' in dictionary:
+            self.limit = dictionary['limit']
+        if 'offset' in dictionary:
+            self.offset = dictionary['offset']
+        if 'refunds' in dictionary:
+            if not isinstance(dictionary['refunds'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['refunds']))
+            self.refunds = []
+            for element in dictionary['refunds']:
+                value = RefundResult()
+                self.refunds.append(value.from_dictionary(element))
+        if 'totalCount' in dictionary:
+            self.total_count = dictionary['totalCount']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/fixed_list_validator.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 List, Optional
+
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class FixedListValidator(DataObject):
+
+    __allowed_values: Optional[List[str]] = None
+
+    @property
+    def allowed_values(self) -> Optional[List[str]]:
+        """
+        | List of the allowed values that the field will be validated against
+
+        Type: list[str]
+        """
+        return self.__allowed_values
+
+    @allowed_values.setter
+    def allowed_values(self, value: Optional[List[str]]) -> None:
+        self.__allowed_values = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(FixedListValidator, self).to_dictionary()
+        if self.allowed_values is not None:
+            dictionary['allowedValues'] = []
+            for element in self.allowed_values:
+                if element is not None:
+                    dictionary['allowedValues'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'FixedListValidator':
+        super(FixedListValidator, self).from_dictionary(dictionary)
+        if 'allowedValues' in dictionary:
+            if not isinstance(dictionary['allowedValues'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['allowedValues']))
+            self.allowed_values = []
+            for element in dictionary['allowedValues']:
+                self.allowed_values.append(element)
+        return self