connect-sdk-python3 4.0.0__zip → 4.0.1__zip

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

@@ -1,83 +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 PersonalIdentification(DataObject):
-
-    __id_issuing_country_code: Optional[str] = None
-    __id_type: Optional[str] = None
-    __id_value: Optional[str] = None
-
-    @property
-    def id_issuing_country_code(self) -> Optional[str]:
-        """
-        | ISO 3166-1 alpha-2 country code of the country that issued the identification document
-        
-        Type: str
-        """
-        return self.__id_issuing_country_code
-
-    @id_issuing_country_code.setter
-    def id_issuing_country_code(self, value: Optional[str]) -> None:
-        self.__id_issuing_country_code = value
-
-    @property
-    def id_type(self) -> Optional[str]:
-        """
-        | Indicates the type of identification 
-        
-        * nationalIdentification = The provided idValue is a national identification number.
-        * passportNumber = The provided idValue is a passport number.
-        * driverLicense = The provided idValue is driving License of the individual.
-        * companyRegistrationNumber = The provided idValue is a company identifier. It verifies its legal existence as an incorporated entity.
-        * socialSecurityNumber =n The provided idValue is a social security number, issued to an individual by the individual's government.
-        * alienRegistrationNumber = The provided idValue is an alien registration number, provided by immigration services of a country.
-        * lawEnforcementIdentification = The provided idValue is an alien registration number, provided by immigration services of a country.
-        * militaryIdentification = The provided idValue is an identification issued to military personnel of a country.
-        
-        Type: str
-        """
-        return self.__id_type
-
-    @id_type.setter
-    def id_type(self, value: Optional[str]) -> None:
-        self.__id_type = value
-
-    @property
-    def id_value(self) -> Optional[str]:
-        """
-        | The value of the identification
-        
-        Type: str
-        """
-        return self.__id_value
-
-    @id_value.setter
-    def id_value(self, value: Optional[str]) -> None:
-        self.__id_value = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PersonalIdentification, self).to_dictionary()
-        if self.id_issuing_country_code is not None:
-            dictionary['idIssuingCountryCode'] = self.id_issuing_country_code
-        if self.id_type is not None:
-            dictionary['idType'] = self.id_type
-        if self.id_value is not None:
-            dictionary['idValue'] = self.id_value
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PersonalIdentification':
-        super(PersonalIdentification, self).from_dictionary(dictionary)
-        if 'idIssuingCountryCode' in dictionary:
-            self.id_issuing_country_code = dictionary['idIssuingCountryCode']
-        if 'idType' in dictionary:
-            self.id_type = dictionary['idType']
-        if 'idValue' in dictionary:
-            self.id_value = dictionary['idValue']
-        return self

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

@@ -1,105 +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.personal_identification import PersonalIdentification
-from worldline.connect.sdk.v1.domain.personal_name import PersonalName
-
-
-class PersonalInformation(DataObject):
-
-    __date_of_birth: Optional[str] = None
-    __gender: Optional[str] = None
-    __identification: Optional[PersonalIdentification] = None
-    __name: Optional[PersonalName] = None
-
-    @property
-    def date_of_birth(self) -> Optional[str]:
-        """
-        | The date of birth of the customer
-        | Format: YYYYMMDD
-        
-        Type: str
-        """
-        return self.__date_of_birth
-
-    @date_of_birth.setter
-    def date_of_birth(self, value: Optional[str]) -> None:
-        self.__date_of_birth = value
-
-    @property
-    def gender(self) -> Optional[str]:
-        """
-        | The gender of the customer, possible values are:
-        
-        * male
-        * female
-        * unknown or empty
-        
-        Type: str
-        """
-        return self.__gender
-
-    @gender.setter
-    def gender(self, value: Optional[str]) -> None:
-        self.__gender = value
-
-    @property
-    def identification(self) -> Optional[PersonalIdentification]:
-        """
-        | Object containing identification documents information
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.personal_identification.PersonalIdentification`
-        """
-        return self.__identification
-
-    @identification.setter
-    def identification(self, value: Optional[PersonalIdentification]) -> None:
-        self.__identification = value
-
-    @property
-    def name(self) -> Optional[PersonalName]:
-        """
-        | Object containing the name details of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.personal_name.PersonalName`
-        """
-        return self.__name
-
-    @name.setter
-    def name(self, value: Optional[PersonalName]) -> None:
-        self.__name = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PersonalInformation, self).to_dictionary()
-        if self.date_of_birth is not None:
-            dictionary['dateOfBirth'] = self.date_of_birth
-        if self.gender is not None:
-            dictionary['gender'] = self.gender
-        if self.identification is not None:
-            dictionary['identification'] = self.identification.to_dictionary()
-        if self.name is not None:
-            dictionary['name'] = self.name.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PersonalInformation':
-        super(PersonalInformation, self).from_dictionary(dictionary)
-        if 'dateOfBirth' in dictionary:
-            self.date_of_birth = dictionary['dateOfBirth']
-        if 'gender' in dictionary:
-            self.gender = dictionary['gender']
-        if 'identification' in dictionary:
-            if not isinstance(dictionary['identification'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['identification']))
-            value = PersonalIdentification()
-            self.identification = value.from_dictionary(dictionary['identification'])
-        if 'name' in dictionary:
-            if not isinstance(dictionary['name'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['name']))
-            value = PersonalName()
-            self.name = value.from_dictionary(dictionary['name'])
-        return self

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

