connect-sdk-python3 4.0.0__zip → 4.1.0__zip

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/debtor.py

@@ -0,0 +1,225 @@
+# -*- 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 Debtor(DataObject):
+    """
+    | This object describes the the consumer (or company) that will be debited and it is part of a SEPA Direct Debit Mandate
+    """
+
+    __additional_address_info: Optional[str] = None
+    __city: Optional[str] = None
+    __country_code: Optional[str] = None
+    __first_name: Optional[str] = None
+    __house_number: Optional[str] = None
+    __state: Optional[str] = None
+    __state_code: Optional[str] = None
+    __street: Optional[str] = None
+    __surname: Optional[str] = None
+    __surname_prefix: Optional[str] = None
+    __zip: Optional[str] = None
+
+    @property
+    def additional_address_info(self) -> Optional[str]:
+        """
+        | Additional information about the debtor's address, like Suite II, Apartment 2a
+
+        Type: str
+        """
+        return self.__additional_address_info
+
+    @additional_address_info.setter
+    def additional_address_info(self, value: Optional[str]) -> None:
+        self.__additional_address_info = value
+
+    @property
+    def city(self) -> Optional[str]:
+        """
+        | City of the debtor's address
+
+        Type: str
+        """
+        return self.__city
+
+    @city.setter
+    def city(self, value: Optional[str]) -> None:
+        self.__city = value
+
+    @property
+    def country_code(self) -> Optional[str]:
+        """
+        | ISO 3166-1 alpha-2 country code of the debtor's address
+
+        Type: str
+        """
+        return self.__country_code
+
+    @country_code.setter
+    def country_code(self, value: Optional[str]) -> None:
+        self.__country_code = value
+
+    @property
+    def first_name(self) -> Optional[str]:
+        """
+        | Debtor first name
+
+        Type: str
+        """
+        return self.__first_name
+
+    @first_name.setter
+    def first_name(self, value: Optional[str]) -> None:
+        self.__first_name = value
+
+    @property
+    def house_number(self) -> Optional[str]:
+        """
+        | House number of the debtor's address
+
+        Type: str
+        """
+        return self.__house_number
+
+    @house_number.setter
+    def house_number(self, value: Optional[str]) -> None:
+        self.__house_number = value
+
+    @property
+    def state(self) -> Optional[str]:
+        """
+        | State of debtor address
+
+        Type: str
+        """
+        return self.__state
+
+    @state.setter
+    def state(self, value: Optional[str]) -> None:
+        self.__state = value
+
+    @property
+    def state_code(self) -> Optional[str]:
+        """
+        | ISO 3166-2 alpha-3 state code
+        | Notes:
+        
+        * The maximum length for 3-D Secure version 2 is AN3.
+        * The maximum length for paymentProductId 1503 (Boleto) is AN2.
+
+        Type: str
+        """
+        return self.__state_code
+
+    @state_code.setter
+    def state_code(self, value: Optional[str]) -> None:
+        self.__state_code = value
+
+    @property
+    def street(self) -> Optional[str]:
+        """
+        | Street of debtor's address
+
+        Type: str
+        """
+        return self.__street
+
+    @street.setter
+    def street(self, value: Optional[str]) -> None:
+        self.__street = value
+
+    @property
+    def surname(self) -> Optional[str]:
+        """
+        | Debtor's last name
+
+        Type: str
+        """
+        return self.__surname
+
+    @surname.setter
+    def surname(self, value: Optional[str]) -> None:
+        self.__surname = value
+
+    @property
+    def surname_prefix(self) -> Optional[str]:
+        """
+        | Prefix of the debtor's last name
+
+        Type: str
+        """
+        return self.__surname_prefix
+
+    @surname_prefix.setter
+    def surname_prefix(self, value: Optional[str]) -> None:
+        self.__surname_prefix = value
+
+    @property
+    def zip(self) -> Optional[str]:
+        """
+        | ZIP code of the debtor's address
+
+        Type: str
+        """
+        return self.__zip
+
+    @zip.setter
+    def zip(self, value: Optional[str]) -> None:
+        self.__zip = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Debtor, self).to_dictionary()
+        if self.additional_address_info is not None:
+            dictionary['additionalAddressInfo'] = self.additional_address_info
+        if self.city is not None:
+            dictionary['city'] = self.city
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.first_name is not None:
+            dictionary['firstName'] = self.first_name
+        if self.house_number is not None:
+            dictionary['houseNumber'] = self.house_number
+        if self.state is not None:
+            dictionary['state'] = self.state
+        if self.state_code is not None:
+            dictionary['stateCode'] = self.state_code
+        if self.street is not None:
+            dictionary['street'] = self.street
+        if self.surname is not None:
+            dictionary['surname'] = self.surname
+        if self.surname_prefix is not None:
+            dictionary['surnamePrefix'] = self.surname_prefix
+        if self.zip is not None:
+            dictionary['zip'] = self.zip
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Debtor':
+        super(Debtor, self).from_dictionary(dictionary)
+        if 'additionalAddressInfo' in dictionary:
+            self.additional_address_info = dictionary['additionalAddressInfo']
+        if 'city' in dictionary:
+            self.city = dictionary['city']
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'firstName' in dictionary:
+            self.first_name = dictionary['firstName']
+        if 'houseNumber' in dictionary:
+            self.house_number = dictionary['houseNumber']
+        if 'state' in dictionary:
+            self.state = dictionary['state']
+        if 'stateCode' in dictionary:
+            self.state_code = dictionary['stateCode']
+        if 'street' in dictionary:
+            self.street = dictionary['street']
+        if 'surname' in dictionary:
+            self.surname = dictionary['surname']
+        if 'surnamePrefix' in dictionary:
+            self.surname_prefix = dictionary['surnamePrefix']
+        if 'zip' in dictionary:
+            self.zip = dictionary['zip']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/decrypted_payment_data.py

