connect-sdk-python3 4.0.0__zip → 4.0.1__zip

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/hosted_checkout_specific_output.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 HostedCheckoutSpecificOutput(DataObject):
+
+    __hosted_checkout_id: Optional[str] = None
+    __variant: Optional[str] = None
+
+    @property
+    def hosted_checkout_id(self) -> Optional[str]:
+        """
+        | The ID of the Hosted Checkout Session in which the payment was made.
+
+        Type: str
+        """
+        return self.__hosted_checkout_id
+
+    @hosted_checkout_id.setter
+    def hosted_checkout_id(self, value: Optional[str]) -> None:
+        self.__hosted_checkout_id = value
+
+    @property
+    def variant(self) -> Optional[str]:
+        """
+        | Using the Configuration Center it is possible to create multiple variations of your MyCheckout payment pages. By specifying a specific variant you can force the use of another variant then the default. This allows you to test out the effect of certain changes to your hosted mandate pages in a controlled manner. Please note that you need to specify the ID of the variant.
+
+        Type: str
+        """
+        return self.__variant
+
+    @variant.setter
+    def variant(self, value: Optional[str]) -> None:
+        self.__variant = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(HostedCheckoutSpecificOutput, self).to_dictionary()
+        if self.hosted_checkout_id is not None:
+            dictionary['hostedCheckoutId'] = self.hosted_checkout_id
+        if self.variant is not None:
+            dictionary['variant'] = self.variant
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'HostedCheckoutSpecificOutput':
+        super(HostedCheckoutSpecificOutput, self).from_dictionary(dictionary)
+        if 'hostedCheckoutId' in dictionary:
+            self.hosted_checkout_id = dictionary['hostedCheckoutId']
+        if 'variant' in dictionary:
+            self.variant = dictionary['variant']
+        return self

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

@@ -0,0 +1,95 @@
+# -*- 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 HostedFile(DataObject):
+    """
+    | File items.
+    """
+
+    __file_name: Optional[str] = None
+    __file_size: Optional[str] = None
+    __file_type: Optional[str] = None
+    __id: Optional[str] = None
+
+    @property
+    def file_name(self) -> Optional[str]:
+        """
+        | The name of the file.
+
+        Type: str
+        """
+        return self.__file_name
+
+    @file_name.setter
+    def file_name(self, value: Optional[str]) -> None:
+        self.__file_name = value
+
+    @property
+    def file_size(self) -> Optional[str]:
+        """
+        | The size of the file in bytes.
+
+        Type: str
+        """
+        return self.__file_size
+
+    @file_size.setter
+    def file_size(self, value: Optional[str]) -> None:
+        self.__file_size = value
+
+    @property
+    def file_type(self) -> Optional[str]:
+        """
+        | The type of the file.
+
+        Type: str
+        """
+        return self.__file_type
+
+    @file_type.setter
+    def file_type(self, value: Optional[str]) -> None:
+        self.__file_type = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | The numeric identifier of the file.
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(HostedFile, self).to_dictionary()
+        if self.file_name is not None:
+            dictionary['fileName'] = self.file_name
+        if self.file_size is not None:
+            dictionary['fileSize'] = self.file_size
+        if self.file_type is not None:
+            dictionary['fileType'] = self.file_type
+        if self.id is not None:
+            dictionary['id'] = self.id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'HostedFile':
+        super(HostedFile, self).from_dictionary(dictionary)
+        if 'fileName' in dictionary:
+            self.file_name = dictionary['fileName']
+        if 'fileSize' in dictionary:
+            self.file_size = dictionary['fileSize']
+        if 'fileType' in dictionary:
+            self.file_type = dictionary['fileType']
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        return self

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

