connect-sdk-python3 4.0.0__zip → 4.0.1__zip

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

@@ -1,63 +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 PaymentProduct320SpecificData(DataObject):
-
-    __gateway: Optional[str] = None
-    __networks: Optional[List[str]] = None
-
-    @property
-    def gateway(self) -> Optional[str]:
-        """
-        | The GlobalCollect gateway identifier. You should use this when creating a tokenization specification <https://developers.google.com/pay/api/android/reference/object#Gateway>.
-        
-        Type: str
-        """
-        return self.__gateway
-
-    @gateway.setter
-    def gateway(self, value: Optional[str]) -> None:
-        self.__gateway = value
-
-    @property
-    def networks(self) -> Optional[List[str]]:
-        """
-        | The networks that can be used in the current payment context. The strings that represent the networks in the array are identical to the strings that Google uses in their documentation <https://developers.google.com/pay/api/android/reference/object#CardParameters>.For instance: "VISA".
-        
-        Type: list[str]
-        """
-        return self.__networks
-
-    @networks.setter
-    def networks(self, value: Optional[List[str]]) -> None:
-        self.__networks = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProduct320SpecificData, self).to_dictionary()
-        if self.gateway is not None:
-            dictionary['gateway'] = self.gateway
-        if self.networks is not None:
-            dictionary['networks'] = []
-            for element in self.networks:
-                if element is not None:
-                    dictionary['networks'].append(element)
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct320SpecificData':
-        super(PaymentProduct320SpecificData, self).from_dictionary(dictionary)
-        if 'gateway' in dictionary:
-            self.gateway = dictionary['gateway']
-        if 'networks' in dictionary:
-            if not isinstance(dictionary['networks'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['networks']))
-            self.networks = []
-            for element in dictionary['networks']:
-                self.networks.append(element)
-        return self

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

@@ -1,38 +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 PaymentProduct771SpecificOutput(DataObject):
-
-    __mandate_reference: Optional[str] = None
-
-    @property
-    def mandate_reference(self) -> Optional[str]:
-        """
-        | Unique reference to a Mandate
-        
-        Type: str
-        """
-        return self.__mandate_reference
-
-    @mandate_reference.setter
-    def mandate_reference(self, value: Optional[str]) -> None:
-        self.__mandate_reference = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProduct771SpecificOutput, self).to_dictionary()
-        if self.mandate_reference is not None:
-            dictionary['mandateReference'] = self.mandate_reference
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct771SpecificOutput':
-        super(PaymentProduct771SpecificOutput, self).from_dictionary(dictionary)
-        if 'mandateReference' in dictionary:
-            self.mandate_reference = dictionary['mandateReference']
-        return self

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

