connect-sdk-python3 4.0.0__zip → 4.1.0__zip

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

@@ -1,77 +0,0 @@
-# -*- 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.0/worldline/connect/sdk/v1/domain/external_cardholder_authentication_data.py

@@ -1,237 +0,0 @@
-# -*- 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.0/worldline/connect/sdk/v1/domain/find_payments_response.py

@@ -1,101 +0,0 @@
-# -*- 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.0/worldline/connect/sdk/v1/domain/find_payouts_response.py

@@ -1,101 +0,0 @@
-# -*- 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.0/worldline/connect/sdk/v1/domain/find_refunds_response.py

@@ -1,101 +0,0 @@
-# -*- 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.0/worldline/connect/sdk/v1/domain/fixed_list_validator.py

@@ -1,45 +0,0 @@
-# -*- 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