@@ -1,42 +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.personal_name_risk_assessment import PersonalNameRiskAssessment
-
-
-class PersonalInformationRiskAssessment(DataObject):
-
-    __name: Optional[PersonalNameRiskAssessment] = None
-
-    @property
-    def name(self) -> Optional[PersonalNameRiskAssessment]:
-        """
-        | Object containing the name details of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.personal_name_risk_assessment.PersonalNameRiskAssessment`
-        """
-        return self.__name
-
-    @name.setter
-    def name(self, value: Optional[PersonalNameRiskAssessment]) -> None:
-        self.__name = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PersonalInformationRiskAssessment, self).to_dictionary()
-        if self.name is not None:
-            dictionary['name'] = self.name.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PersonalInformationRiskAssessment':
-        super(PersonalInformationRiskAssessment, self).from_dictionary(dictionary)
-        if 'name' in dictionary:
-            if not isinstance(dictionary['name'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['name']))
-            value = PersonalNameRiskAssessment()
-            self.name = value.from_dictionary(dictionary['name'])
-        return self

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

@@ -1,42 +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.personal_name_token import PersonalNameToken
-
-
-class PersonalInformationToken(DataObject):
-
-    __name: Optional[PersonalNameToken] = None
-
-    @property
-    def name(self) -> Optional[PersonalNameToken]:
-        """
-        | Given name(s) or first name(s) of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.personal_name_token.PersonalNameToken`
-        """
-        return self.__name
-
-    @name.setter
-    def name(self, value: Optional[PersonalNameToken]) -> None:
-        self.__name = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PersonalInformationToken, self).to_dictionary()
-        if self.name is not None:
-            dictionary['name'] = self.name.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PersonalInformationToken':
-        super(PersonalInformationToken, self).from_dictionary(dictionary)
-        if 'name' in dictionary:
-            if not isinstance(dictionary['name'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['name']))
-            value = PersonalNameToken()
-            self.name = value.from_dictionary(dictionary['name'])
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/personal_name.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.v1.domain.personal_name_base import PersonalNameBase
-
-
-class PersonalName(PersonalNameBase):
-
-    __title: Optional[str] = None
-
-    @property
-    def title(self) -> Optional[str]:
-        """
-        | Title of customer
-        
-        Type: str
-        """
-        return self.__title
-
-    @title.setter
-    def title(self, value: Optional[str]) -> None:
-        self.__title = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PersonalName, self).to_dictionary()
-        if self.title is not None:
-            dictionary['title'] = self.title
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PersonalName':
-        super(PersonalName, self).from_dictionary(dictionary)
-        if 'title' in dictionary:
-            self.title = dictionary['title']
-        return self

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

@@ -1,72 +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 PersonalNameBase(DataObject):
-
-    __first_name: Optional[str] = None
-    __surname: Optional[str] = None
-    __surname_prefix: Optional[str] = None
-
-    @property
-    def first_name(self) -> Optional[str]:
-        """
-        | Given name(s) or first name(s) of the customer
-        
-        Type: str
-        """
-        return self.__first_name
-
-    @first_name.setter
-    def first_name(self, value: Optional[str]) -> None:
-        self.__first_name = value
-
-    @property
-    def surname(self) -> Optional[str]:
-        """
-        Type: str
-        """
-        return self.__surname
-
-    @surname.setter
-    def surname(self, value: Optional[str]) -> None:
-        self.__surname = value
-
-    @property
-    def surname_prefix(self) -> Optional[str]:
-        """
-        | Middle name - In between first name and surname - of the customer
-        
-        Type: str
-        """
-        return self.__surname_prefix
-
-    @surname_prefix.setter
-    def surname_prefix(self, value: Optional[str]) -> None:
-        self.__surname_prefix = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PersonalNameBase, self).to_dictionary()
-        if self.first_name is not None:
-            dictionary['firstName'] = self.first_name
-        if self.surname is not None:
-            dictionary['surname'] = self.surname
-        if self.surname_prefix is not None:
-            dictionary['surnamePrefix'] = self.surname_prefix
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PersonalNameBase':
-        super(PersonalNameBase, self).from_dictionary(dictionary)
-        if 'firstName' in dictionary:
-            self.first_name = dictionary['firstName']
-        if 'surname' in dictionary:
-            self.surname = dictionary['surname']
-        if 'surnamePrefix' in dictionary:
-            self.surname_prefix = dictionary['surnamePrefix']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/protection_eligibility.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
-
-
-class ProtectionEligibility(DataObject):
-
-    __eligibility: Optional[str] = None
-    __type: Optional[str] = None
-
-    @property
-    def eligibility(self) -> Optional[str]:
-        """
-        | Possible values: 
-        |  
-        *  Eligible 
-        *  PartiallyEligible 
-        *  Ineligible
-        
-        Type: str
-        """
-        return self.__eligibility
-
-    @eligibility.setter
-    def eligibility(self, value: Optional[str]) -> None:
-        self.__eligibility = value
-
-    @property
-    def type(self) -> Optional[str]:
-        """
-        | Possible values: 
-        |  
-        *  ItemNotReceivedEligible 
-        *  UnauthorizedPaymentEligible 
-        *  Ineligible
-        
-        Type: str
-        """
-        return self.__type
-
-    @type.setter
-    def type(self, value: Optional[str]) -> None:
-        self.__type = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(ProtectionEligibility, self).to_dictionary()
-        if self.eligibility is not None:
-            dictionary['eligibility'] = self.eligibility
-        if self.type is not None:
-            dictionary['type'] = self.type
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'ProtectionEligibility':
-        super(ProtectionEligibility, self).from_dictionary(dictionary)
-        if 'eligibility' in dictionary:
-            self.eligibility = dictionary['eligibility']
-        if 'type' in dictionary:
-            self.type = dictionary['type']
-        return self

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

