connect-sdk-python3 4.0.0__zip → 4.1.0__zip

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

@@ -0,0 +1,59 @@
+# -*- 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 ContactDetailsBase(DataObject):
+
+    __email_address: Optional[str] = None
+    __email_message_type: 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
+
+    @property
+    def email_message_type(self) -> Optional[str]:
+        """
+        | Preference for the type of email message markup
+        
+        * plain-text
+        * html
+
+        Type: str
+        """
+        return self.__email_message_type
+
+    @email_message_type.setter
+    def email_message_type(self, value: Optional[str]) -> None:
+        self.__email_message_type = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ContactDetailsBase, self).to_dictionary()
+        if self.email_address is not None:
+            dictionary['emailAddress'] = self.email_address
+        if self.email_message_type is not None:
+            dictionary['emailMessageType'] = self.email_message_type
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ContactDetailsBase':
+        super(ContactDetailsBase, self).from_dictionary(dictionary)
+        if 'emailAddress' in dictionary:
+            self.email_address = dictionary['emailAddress']
+        if 'emailMessageType' in dictionary:
+            self.email_message_type = dictionary['emailMessageType']
+        return self

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

@@ -0,0 +1,38 @@
+# -*- 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 ContactDetailsRiskAssessment(DataObject):
+
+    __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(ContactDetailsRiskAssessment, self).to_dictionary()
+        if self.email_address is not None:
+            dictionary['emailAddress'] = self.email_address
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ContactDetailsRiskAssessment':
+        super(ContactDetailsRiskAssessment, 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/convert_amount.py

@@ -0,0 +1,38 @@
+# -*- 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 ConvertAmount(DataObject):
+
+    __converted_amount: Optional[int] = None
+
+    @property
+    def converted_amount(self) -> Optional[int]:
+        """
+        | Converted amount in cents and having 2 decimal
+
+        Type: int
+        """
+        return self.__converted_amount
+
+    @converted_amount.setter
+    def converted_amount(self, value: Optional[int]) -> None:
+        self.__converted_amount = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ConvertAmount, self).to_dictionary()
+        if self.converted_amount is not None:
+            dictionary['convertedAmount'] = self.converted_amount
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ConvertAmount':
+        super(ConvertAmount, self).from_dictionary(dictionary)
+        if 'convertedAmount' in dictionary:
+            self.converted_amount = dictionary['convertedAmount']
+        return self

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

@@ -0,0 +1,114 @@
+# -*- 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.amount_of_money import AmountOfMoney
+
+
+class CreateDisputeRequest(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __contact_person: Optional[str] = None
+    __email_address: Optional[str] = None
+    __reply_to: Optional[str] = None
+    __request_message: Optional[str] = None
+
+    @property
+    def amount_of_money(self) -> Optional[AmountOfMoney]:
+        """
+        | The amount of money that is to be disputed.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__amount_of_money
+
+    @amount_of_money.setter
+    def amount_of_money(self, value: Optional[AmountOfMoney]) -> None:
+        self.__amount_of_money = value
+
+    @property
+    def contact_person(self) -> Optional[str]:
+        """
+        | The name of the person on your side who can be contacted regarding this dispute.
+
+        Type: str
+        """
+        return self.__contact_person
+
+    @contact_person.setter
+    def contact_person(self, value: Optional[str]) -> None:
+        self.__contact_person = value
+
+    @property
+    def email_address(self) -> Optional[str]:
+        """
+        | The email address of the contact person.
+
+        Type: str
+        """
+        return self.__email_address
+
+    @email_address.setter
+    def email_address(self, value: Optional[str]) -> None:
+        self.__email_address = value
+
+    @property
+    def reply_to(self) -> Optional[str]:
+        """
+        | The email address to which the reply message will be sent.
+
+        Type: str
+        """
+        return self.__reply_to
+
+    @reply_to.setter
+    def reply_to(self, value: Optional[str]) -> None:
+        self.__reply_to = value
+
+    @property
+    def request_message(self) -> Optional[str]:
+        """
+        | The message sent from you to Worldline.
+
+        Type: str
+        """
+        return self.__request_message
+
+    @request_message.setter
+    def request_message(self, value: Optional[str]) -> None:
+        self.__request_message = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateDisputeRequest, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.contact_person is not None:
+            dictionary['contactPerson'] = self.contact_person
+        if self.email_address is not None:
+            dictionary['emailAddress'] = self.email_address
+        if self.reply_to is not None:
+            dictionary['replyTo'] = self.reply_to
+        if self.request_message is not None:
+            dictionary['requestMessage'] = self.request_message
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateDisputeRequest':
+        super(CreateDisputeRequest, self).from_dictionary(dictionary)
+        if 'amountOfMoney' in dictionary:
+            if not isinstance(dictionary['amountOfMoney'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amountOfMoney']))
+            value = AmountOfMoney()
+            self.amount_of_money = value.from_dictionary(dictionary['amountOfMoney'])
+        if 'contactPerson' in dictionary:
+            self.contact_person = dictionary['contactPerson']
+        if 'emailAddress' in dictionary:
+            self.email_address = dictionary['emailAddress']
+        if 'replyTo' in dictionary:
+            self.reply_to = dictionary['replyTo']
+        if 'requestMessage' in dictionary:
+            self.request_message = dictionary['requestMessage']
+        return self

connect-sdk-python3-4.1.0/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.1.0/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