@@ -0,0 +1,140 @@
+# -*- 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.mandate_customer import MandateCustomer
+
+
+class HostedMandateInfo(DataObject):
+
+    __alias: Optional[str] = None
+    __customer: Optional[MandateCustomer] = None
+    __customer_reference: Optional[str] = None
+    __recurrence_type: Optional[str] = None
+    __signature_type: Optional[str] = None
+    __unique_mandate_reference: Optional[str] = None
+
+    @property
+    def alias(self) -> Optional[str]:
+        """
+        | An alias for the mandate. This can be used to visually represent the mandate.
+        | Do not include any unobfuscated sensitive data in the alias.
+        | Default value if not provided is the obfuscated IBAN of the customer.
+
+        Type: str
+        """
+        return self.__alias
+
+    @alias.setter
+    def alias(self, value: Optional[str]) -> None:
+        self.__alias = value
+
+    @property
+    def customer(self) -> Optional[MandateCustomer]:
+        """
+        | Customer object containing customer specific inputs
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mandate_customer.MandateCustomer`
+        """
+        return self.__customer
+
+    @customer.setter
+    def customer(self, value: Optional[MandateCustomer]) -> None:
+        self.__customer = value
+
+    @property
+    def customer_reference(self) -> Optional[str]:
+        """
+        | The unique identifier of a customer
+
+        Type: str
+        """
+        return self.__customer_reference
+
+    @customer_reference.setter
+    def customer_reference(self, value: Optional[str]) -> None:
+        self.__customer_reference = value
+
+    @property
+    def recurrence_type(self) -> Optional[str]:
+        """
+        | Specifies whether the mandate is for one-off or recurring payments. Possible values are:
+        |  
+        * UNIQUE
+        * RECURRING
+
+        Type: str
+        """
+        return self.__recurrence_type
+
+    @recurrence_type.setter
+    def recurrence_type(self, value: Optional[str]) -> None:
+        self.__recurrence_type = value
+
+    @property
+    def signature_type(self) -> Optional[str]:
+        """
+        | Specifies whether the mandate is unsigned or singed by SMS. Possible values are:
+        |  
+        * UNSIGNED
+        * SMS
+
+        Type: str
+        """
+        return self.__signature_type
+
+    @signature_type.setter
+    def signature_type(self, value: Optional[str]) -> None:
+        self.__signature_type = value
+
+    @property
+    def unique_mandate_reference(self) -> Optional[str]:
+        """
+        | The unique identifier of the mandate
+
+        Type: str
+        """
+        return self.__unique_mandate_reference
+
+    @unique_mandate_reference.setter
+    def unique_mandate_reference(self, value: Optional[str]) -> None:
+        self.__unique_mandate_reference = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(HostedMandateInfo, self).to_dictionary()
+        if self.alias is not None:
+            dictionary['alias'] = self.alias
+        if self.customer is not None:
+            dictionary['customer'] = self.customer.to_dictionary()
+        if self.customer_reference is not None:
+            dictionary['customerReference'] = self.customer_reference
+        if self.recurrence_type is not None:
+            dictionary['recurrenceType'] = self.recurrence_type
+        if self.signature_type is not None:
+            dictionary['signatureType'] = self.signature_type
+        if self.unique_mandate_reference is not None:
+            dictionary['uniqueMandateReference'] = self.unique_mandate_reference
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'HostedMandateInfo':
+        super(HostedMandateInfo, self).from_dictionary(dictionary)
+        if 'alias' in dictionary:
+            self.alias = dictionary['alias']
+        if 'customer' in dictionary:
+            if not isinstance(dictionary['customer'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customer']))
+            value = MandateCustomer()
+            self.customer = value.from_dictionary(dictionary['customer'])
+        if 'customerReference' in dictionary:
+            self.customer_reference = dictionary['customerReference']
+        if 'recurrenceType' in dictionary:
+            self.recurrence_type = dictionary['recurrenceType']
+        if 'signatureType' in dictionary:
+            self.signature_type = dictionary['signatureType']
+        if 'uniqueMandateReference' in dictionary:
+            self.unique_mandate_reference = dictionary['uniqueMandateReference']
+        return self

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

@@ -0,0 +1,97 @@
+# -*- 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 HostedMandateManagementSpecificInput(DataObject):
+
+    __locale: Optional[str] = None
+    __return_url: Optional[str] = None
+    __show_result_page: Optional[bool] = None
+    __variant: Optional[str] = None
+
+    @property
+    def locale(self) -> Optional[str]:
+        """
+        | Locale to use to present the hosted mandate pages to the customer. Please make sure that a language pack is configured for the locale you are submitting. If you submit a locale that is not setup on your account we will use the default language pack for your account. You can easily upload additional language packs and set the default language pack in the Configuration Center.
+
+        Type: str
+        """
+        return self.__locale
+
+    @locale.setter
+    def locale(self, value: Optional[str]) -> None:
+        self.__locale = value
+
+    @property
+    def return_url(self) -> Optional[str]:
+        """
+        | The URL that the customer is redirect to after the mandate flow has finished. You can add any number of key value pairs in the query string that, for instance help you to identify the customer when they return to your site. Please note that we will also append some additional key value pairs that will also help you with this identification process.
+        | Note: The provided URL should be absolute and contain the protocol to use, e.g. http:// or https://. For use on mobile devices a custom protocol can be used in the form of *protocol*://. This protocol must be registered on the device first.
+        | URLs without a protocol will be rejected.
+
+        Type: str
+        """
+        return self.__return_url
+
+    @return_url.setter
+    def return_url(self, value: Optional[str]) -> None:
+        self.__return_url = value
+
+    @property
+    def show_result_page(self) -> Optional[bool]:
+        """
+        * true - MyMandate will show a result page to the customer when applicable. Default.
+        * false - MyMandate will redirect the customer back to the provided returnUrl when this is possible.
+        
+        | The default value for this property is true.
+
+        Type: bool
+        """
+        return self.__show_result_page
+
+    @show_result_page.setter
+    def show_result_page(self, value: Optional[bool]) -> None:
+        self.__show_result_page = value
+
+    @property
+    def variant(self) -> Optional[str]:
+        """
+        | The ID of the variant used to create the Hosted Mandate Management Session in which the payment was made.
+
+        Type: str
+        """
+        return self.__variant
+
+    @variant.setter
+    def variant(self, value: Optional[str]) -> None:
+        self.__variant = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(HostedMandateManagementSpecificInput, self).to_dictionary()
+        if self.locale is not None:
+            dictionary['locale'] = self.locale
+        if self.return_url is not None:
+            dictionary['returnUrl'] = self.return_url
+        if self.show_result_page is not None:
+            dictionary['showResultPage'] = self.show_result_page
+        if self.variant is not None:
+            dictionary['variant'] = self.variant
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'HostedMandateManagementSpecificInput':
+        super(HostedMandateManagementSpecificInput, self).from_dictionary(dictionary)
+        if 'locale' in dictionary:
+            self.locale = dictionary['locale']
+        if 'returnUrl' in dictionary:
+            self.return_url = dictionary['returnUrl']
+        if 'showResultPage' in dictionary:
+            self.show_result_page = dictionary['showResultPage']
+        if 'variant' in dictionary:
+            self.variant = dictionary['variant']
+        return self

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

@@ -0,0 +1,63 @@
+# -*- 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 IINDetail(DataObject):
+    """
+    | Output of the retrieval of the IIN details request
+    """
+
+    __is_allowed_in_context: Optional[bool] = None
+    __payment_product_id: Optional[int] = None
+
+    @property
+    def is_allowed_in_context(self) -> Optional[bool]:
+        """
+        | Populated only if you submitted a payment context.
+        
+        * true - The payment product is allowed in the submitted context.
+        * false - The payment product is not allowed in the submitted context. Note that in this case, none of the brands of the card will be allowed in the submitted context.
+
+        Type: bool
+        """
+        return self.__is_allowed_in_context
+
+    @is_allowed_in_context.setter
+    def is_allowed_in_context(self, value: Optional[bool]) -> None:
+        self.__is_allowed_in_context = value
+
+    @property
+    def payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier
+        | Please see payment products <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/paymentproducts.html> for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__payment_product_id
+
+    @payment_product_id.setter
+    def payment_product_id(self, value: Optional[int]) -> None:
+        self.__payment_product_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(IINDetail, self).to_dictionary()
+        if self.is_allowed_in_context is not None:
+            dictionary['isAllowedInContext'] = self.is_allowed_in_context
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'IINDetail':
+        super(IINDetail, self).from_dictionary(dictionary)
+        if 'isAllowedInContext' in dictionary:
+            self.is_allowed_in_context = dictionary['isAllowedInContext']
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        return self

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

@@ -0,0 +1,120 @@
+# -*- 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 InAuth(DataObject):
+
+    __device_category: Optional[str] = None
+    __device_id: Optional[str] = None
+    __risk_score: Optional[str] = None
+    __true_ip_address: Optional[str] = None
+    __true_ip_address_country: Optional[str] = None
+
+    @property
+    def device_category(self) -> Optional[str]:
+        """
+        | The type of device used by the customer. Example values:
+        
+        * SMARTPHONE
+        * PERSONAL_COMPUTER 
+        * TABLET 
+        * WEARABLE_COMPUTER 
+        * GAME_CONSOLE 
+        * SMART_TV 
+        * PDA 
+        * OTHER 
+        * UNKNOWN
+
+        Type: str
+        """
+        return self.__device_category
+
+    @device_category.setter
+    def device_category(self, value: Optional[str]) -> None:
+        self.__device_category = value
+
+    @property
+    def device_id(self) -> Optional[str]:
+        """
+        | This is the device fingerprint value. Based on the amount of data that the device fingerprint collector script was able to collect, this will be a proxy ID for the device used by the customer.
+
+        Type: str
+        """
+        return self.__device_id
+
+    @device_id.setter
+    def device_id(self, value: Optional[str]) -> None:
+        self.__device_id = value
+
+    @property
+    def risk_score(self) -> Optional[str]:
+        """
+        | The score calculated on the basis of Anomalies, Velocity, Location, Integrity, List-Based, and Device Reputation. Range of the score is between 0 and 100. A lower value is better.
+
+        Type: str
+        """
+        return self.__risk_score
+
+    @risk_score.setter
+    def risk_score(self, value: Optional[str]) -> None:
+        self.__risk_score = value
+
+    @property
+    def true_ip_address(self) -> Optional[str]:
+        """
+        | The true IP address as determined by inAuth. This might be different from the IP address that you are seeing on your side due to the proxy piercing technology deployed by inAuth.
+
+        Type: str
+        """
+        return self.__true_ip_address
+
+    @true_ip_address.setter
+    def true_ip_address(self, value: Optional[str]) -> None:
+        self.__true_ip_address = value
+
+    @property
+    def true_ip_address_country(self) -> Optional[str]:
+        """
+        | The country of the customer based on the location of the True IP Address determined by inAuth.
+
+        Type: str
+        """
+        return self.__true_ip_address_country
+
+    @true_ip_address_country.setter
+    def true_ip_address_country(self, value: Optional[str]) -> None:
+        self.__true_ip_address_country = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(InAuth, self).to_dictionary()
+        if self.device_category is not None:
+            dictionary['deviceCategory'] = self.device_category
+        if self.device_id is not None:
+            dictionary['deviceId'] = self.device_id
+        if self.risk_score is not None:
+            dictionary['riskScore'] = self.risk_score
+        if self.true_ip_address is not None:
+            dictionary['trueIpAddress'] = self.true_ip_address
+        if self.true_ip_address_country is not None:
+            dictionary['trueIpAddressCountry'] = self.true_ip_address_country
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'InAuth':
+        super(InAuth, self).from_dictionary(dictionary)
+        if 'deviceCategory' in dictionary:
+            self.device_category = dictionary['deviceCategory']
+        if 'deviceId' in dictionary:
+            self.device_id = dictionary['deviceId']
+        if 'riskScore' in dictionary:
+            self.risk_score = dictionary['riskScore']
+        if 'trueIpAddress' in dictionary:
+            self.true_ip_address = dictionary['trueIpAddress']
+        if 'trueIpAddressCountry' in dictionary:
+            self.true_ip_address_country = dictionary['trueIpAddressCountry']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/installment_display_hints.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 InstallmentDisplayHints(DataObject):
+    """
+    | Object containing information for the client on how best to display this options
+    """
+
+    __display_order: Optional[int] = None
+    __label: Optional[str] = None
+    __logo: Optional[str] = None
+
+    @property
+    def display_order(self) -> Optional[int]:
+        """
+        | Determines the order in which the installment options should be shown (sorted ascending). In countries like Turkey there are multiple loyalty programs that offer installments
+
+        Type: int
+        """
+        return self.__display_order
+
+    @display_order.setter
+    def display_order(self, value: Optional[int]) -> None:
+        self.__display_order = value
+
+    @property
+    def label(self) -> Optional[str]:
+        """
+        | Name of the installment option
+
+        Type: str
+        """
+        return self.__label
+
+    @label.setter
+    def label(self, value: Optional[str]) -> None:
+        self.__label = value
+
+    @property
+    def logo(self) -> Optional[str]:
+        """
+        | Partial URL that you can reference for the image of this installment provider. You can use our server-side resize functionality by appending '?size={{width}}x{{height}}' to the full URL, where width and height are specified in pixels. The resized image will always keep its correct aspect ratio.
+
+        Type: str
+        """
+        return self.__logo
+
+    @logo.setter
+    def logo(self, value: Optional[str]) -> None:
+        self.__logo = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(InstallmentDisplayHints, self).to_dictionary()
+        if self.display_order is not None:
+            dictionary['displayOrder'] = self.display_order
+        if self.label is not None:
+            dictionary['label'] = self.label
+        if self.logo is not None:
+            dictionary['logo'] = self.logo
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'InstallmentDisplayHints':
+        super(InstallmentDisplayHints, self).from_dictionary(dictionary)
+        if 'displayOrder' in dictionary:
+            self.display_order = dictionary['displayOrder']
+        if 'label' in dictionary:
+            self.label = dictionary['label']
+        if 'logo' in dictionary:
+            self.logo = dictionary['logo']
+        return self