connect-sdk-python3 4.0.0__zip → 4.1.0__zip

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

@@ -0,0 +1,76 @@
+# -*- 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 MandateApproval(DataObject):
+
+    __mandate_signature_date: Optional[str] = None
+    __mandate_signature_place: Optional[str] = None
+    __mandate_signed: Optional[bool] = None
+
+    @property
+    def mandate_signature_date(self) -> Optional[str]:
+        """
+        | The date when the mandate was signed
+        | Format: YYYYMMDD
+
+        Type: str
+        """
+        return self.__mandate_signature_date
+
+    @mandate_signature_date.setter
+    def mandate_signature_date(self, value: Optional[str]) -> None:
+        self.__mandate_signature_date = value
+
+    @property
+    def mandate_signature_place(self) -> Optional[str]:
+        """
+        | The city where the mandate was signed
+
+        Type: str
+        """
+        return self.__mandate_signature_place
+
+    @mandate_signature_place.setter
+    def mandate_signature_place(self, value: Optional[str]) -> None:
+        self.__mandate_signature_place = value
+
+    @property
+    def mandate_signed(self) -> Optional[bool]:
+        """
+        * true = Mandate is signed
+        * false = Mandate is not signed
+
+        Type: bool
+        """
+        return self.__mandate_signed
+
+    @mandate_signed.setter
+    def mandate_signed(self, value: Optional[bool]) -> None:
+        self.__mandate_signed = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MandateApproval, self).to_dictionary()
+        if self.mandate_signature_date is not None:
+            dictionary['mandateSignatureDate'] = self.mandate_signature_date
+        if self.mandate_signature_place is not None:
+            dictionary['mandateSignaturePlace'] = self.mandate_signature_place
+        if self.mandate_signed is not None:
+            dictionary['mandateSigned'] = self.mandate_signed
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MandateApproval':
+        super(MandateApproval, self).from_dictionary(dictionary)
+        if 'mandateSignatureDate' in dictionary:
+            self.mandate_signature_date = dictionary['mandateSignatureDate']
+        if 'mandateSignaturePlace' in dictionary:
+            self.mandate_signature_place = dictionary['mandateSignaturePlace']
+        if 'mandateSigned' in dictionary:
+            self.mandate_signed = dictionary['mandateSigned']
+        return self

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

@@ -0,0 +1,41 @@
+# -*- 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 MandateContactDetails(DataObject):
+    """
+    | Contact details of the consumer
+    """
+
+    __email_address: Optional[str] = None
+
+    @property
+    def email_address(self) -> Optional[str]:
+        """
+        | Email address of the customer
+
+        Type: str
+        """
+        return self.__email_address
+
+    @email_address.setter
+    def email_address(self, value: Optional[str]) -> None:
+        self.__email_address = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MandateContactDetails, self).to_dictionary()
+        if self.email_address is not None:
+            dictionary['emailAddress'] = self.email_address
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MandateContactDetails':
+        super(MandateContactDetails, self).from_dictionary(dictionary)
+        if 'emailAddress' in dictionary:
+            self.email_address = dictionary['emailAddress']
+        return self

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