@@ -0,0 +1,198 @@
+# -*- 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 DecryptedPaymentData(DataObject):
+
+    __auth_method: Optional[str] = None
+    __cardholder_name: Optional[str] = None
+    __cryptogram: Optional[str] = None
+    __dpan: Optional[str] = None
+    __eci: Optional[int] = None
+    __expiry_date: Optional[str] = None
+    __pan: Optional[str] = None
+    __payment_method: Optional[str] = None
+
+    @property
+    def auth_method(self) -> Optional[str]:
+        """
+        | The type of payment credential which the customer used.
+        
+        * For Google Pay, maps to the paymentMethodDetails.authMethod property in the encrypted payment data.
+        
+        | .
+
+        Type: str
+
+        Deprecated; Use decryptedPaymentData.paymentMethod instead
+        """
+        return self.__auth_method
+
+    @auth_method.setter
+    def auth_method(self, value: Optional[str]) -> None:
+        self.__auth_method = value
+
+    @property
+    def cardholder_name(self) -> Optional[str]:
+        """
+        | Card holder's name on the card.
+        
+        * For Apple Pay, maps to the cardholderName property in the encrypted payment data.
+        * For Google Pay this is not available in the encrypted payment data, and can be omitted.
+
+        Type: str
+        """
+        return self.__cardholder_name
+
+    @cardholder_name.setter
+    def cardholder_name(self, value: Optional[str]) -> None:
+        self.__cardholder_name = value
+
+    @property
+    def cryptogram(self) -> Optional[str]:
+        """
+        | The 3D secure online payment cryptogram.
+        
+        * For Apple Pay, maps to the paymentData.onlinePaymentCryptogram property in the encrypted payment data.
+        * For Google Pay, maps to the paymentMethodDetails.cryptogram property in the encrypted payment data.
+        
+        | Not allowed for Google Pay if the authMethod in the response of Google is PAN_ONLY.
+
+        Type: str
+        """
+        return self.__cryptogram
+
+    @cryptogram.setter
+    def cryptogram(self, value: Optional[str]) -> None:
+        self.__cryptogram = value
+
+    @property
+    def dpan(self) -> Optional[str]:
+        """
+        | The device specific PAN.
+        
+        * For Apple Pay, maps to the applicationPrimaryAccountNumber property in the encrypted payment data.
+        * For Google Pay, maps to the paymentMethodDetails.dpan property in the encrypted payment data.
+        
+        | Not allowed for Google Pay if the authMethod in the response of Google is PAN_ONLY.
+
+        Type: str
+        """
+        return self.__dpan
+
+    @dpan.setter
+    def dpan(self, value: Optional[str]) -> None:
+        self.__dpan = value
+
+    @property
+    def eci(self) -> Optional[int]:
+        """
+        | The eci is Electronic Commerce Indicator.
+        
+        * For Apple Pay, maps to the paymentData.eciIndicator property in the encrypted payment data.
+        * For Google Pay, maps to the paymentMethodDetails.eciIndicator property in the encrypted payment data.
+
+        Type: int
+        """
+        return self.__eci
+
+    @eci.setter
+    def eci(self, value: Optional[int]) -> None:
+        self.__eci = value
+
+    @property
+    def expiry_date(self) -> Optional[str]:
+        """
+        | Expiry date of the card
+        | Format: MMYY.
+        
+        * For Apple Pay, maps to the applicationExpirationDate property in the encrypted payment data. This property is formatted as YYMMDD, so this needs to be converted to get a correctly formatted expiry date.
+        * For Google Pay, maps to the paymentMethodDetails.expirationMonth and paymentMethodDetails.expirationYear properties in the encrypted payment data. These need to be combined to get a correctly formatted expiry date.
+
+        Type: str
+        """
+        return self.__expiry_date
+
+    @expiry_date.setter
+    def expiry_date(self, value: Optional[str]) -> None:
+        self.__expiry_date = value
+
+    @property
+    def pan(self) -> Optional[str]:
+        """
+        | The non-device specific complete credit/debit card number (also know as the PAN).
+        
+        * For Apple Pay this is not available in the encrypted payment data, and must be omitted.
+        * For Google Pay, maps to the paymentMethodDetails.pan property in the encrypted payment data.
+        
+        | Not allowed for Google Pay if the authMethod in the response of Google is CRYPTOGRAM_3DS.
+
+        Type: str
+        """
+        return self.__pan
+
+    @pan.setter
+    def pan(self, value: Optional[str]) -> None:
+        self.__pan = value
+
+    @property
+    def payment_method(self) -> Optional[str]:
+        """
+        * In case Google provides in the response as authMethod: CRYPTOGRAM_3DS send in as value of this property TOKENIZED_CARD.
+        * In case Google provides in the response as authMethod: PAN_ONLY send in as value of this property CARD.
+        
+        | For Apple Pay this is not available in the encrypted payment data, and must be omitted.
+
+        Type: str
+        """
+        return self.__payment_method
+
+    @payment_method.setter
+    def payment_method(self, value: Optional[str]) -> None:
+        self.__payment_method = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(DecryptedPaymentData, self).to_dictionary()
+        if self.auth_method is not None:
+            dictionary['authMethod'] = self.auth_method
+        if self.cardholder_name is not None:
+            dictionary['cardholderName'] = self.cardholder_name
+        if self.cryptogram is not None:
+            dictionary['cryptogram'] = self.cryptogram
+        if self.dpan is not None:
+            dictionary['dpan'] = self.dpan
+        if self.eci is not None:
+            dictionary['eci'] = self.eci
+        if self.expiry_date is not None:
+            dictionary['expiryDate'] = self.expiry_date
+        if self.pan is not None:
+            dictionary['pan'] = self.pan
+        if self.payment_method is not None:
+            dictionary['paymentMethod'] = self.payment_method
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'DecryptedPaymentData':
+        super(DecryptedPaymentData, self).from_dictionary(dictionary)
+        if 'authMethod' in dictionary:
+            self.auth_method = dictionary['authMethod']
+        if 'cardholderName' in dictionary:
+            self.cardholder_name = dictionary['cardholderName']
+        if 'cryptogram' in dictionary:
+            self.cryptogram = dictionary['cryptogram']
+        if 'dpan' in dictionary:
+            self.dpan = dictionary['dpan']
+        if 'eci' in dictionary:
+            self.eci = dictionary['eci']
+        if 'expiryDate' in dictionary:
+            self.expiry_date = dictionary['expiryDate']
+        if 'pan' in dictionary:
+            self.pan = dictionary['pan']
+        if 'paymentMethod' in dictionary:
+            self.payment_method = dictionary['paymentMethod']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/device_fingerprint_details.py

