connect-sdk-python3 4.0.0__zip → 4.0.1__zip

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

@@ -1,127 +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
-from worldline.connect.sdk.v1.domain.bank_refund_method_specific_input import BankRefundMethodSpecificInput
-from worldline.connect.sdk.v1.domain.refund_customer import RefundCustomer
-from worldline.connect.sdk.v1.domain.refund_references import RefundReferences
-
-
-class RefundRequest(DataObject):
-
-    __amount_of_money: Optional[AmountOfMoney] = None
-    __bank_refund_method_specific_input: Optional[BankRefundMethodSpecificInput] = None
-    __customer: Optional[RefundCustomer] = None
-    __refund_date: Optional[str] = None
-    __refund_references: Optional[RefundReferences] = None
-
-    @property
-    def amount_of_money(self) -> Optional[AmountOfMoney]:
-        """
-        | Object containing amount and ISO currency code attributes
-        
-        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 bank_refund_method_specific_input(self) -> Optional[BankRefundMethodSpecificInput]:
-        """
-        | Object containing the specific input details for a bank refund
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.bank_refund_method_specific_input.BankRefundMethodSpecificInput`
-        """
-        return self.__bank_refund_method_specific_input
-
-    @bank_refund_method_specific_input.setter
-    def bank_refund_method_specific_input(self, value: Optional[BankRefundMethodSpecificInput]) -> None:
-        self.__bank_refund_method_specific_input = value
-
-    @property
-    def customer(self) -> Optional[RefundCustomer]:
-        """
-        | Object containing the details of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_customer.RefundCustomer`
-        """
-        return self.__customer
-
-    @customer.setter
-    def customer(self, value: Optional[RefundCustomer]) -> None:
-        self.__customer = value
-
-    @property
-    def refund_date(self) -> Optional[str]:
-        """
-        | Refund date
-        | Format: YYYYMMDD
-        
-        Type: str
-        """
-        return self.__refund_date
-
-    @refund_date.setter
-    def refund_date(self, value: Optional[str]) -> None:
-        self.__refund_date = value
-
-    @property
-    def refund_references(self) -> Optional[RefundReferences]:
-        """
-        | Object that holds all reference properties that are linked to this refund
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_references.RefundReferences`
-        """
-        return self.__refund_references
-
-    @refund_references.setter
-    def refund_references(self, value: Optional[RefundReferences]) -> None:
-        self.__refund_references = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RefundRequest, self).to_dictionary()
-        if self.amount_of_money is not None:
-            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
-        if self.bank_refund_method_specific_input is not None:
-            dictionary['bankRefundMethodSpecificInput'] = self.bank_refund_method_specific_input.to_dictionary()
-        if self.customer is not None:
-            dictionary['customer'] = self.customer.to_dictionary()
-        if self.refund_date is not None:
-            dictionary['refundDate'] = self.refund_date
-        if self.refund_references is not None:
-            dictionary['refundReferences'] = self.refund_references.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RefundRequest':
-        super(RefundRequest, 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 'bankRefundMethodSpecificInput' in dictionary:
-            if not isinstance(dictionary['bankRefundMethodSpecificInput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankRefundMethodSpecificInput']))
-            value = BankRefundMethodSpecificInput()
-            self.bank_refund_method_specific_input = value.from_dictionary(dictionary['bankRefundMethodSpecificInput'])
-        if 'customer' in dictionary:
-            if not isinstance(dictionary['customer'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customer']))
-            value = RefundCustomer()
-            self.customer = value.from_dictionary(dictionary['customer'])
-        if 'refundDate' in dictionary:
-            self.refund_date = dictionary['refundDate']
-        if 'refundReferences' in dictionary:
-            if not isinstance(dictionary['refundReferences'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['refundReferences']))
-            value = RefundReferences()
-            self.refund_references = value.from_dictionary(dictionary['refundReferences'])
-        return self

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

@@ -1,94 +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.order_status_output import OrderStatusOutput
-from worldline.connect.sdk.v1.domain.refund_output import RefundOutput
-
-
-class RefundResult(AbstractOrderStatus):
-
-    __refund_output: Optional[RefundOutput] = None
-    __status: Optional[str] = None
-    __status_output: Optional[OrderStatusOutput] = None
-
-    @property
-    def refund_output(self) -> Optional[RefundOutput]:
-        """
-        | Object containing refund details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.refund_output.RefundOutput`
-        """
-        return self.__refund_output
-
-    @refund_output.setter
-    def refund_output(self, value: Optional[RefundOutput]) -> None:
-        self.__refund_output = value
-
-    @property
-    def status(self) -> Optional[str]:
-        """
-        | Current high-level status of the refund in a human-readable form. Possible values are:
-        
-        * CREATED - The transaction has been created. This is the initial state once a new refund is created.
-        * PENDING_APPROVAL - The transaction is awaiting approval from you to proceed with the processing of the refund
-        * REJECTED - The refund has been rejected
-        * REFUND_REQUESTED - The transaction is in the queue to be refunded
-        * REFUNDED - We have successfully refunded the customer
-        * REJECTED_CAPTURE - The refund was rejected by the bank or us during processing
-        * CANCELLED - You have cancelled the transaction
-        
-        
-        | 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[OrderStatusOutput]:
-        """
-        | This object has the numeric representation of the current refund status, timestamp of last status change and performable action on the current refund resource.
-        | In case of a rejected refund, detailed error information is listed.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.order_status_output.OrderStatusOutput`
-        """
-        return self.__status_output
-
-    @status_output.setter
-    def status_output(self, value: Optional[OrderStatusOutput]) -> None:
-        self.__status_output = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RefundResult, self).to_dictionary()
-        if self.refund_output is not None:
-            dictionary['refundOutput'] = self.refund_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) -> 'RefundResult':
-        super(RefundResult, self).from_dictionary(dictionary)
-        if 'refundOutput' in dictionary:
-            if not isinstance(dictionary['refundOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['refundOutput']))
-            value = RefundOutput()
-            self.refund_output = value.from_dictionary(dictionary['refundOutput'])
-        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 = OrderStatusOutput()
-            self.status_output = value.from_dictionary(dictionary['statusOutput'])
-        return self

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

@@ -1,47 +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.refund_result import RefundResult
-
-
-class RefundsResponse(DataObject):
-
-    __refunds: Optional[List[RefundResult]] = None
-
-    @property
-    def refunds(self) -> Optional[List[RefundResult]]:
-        """
-        | The list of all refunds performed on the requested payment.
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.refund_result.RefundResult`]
-        """
-        return self.__refunds
-
-    @refunds.setter
-    def refunds(self, value: Optional[List[RefundResult]]) -> None:
-        self.__refunds = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RefundsResponse, self).to_dictionary()
-        if self.refunds is not None:
-            dictionary['refunds'] = []
-            for element in self.refunds:
-                if element is not None:
-                    dictionary['refunds'].append(element.to_dictionary())
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RefundsResponse':
-        super(RefundsResponse, self).from_dictionary(dictionary)
-        if 'refunds' in dictionary:
-            if not isinstance(dictionary['refunds'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['refunds']))
-            self.refunds = []
-            for element in dictionary['refunds']:
-                value = RefundResult()
-                self.refunds.append(value.from_dictionary(element))
-        return self

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

@@ -1,38 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class RegularExpressionValidator(DataObject):
-
-    __regular_expression: Optional[str] = None
-
-    @property
-    def regular_expression(self) -> Optional[str]:
-        """
-        | Contains the regular expression that the value of the field needs to be validated against
-        
-        Type: str
-        """
-        return self.__regular_expression
-
-    @regular_expression.setter
-    def regular_expression(self, value: Optional[str]) -> None:
-        self.__regular_expression = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RegularExpressionValidator, self).to_dictionary()
-        if self.regular_expression is not None:
-            dictionary['regularExpression'] = self.regular_expression
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RegularExpressionValidator':
-        super(RegularExpressionValidator, self).from_dictionary(dictionary)
-        if 'regularExpression' in dictionary:
-            self.regular_expression = dictionary['regularExpression']
-        return self

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