@@ -1,64 +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
-from worldline.connect.sdk.v1.domain.address import Address
-from worldline.connect.sdk.v1.domain.trustly_bank_account import TrustlyBankAccount
-
-
-class PaymentProduct806SpecificOutput(DataObject):
-
-    __billing_address: Optional[Address] = None
-    __customer_account: Optional[TrustlyBankAccount] = None
-
-    @property
-    def billing_address(self) -> Optional[Address]:
-        """
-        | Object containing the billing address details of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.address.Address`
-        """
-        return self.__billing_address
-
-    @billing_address.setter
-    def billing_address(self, value: Optional[Address]) -> None:
-        self.__billing_address = value
-
-    @property
-    def customer_account(self) -> Optional[TrustlyBankAccount]:
-        """
-        | Object containing the account details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.trustly_bank_account.TrustlyBankAccount`
-        """
-        return self.__customer_account
-
-    @customer_account.setter
-    def customer_account(self, value: Optional[TrustlyBankAccount]) -> None:
-        self.__customer_account = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProduct806SpecificOutput, self).to_dictionary()
-        if self.billing_address is not None:
-            dictionary['billingAddress'] = self.billing_address.to_dictionary()
-        if self.customer_account is not None:
-            dictionary['customerAccount'] = self.customer_account.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct806SpecificOutput':
-        super(PaymentProduct806SpecificOutput, self).from_dictionary(dictionary)
-        if 'billingAddress' in dictionary:
-            if not isinstance(dictionary['billingAddress'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['billingAddress']))
-            value = Address()
-            self.billing_address = value.from_dictionary(dictionary['billingAddress'])
-        if 'customerAccount' in dictionary:
-            if not isinstance(dictionary['customerAccount'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customerAccount']))
-            value = TrustlyBankAccount()
-            self.customer_account = value.from_dictionary(dictionary['customerAccount'])
-        return self

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

@@ -1,41 +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 PaymentProduct836SpecificOutput(DataObject):
-
-    __security_indicator: Optional[str] = None
-
-    @property
-    def security_indicator(self) -> Optional[str]:
-        """
-        | Indicates if SofortBank could estabilish if the transaction could successfully be processed.
-        
-        * 0 - You should wait for the transaction to be reported as paid before shipping any goods.
-        * 1 - You can ship the goods. In case the transaction is not reported as paid you can initiate a claims process with SofortBank.
-        
-        Type: str
-        """
-        return self.__security_indicator
-
-    @security_indicator.setter
-    def security_indicator(self, value: Optional[str]) -> None:
-        self.__security_indicator = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProduct836SpecificOutput, self).to_dictionary()
-        if self.security_indicator is not None:
-            dictionary['securityIndicator'] = self.security_indicator
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct836SpecificOutput':
-        super(PaymentProduct836SpecificOutput, self).from_dictionary(dictionary)
-        if 'securityIndicator' in dictionary:
-            self.security_indicator = dictionary['securityIndicator']
-        return self

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

@@ -1,212 +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 PaymentProduct840CustomerAccount(DataObject):
-    """
-    | PayPal account details as returned by PayPal
-    """
-
-    __account_id: Optional[str] = None
-    __billing_agreement_id: Optional[str] = None
-    __company_name: Optional[str] = None
-    __contact_phone: Optional[str] = None
-    __country_code: Optional[str] = None
-    __customer_account_status: Optional[str] = None
-    __customer_address_status: Optional[str] = None
-    __first_name: Optional[str] = None
-    __payer_id: Optional[str] = None
-    __surname: Optional[str] = None
-
-    @property
-    def account_id(self) -> Optional[str]:
-        """
-        | Username with which the PayPal account holder has registered at PayPal
-        
-        Type: str
-        """
-        return self.__account_id
-
-    @account_id.setter
-    def account_id(self, value: Optional[str]) -> None:
-        self.__account_id = value
-
-    @property
-    def billing_agreement_id(self) -> Optional[str]:
-        """
-        | Identification of the PayPal recurring billing agreement
-        
-        Type: str
-        """
-        return self.__billing_agreement_id
-
-    @billing_agreement_id.setter
-    def billing_agreement_id(self, value: Optional[str]) -> None:
-        self.__billing_agreement_id = value
-
-    @property
-    def company_name(self) -> Optional[str]:
-        """
-        | Name of the company in case the PayPal account is owned by a business
-        
-        Type: str
-        """
-        return self.__company_name
-
-    @company_name.setter
-    def company_name(self, value: Optional[str]) -> None:
-        self.__company_name = value
-
-    @property
-    def contact_phone(self) -> Optional[str]:
-        """
-        | The phone number of the PayPal account holder
-        
-        Type: str
-        """
-        return self.__contact_phone
-
-    @contact_phone.setter
-    def contact_phone(self, value: Optional[str]) -> None:
-        self.__contact_phone = value
-
-    @property
-    def country_code(self) -> Optional[str]:
-        """
-        | Country where the PayPal account is located
-        
-        Type: str
-        """
-        return self.__country_code
-
-    @country_code.setter
-    def country_code(self, value: Optional[str]) -> None:
-        self.__country_code = value
-
-    @property
-    def customer_account_status(self) -> Optional[str]:
-        """
-        | Status of the PayPal account.
-        | Possible values are:
-        
-        * verified - PayPal has verified the funding means for this account
-        * unverified - PayPal has not verified the funding means for this account
-        
-        Type: str
-        """
-        return self.__customer_account_status
-
-    @customer_account_status.setter
-    def customer_account_status(self, value: Optional[str]) -> None:
-        self.__customer_account_status = value
-
-    @property
-    def customer_address_status(self) -> Optional[str]:
-        """
-        | Status of the customer's shipping address as registered by PayPal
-        | Possible values are:
-        
-        * none - Status is unknown at PayPal
-        * confirmed - The address has been confirmed
-        * unconfirmed - The address has not been confirmed
-        
-        Type: str
-        """
-        return self.__customer_address_status
-
-    @customer_address_status.setter
-    def customer_address_status(self, value: Optional[str]) -> None:
-        self.__customer_address_status = value
-
-    @property
-    def first_name(self) -> Optional[str]:
-        """
-        | First name of the PayPal account holder
-        
-        Type: str
-        """
-        return self.__first_name
-
-    @first_name.setter
-    def first_name(self, value: Optional[str]) -> None:
-        self.__first_name = value
-
-    @property
-    def payer_id(self) -> Optional[str]:
-        """
-        | The unique identifier of a PayPal account and will never change in the life cycle of a PayPal account
-        
-        Type: str
-        """
-        return self.__payer_id
-
-    @payer_id.setter
-    def payer_id(self, value: Optional[str]) -> None:
-        self.__payer_id = value
-
-    @property
-    def surname(self) -> Optional[str]:
-        """
-        | Surname of the PayPal account holder
-        
-        Type: str
-        """
-        return self.__surname
-
-    @surname.setter
-    def surname(self, value: Optional[str]) -> None:
-        self.__surname = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProduct840CustomerAccount, self).to_dictionary()
-        if self.account_id is not None:
-            dictionary['accountId'] = self.account_id
-        if self.billing_agreement_id is not None:
-            dictionary['billingAgreementId'] = self.billing_agreement_id
-        if self.company_name is not None:
-            dictionary['companyName'] = self.company_name
-        if self.contact_phone is not None:
-            dictionary['contactPhone'] = self.contact_phone
-        if self.country_code is not None:
-            dictionary['countryCode'] = self.country_code
-        if self.customer_account_status is not None:
-            dictionary['customerAccountStatus'] = self.customer_account_status
-        if self.customer_address_status is not None:
-            dictionary['customerAddressStatus'] = self.customer_address_status
-        if self.first_name is not None:
-            dictionary['firstName'] = self.first_name
-        if self.payer_id is not None:
-            dictionary['payerId'] = self.payer_id
-        if self.surname is not None:
-            dictionary['surname'] = self.surname
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct840CustomerAccount':
-        super(PaymentProduct840CustomerAccount, self).from_dictionary(dictionary)
-        if 'accountId' in dictionary:
-            self.account_id = dictionary['accountId']
-        if 'billingAgreementId' in dictionary:
-            self.billing_agreement_id = dictionary['billingAgreementId']
-        if 'companyName' in dictionary:
-            self.company_name = dictionary['companyName']
-        if 'contactPhone' in dictionary:
-            self.contact_phone = dictionary['contactPhone']
-        if 'countryCode' in dictionary:
-            self.country_code = dictionary['countryCode']
-        if 'customerAccountStatus' in dictionary:
-            self.customer_account_status = dictionary['customerAccountStatus']
-        if 'customerAddressStatus' in dictionary:
-            self.customer_address_status = dictionary['customerAddressStatus']
-        if 'firstName' in dictionary:
-            self.first_name = dictionary['firstName']
-        if 'payerId' in dictionary:
-            self.payer_id = dictionary['payerId']
-        if 'surname' in dictionary:
-            self.surname = dictionary['surname']
-        return self

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