@@ -0,0 +1,56 @@
+# -*- 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 DeviceFingerprintDetails(DataObject):
+
+    __payment_id: Optional[str] = None
+    __raw_device_fingerprint_output: Optional[str] = None
+
+    @property
+    def payment_id(self) -> Optional[str]:
+        """
+        | The ID of the payment that is linked to the Device Fingerprint data.
+
+        Type: str
+        """
+        return self.__payment_id
+
+    @payment_id.setter
+    def payment_id(self, value: Optional[str]) -> None:
+        self.__payment_id = value
+
+    @property
+    def raw_device_fingerprint_output(self) -> Optional[str]:
+        """
+        | The detailed data that was collected during the Device Fingerprint collection. The structure will be different depending on the collection method and device fingerprint partner used. Please contact us if you want more information on the details that are returned in this string.
+
+        Type: str
+        """
+        return self.__raw_device_fingerprint_output
+
+    @raw_device_fingerprint_output.setter
+    def raw_device_fingerprint_output(self, value: Optional[str]) -> None:
+        self.__raw_device_fingerprint_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(DeviceFingerprintDetails, self).to_dictionary()
+        if self.payment_id is not None:
+            dictionary['paymentId'] = self.payment_id
+        if self.raw_device_fingerprint_output is not None:
+            dictionary['rawDeviceFingerprintOutput'] = self.raw_device_fingerprint_output
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'DeviceFingerprintDetails':
+        super(DeviceFingerprintDetails, self).from_dictionary(dictionary)
+        if 'paymentId' in dictionary:
+            self.payment_id = dictionary['paymentId']
+        if 'rawDeviceFingerprintOutput' in dictionary:
+            self.raw_device_fingerprint_output = dictionary['rawDeviceFingerprintOutput']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/device_fingerprint_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 DeviceFingerprintRequest(DataObject):
+
+    __collector_callback: Optional[str] = None
+
+    @property
+    def collector_callback(self) -> Optional[str]:
+        """
+        | You can supply a JavaScript function call that will be called after the device fingerprint data collecting using the provided JavaScript snippet is finished. This will then be added to the snippet that is returned in the property html.
+
+        Type: str
+        """
+        return self.__collector_callback
+
+    @collector_callback.setter
+    def collector_callback(self, value: Optional[str]) -> None:
+        self.__collector_callback = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(DeviceFingerprintRequest, self).to_dictionary()
+        if self.collector_callback is not None:
+            dictionary['collectorCallback'] = self.collector_callback
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'DeviceFingerprintRequest':
+        super(DeviceFingerprintRequest, self).from_dictionary(dictionary)
+        if 'collectorCallback' in dictionary:
+            self.collector_callback = dictionary['collectorCallback']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/device_fingerprint_response.py

