connect-sdk-python3 4.0.0__zip → 4.1.0__zip

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

@@ -0,0 +1,181 @@
+# -*- 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.browser_data import BrowserData
+
+
+class CustomerDevice(DataObject):
+    """
+    | Object containing information on the device and browser of the customer
+    """
+
+    __accept_header: Optional[str] = None
+    __browser_data: Optional[BrowserData] = None
+    __default_form_fill: Optional[str] = None
+    __device_fingerprint_transaction_id: Optional[str] = None
+    __ip_address: Optional[str] = None
+    __locale: Optional[str] = None
+    __timezone_offset_utc_minutes: Optional[str] = None
+    __user_agent: Optional[str] = None
+
+    @property
+    def accept_header(self) -> Optional[str]:
+        """
+        | The accept-header of the customer client from the HTTP Headers.
+
+        Type: str
+        """
+        return self.__accept_header
+
+    @accept_header.setter
+    def accept_header(self, value: Optional[str]) -> None:
+        self.__accept_header = value
+
+    @property
+    def browser_data(self) -> Optional[BrowserData]:
+        """
+        | Object containing information regarding the browser of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.browser_data.BrowserData`
+        """
+        return self.__browser_data
+
+    @browser_data.setter
+    def browser_data(self, value: Optional[BrowserData]) -> None:
+        self.__browser_data = value
+
+    @property
+    def default_form_fill(self) -> Optional[str]:
+        """
+        | Degree of default form fill, with the following possible values:
+        
+        * automatically - All fields filled automatically
+        * automatically-but-modified - All fields filled automatically, but some fields were modified manually
+        * manually - All fields were entered manually
+
+        Type: str
+        """
+        return self.__default_form_fill
+
+    @default_form_fill.setter
+    def default_form_fill(self, value: Optional[str]) -> None:
+        self.__default_form_fill = value
+
+    @property
+    def device_fingerprint_transaction_id(self) -> Optional[str]:
+        """
+        | One must set the deviceFingerprintTransactionId received by the response of the endpoint /{merchant}/products/{paymentProductId}/deviceFingerprint
+
+        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 ip_address(self) -> Optional[str]:
+        """
+        | The IP address of the customer client from the HTTP Headers.
+
+        Type: str
+        """
+        return self.__ip_address
+
+    @ip_address.setter
+    def ip_address(self, value: Optional[str]) -> None:
+        self.__ip_address = value
+
+    @property
+    def locale(self) -> Optional[str]:
+        """
+        | Locale of the client device/browser. Returned in the browser from the navigator.language property.
+        
+        | If you use the latest version of our JavaScript Client SDK, we will collect this data and include it in the encryptedCustomerInput property. We will then automatically populate this data if available.
+
+        Type: str
+        """
+        return self.__locale
+
+    @locale.setter
+    def locale(self, value: Optional[str]) -> None:
+        self.__locale = value
+
+    @property
+    def timezone_offset_utc_minutes(self) -> Optional[str]:
+        """
+        | Offset in minutes of timezone of the client versus the UTC. Value is returned by the JavaScript getTimezoneOffset() Method.
+        
+        | If you use the latest version of our JavaScript Client SDK, we will collect this data and include it in the encryptedCustomerInput property. We will then automatically populate this data if available.
+
+        Type: str
+        """
+        return self.__timezone_offset_utc_minutes
+
+    @timezone_offset_utc_minutes.setter
+    def timezone_offset_utc_minutes(self, value: Optional[str]) -> None:
+        self.__timezone_offset_utc_minutes = value
+
+    @property
+    def user_agent(self) -> Optional[str]:
+        """
+        | User-Agent of the client device/browser from the HTTP Headers.
+        
+        | As a fall-back we will use the userAgent that might be included in the encryptedCustomerInput, but this is captured client side using JavaScript and might be different.
+
+        Type: str
+        """
+        return self.__user_agent
+
+    @user_agent.setter
+    def user_agent(self, value: Optional[str]) -> None:
+        self.__user_agent = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerDevice, self).to_dictionary()
+        if self.accept_header is not None:
+            dictionary['acceptHeader'] = self.accept_header
+        if self.browser_data is not None:
+            dictionary['browserData'] = self.browser_data.to_dictionary()
+        if self.default_form_fill is not None:
+            dictionary['defaultFormFill'] = self.default_form_fill
+        if self.device_fingerprint_transaction_id is not None:
+            dictionary['deviceFingerprintTransactionId'] = self.device_fingerprint_transaction_id
+        if self.ip_address is not None:
+            dictionary['ipAddress'] = self.ip_address
+        if self.locale is not None:
+            dictionary['locale'] = self.locale
+        if self.timezone_offset_utc_minutes is not None:
+            dictionary['timezoneOffsetUtcMinutes'] = self.timezone_offset_utc_minutes
+        if self.user_agent is not None:
+            dictionary['userAgent'] = self.user_agent
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerDevice':
+        super(CustomerDevice, self).from_dictionary(dictionary)
+        if 'acceptHeader' in dictionary:
+            self.accept_header = dictionary['acceptHeader']
+        if 'browserData' in dictionary:
+            if not isinstance(dictionary['browserData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['browserData']))
+            value = BrowserData()
+            self.browser_data = value.from_dictionary(dictionary['browserData'])
+        if 'defaultFormFill' in dictionary:
+            self.default_form_fill = dictionary['defaultFormFill']
+        if 'deviceFingerprintTransactionId' in dictionary:
+            self.device_fingerprint_transaction_id = dictionary['deviceFingerprintTransactionId']
+        if 'ipAddress' in dictionary:
+            self.ip_address = dictionary['ipAddress']
+        if 'locale' in dictionary:
+            self.locale = dictionary['locale']
+        if 'timezoneOffsetUtcMinutes' in dictionary:
+            self.timezone_offset_utc_minutes = dictionary['timezoneOffsetUtcMinutes']
+        if 'userAgent' in dictionary:
+            self.user_agent = dictionary['userAgent']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/customer_device_risk_assessment.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 CustomerDeviceRiskAssessment(DataObject):
+    """
+    | Object containing information on the device and browser of the customer
+    """
+
+    __default_form_fill: Optional[str] = None
+    __device_fingerprint_transaction_id: Optional[str] = None
+
+    @property
+    def default_form_fill(self) -> Optional[str]:
+        """
+        | Degree of default form fill, with the following possible values:
+        
+        * automatically - All fields filled automatically
+        * automatically-but-modified - All fields filled automatically, but some fields were modified manually
+        * manually - All fields were entered manually
+
+        Type: str
+        """
+        return self.__default_form_fill
+
+    @default_form_fill.setter
+    def default_form_fill(self, value: Optional[str]) -> None:
+        self.__default_form_fill = value
+
+    @property
+    def device_fingerprint_transaction_id(self) -> Optional[str]:
+        """
+        | One must set the deviceFingerprintTransactionId received by the response of the endpoint /{merchant}/products/{paymentProductId}/deviceFingerprint
+
+        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
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerDeviceRiskAssessment, self).to_dictionary()
+        if self.default_form_fill is not None:
+            dictionary['defaultFormFill'] = self.default_form_fill
+        if self.device_fingerprint_transaction_id is not None:
+            dictionary['deviceFingerprintTransactionId'] = self.device_fingerprint_transaction_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerDeviceRiskAssessment':
+        super(CustomerDeviceRiskAssessment, self).from_dictionary(dictionary)
+        if 'defaultFormFill' in dictionary:
+            self.default_form_fill = dictionary['defaultFormFill']
+        if 'deviceFingerprintTransactionId' in dictionary:
+            self.device_fingerprint_transaction_id = dictionary['deviceFingerprintTransactionId']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/customer_payment_activity.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 CustomerPaymentActivity(DataObject):
+    """
+    | Object containing data on the purchase history of the customer with you
+    """
+
+    __number_of_payment_attempts_last24_hours: Optional[int] = None
+    __number_of_payment_attempts_last_year: Optional[int] = None
+    __number_of_purchases_last6_months: Optional[int] = None
+
+    @property
+    def number_of_payment_attempts_last24_hours(self) -> Optional[int]:
+        """
+        | Number of payment attempts (so including unsuccessful ones) made by this customer with you in the last 24 hours
+
+        Type: int
+        """
+        return self.__number_of_payment_attempts_last24_hours
+
+    @number_of_payment_attempts_last24_hours.setter
+    def number_of_payment_attempts_last24_hours(self, value: Optional[int]) -> None:
+        self.__number_of_payment_attempts_last24_hours = value
+
+    @property
+    def number_of_payment_attempts_last_year(self) -> Optional[int]:
+        """
+        | Number of payment attempts (so including unsuccessful ones) made by this customer with you in the last 12 months
+
+        Type: int
+        """
+        return self.__number_of_payment_attempts_last_year
+
+    @number_of_payment_attempts_last_year.setter
+    def number_of_payment_attempts_last_year(self, value: Optional[int]) -> None:
+        self.__number_of_payment_attempts_last_year = value
+
+    @property
+    def number_of_purchases_last6_months(self) -> Optional[int]:
+        """
+        | Number of successful purchases made by this customer with you in the last 6 months
+
+        Type: int
+        """
+        return self.__number_of_purchases_last6_months
+
+    @number_of_purchases_last6_months.setter
+    def number_of_purchases_last6_months(self, value: Optional[int]) -> None:
+        self.__number_of_purchases_last6_months = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerPaymentActivity, self).to_dictionary()
+        if self.number_of_payment_attempts_last24_hours is not None:
+            dictionary['numberOfPaymentAttemptsLast24Hours'] = self.number_of_payment_attempts_last24_hours
+        if self.number_of_payment_attempts_last_year is not None:
+            dictionary['numberOfPaymentAttemptsLastYear'] = self.number_of_payment_attempts_last_year
+        if self.number_of_purchases_last6_months is not None:
+            dictionary['numberOfPurchasesLast6Months'] = self.number_of_purchases_last6_months
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerPaymentActivity':
+        super(CustomerPaymentActivity, self).from_dictionary(dictionary)
+        if 'numberOfPaymentAttemptsLast24Hours' in dictionary:
+            self.number_of_payment_attempts_last24_hours = dictionary['numberOfPaymentAttemptsLast24Hours']
+        if 'numberOfPaymentAttemptsLastYear' in dictionary:
+            self.number_of_payment_attempts_last_year = dictionary['numberOfPaymentAttemptsLastYear']
+        if 'numberOfPurchasesLast6Months' in dictionary:
+            self.number_of_purchases_last6_months = dictionary['numberOfPurchasesLast6Months']
+        return self

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

