connect-sdk-python3 3.47.0__zip → 4.0.1__zip

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

@@ -0,0 +1,262 @@
+# -*- 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_transfer_payment_method_specific_input_base import BankTransferPaymentMethodSpecificInputBase
+from worldline.connect.sdk.v1.domain.card_payment_method_specific_input_base import CardPaymentMethodSpecificInputBase
+from worldline.connect.sdk.v1.domain.cash_payment_method_specific_input_base import CashPaymentMethodSpecificInputBase
+from worldline.connect.sdk.v1.domain.e_invoice_payment_method_specific_input_base import EInvoicePaymentMethodSpecificInputBase
+from worldline.connect.sdk.v1.domain.fraud_fields import FraudFields
+from worldline.connect.sdk.v1.domain.hosted_checkout_specific_input import HostedCheckoutSpecificInput
+from worldline.connect.sdk.v1.domain.merchant import Merchant
+from worldline.connect.sdk.v1.domain.mobile_payment_method_specific_input_hosted_checkout import MobilePaymentMethodSpecificInputHostedCheckout
+from worldline.connect.sdk.v1.domain.order import Order
+from worldline.connect.sdk.v1.domain.redirect_payment_method_specific_input_base import RedirectPaymentMethodSpecificInputBase
+from worldline.connect.sdk.v1.domain.sepa_direct_debit_payment_method_specific_input_base import SepaDirectDebitPaymentMethodSpecificInputBase
+
+
+class CreateHostedCheckoutRequest(DataObject):
+
+    __bank_transfer_payment_method_specific_input: Optional[BankTransferPaymentMethodSpecificInputBase] = None
+    __card_payment_method_specific_input: Optional[CardPaymentMethodSpecificInputBase] = None
+    __cash_payment_method_specific_input: Optional[CashPaymentMethodSpecificInputBase] = None
+    __e_invoice_payment_method_specific_input: Optional[EInvoicePaymentMethodSpecificInputBase] = None
+    __fraud_fields: Optional[FraudFields] = None
+    __hosted_checkout_specific_input: Optional[HostedCheckoutSpecificInput] = None
+    __merchant: Optional[Merchant] = None
+    __mobile_payment_method_specific_input: Optional[MobilePaymentMethodSpecificInputHostedCheckout] = None
+    __order: Optional[Order] = None
+    __redirect_payment_method_specific_input: Optional[RedirectPaymentMethodSpecificInputBase] = None
+    __sepa_direct_debit_payment_method_specific_input: Optional[SepaDirectDebitPaymentMethodSpecificInputBase] = None
+
+    @property
+    def bank_transfer_payment_method_specific_input(self) -> Optional[BankTransferPaymentMethodSpecificInputBase]:
+        """
+        | Object containing the specific input details for bank transfer payments
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_transfer_payment_method_specific_input_base.BankTransferPaymentMethodSpecificInputBase`
+        """
+        return self.__bank_transfer_payment_method_specific_input
+
+    @bank_transfer_payment_method_specific_input.setter
+    def bank_transfer_payment_method_specific_input(self, value: Optional[BankTransferPaymentMethodSpecificInputBase]) -> None:
+        self.__bank_transfer_payment_method_specific_input = value
+
+    @property
+    def card_payment_method_specific_input(self) -> Optional[CardPaymentMethodSpecificInputBase]:
+        """
+        | Object containing the specific input details for card payments
+
+        Type: :class:`worldline.connect.sdk.v1.domain.card_payment_method_specific_input_base.CardPaymentMethodSpecificInputBase`
+        """
+        return self.__card_payment_method_specific_input
+
+    @card_payment_method_specific_input.setter
+    def card_payment_method_specific_input(self, value: Optional[CardPaymentMethodSpecificInputBase]) -> None:
+        self.__card_payment_method_specific_input = value
+
+    @property
+    def cash_payment_method_specific_input(self) -> Optional[CashPaymentMethodSpecificInputBase]:
+        """
+        | Object containing the specific input details for cash payments
+
+        Type: :class:`worldline.connect.sdk.v1.domain.cash_payment_method_specific_input_base.CashPaymentMethodSpecificInputBase`
+        """
+        return self.__cash_payment_method_specific_input
+
+    @cash_payment_method_specific_input.setter
+    def cash_payment_method_specific_input(self, value: Optional[CashPaymentMethodSpecificInputBase]) -> None:
+        self.__cash_payment_method_specific_input = value
+
+    @property
+    def e_invoice_payment_method_specific_input(self) -> Optional[EInvoicePaymentMethodSpecificInputBase]:
+        """
+        | Object containing the specific input details for eInvoice payments
+
+        Type: :class:`worldline.connect.sdk.v1.domain.e_invoice_payment_method_specific_input_base.EInvoicePaymentMethodSpecificInputBase`
+        """
+        return self.__e_invoice_payment_method_specific_input
+
+    @e_invoice_payment_method_specific_input.setter
+    def e_invoice_payment_method_specific_input(self, value: Optional[EInvoicePaymentMethodSpecificInputBase]) -> None:
+        self.__e_invoice_payment_method_specific_input = value
+
+    @property
+    def fraud_fields(self) -> Optional[FraudFields]:
+        """
+        | Object containing additional data that will be used to assess the risk of fraud
+
+        Type: :class:`worldline.connect.sdk.v1.domain.fraud_fields.FraudFields`
+        """
+        return self.__fraud_fields
+
+    @fraud_fields.setter
+    def fraud_fields(self, value: Optional[FraudFields]) -> None:
+        self.__fraud_fields = value
+
+    @property
+    def hosted_checkout_specific_input(self) -> Optional[HostedCheckoutSpecificInput]:
+        """
+        | Object containing hosted checkout specific data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.hosted_checkout_specific_input.HostedCheckoutSpecificInput`
+        """
+        return self.__hosted_checkout_specific_input
+
+    @hosted_checkout_specific_input.setter
+    def hosted_checkout_specific_input(self, value: Optional[HostedCheckoutSpecificInput]) -> None:
+        self.__hosted_checkout_specific_input = value
+
+    @property
+    def merchant(self) -> Optional[Merchant]:
+        """
+        | Object containing information on you, the merchant
+
+        Type: :class:`worldline.connect.sdk.v1.domain.merchant.Merchant`
+        """
+        return self.__merchant
+
+    @merchant.setter
+    def merchant(self, value: Optional[Merchant]) -> None:
+        self.__merchant = value
+
+    @property
+    def mobile_payment_method_specific_input(self) -> Optional[MobilePaymentMethodSpecificInputHostedCheckout]:
+        """
+        | Object containing reference data for Google Pay (paymentProductId 320) and Apple Pay (paymentProductID 302).
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mobile_payment_method_specific_input_hosted_checkout.MobilePaymentMethodSpecificInputHostedCheckout`
+        """
+        return self.__mobile_payment_method_specific_input
+
+    @mobile_payment_method_specific_input.setter
+    def mobile_payment_method_specific_input(self, value: Optional[MobilePaymentMethodSpecificInputHostedCheckout]) -> None:
+        self.__mobile_payment_method_specific_input = value
+
+    @property
+    def order(self) -> Optional[Order]:
+        """
+        | Order object containing order related data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.order.Order`
+        """
+        return self.__order
+
+    @order.setter
+    def order(self, value: Optional[Order]) -> None:
+        self.__order = value
+
+    @property
+    def redirect_payment_method_specific_input(self) -> Optional[RedirectPaymentMethodSpecificInputBase]:
+        """
+        | Object containing the specific input details for payments that involve redirects to 3rd parties to complete, like iDeal and PayPal
+
+        Type: :class:`worldline.connect.sdk.v1.domain.redirect_payment_method_specific_input_base.RedirectPaymentMethodSpecificInputBase`
+        """
+        return self.__redirect_payment_method_specific_input
+
+    @redirect_payment_method_specific_input.setter
+    def redirect_payment_method_specific_input(self, value: Optional[RedirectPaymentMethodSpecificInputBase]) -> None:
+        self.__redirect_payment_method_specific_input = value
+
+    @property
+    def sepa_direct_debit_payment_method_specific_input(self) -> Optional[SepaDirectDebitPaymentMethodSpecificInputBase]:
+        """
+        | Object containing the specific input details for SEPA direct debit payments
+
+        Type: :class:`worldline.connect.sdk.v1.domain.sepa_direct_debit_payment_method_specific_input_base.SepaDirectDebitPaymentMethodSpecificInputBase`
+        """
+        return self.__sepa_direct_debit_payment_method_specific_input
+
+    @sepa_direct_debit_payment_method_specific_input.setter
+    def sepa_direct_debit_payment_method_specific_input(self, value: Optional[SepaDirectDebitPaymentMethodSpecificInputBase]) -> None:
+        self.__sepa_direct_debit_payment_method_specific_input = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateHostedCheckoutRequest, self).to_dictionary()
+        if self.bank_transfer_payment_method_specific_input is not None:
+            dictionary['bankTransferPaymentMethodSpecificInput'] = self.bank_transfer_payment_method_specific_input.to_dictionary()
+        if self.card_payment_method_specific_input is not None:
+            dictionary['cardPaymentMethodSpecificInput'] = self.card_payment_method_specific_input.to_dictionary()
+        if self.cash_payment_method_specific_input is not None:
+            dictionary['cashPaymentMethodSpecificInput'] = self.cash_payment_method_specific_input.to_dictionary()
+        if self.e_invoice_payment_method_specific_input is not None:
+            dictionary['eInvoicePaymentMethodSpecificInput'] = self.e_invoice_payment_method_specific_input.to_dictionary()
+        if self.fraud_fields is not None:
+            dictionary['fraudFields'] = self.fraud_fields.to_dictionary()
+        if self.hosted_checkout_specific_input is not None:
+            dictionary['hostedCheckoutSpecificInput'] = self.hosted_checkout_specific_input.to_dictionary()
+        if self.merchant is not None:
+            dictionary['merchant'] = self.merchant.to_dictionary()
+        if self.mobile_payment_method_specific_input is not None:
+            dictionary['mobilePaymentMethodSpecificInput'] = self.mobile_payment_method_specific_input.to_dictionary()
+        if self.order is not None:
+            dictionary['order'] = self.order.to_dictionary()
+        if self.redirect_payment_method_specific_input is not None:
+            dictionary['redirectPaymentMethodSpecificInput'] = self.redirect_payment_method_specific_input.to_dictionary()
+        if self.sepa_direct_debit_payment_method_specific_input is not None:
+            dictionary['sepaDirectDebitPaymentMethodSpecificInput'] = self.sepa_direct_debit_payment_method_specific_input.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateHostedCheckoutRequest':
+        super(CreateHostedCheckoutRequest, self).from_dictionary(dictionary)
+        if 'bankTransferPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['bankTransferPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankTransferPaymentMethodSpecificInput']))
+            value = BankTransferPaymentMethodSpecificInputBase()
+            self.bank_transfer_payment_method_specific_input = value.from_dictionary(dictionary['bankTransferPaymentMethodSpecificInput'])
+        if 'cardPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['cardPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardPaymentMethodSpecificInput']))
+            value = CardPaymentMethodSpecificInputBase()
+            self.card_payment_method_specific_input = value.from_dictionary(dictionary['cardPaymentMethodSpecificInput'])
+        if 'cashPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['cashPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cashPaymentMethodSpecificInput']))
+            value = CashPaymentMethodSpecificInputBase()
+            self.cash_payment_method_specific_input = value.from_dictionary(dictionary['cashPaymentMethodSpecificInput'])
+        if 'eInvoicePaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['eInvoicePaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['eInvoicePaymentMethodSpecificInput']))
+            value = EInvoicePaymentMethodSpecificInputBase()
+            self.e_invoice_payment_method_specific_input = value.from_dictionary(dictionary['eInvoicePaymentMethodSpecificInput'])
+        if 'fraudFields' in dictionary:
+            if not isinstance(dictionary['fraudFields'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraudFields']))
+            value = FraudFields()
+            self.fraud_fields = value.from_dictionary(dictionary['fraudFields'])
+        if 'hostedCheckoutSpecificInput' in dictionary:
+            if not isinstance(dictionary['hostedCheckoutSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['hostedCheckoutSpecificInput']))
+            value = HostedCheckoutSpecificInput()
+            self.hosted_checkout_specific_input = value.from_dictionary(dictionary['hostedCheckoutSpecificInput'])
+        if 'merchant' in dictionary:
+            if not isinstance(dictionary['merchant'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['merchant']))
+            value = Merchant()
+            self.merchant = value.from_dictionary(dictionary['merchant'])
+        if 'mobilePaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['mobilePaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mobilePaymentMethodSpecificInput']))
+            value = MobilePaymentMethodSpecificInputHostedCheckout()
+            self.mobile_payment_method_specific_input = value.from_dictionary(dictionary['mobilePaymentMethodSpecificInput'])
+        if 'order' in dictionary:
+            if not isinstance(dictionary['order'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['order']))
+            value = Order()
+            self.order = value.from_dictionary(dictionary['order'])
+        if 'redirectPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['redirectPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectPaymentMethodSpecificInput']))
+            value = RedirectPaymentMethodSpecificInputBase()
+            self.redirect_payment_method_specific_input = value.from_dictionary(dictionary['redirectPaymentMethodSpecificInput'])
+        if 'sepaDirectDebitPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['sepaDirectDebitPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sepaDirectDebitPaymentMethodSpecificInput']))
+            value = SepaDirectDebitPaymentMethodSpecificInputBase()
+            self.sepa_direct_debit_payment_method_specific_input = value.from_dictionary(dictionary['sepaDirectDebitPaymentMethodSpecificInput'])
+        return self

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

@@ -0,0 +1,119 @@
+# -*- 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 CreateHostedCheckoutResponse(DataObject):
+
+    __returnmac: Optional[str] = None
+    __hosted_checkout_id: Optional[str] = None
+    __invalid_tokens: Optional[List[str]] = None
+    __merchant_reference: Optional[str] = None
+    __partial_redirect_url: Optional[str] = None
+
+    @property
+    def returnmac(self) -> Optional[str]:
+        """
+        | When the customer is returned to your site we will append this property and value to the query-string. You should store this data, so you can identify the returning customer.
+
+        Type: str
+        """
+        return self.__returnmac
+
+    @returnmac.setter
+    def returnmac(self, value: Optional[str]) -> None:
+        self.__returnmac = value
+
+    @property
+    def hosted_checkout_id(self) -> Optional[str]:
+        """
+        | This is the ID under which the data for this checkout can be retrieved.
+
+        Type: str
+        """
+        return self.__hosted_checkout_id
+
+    @hosted_checkout_id.setter
+    def hosted_checkout_id(self, value: Optional[str]) -> None:
+        self.__hosted_checkout_id = value
+
+    @property
+    def invalid_tokens(self) -> Optional[List[str]]:
+        """
+        | Tokens that are submitted in the request are validated. In case any of the tokens can't be used anymore they are returned in this array. You should most likely remove those tokens from your system.
+
+        Type: list[str]
+        """
+        return self.__invalid_tokens
+
+    @invalid_tokens.setter
+    def invalid_tokens(self, value: Optional[List[str]]) -> None:
+        self.__invalid_tokens = value
+
+    @property
+    def merchant_reference(self) -> Optional[str]:
+        """
+        | If a payment is created during this hosted checkout, then it will use this merchantReference. This is the merchantReference you provided in the Create Hosted Checkout request, or if you did not provide one, a reference generated by Connect. This allows you to to link a webhook related to the created payment back to this hosted checkout using the webhook's paymentOutput.references.merchantReference.
+        
+        | This property is intended primarily for hosted checkouts on the Ogone Payment Platform. On the GlobalCollect platform, you can also use hostedCheckoutSpecificOutput.hostedCheckoutId.
+
+        Type: str
+        """
+        return self.__merchant_reference
+
+    @merchant_reference.setter
+    def merchant_reference(self, value: Optional[str]) -> None:
+        self.__merchant_reference = value
+
+    @property
+    def partial_redirect_url(self) -> Optional[str]:
+        """
+        | The partial URL as generated by our system. You will need to add the protocol and the relevant subdomain to this URL, before redirecting your customer to this URL. A special 'payment' subdomain will always work so you can always add 'https://payment.' at the beginning of this response value to view your MyCheckout hosted payment pages.
+
+        Type: str
+        """
+        return self.__partial_redirect_url
+
+    @partial_redirect_url.setter
+    def partial_redirect_url(self, value: Optional[str]) -> None:
+        self.__partial_redirect_url = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateHostedCheckoutResponse, self).to_dictionary()
+        if self.returnmac is not None:
+            dictionary['RETURNMAC'] = self.returnmac
+        if self.hosted_checkout_id is not None:
+            dictionary['hostedCheckoutId'] = self.hosted_checkout_id
+        if self.invalid_tokens is not None:
+            dictionary['invalidTokens'] = []
+            for element in self.invalid_tokens:
+                if element is not None:
+                    dictionary['invalidTokens'].append(element)
+        if self.merchant_reference is not None:
+            dictionary['merchantReference'] = self.merchant_reference
+        if self.partial_redirect_url is not None:
+            dictionary['partialRedirectUrl'] = self.partial_redirect_url
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateHostedCheckoutResponse':
+        super(CreateHostedCheckoutResponse, self).from_dictionary(dictionary)
+        if 'RETURNMAC' in dictionary:
+            self.returnmac = dictionary['RETURNMAC']
+        if 'hostedCheckoutId' in dictionary:
+            self.hosted_checkout_id = dictionary['hostedCheckoutId']
+        if 'invalidTokens' in dictionary:
+            if not isinstance(dictionary['invalidTokens'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['invalidTokens']))
+            self.invalid_tokens = []
+            for element in dictionary['invalidTokens']:
+                self.invalid_tokens.append(element)
+        if 'merchantReference' in dictionary:
+            self.merchant_reference = dictionary['merchantReference']
+        if 'partialRedirectUrl' in dictionary:
+            self.partial_redirect_url = dictionary['partialRedirectUrl']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/create_hosted_mandate_management_request.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.hosted_mandate_info import HostedMandateInfo
+from worldline.connect.sdk.v1.domain.hosted_mandate_management_specific_input import HostedMandateManagementSpecificInput
+
+
+class CreateHostedMandateManagementRequest(DataObject):
+
+    __create_mandate_info: Optional[HostedMandateInfo] = None
+    __hosted_mandate_management_specific_input: Optional[HostedMandateManagementSpecificInput] = None
+
+    @property
+    def create_mandate_info(self) -> Optional[HostedMandateInfo]:
+        """
+        | Object containing partial information needed for the creation of the mandate. The recurrencetype, signature type of the mandate and reference to the customer are mandatory. You can also supply any personal information you already know about the customer so they have to fill in less details.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.hosted_mandate_info.HostedMandateInfo`
+        """
+        return self.__create_mandate_info
+
+    @create_mandate_info.setter
+    def create_mandate_info(self, value: Optional[HostedMandateInfo]) -> None:
+        self.__create_mandate_info = value
+
+    @property
+    def hosted_mandate_management_specific_input(self) -> Optional[HostedMandateManagementSpecificInput]:
+        """
+        | Object containing hosted mandate management specific data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.hosted_mandate_management_specific_input.HostedMandateManagementSpecificInput`
+        """
+        return self.__hosted_mandate_management_specific_input
+
+    @hosted_mandate_management_specific_input.setter
+    def hosted_mandate_management_specific_input(self, value: Optional[HostedMandateManagementSpecificInput]) -> None:
+        self.__hosted_mandate_management_specific_input = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateHostedMandateManagementRequest, self).to_dictionary()
+        if self.create_mandate_info is not None:
+            dictionary['createMandateInfo'] = self.create_mandate_info.to_dictionary()
+        if self.hosted_mandate_management_specific_input is not None:
+            dictionary['hostedMandateManagementSpecificInput'] = self.hosted_mandate_management_specific_input.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateHostedMandateManagementRequest':
+        super(CreateHostedMandateManagementRequest, self).from_dictionary(dictionary)
+        if 'createMandateInfo' in dictionary:
+            if not isinstance(dictionary['createMandateInfo'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['createMandateInfo']))
+            value = HostedMandateInfo()
+            self.create_mandate_info = value.from_dictionary(dictionary['createMandateInfo'])
+        if 'hostedMandateManagementSpecificInput' in dictionary:
+            if not isinstance(dictionary['hostedMandateManagementSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['hostedMandateManagementSpecificInput']))
+            value = HostedMandateManagementSpecificInput()
+            self.hosted_mandate_management_specific_input = value.from_dictionary(dictionary['hostedMandateManagementSpecificInput'])
+        return self

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

@@ -0,0 +1,74 @@
+# -*- 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 CreateHostedMandateManagementResponse(DataObject):
+
+    __returnmac: Optional[str] = None
+    __hosted_mandate_management_id: Optional[str] = None
+    __partial_redirect_url: Optional[str] = None
+
+    @property
+    def returnmac(self) -> Optional[str]:
+        """
+        | When the customer is returned to your site we will append this property and value to the query-string. You should store this data, so you can identify the returning customer.
+
+        Type: str
+        """
+        return self.__returnmac
+
+    @returnmac.setter
+    def returnmac(self, value: Optional[str]) -> None:
+        self.__returnmac = value
+
+    @property
+    def hosted_mandate_management_id(self) -> Optional[str]:
+        """
+        | This is the ID under which the data for this mandate management can be retrieved.
+
+        Type: str
+        """
+        return self.__hosted_mandate_management_id
+
+    @hosted_mandate_management_id.setter
+    def hosted_mandate_management_id(self, value: Optional[str]) -> None:
+        self.__hosted_mandate_management_id = value
+
+    @property
+    def partial_redirect_url(self) -> Optional[str]:
+        """
+        | The partial URL as generated by our system. You will need to add the protocol and the relevant subdomain to this URL, before redirecting your customer to this URL. A special 'payment' subdomain will always work so you can always add 'https://payment.' at the beginning of this response value to view your hosted mandate management pages.
+
+        Type: str
+        """
+        return self.__partial_redirect_url
+
+    @partial_redirect_url.setter
+    def partial_redirect_url(self, value: Optional[str]) -> None:
+        self.__partial_redirect_url = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateHostedMandateManagementResponse, self).to_dictionary()
+        if self.returnmac is not None:
+            dictionary['RETURNMAC'] = self.returnmac
+        if self.hosted_mandate_management_id is not None:
+            dictionary['hostedMandateManagementId'] = self.hosted_mandate_management_id
+        if self.partial_redirect_url is not None:
+            dictionary['partialRedirectUrl'] = self.partial_redirect_url
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateHostedMandateManagementResponse':
+        super(CreateHostedMandateManagementResponse, self).from_dictionary(dictionary)
+        if 'RETURNMAC' in dictionary:
+            self.returnmac = dictionary['RETURNMAC']
+        if 'hostedMandateManagementId' in dictionary:
+            self.hosted_mandate_management_id = dictionary['hostedMandateManagementId']
+        if 'partialRedirectUrl' in dictionary:
+            self.partial_redirect_url = dictionary['partialRedirectUrl']
+        return self