@@ -0,0 +1,56 @@
+# -*- 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 DeviceFingerprintResponse(DataObject):
+
+    __device_fingerprint_transaction_id: Optional[str] = None
+    __html: Optional[str] = None
+
+    @property
+    def device_fingerprint_transaction_id(self) -> Optional[str]:
+        """
+        | Contains the unique id which is used by the device fingerprint collector script. This must be used to set the property fraudFields.deviceFingerprintTransactionId in either in the CreatePayment.order.customer.device.deviceFingerprintTransactionId, the CreateRiskAssessmentCards.order.customer.device.deviceFingerprintTransactionId or the CreateRiskAssessmentBankaccounts.order.customer.device.deviceFingerprintTransactionId.
+
+        Type: str
+        """
+        return self.__device_fingerprint_transaction_id
+
+    @device_fingerprint_transaction_id.setter
+    def device_fingerprint_transaction_id(self, value: Optional[str]) -> None:
+        self.__device_fingerprint_transaction_id = value
+
+    @property
+    def html(self) -> Optional[str]:
+        """
+        | Contains the ready-to-use device fingerprint collector script. You have to inject it into your page and call it when the customer presses the final payment submit button. You should only call it once per payment request.
+
+        Type: str
+        """
+        return self.__html
+
+    @html.setter
+    def html(self, value: Optional[str]) -> None:
+        self.__html = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(DeviceFingerprintResponse, self).to_dictionary()
+        if self.device_fingerprint_transaction_id is not None:
+            dictionary['deviceFingerprintTransactionId'] = self.device_fingerprint_transaction_id
+        if self.html is not None:
+            dictionary['html'] = self.html
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'DeviceFingerprintResponse':
+        super(DeviceFingerprintResponse, self).from_dictionary(dictionary)
+        if 'deviceFingerprintTransactionId' in dictionary:
+            self.device_fingerprint_transaction_id = dictionary['deviceFingerprintTransactionId']
+        if 'html' in dictionary:
+            self.html = dictionary['html']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/device_render_options.py