@@ -0,0 +1,126 @@
+# -*- 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.bank_account_iban import BankAccountIban
+from worldline.connect.sdk.v1.domain.mandate_address import MandateAddress
+from worldline.connect.sdk.v1.domain.mandate_contact_details import MandateContactDetails
+from worldline.connect.sdk.v1.domain.mandate_personal_information import MandatePersonalInformation
+
+
+class MandateCustomer(DataObject):
+
+    __bank_account_iban: Optional[BankAccountIban] = None
+    __company_name: Optional[str] = None
+    __contact_details: Optional[MandateContactDetails] = None
+    __mandate_address: Optional[MandateAddress] = None
+    __personal_information: Optional[MandatePersonalInformation] = None
+
+    @property
+    def bank_account_iban(self) -> Optional[BankAccountIban]:
+        """
+        | Object containing IBAN information
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_iban.BankAccountIban`
+        """
+        return self.__bank_account_iban
+
+    @bank_account_iban.setter
+    def bank_account_iban(self, value: Optional[BankAccountIban]) -> None:
+        self.__bank_account_iban = value
+
+    @property
+    def company_name(self) -> Optional[str]:
+        """
+        | Name of company, as a customer
+
+        Type: str
+        """
+        return self.__company_name
+
+    @company_name.setter
+    def company_name(self, value: Optional[str]) -> None:
+        self.__company_name = value
+
+    @property
+    def contact_details(self) -> Optional[MandateContactDetails]:
+        """
+        | Object containing contact details like email address and phone number
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mandate_contact_details.MandateContactDetails`
+        """
+        return self.__contact_details
+
+    @contact_details.setter
+    def contact_details(self, value: Optional[MandateContactDetails]) -> None:
+        self.__contact_details = value
+
+    @property
+    def mandate_address(self) -> Optional[MandateAddress]:
+        """
+        | Object containing billing address details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mandate_address.MandateAddress`
+        """
+        return self.__mandate_address
+
+    @mandate_address.setter
+    def mandate_address(self, value: Optional[MandateAddress]) -> None:
+        self.__mandate_address = value
+
+    @property
+    def personal_information(self) -> Optional[MandatePersonalInformation]:
+        """
+        | Object containing personal information of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mandate_personal_information.MandatePersonalInformation`
+        """
+        return self.__personal_information
+
+    @personal_information.setter
+    def personal_information(self, value: Optional[MandatePersonalInformation]) -> None:
+        self.__personal_information = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MandateCustomer, self).to_dictionary()
+        if self.bank_account_iban is not None:
+            dictionary['bankAccountIban'] = self.bank_account_iban.to_dictionary()
+        if self.company_name is not None:
+            dictionary['companyName'] = self.company_name
+        if self.contact_details is not None:
+            dictionary['contactDetails'] = self.contact_details.to_dictionary()
+        if self.mandate_address is not None:
+            dictionary['mandateAddress'] = self.mandate_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) -> 'MandateCustomer':
+        super(MandateCustomer, self).from_dictionary(dictionary)
+        if 'bankAccountIban' in dictionary:
+            if not isinstance(dictionary['bankAccountIban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountIban']))
+            value = BankAccountIban()
+            self.bank_account_iban = value.from_dictionary(dictionary['bankAccountIban'])
+        if 'companyName' in dictionary:
+            self.company_name = dictionary['companyName']
+        if 'contactDetails' in dictionary:
+            if not isinstance(dictionary['contactDetails'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['contactDetails']))
+            value = MandateContactDetails()
+            self.contact_details = value.from_dictionary(dictionary['contactDetails'])
+        if 'mandateAddress' in dictionary:
+            if not isinstance(dictionary['mandateAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mandateAddress']))
+            value = MandateAddress()
+            self.mandate_address = value.from_dictionary(dictionary['mandateAddress'])
+        if 'personalInformation' in dictionary:
+            if not isinstance(dictionary['personalInformation'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['personalInformation']))
+            value = MandatePersonalInformation()
+            self.personal_information = value.from_dictionary(dictionary['personalInformation'])
+        return self

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