@@ -1,113 +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.retail_decisions_cc_fraud_check_output import RetailDecisionsCCFraudCheckOutput
-from worldline.connect.sdk.v1.domain.validation_bank_account_output import ValidationBankAccountOutput
-
-
-class ResultDoRiskAssessment(DataObject):
-
-    __category: Optional[str] = None
-    __result: Optional[str] = None
-    __retaildecisions_cc_fraud_check_output: Optional[RetailDecisionsCCFraudCheckOutput] = None
-    __validation_bank_account_output: Optional[ValidationBankAccountOutput] = None
-
-    @property
-    def category(self) -> Optional[str]:
-        """
-        | The Risk Services category with the following possible values:
-        
-        * retaildecisionsCCFraudCheck - checks performed by Retail Decisions
-        * globalcollectBlacklistCheckCC - Checked against the blacklist on the GlobalCollect platform
-        * authorizationCheck - 0$ auth card account validation check
-        * ddFraudCheck - Check performed for German market via InterCard
-        * validationbankAccount - Bank account details are algorithmically checked if they could exist
-        * globalcollectBlacklistCheckDD - Checked against the blacklist on the GlobalCollect platform
-        
-        Type: str
-        """
-        return self.__category
-
-    @category.setter
-    def category(self, value: Optional[str]) -> None:
-        self.__category = value
-
-    @property
-    def result(self) -> Optional[str]:
-        """
-        | Risk service result with the following possible results:
-        
-        * accepted - Based on the checks performed the transaction can be accepted
-        * challenged - Based on the checks performed the transaction should be manually reviewed
-        * denied - Based on the checks performed the transaction should be rejected
-        * no-advice - No fraud check was requested/performed
-        * error - The fraud check resulted in an error and the fraud check was thus not performed
-        
-        Type: str
-        """
-        return self.__result
-
-    @result.setter
-    def result(self, value: Optional[str]) -> None:
-        self.__result = value
-
-    @property
-    def retaildecisions_cc_fraud_check_output(self) -> Optional[RetailDecisionsCCFraudCheckOutput]:
-        """
-        | Object containing the results of the fraud checks performed by Retail Decisions
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.retail_decisions_cc_fraud_check_output.RetailDecisionsCCFraudCheckOutput`
-        """
-        return self.__retaildecisions_cc_fraud_check_output
-
-    @retaildecisions_cc_fraud_check_output.setter
-    def retaildecisions_cc_fraud_check_output(self, value: Optional[RetailDecisionsCCFraudCheckOutput]) -> None:
-        self.__retaildecisions_cc_fraud_check_output = value
-
-    @property
-    def validation_bank_account_output(self) -> Optional[ValidationBankAccountOutput]:
-        """
-        | Object containing the results of the fraud checks performed on the bank account data
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.validation_bank_account_output.ValidationBankAccountOutput`
-        """
-        return self.__validation_bank_account_output
-
-    @validation_bank_account_output.setter
-    def validation_bank_account_output(self, value: Optional[ValidationBankAccountOutput]) -> None:
-        self.__validation_bank_account_output = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(ResultDoRiskAssessment, self).to_dictionary()
-        if self.category is not None:
-            dictionary['category'] = self.category
-        if self.result is not None:
-            dictionary['result'] = self.result
-        if self.retaildecisions_cc_fraud_check_output is not None:
-            dictionary['retaildecisionsCCFraudCheckOutput'] = self.retaildecisions_cc_fraud_check_output.to_dictionary()
-        if self.validation_bank_account_output is not None:
-            dictionary['validationBankAccountOutput'] = self.validation_bank_account_output.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'ResultDoRiskAssessment':
-        super(ResultDoRiskAssessment, self).from_dictionary(dictionary)
-        if 'category' in dictionary:
-            self.category = dictionary['category']
-        if 'result' in dictionary:
-            self.result = dictionary['result']
-        if 'retaildecisionsCCFraudCheckOutput' in dictionary:
-            if not isinstance(dictionary['retaildecisionsCCFraudCheckOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['retaildecisionsCCFraudCheckOutput']))
-            value = RetailDecisionsCCFraudCheckOutput()
-            self.retaildecisions_cc_fraud_check_output = value.from_dictionary(dictionary['retaildecisionsCCFraudCheckOutput'])
-        if 'validationBankAccountOutput' in dictionary:
-            if not isinstance(dictionary['validationBankAccountOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['validationBankAccountOutput']))
-            value = ValidationBankAccountOutput()
-            self.validation_bank_account_output = value.from_dictionary(dictionary['validationBankAccountOutput'])
-        return self

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

@@ -1,74 +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 RetailDecisionsCCFraudCheckOutput(DataObject):
-
-    __fraud_code: Optional[str] = None
-    __fraud_neural: Optional[str] = None
-    __fraud_rcf: Optional[str] = None
-
-    @property
-    def fraud_code(self) -> Optional[str]:
-        """
-        | Provides additional information about the fraud result
-        
-        Type: str
-        """
-        return self.__fraud_code
-
-    @fraud_code.setter
-    def fraud_code(self, value: Optional[str]) -> None:
-        self.__fraud_code = value
-
-    @property
-    def fraud_neural(self) -> Optional[str]:
-        """
-        | The raw score returned by the Neural check returned by the evaluation of the transaction
-        
-        Type: str
-        """
-        return self.__fraud_neural
-
-    @fraud_neural.setter
-    def fraud_neural(self, value: Optional[str]) -> None:
-        self.__fraud_neural = value
-
-    @property
-    def fraud_rcf(self) -> Optional[str]:
-        """
-        | List of RuleCategoryFlags as setup in the Retail Decisions system that lead to the result
-        
-        Type: str
-        """
-        return self.__fraud_rcf
-
-    @fraud_rcf.setter
-    def fraud_rcf(self, value: Optional[str]) -> None:
-        self.__fraud_rcf = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RetailDecisionsCCFraudCheckOutput, self).to_dictionary()
-        if self.fraud_code is not None:
-            dictionary['fraudCode'] = self.fraud_code
-        if self.fraud_neural is not None:
-            dictionary['fraudNeural'] = self.fraud_neural
-        if self.fraud_rcf is not None:
-            dictionary['fraudRCF'] = self.fraud_rcf
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RetailDecisionsCCFraudCheckOutput':
-        super(RetailDecisionsCCFraudCheckOutput, self).from_dictionary(dictionary)
-        if 'fraudCode' in dictionary:
-            self.fraud_code = dictionary['fraudCode']
-        if 'fraudNeural' in dictionary:
-            self.fraud_neural = dictionary['fraudNeural']
-        if 'fraudRCF' in dictionary:
-            self.fraud_rcf = dictionary['fraudRCF']
-        return self

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

@@ -1,101 +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.fraud_fields import FraudFields
-from worldline.connect.sdk.v1.domain.merchant_risk_assessment import MerchantRiskAssessment
-from worldline.connect.sdk.v1.domain.order_risk_assessment import OrderRiskAssessment
-
-
-class RiskAssessment(DataObject):
-
-    __fraud_fields: Optional[FraudFields] = None
-    __merchant: Optional[MerchantRiskAssessment] = None
-    __order: Optional[OrderRiskAssessment] = None
-    __payment_product_id: Optional[int] = None
-
-    @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 merchant(self) -> Optional[MerchantRiskAssessment]:
-        """
-        Type: :class:`worldline.connect.sdk.v1.domain.merchant_risk_assessment.MerchantRiskAssessment`
-        """
-        return self.__merchant
-
-    @merchant.setter
-    def merchant(self, value: Optional[MerchantRiskAssessment]) -> None:
-        self.__merchant = value
-
-    @property
-    def order(self) -> Optional[OrderRiskAssessment]:
-        """
-        Type: :class:`worldline.connect.sdk.v1.domain.order_risk_assessment.OrderRiskAssessment`
-        """
-        return self.__order
-
-    @order.setter
-    def order(self, value: Optional[OrderRiskAssessment]) -> None:
-        self.__order = value
-
-    @property
-    def payment_product_id(self) -> Optional[int]:
-        """
-        | Payment product identifier
-        | Please see payment products <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/paymentproducts.html> for a full overview of possible values.
-        
-        Type: int
-        """
-        return self.__payment_product_id
-
-    @payment_product_id.setter
-    def payment_product_id(self, value: Optional[int]) -> None:
-        self.__payment_product_id = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RiskAssessment, self).to_dictionary()
-        if self.fraud_fields is not None:
-            dictionary['fraudFields'] = self.fraud_fields.to_dictionary()
-        if self.merchant is not None:
-            dictionary['merchant'] = self.merchant.to_dictionary()
-        if self.order is not None:
-            dictionary['order'] = self.order.to_dictionary()
-        if self.payment_product_id is not None:
-            dictionary['paymentProductId'] = self.payment_product_id
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RiskAssessment':
-        super(RiskAssessment, self).from_dictionary(dictionary)
-        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 'merchant' in dictionary:
-            if not isinstance(dictionary['merchant'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['merchant']))
-            value = MerchantRiskAssessment()
-            self.merchant = value.from_dictionary(dictionary['merchant'])
-        if 'order' in dictionary:
-            if not isinstance(dictionary['order'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['order']))
-            value = OrderRiskAssessment()
-            self.order = value.from_dictionary(dictionary['order'])
-        if 'paymentProductId' in dictionary:
-            self.payment_product_id = dictionary['paymentProductId']
-        return self

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

@@ -1,64 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.v1.domain.bank_account_bban import BankAccountBban
-from worldline.connect.sdk.v1.domain.bank_account_iban import BankAccountIban
-from worldline.connect.sdk.v1.domain.risk_assessment import RiskAssessment
-
-
-class RiskAssessmentBankAccount(RiskAssessment):
-
-    __bank_account_bban: Optional[BankAccountBban] = None
-    __bank_account_iban: Optional[BankAccountIban] = None
-
-    @property
-    def bank_account_bban(self) -> Optional[BankAccountBban]:
-        """
-        | Object containing account holder name and bank account information
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_bban.BankAccountBban`
-        """
-        return self.__bank_account_bban
-
-    @bank_account_bban.setter
-    def bank_account_bban(self, value: Optional[BankAccountBban]) -> None:
-        self.__bank_account_bban = value
-
-    @property
-    def bank_account_iban(self) -> Optional[BankAccountIban]:
-        """
-        | Object containing account holder name and 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
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(RiskAssessmentBankAccount, self).to_dictionary()
-        if self.bank_account_bban is not None:
-            dictionary['bankAccountBban'] = self.bank_account_bban.to_dictionary()
-        if self.bank_account_iban is not None:
-            dictionary['bankAccountIban'] = self.bank_account_iban.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'RiskAssessmentBankAccount':
-        super(RiskAssessmentBankAccount, self).from_dictionary(dictionary)
-        if 'bankAccountBban' in dictionary:
-            if not isinstance(dictionary['bankAccountBban'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountBban']))
-            value = BankAccountBban()
-            self.bank_account_bban = value.from_dictionary(dictionary['bankAccountBban'])
-        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'])
-        return self