@@ -0,0 +1,108 @@
+# -*- 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 DeviceRenderOptions(DataObject):
+    """
+    | Object containing rendering options of the device
+    """
+
+    __sdk_interface: Optional[str] = None
+    __sdk_ui_type: Optional[str] = None
+    __sdk_ui_types: Optional[List[str]] = None
+
+    @property
+    def sdk_interface(self) -> Optional[str]:
+        """
+        | Lists all of the SDK Interface types that the device supports for displaying specific challenge user interfaces within the SDK.
+        
+        
+        
+        * native = The app supports only a native user interface
+        * html = The app supports only an HTML user interface
+        * both = Both Native and HTML user interfaces are supported by the app
+
+        Type: str
+        """
+        return self.__sdk_interface
+
+    @sdk_interface.setter
+    def sdk_interface(self, value: Optional[str]) -> None:
+        self.__sdk_interface = value
+
+    @property
+    def sdk_ui_type(self) -> Optional[str]:
+        """
+        | Lists all UI types that the device supports for displaying specific challenge user interfaces within the SDK.
+        
+        
+        
+        * text = Text interface
+        * single-select = Select a single option
+        * multi-select = Select multiple options
+        * oob = Out of ounds
+        * html-other = HTML Other (only valid when cardPaymentMethodSpecificInput.threeDSecure.sdkData.deviceRenderOptions.sdkInterface is set to html)
+
+        Type: str
+
+        Deprecated; Use deviceRenderOptions.sdkUiTypes instead
+        """
+        return self.__sdk_ui_type
+
+    @sdk_ui_type.setter
+    def sdk_ui_type(self, value: Optional[str]) -> None:
+        self.__sdk_ui_type = value
+
+    @property
+    def sdk_ui_types(self) -> Optional[List[str]]:
+        """
+        | Lists all UI types that the device supports for displaying specific challenge user interfaces within the SDK.
+        
+        
+        
+        * text = Text interface
+        * single-select = Select a single option
+        * multi-select = Select multiple options
+        * oob = Out of ounds
+        * html-other = HTML Other (only valid when cardPaymentMethodSpecificInput.threeDSecure.sdkData.deviceRenderOptions.sdkInterface is set to html)
+
+        Type: list[str]
+        """
+        return self.__sdk_ui_types
+
+    @sdk_ui_types.setter
+    def sdk_ui_types(self, value: Optional[List[str]]) -> None:
+        self.__sdk_ui_types = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(DeviceRenderOptions, self).to_dictionary()
+        if self.sdk_interface is not None:
+            dictionary['sdkInterface'] = self.sdk_interface
+        if self.sdk_ui_type is not None:
+            dictionary['sdkUiType'] = self.sdk_ui_type
+        if self.sdk_ui_types is not None:
+            dictionary['sdkUiTypes'] = []
+            for element in self.sdk_ui_types:
+                if element is not None:
+                    dictionary['sdkUiTypes'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'DeviceRenderOptions':
+        super(DeviceRenderOptions, self).from_dictionary(dictionary)
+        if 'sdkInterface' in dictionary:
+            self.sdk_interface = dictionary['sdkInterface']
+        if 'sdkUiType' in dictionary:
+            self.sdk_ui_type = dictionary['sdkUiType']
+        if 'sdkUiTypes' in dictionary:
+            if not isinstance(dictionary['sdkUiTypes'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['sdkUiTypes']))
+            self.sdk_ui_types = []
+            for element in dictionary['sdkUiTypes']:
+                self.sdk_ui_types.append(element)
+        return self