@@ -1,56 +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 RangeValidator(DataObject):
-
-    __max_value: Optional[int] = None
-    __min_value: Optional[int] = None
-
-    @property
-    def max_value(self) -> Optional[int]:
-        """
-        | Upper value of the range that is still valid
-        
-        Type: int
-        """
-        return self.__max_value
-
-    @max_value.setter
-    def max_value(self, value: Optional[int]) -> None:
-        self.__max_value = value
-
-    @property
-    def min_value(self) -> Optional[int]:
-        """
-        | Lower value of the range that is still valid
-        
-        Type: int
-        """
-        return self.__min_value
-
-    @min_value.setter
-    def min_value(self, value: Optional[int]) -> None:
-        self.__min_value = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RangeValidator, self).to_dictionary()
-        if self.max_value is not None:
-            dictionary['maxValue'] = self.max_value
-        if self.min_value is not None:
-            dictionary['minValue'] = self.min_value
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RangeValidator':
-        super(RangeValidator, self).from_dictionary(dictionary)
-        if 'maxValue' in dictionary:
-            self.max_value = dictionary['maxValue']
-        if 'minValue' in dictionary:
-            self.min_value = dictionary['minValue']
-        return self

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

@@ -1,72 +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.frequency import Frequency
-from worldline.connect.sdk.v1.domain.trial_information import TrialInformation
-
-
-class RecurringPaymentsData(DataObject):
-    """
-    | The object containing reference data for the text that can be displayed on MyCheckout hosted payment page with subscription information.
-    
-    | Note:
-    
-    | The data in this object is only meant for displaying recurring payments-related data on your checkout page.
-    | You still need to submit all the recurring payment-related data in the corresponding payment product-specific input. (example: cardPaymentMethodSpecificInput.recurring and cardPaymentMethodSpecificInput.isRecurring)
-    """
-
-    __recurring_interval: Optional[Frequency] = None
-    __trial_information: Optional[TrialInformation] = None
-
-    @property
-    def recurring_interval(self) -> Optional[Frequency]:
-        """
-        | The object containing the frequency and interval between recurring payments.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.frequency.Frequency`
-        """
-        return self.__recurring_interval
-
-    @recurring_interval.setter
-    def recurring_interval(self, value: Optional[Frequency]) -> None:
-        self.__recurring_interval = value
-
-    @property
-    def trial_information(self) -> Optional[TrialInformation]:
-        """
-        | The object containing data of the trial period: no-cost or discounted time-constrained trial subscription period. 
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.trial_information.TrialInformation`
-        """
-        return self.__trial_information
-
-    @trial_information.setter
-    def trial_information(self, value: Optional[TrialInformation]) -> None:
-        self.__trial_information = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RecurringPaymentsData, self).to_dictionary()
-        if self.recurring_interval is not None:
-            dictionary['recurringInterval'] = self.recurring_interval.to_dictionary()
-        if self.trial_information is not None:
-            dictionary['trialInformation'] = self.trial_information.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RecurringPaymentsData':
-        super(RecurringPaymentsData, self).from_dictionary(dictionary)
-        if 'recurringInterval' in dictionary:
-            if not isinstance(dictionary['recurringInterval'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['recurringInterval']))
-            value = Frequency()
-            self.recurring_interval = value.from_dictionary(dictionary['recurringInterval'])
-        if 'trialInformation' in dictionary:
-            if not isinstance(dictionary['trialInformation'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['trialInformation']))
-            value = TrialInformation()
-            self.trial_information = value.from_dictionary(dictionary['trialInformation'])
-        return self