@@ -1,107 +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
-from worldline.connect.sdk.v1.domain.address import Address
-from worldline.connect.sdk.v1.domain.payment_product840_customer_account import PaymentProduct840CustomerAccount
-from worldline.connect.sdk.v1.domain.protection_eligibility import ProtectionEligibility
-
-
-class PaymentProduct840SpecificOutput(DataObject):
-
-    __billing_address: Optional[Address] = None
-    __customer_account: Optional[PaymentProduct840CustomerAccount] = None
-    __customer_address: Optional[Address] = None
-    __protection_eligibility: Optional[ProtectionEligibility] = None
-
-    @property
-    def billing_address(self) -> Optional[Address]:
-        """
-        | Object containing the billing address details of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.address.Address`
-        """
-        return self.__billing_address
-
-    @billing_address.setter
-    def billing_address(self, value: Optional[Address]) -> None:
-        self.__billing_address = value
-
-    @property
-    def customer_account(self) -> Optional[PaymentProduct840CustomerAccount]:
-        """
-        | Object containing the details of the PayPal account
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_product840_customer_account.PaymentProduct840CustomerAccount`
-        """
-        return self.__customer_account
-
-    @customer_account.setter
-    def customer_account(self, value: Optional[PaymentProduct840CustomerAccount]) -> None:
-        self.__customer_account = value
-
-    @property
-    def customer_address(self) -> Optional[Address]:
-        """
-        | Object containing the address details of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.address.Address`
-        """
-        return self.__customer_address
-
-    @customer_address.setter
-    def customer_address(self, value: Optional[Address]) -> None:
-        self.__customer_address = value
-
-    @property
-    def protection_eligibility(self) -> Optional[ProtectionEligibility]:
-        """
-        | Protection Eligibility data of the PayPal customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.protection_eligibility.ProtectionEligibility`
-        """
-        return self.__protection_eligibility
-
-    @protection_eligibility.setter
-    def protection_eligibility(self, value: Optional[ProtectionEligibility]) -> None:
-        self.__protection_eligibility = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProduct840SpecificOutput, self).to_dictionary()
-        if self.billing_address is not None:
-            dictionary['billingAddress'] = self.billing_address.to_dictionary()
-        if self.customer_account is not None:
-            dictionary['customerAccount'] = self.customer_account.to_dictionary()
-        if self.customer_address is not None:
-            dictionary['customerAddress'] = self.customer_address.to_dictionary()
-        if self.protection_eligibility is not None:
-            dictionary['protectionEligibility'] = self.protection_eligibility.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct840SpecificOutput':
-        super(PaymentProduct840SpecificOutput, self).from_dictionary(dictionary)
-        if 'billingAddress' in dictionary:
-            if not isinstance(dictionary['billingAddress'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['billingAddress']))
-            value = Address()
-            self.billing_address = value.from_dictionary(dictionary['billingAddress'])
-        if 'customerAccount' in dictionary:
-            if not isinstance(dictionary['customerAccount'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customerAccount']))
-            value = PaymentProduct840CustomerAccount()
-            self.customer_account = value.from_dictionary(dictionary['customerAccount'])
-        if 'customerAddress' in dictionary:
-            if not isinstance(dictionary['customerAddress'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customerAddress']))
-            value = Address()
-            self.customer_address = value.from_dictionary(dictionary['customerAddress'])
-        if 'protectionEligibility' in dictionary:
-            if not isinstance(dictionary['protectionEligibility'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['protectionEligibility']))
-            value = ProtectionEligibility()
-            self.protection_eligibility = value.from_dictionary(dictionary['protectionEligibility'])
-        return self

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

@@ -1,49 +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 PaymentProduct863SpecificData(DataObject):
-
-    __integration_types: Optional[List[str]] = None
-
-    @property
-    def integration_types(self) -> Optional[List[str]]:
-        """
-        | The WeChat Pay integration types that can be used in the current payment context. Possible values:
-        
-        * desktopQRCode - used on desktops, the customer opens the WeChat app by scanning a QR code.
-        * urlIntent - used in mobile apps or on mobile web pages, the customer opens the WeChat app using a URL intent.
-        * nativeInApp - used in mobile apps that use the WeChat Pay SDK.
-        
-        Type: list[str]
-        """
-        return self.__integration_types
-
-    @integration_types.setter
-    def integration_types(self, value: Optional[List[str]]) -> None:
-        self.__integration_types = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentProduct863SpecificData, self).to_dictionary()
-        if self.integration_types is not None:
-            dictionary['integrationTypes'] = []
-            for element in self.integration_types:
-                if element is not None:
-                    dictionary['integrationTypes'].append(element)
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct863SpecificData':
-        super(PaymentProduct863SpecificData, self).from_dictionary(dictionary)
-        if 'integrationTypes' in dictionary:
-            if not isinstance(dictionary['integrationTypes'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['integrationTypes']))
-            self.integration_types = []
-            for element in dictionary['integrationTypes']:
-                self.integration_types.append(element)
-        return self