@@ -0,0 +1,218 @@
+# -*- 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.address_personal import AddressPersonal
+from worldline.connect.sdk.v1.domain.contact_details_risk_assessment import ContactDetailsRiskAssessment
+from worldline.connect.sdk.v1.domain.customer_account_risk_assessment import CustomerAccountRiskAssessment
+from worldline.connect.sdk.v1.domain.customer_device_risk_assessment import CustomerDeviceRiskAssessment
+from worldline.connect.sdk.v1.domain.personal_information_risk_assessment import PersonalInformationRiskAssessment
+
+
+class CustomerRiskAssessment(DataObject):
+    """
+    | Object containing data related to the customer
+    """
+
+    __account: Optional[CustomerAccountRiskAssessment] = None
+    __account_type: Optional[str] = None
+    __billing_address: Optional[Address] = None
+    __contact_details: Optional[ContactDetailsRiskAssessment] = None
+    __device: Optional[CustomerDeviceRiskAssessment] = None
+    __is_previous_customer: Optional[bool] = None
+    __locale: Optional[str] = None
+    __personal_information: Optional[PersonalInformationRiskAssessment] = None
+    __shipping_address: Optional[AddressPersonal] = None
+
+    @property
+    def account(self) -> Optional[CustomerAccountRiskAssessment]:
+        """
+        | Object containing data related to the account the customer has with you
+
+        Type: :class:`worldline.connect.sdk.v1.domain.customer_account_risk_assessment.CustomerAccountRiskAssessment`
+        """
+        return self.__account
+
+    @account.setter
+    def account(self, value: Optional[CustomerAccountRiskAssessment]) -> None:
+        self.__account = value
+
+    @property
+    def account_type(self) -> Optional[str]:
+        """
+        | Type of the customer account that is used to place this order. Can have one of the following values:
+        
+        * none - The account that was used to place the order is a guest account or no account was used at all
+        * created - The customer account was created during this transaction
+        * existing - The customer account was an already existing account prior to this transaction
+
+        Type: str
+        """
+        return self.__account_type
+
+    @account_type.setter
+    def account_type(self, value: Optional[str]) -> None:
+        self.__account_type = value
+
+    @property
+    def billing_address(self) -> Optional[Address]:
+        """
+        | Object containing billing address details
+
+        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 contact_details(self) -> Optional[ContactDetailsRiskAssessment]:
+        """
+        | Object containing contact details like email address
+
+        Type: :class:`worldline.connect.sdk.v1.domain.contact_details_risk_assessment.ContactDetailsRiskAssessment`
+        """
+        return self.__contact_details
+
+    @contact_details.setter
+    def contact_details(self, value: Optional[ContactDetailsRiskAssessment]) -> None:
+        self.__contact_details = value
+
+    @property
+    def device(self) -> Optional[CustomerDeviceRiskAssessment]:
+        """
+        | Object containing information on the device and browser of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.customer_device_risk_assessment.CustomerDeviceRiskAssessment`
+        """
+        return self.__device
+
+    @device.setter
+    def device(self, value: Optional[CustomerDeviceRiskAssessment]) -> None:
+        self.__device = value
+
+    @property
+    def is_previous_customer(self) -> Optional[bool]:
+        """
+        | Specifies if the customer has a history of online shopping with the merchant
+        
+        * true - The customer is a known returning customer
+        * false - The customer is new/unknown customer
+
+        Type: bool
+        """
+        return self.__is_previous_customer
+
+    @is_previous_customer.setter
+    def is_previous_customer(self, value: Optional[bool]) -> None:
+        self.__is_previous_customer = value
+
+    @property
+    def locale(self) -> Optional[str]:
+        """
+        | The locale that the customer should be addressed in (for 3rd parties). Note that some 3rd party providers only support the languageCode part of the locale, in those cases we will only use part of the locale provided.
+
+        Type: str
+        """
+        return self.__locale
+
+    @locale.setter
+    def locale(self, value: Optional[str]) -> None:
+        self.__locale = value
+
+    @property
+    def personal_information(self) -> Optional[PersonalInformationRiskAssessment]:
+        """
+        | Object containing personal information like name, date of birth and gender
+
+        Type: :class:`worldline.connect.sdk.v1.domain.personal_information_risk_assessment.PersonalInformationRiskAssessment`
+        """
+        return self.__personal_information
+
+    @personal_information.setter
+    def personal_information(self, value: Optional[PersonalInformationRiskAssessment]) -> None:
+        self.__personal_information = value
+
+    @property
+    def shipping_address(self) -> Optional[AddressPersonal]:
+        """
+        | Object containing shipping address details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.address_personal.AddressPersonal`
+
+        Deprecated; Use Order.shipping.address instead
+        """
+        return self.__shipping_address
+
+    @shipping_address.setter
+    def shipping_address(self, value: Optional[AddressPersonal]) -> None:
+        self.__shipping_address = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerRiskAssessment, self).to_dictionary()
+        if self.account is not None:
+            dictionary['account'] = self.account.to_dictionary()
+        if self.account_type is not None:
+            dictionary['accountType'] = self.account_type
+        if self.billing_address is not None:
+            dictionary['billingAddress'] = self.billing_address.to_dictionary()
+        if self.contact_details is not None:
+            dictionary['contactDetails'] = self.contact_details.to_dictionary()
+        if self.device is not None:
+            dictionary['device'] = self.device.to_dictionary()
+        if self.is_previous_customer is not None:
+            dictionary['isPreviousCustomer'] = self.is_previous_customer
+        if self.locale is not None:
+            dictionary['locale'] = self.locale
+        if self.personal_information is not None:
+            dictionary['personalInformation'] = self.personal_information.to_dictionary()
+        if self.shipping_address is not None:
+            dictionary['shippingAddress'] = self.shipping_address.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerRiskAssessment':
+        super(CustomerRiskAssessment, self).from_dictionary(dictionary)
+        if 'account' in dictionary:
+            if not isinstance(dictionary['account'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['account']))
+            value = CustomerAccountRiskAssessment()
+            self.account = value.from_dictionary(dictionary['account'])
+        if 'accountType' in dictionary:
+            self.account_type = dictionary['accountType']
+        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 'contactDetails' in dictionary:
+            if not isinstance(dictionary['contactDetails'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['contactDetails']))
+            value = ContactDetailsRiskAssessment()
+            self.contact_details = value.from_dictionary(dictionary['contactDetails'])
+        if 'device' in dictionary:
+            if not isinstance(dictionary['device'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['device']))
+            value = CustomerDeviceRiskAssessment()
+            self.device = value.from_dictionary(dictionary['device'])
+        if 'isPreviousCustomer' in dictionary:
+            self.is_previous_customer = dictionary['isPreviousCustomer']
+        if 'locale' in dictionary:
+            self.locale = dictionary['locale']
+        if 'personalInformation' in dictionary:
+            if not isinstance(dictionary['personalInformation'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['personalInformation']))
+            value = PersonalInformationRiskAssessment()
+            self.personal_information = value.from_dictionary(dictionary['personalInformation'])
+        if 'shippingAddress' in dictionary:
+            if not isinstance(dictionary['shippingAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shippingAddress']))
+            value = AddressPersonal()
+            self.shipping_address = value.from_dictionary(dictionary['shippingAddress'])
+        return self

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

@@ -0,0 +1,64 @@
+# -*- 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.v1.domain.address import Address
+from worldline.connect.sdk.v1.domain.customer_base import CustomerBase
+from worldline.connect.sdk.v1.domain.personal_information_token import PersonalInformationToken
+
+
+class CustomerToken(CustomerBase):
+
+    __billing_address: Optional[Address] = None
+    __personal_information: Optional[PersonalInformationToken] = None
+
+    @property
+    def billing_address(self) -> Optional[Address]:
+        """
+        | Object containing the billing address details
+
+        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 personal_information(self) -> Optional[PersonalInformationToken]:
+        """
+        | Object containing personal information of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.personal_information_token.PersonalInformationToken`
+        """
+        return self.__personal_information
+
+    @personal_information.setter
+    def personal_information(self, value: Optional[PersonalInformationToken]) -> None:
+        self.__personal_information = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerToken, self).to_dictionary()
+        if self.billing_address is not None:
+            dictionary['billingAddress'] = self.billing_address.to_dictionary()
+        if self.personal_information is not None:
+            dictionary['personalInformation'] = self.personal_information.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerToken':
+        super(CustomerToken, 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 'personalInformation' in dictionary:
+            if not isinstance(dictionary['personalInformation'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['personalInformation']))
+            value = PersonalInformationToken()
+            self.personal_information = value.from_dictionary(dictionary['personalInformation'])
+        return self

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

@@ -0,0 +1,42 @@
+# -*- 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.v1.domain.contact_details_token import ContactDetailsToken
+from worldline.connect.sdk.v1.domain.customer_token import CustomerToken
+
+
+class CustomerTokenWithContactDetails(CustomerToken):
+
+    __contact_details: Optional[ContactDetailsToken] = None
+
+    @property
+    def contact_details(self) -> Optional[ContactDetailsToken]:
+        """
+        | Object containing contact details like email address and phone number
+
+        Type: :class:`worldline.connect.sdk.v1.domain.contact_details_token.ContactDetailsToken`
+        """
+        return self.__contact_details
+
+    @contact_details.setter
+    def contact_details(self, value: Optional[ContactDetailsToken]) -> None:
+        self.__contact_details = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerTokenWithContactDetails, self).to_dictionary()
+        if self.contact_details is not None:
+            dictionary['contactDetails'] = self.contact_details.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerTokenWithContactDetails':
+        super(CustomerTokenWithContactDetails, self).from_dictionary(dictionary)
+        if 'contactDetails' in dictionary:
+            if not isinstance(dictionary['contactDetails'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['contactDetails']))
+            value = ContactDetailsToken()
+            self.contact_details = value.from_dictionary(dictionary['contactDetails'])
+        return self