connect-sdk-python3 4.0.0__zip → 4.1.0__zip

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

@@ -1,128 +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.abstract_order_status import AbstractOrderStatus
-from worldline.connect.sdk.v1.domain.hosted_checkout_specific_output import HostedCheckoutSpecificOutput
-from worldline.connect.sdk.v1.domain.payment_output import PaymentOutput
-from worldline.connect.sdk.v1.domain.payment_status_output import PaymentStatusOutput
-
-
-class Payment(AbstractOrderStatus):
-
-    __hosted_checkout_specific_output: Optional[HostedCheckoutSpecificOutput] = None
-    __payment_output: Optional[PaymentOutput] = None
-    __status: Optional[str] = None
-    __status_output: Optional[PaymentStatusOutput] = None
-
-    @property
-    def hosted_checkout_specific_output(self) -> Optional[HostedCheckoutSpecificOutput]:
-        """
-        | Hosted Checkout specific information. Populated if the payment was created on the GlobalCollect platform through a Hosted Checkout.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.hosted_checkout_specific_output.HostedCheckoutSpecificOutput`
-        """
-        return self.__hosted_checkout_specific_output
-
-    @hosted_checkout_specific_output.setter
-    def hosted_checkout_specific_output(self, value: Optional[HostedCheckoutSpecificOutput]) -> None:
-        self.__hosted_checkout_specific_output = value
-
-    @property
-    def payment_output(self) -> Optional[PaymentOutput]:
-        """
-        | Object containing payment details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_output.PaymentOutput`
-        """
-        return self.__payment_output
-
-    @payment_output.setter
-    def payment_output(self, value: Optional[PaymentOutput]) -> None:
-        self.__payment_output = value
-
-    @property
-    def status(self) -> Optional[str]:
-        """
-        | Current high-level status of the payment in a human-readable form. Possible values are :
-        
-        * ACCOUNT_VERIFIED - The account has been verified using a validation services like 0$ auth
-        * CREATED - The transaction has been created. This is the initial state once a new payment is created.
-        * REDIRECTED - The customer has been redirected to a 3rd party to complete the authentication/payment
-        * PENDING_PAYMENT - Instructions have been provided and we are now waiting for the money to come in
-        * PENDING_FRAUD_APPROVAL - The transaction has been marked for manual review after an automatic fraud screening
-        * PENDING_APPROVAL - The transaction is awaiting approval from you to proceed with the capturing of the funds
-        * PENDING_COMPLETION - The transaction needs to be completed.
-        * PENDING_CAPTURE - The transaction is waiting for you to request one or more captures of the funds.
-        * REJECTED - The transaction has been rejected
-        * AUTHORIZATION_REQUESTED - we have requested an authorization against an asynchronous system and is awaiting its response
-        * CAPTURE_REQUESTED - The transaction is in the queue to be captured
-        * CAPTURED - The transaction has been captured and we have received online confirmation
-        * PAID - We have matched the incoming funds to the transaction
-        * CANCELLED - You have cancelled the transaction
-        * REJECTED_CAPTURE - We or one of our downstream acquirers/providers have rejected the capture request
-        * REVERSED - The transaction has been reversed
-        * CHARGEBACK_NOTIFICATION - We have received a notification of chargeback and this status informs you that your account will be debited for a particular transaction
-        * CHARGEBACKED - The transaction has been chargebacked
-        * REFUNDED - The transaction has been refunded
-        
-        
-        | Please see Statuses <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/statuses.html> for a full overview of possible values.
-        
-        Type: str
-        """
-        return self.__status
-
-    @status.setter
-    def status(self, value: Optional[str]) -> None:
-        self.__status = value
-
-    @property
-    def status_output(self) -> Optional[PaymentStatusOutput]:
-        """
-        | This object has the numeric representation of the current payment status, timestamp of last status change and performable action on the current payment resource.
-        | In case of failed payments and negative scenarios, detailed error information is listed.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_status_output.PaymentStatusOutput`
-        """
-        return self.__status_output
-
-    @status_output.setter
-    def status_output(self, value: Optional[PaymentStatusOutput]) -> None:
-        self.__status_output = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(Payment, self).to_dictionary()
-        if self.hosted_checkout_specific_output is not None:
-            dictionary['hostedCheckoutSpecificOutput'] = self.hosted_checkout_specific_output.to_dictionary()
-        if self.payment_output is not None:
-            dictionary['paymentOutput'] = self.payment_output.to_dictionary()
-        if self.status is not None:
-            dictionary['status'] = self.status
-        if self.status_output is not None:
-            dictionary['statusOutput'] = self.status_output.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'Payment':
-        super(Payment, self).from_dictionary(dictionary)
-        if 'hostedCheckoutSpecificOutput' in dictionary:
-            if not isinstance(dictionary['hostedCheckoutSpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['hostedCheckoutSpecificOutput']))
-            value = HostedCheckoutSpecificOutput()
-            self.hosted_checkout_specific_output = value.from_dictionary(dictionary['hostedCheckoutSpecificOutput'])
-        if 'paymentOutput' in dictionary:
-            if not isinstance(dictionary['paymentOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentOutput']))
-            value = PaymentOutput()
-            self.payment_output = value.from_dictionary(dictionary['paymentOutput'])
-        if 'status' in dictionary:
-            self.status = dictionary['status']
-        if 'statusOutput' in dictionary:
-            if not isinstance(dictionary['statusOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['statusOutput']))
-            value = PaymentStatusOutput()
-            self.status_output = value.from_dictionary(dictionary['statusOutput'])
-        return self

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

@@ -1,61 +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 PaymentAccountOnFile(DataObject):
-    """
-    | Object containing information on the payment account data on file (tokens)
-    """
-
-    __create_date: Optional[str] = None
-    __number_of_card_on_file_creation_attempts_last24_hours: Optional[int] = None
-
-    @property
-    def create_date(self) -> Optional[str]:
-        """
-        | The date (YYYYMMDD) when the payment account on file was first created.
-        
-        | In case a token is used for the transaction we will use the creation date of the token in our system in case you leave this property empty.
-        
-        Type: str
-        """
-        return self.__create_date
-
-    @create_date.setter
-    def create_date(self, value: Optional[str]) -> None:
-        self.__create_date = value
-
-    @property
-    def number_of_card_on_file_creation_attempts_last24_hours(self) -> Optional[int]:
-        """
-        | Number of attempts made to add new card to the customer account in the last 24 hours
-        
-        Type: int
-        """
-        return self.__number_of_card_on_file_creation_attempts_last24_hours
-
-    @number_of_card_on_file_creation_attempts_last24_hours.setter
-    def number_of_card_on_file_creation_attempts_last24_hours(self, value: Optional[int]) -> None:
-        self.__number_of_card_on_file_creation_attempts_last24_hours = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentAccountOnFile, self).to_dictionary()
-        if self.create_date is not None:
-            dictionary['createDate'] = self.create_date
-        if self.number_of_card_on_file_creation_attempts_last24_hours is not None:
-            dictionary['numberOfCardOnFileCreationAttemptsLast24Hours'] = self.number_of_card_on_file_creation_attempts_last24_hours
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentAccountOnFile':
-        super(PaymentAccountOnFile, self).from_dictionary(dictionary)
-        if 'createDate' in dictionary:
-            self.create_date = dictionary['createDate']
-        if 'numberOfCardOnFileCreationAttemptsLast24Hours' in dictionary:
-            self.number_of_card_on_file_creation_attempts_last24_hours = dictionary['numberOfCardOnFileCreationAttemptsLast24Hours']
-        return self

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

@@ -1,110 +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.approve_payment_card_payment_method_specific_output import ApprovePaymentCardPaymentMethodSpecificOutput
-from worldline.connect.sdk.v1.domain.approve_payment_mobile_payment_method_specific_output import ApprovePaymentMobilePaymentMethodSpecificOutput
-from worldline.connect.sdk.v1.domain.payment import Payment
-
-
-class PaymentApprovalResponse(DataObject):
-
-    __card_payment_method_specific_output: Optional[ApprovePaymentCardPaymentMethodSpecificOutput] = None
-    __mobile_payment_method_specific_output: Optional[ApprovePaymentMobilePaymentMethodSpecificOutput] = None
-    __payment: Optional[Payment] = None
-    __payment_method_specific_output: Optional[ApprovePaymentCardPaymentMethodSpecificOutput] = None
-
-    @property
-    def card_payment_method_specific_output(self) -> Optional[ApprovePaymentCardPaymentMethodSpecificOutput]:
-        """
-        | Object containing additional card payment method specific details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.approve_payment_card_payment_method_specific_output.ApprovePaymentCardPaymentMethodSpecificOutput`
-        """
-        return self.__card_payment_method_specific_output
-
-    @card_payment_method_specific_output.setter
-    def card_payment_method_specific_output(self, value: Optional[ApprovePaymentCardPaymentMethodSpecificOutput]) -> None:
-        self.__card_payment_method_specific_output = value
-
-    @property
-    def mobile_payment_method_specific_output(self) -> Optional[ApprovePaymentMobilePaymentMethodSpecificOutput]:
-        """
-        | Object containing additional mobile payment method specific details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.approve_payment_mobile_payment_method_specific_output.ApprovePaymentMobilePaymentMethodSpecificOutput`
-        """
-        return self.__mobile_payment_method_specific_output
-
-    @mobile_payment_method_specific_output.setter
-    def mobile_payment_method_specific_output(self, value: Optional[ApprovePaymentMobilePaymentMethodSpecificOutput]) -> None:
-        self.__mobile_payment_method_specific_output = value
-
-    @property
-    def payment(self) -> Optional[Payment]:
-        """
-        | Object that holds the payment data
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment.Payment`
-        """
-        return self.__payment
-
-    @payment.setter
-    def payment(self, value: Optional[Payment]) -> None:
-        self.__payment = value
-
-    @property
-    def payment_method_specific_output(self) -> Optional[ApprovePaymentCardPaymentMethodSpecificOutput]:
-        """
-        | Object containing additional payment method specific details
-        | Deprecated: this property does not support different outputs for payment methods other than cards. Please use cardPaymentMethodSpecificOutput instead.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.approve_payment_card_payment_method_specific_output.ApprovePaymentCardPaymentMethodSpecificOutput`
-        
-        Deprecated; Use cardPaymentMethodSpecificOutput instead
-        """
-        return self.__payment_method_specific_output
-
-    @payment_method_specific_output.setter
-    def payment_method_specific_output(self, value: Optional[ApprovePaymentCardPaymentMethodSpecificOutput]) -> None:
-        self.__payment_method_specific_output = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentApprovalResponse, self).to_dictionary()
-        if self.card_payment_method_specific_output is not None:
-            dictionary['cardPaymentMethodSpecificOutput'] = self.card_payment_method_specific_output.to_dictionary()
-        if self.mobile_payment_method_specific_output is not None:
-            dictionary['mobilePaymentMethodSpecificOutput'] = self.mobile_payment_method_specific_output.to_dictionary()
-        if self.payment is not None:
-            dictionary['payment'] = self.payment.to_dictionary()
-        if self.payment_method_specific_output is not None:
-            dictionary['paymentMethodSpecificOutput'] = self.payment_method_specific_output.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentApprovalResponse':
-        super(PaymentApprovalResponse, self).from_dictionary(dictionary)
-        if 'cardPaymentMethodSpecificOutput' in dictionary:
-            if not isinstance(dictionary['cardPaymentMethodSpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardPaymentMethodSpecificOutput']))
-            value = ApprovePaymentCardPaymentMethodSpecificOutput()
-            self.card_payment_method_specific_output = value.from_dictionary(dictionary['cardPaymentMethodSpecificOutput'])
-        if 'mobilePaymentMethodSpecificOutput' in dictionary:
-            if not isinstance(dictionary['mobilePaymentMethodSpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mobilePaymentMethodSpecificOutput']))
-            value = ApprovePaymentMobilePaymentMethodSpecificOutput()
-            self.mobile_payment_method_specific_output = value.from_dictionary(dictionary['mobilePaymentMethodSpecificOutput'])
-        if 'payment' in dictionary:
-            if not isinstance(dictionary['payment'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payment']))
-            value = Payment()
-            self.payment = value.from_dictionary(dictionary['payment'])
-        if 'paymentMethodSpecificOutput' in dictionary:
-            if not isinstance(dictionary['paymentMethodSpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentMethodSpecificOutput']))
-            value = ApprovePaymentCardPaymentMethodSpecificOutput()
-            self.payment_method_specific_output = value.from_dictionary(dictionary['paymentMethodSpecificOutput'])
-        return self

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

@@ -1,99 +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.amount_of_money import AmountOfMoney
-
-
-class PaymentContext(DataObject):
-    """
-    | Values that can optionally be set to refine an IIN Lookup
-    """
-
-    __amount_of_money: Optional[AmountOfMoney] = None
-    __country_code: Optional[str] = None
-    __is_installments: Optional[bool] = None
-    __is_recurring: Optional[bool] = None
-
-    @property
-    def amount_of_money(self) -> Optional[AmountOfMoney]:
-        """
-        | The payment amount
-        
-        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 country_code(self) -> Optional[str]:
-        """
-        | The country the payment takes place in
-        
-        Type: str
-        """
-        return self.__country_code
-
-    @country_code.setter
-    def country_code(self, value: Optional[str]) -> None:
-        self.__country_code = value
-
-    @property
-    def is_installments(self) -> Optional[bool]:
-        """
-        | True if the payment is to be paid in multiple installments (numberOfInstallments > 1 for the payment). When true only payment products that support installments will be allowed in context.
-        
-        Type: bool
-        """
-        return self.__is_installments
-
-    @is_installments.setter
-    def is_installments(self, value: Optional[bool]) -> None:
-        self.__is_installments = value
-
-    @property
-    def is_recurring(self) -> Optional[bool]:
-        """
-        | True if the payment is recurring
-        
-        Type: bool
-        """
-        return self.__is_recurring
-
-    @is_recurring.setter
-    def is_recurring(self, value: Optional[bool]) -> None:
-        self.__is_recurring = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentContext, self).to_dictionary()
-        if self.amount_of_money is not None:
-            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
-        if self.country_code is not None:
-            dictionary['countryCode'] = self.country_code
-        if self.is_installments is not None:
-            dictionary['isInstallments'] = self.is_installments
-        if self.is_recurring is not None:
-            dictionary['isRecurring'] = self.is_recurring
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentContext':
-        super(PaymentContext, 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 'countryCode' in dictionary:
-            self.country_code = dictionary['countryCode']
-        if 'isInstallments' in dictionary:
-            self.is_installments = dictionary['isInstallments']
-        if 'isRecurring' in dictionary:
-            self.is_recurring = dictionary['isRecurring']
-        return self

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

@@ -1,95 +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.payment_creation_references import PaymentCreationReferences
-
-
-class PaymentCreationOutput(PaymentCreationReferences):
-
-    __is_checked_remember_me: Optional[bool] = None
-    __is_new_token: Optional[bool] = None
-    __token: Optional[str] = None
-    __tokenization_succeeded: Optional[bool] = None
-
-    @property
-    def is_checked_remember_me(self) -> Optional[bool]:
-        """
-        | Indicates whether the customer ticked the "Remember my details for future purchases" checkbox on the MyCheckout hosted payment pages
-        
-        Type: bool
-        """
-        return self.__is_checked_remember_me
-
-    @is_checked_remember_me.setter
-    def is_checked_remember_me(self, value: Optional[bool]) -> None:
-        self.__is_checked_remember_me = value
-
-    @property
-    def is_new_token(self) -> Optional[bool]:
-        """
-        | Indicates if a new token was created
-        
-        * true - A new token was created
-        * false - A token with the same card number already exists and is returned. Please note that the existing token has not been updated. When you want to update other data then the card number, you need to update data stored in the token explicitly, as data is never updated during the creation of a token.
-        
-        Type: bool
-        """
-        return self.__is_new_token
-
-    @is_new_token.setter
-    def is_new_token(self, value: Optional[bool]) -> None:
-        self.__is_new_token = value
-
-    @property
-    def token(self) -> Optional[str]:
-        """
-        | ID of the token
-        
-        Type: str
-        """
-        return self.__token
-
-    @token.setter
-    def token(self, value: Optional[str]) -> None:
-        self.__token = value
-
-    @property
-    def tokenization_succeeded(self) -> Optional[bool]:
-        """
-        | Indicates if tokenization was successful or not. If this value is false, then the token and isNewToken properties will not be set.
-        
-        Type: bool
-        """
-        return self.__tokenization_succeeded
-
-    @tokenization_succeeded.setter
-    def tokenization_succeeded(self, value: Optional[bool]) -> None:
-        self.__tokenization_succeeded = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentCreationOutput, self).to_dictionary()
-        if self.is_checked_remember_me is not None:
-            dictionary['isCheckedRememberMe'] = self.is_checked_remember_me
-        if self.is_new_token is not None:
-            dictionary['isNewToken'] = self.is_new_token
-        if self.token is not None:
-            dictionary['token'] = self.token
-        if self.tokenization_succeeded is not None:
-            dictionary['tokenizationSucceeded'] = self.tokenization_succeeded
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentCreationOutput':
-        super(PaymentCreationOutput, self).from_dictionary(dictionary)
-        if 'isCheckedRememberMe' in dictionary:
-            self.is_checked_remember_me = dictionary['isCheckedRememberMe']
-        if 'isNewToken' in dictionary:
-            self.is_new_token = dictionary['isNewToken']
-        if 'token' in dictionary:
-            self.token = dictionary['token']
-        if 'tokenizationSucceeded' in dictionary:
-            self.tokenization_succeeded = dictionary['tokenizationSucceeded']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/payment_creation_references.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 PaymentCreationReferences(DataObject):
-
-    __additional_reference: Optional[str] = None
-    __external_reference: Optional[str] = None
-
-    @property
-    def additional_reference(self) -> Optional[str]:
-        """
-        | The additional reference identifier for this transaction. Data in this property will also be returned in our report files, allowing you to reconcile them.
-        
-        Type: str
-        """
-        return self.__additional_reference
-
-    @additional_reference.setter
-    def additional_reference(self, value: Optional[str]) -> None:
-        self.__additional_reference = value
-
-    @property
-    def external_reference(self) -> Optional[str]:
-        """
-        | The external reference identifier for this transaction. Data in this property will also be returned in our report files, allowing you to reconcile them.
-        
-        Type: str
-        """
-        return self.__external_reference
-
-    @external_reference.setter
-    def external_reference(self, value: Optional[str]) -> None:
-        self.__external_reference = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentCreationReferences, self).to_dictionary()
-        if self.additional_reference is not None:
-            dictionary['additionalReference'] = self.additional_reference
-        if self.external_reference is not None:
-            dictionary['externalReference'] = self.external_reference
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentCreationReferences':
-        super(PaymentCreationReferences, self).from_dictionary(dictionary)
-        if 'additionalReference' in dictionary:
-            self.additional_reference = dictionary['additionalReference']
-        if 'externalReference' in dictionary:
-            self.external_reference = dictionary['externalReference']
-        return self

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

@@ -1,87 +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 List, Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.api_error import APIError
-from worldline.connect.sdk.v1.domain.create_payment_result import CreatePaymentResult
-
-
-class PaymentErrorResponse(DataObject):
-
-    __error_id: Optional[str] = None
-    __errors: Optional[List[APIError]] = None
-    __payment_result: Optional[CreatePaymentResult] = None
-
-    @property
-    def error_id(self) -> Optional[str]:
-        """
-        | Unique reference, for debugging purposes, of this error response
-        
-        Type: str
-        """
-        return self.__error_id
-
-    @error_id.setter
-    def error_id(self, value: Optional[str]) -> None:
-        self.__error_id = value
-
-    @property
-    def errors(self) -> Optional[List[APIError]]:
-        """
-        | List of one or more errors
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.api_error.APIError`]
-        """
-        return self.__errors
-
-    @errors.setter
-    def errors(self, value: Optional[List[APIError]]) -> None:
-        self.__errors = value
-
-    @property
-    def payment_result(self) -> Optional[CreatePaymentResult]:
-        """
-        | Object that contains details on the created payment in case one has been created
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.create_payment_result.CreatePaymentResult`
-        """
-        return self.__payment_result
-
-    @payment_result.setter
-    def payment_result(self, value: Optional[CreatePaymentResult]) -> None:
-        self.__payment_result = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentErrorResponse, self).to_dictionary()
-        if self.error_id is not None:
-            dictionary['errorId'] = self.error_id
-        if self.errors is not None:
-            dictionary['errors'] = []
-            for element in self.errors:
-                if element is not None:
-                    dictionary['errors'].append(element.to_dictionary())
-        if self.payment_result is not None:
-            dictionary['paymentResult'] = self.payment_result.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentErrorResponse':
-        super(PaymentErrorResponse, self).from_dictionary(dictionary)
-        if 'errorId' in dictionary:
-            self.error_id = dictionary['errorId']
-        if 'errors' in dictionary:
-            if not isinstance(dictionary['errors'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['errors']))
-            self.errors = []
-            for element in dictionary['errors']:
-                value = APIError()
-                self.errors.append(value.from_dictionary(element))
-        if 'paymentResult' in dictionary:
-            if not isinstance(dictionary['paymentResult'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentResult']))
-            value = CreatePaymentResult()
-            self.payment_result = value.from_dictionary(dictionary['paymentResult'])
-        return self