@@ -0,0 +1,62 @@
+# -*- 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_redirect_data import MandateRedirectData
+
+
+class MandateMerchantAction(DataObject):
+
+    __action_type: Optional[str] = None
+    __redirect_data: Optional[MandateRedirectData] = None
+
+    @property
+    def action_type(self) -> Optional[str]:
+        """
+        | Action merchants needs to take in the online mandate process. Possible values are:
+        
+        * REDIRECT - The customer needs to be redirected using the details found in redirectData
+
+        Type: str
+        """
+        return self.__action_type
+
+    @action_type.setter
+    def action_type(self, value: Optional[str]) -> None:
+        self.__action_type = value
+
+    @property
+    def redirect_data(self) -> Optional[MandateRedirectData]:
+        """
+        | Object containing all data needed to redirect the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mandate_redirect_data.MandateRedirectData`
+        """
+        return self.__redirect_data
+
+    @redirect_data.setter
+    def redirect_data(self, value: Optional[MandateRedirectData]) -> None:
+        self.__redirect_data = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MandateMerchantAction, self).to_dictionary()
+        if self.action_type is not None:
+            dictionary['actionType'] = self.action_type
+        if self.redirect_data is not None:
+            dictionary['redirectData'] = self.redirect_data.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MandateMerchantAction':
+        super(MandateMerchantAction, self).from_dictionary(dictionary)
+        if 'actionType' in dictionary:
+            self.action_type = dictionary['actionType']
+        if 'redirectData' in dictionary:
+            if not isinstance(dictionary['redirectData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectData']))
+            value = MandateRedirectData()
+            self.redirect_data = value.from_dictionary(dictionary['redirectData'])
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/mandate_non_sepa_direct_debit.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.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit_payment_product705_specific_data import TokenNonSepaDirectDebitPaymentProduct705SpecificData
+from worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit_payment_product730_specific_data import TokenNonSepaDirectDebitPaymentProduct730SpecificData
+
+
+class MandateNonSepaDirectDebit(DataObject):
+
+    __payment_product705_specific_data: Optional[TokenNonSepaDirectDebitPaymentProduct705SpecificData] = None
+    __payment_product730_specific_data: Optional[TokenNonSepaDirectDebitPaymentProduct730SpecificData] = None
+
+    @property
+    def payment_product705_specific_data(self) -> Optional[TokenNonSepaDirectDebitPaymentProduct705SpecificData]:
+        """
+        | Object containing specific data for Direct Debit UK
+
+        Type: :class:`worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit_payment_product705_specific_data.TokenNonSepaDirectDebitPaymentProduct705SpecificData`
+        """
+        return self.__payment_product705_specific_data
+
+    @payment_product705_specific_data.setter
+    def payment_product705_specific_data(self, value: Optional[TokenNonSepaDirectDebitPaymentProduct705SpecificData]) -> None:
+        self.__payment_product705_specific_data = value
+
+    @property
+    def payment_product730_specific_data(self) -> Optional[TokenNonSepaDirectDebitPaymentProduct730SpecificData]:
+        """
+        | Object containing specific data for ACH
+
+        Type: :class:`worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit_payment_product730_specific_data.TokenNonSepaDirectDebitPaymentProduct730SpecificData`
+        """
+        return self.__payment_product730_specific_data
+
+    @payment_product730_specific_data.setter
+    def payment_product730_specific_data(self, value: Optional[TokenNonSepaDirectDebitPaymentProduct730SpecificData]) -> None:
+        self.__payment_product730_specific_data = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MandateNonSepaDirectDebit, self).to_dictionary()
+        if self.payment_product705_specific_data is not None:
+            dictionary['paymentProduct705SpecificData'] = self.payment_product705_specific_data.to_dictionary()
+        if self.payment_product730_specific_data is not None:
+            dictionary['paymentProduct730SpecificData'] = self.payment_product730_specific_data.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MandateNonSepaDirectDebit':
+        super(MandateNonSepaDirectDebit, self).from_dictionary(dictionary)
+        if 'paymentProduct705SpecificData' in dictionary:
+            if not isinstance(dictionary['paymentProduct705SpecificData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct705SpecificData']))
+            value = TokenNonSepaDirectDebitPaymentProduct705SpecificData()
+            self.payment_product705_specific_data = value.from_dictionary(dictionary['paymentProduct705SpecificData'])
+        if 'paymentProduct730SpecificData' in dictionary:
+            if not isinstance(dictionary['paymentProduct730SpecificData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct730SpecificData']))
+            value = TokenNonSepaDirectDebitPaymentProduct730SpecificData()
+            self.payment_product730_specific_data = value.from_dictionary(dictionary['paymentProduct730SpecificData'])
+        return self

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

@@ -0,0 +1,60 @@
+# -*- 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_personal_name import MandatePersonalName
+
+
+class MandatePersonalInformation(DataObject):
+
+    __name: Optional[MandatePersonalName] = None
+    __title: Optional[str] = None
+
+    @property
+    def name(self) -> Optional[MandatePersonalName]:
+        """
+        | Object containing the name details of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mandate_personal_name.MandatePersonalName`
+        """
+        return self.__name
+
+    @name.setter
+    def name(self, value: Optional[MandatePersonalName]) -> None:
+        self.__name = value
+
+    @property
+    def title(self) -> Optional[str]:
+        """
+        | Object containing the title of the customer (Mr, Miss or Mrs)
+
+        Type: str
+        """
+        return self.__title
+
+    @title.setter
+    def title(self, value: Optional[str]) -> None:
+        self.__title = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MandatePersonalInformation, self).to_dictionary()
+        if self.name is not None:
+            dictionary['name'] = self.name.to_dictionary()
+        if self.title is not None:
+            dictionary['title'] = self.title
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MandatePersonalInformation':
+        super(MandatePersonalInformation, 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 = MandatePersonalName()
+            self.name = value.from_dictionary(dictionary['name'])
+        if 'title' in dictionary:
+            self.title = dictionary['title']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/mandate_personal_name.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 MandatePersonalName(DataObject):
+
+    __first_name: Optional[str] = None
+    __surname: 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]:
+        """
+        | Surname(s) or last name(s) of the customer
+
+        Type: str
+        """
+        return self.__surname
+
+    @surname.setter
+    def surname(self, value: Optional[str]) -> None:
+        self.__surname = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MandatePersonalName, 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
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MandatePersonalName':
+        super(MandatePersonalName, self).from_dictionary(dictionary)
+        if 'firstName' in dictionary:
+            self.first_name = dictionary['firstName']
+        if 'surname' in dictionary:
+            self.surname = dictionary['surname']
+        return self

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

@@ -0,0 +1,142 @@
+# -*- 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 MandateResponse(DataObject):
+
+    __alias: Optional[str] = None
+    __customer: Optional[MandateCustomer] = None
+    __customer_reference: Optional[str] = None
+    __recurrence_type: Optional[str] = None
+    __status: 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 the customer to which this mandate is applicable
+
+        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]:
+        """
+        | Specifieds whether the mandate is for one-off or recurring payments.
+
+        Type: str
+        """
+        return self.__recurrence_type
+
+    @recurrence_type.setter
+    def recurrence_type(self, value: Optional[str]) -> None:
+        self.__recurrence_type = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | The status of the mandate. Possible values are:
+        
+        * ACTIVE
+        * EXPIRED
+        * CREATED
+        * REVOKED
+        * WAITING_FOR_REFERENCE
+        * BLOCKED
+        * USED
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = 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(MandateResponse, 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.status is not None:
+            dictionary['status'] = self.status
+        if self.unique_mandate_reference is not None:
+            dictionary['uniqueMandateReference'] = self.unique_mandate_reference
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MandateResponse':
+        super(MandateResponse, 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 'status' in dictionary:
+            self.status = dictionary['status']
+        if 'uniqueMandateReference' in dictionary:
+            self.unique_mandate_reference = dictionary['uniqueMandateReference']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/mandate_sepa_direct_debit.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.creditor import Creditor
+from worldline.connect.sdk.v1.domain.mandate_sepa_direct_debit_with_mandate_id import MandateSepaDirectDebitWithMandateId
+
+
+class MandateSepaDirectDebit(MandateSepaDirectDebitWithMandateId):
+
+    __creditor: Optional[Creditor] = None
+
+    @property
+    def creditor(self) -> Optional[Creditor]:
+        """
+        | Object containing information on the creditor
+
+        Type: :class:`worldline.connect.sdk.v1.domain.creditor.Creditor`
+        """
+        return self.__creditor
+
+    @creditor.setter
+    def creditor(self, value: Optional[Creditor]) -> None:
+        self.__creditor = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MandateSepaDirectDebit, self).to_dictionary()
+        if self.creditor is not None:
+            dictionary['creditor'] = self.creditor.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MandateSepaDirectDebit':
+        super(MandateSepaDirectDebit, self).from_dictionary(dictionary)
+        if 'creditor' in dictionary:
+            if not isinstance(dictionary['creditor'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['creditor']))
+            value = Creditor()
+            self.creditor = value.from_dictionary(dictionary['creditor'])
+        return self