connect-sdk-python3 4.0.0__zip → 4.0.1__zip

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

@@ -1,137 +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.frequency import Frequency
-from worldline.connect.sdk.v1.domain.trial_period import TrialPeriod
-
-
-class TrialInformation(DataObject):
-    """
-    | The object containing data of the trial period: no-cost or discounted time-constrained trial subscription period.
-    """
-
-    __amount_of_money_after_trial: Optional[AmountOfMoney] = None
-    __end_date: Optional[str] = None
-    __is_recurring: Optional[bool] = None
-    __trial_period: Optional[TrialPeriod] = None
-    __trial_period_recurring: Optional[Frequency] = None
-
-    @property
-    def amount_of_money_after_trial(self) -> Optional[AmountOfMoney]:
-        """
-        | The object containing the amount and ISO currency code attributes of money to be paid after the trial period ends.
-        
-        | Note:
-        
-        | The property order.amountOfMoney should be populated with the amount to be paid during or for the trial period (no-cost or discounted time-constrained trial subscription period).
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.amount_of_money.AmountOfMoney`
-        """
-        return self.__amount_of_money_after_trial
-
-    @amount_of_money_after_trial.setter
-    def amount_of_money_after_trial(self, value: Optional[AmountOfMoney]) -> None:
-        self.__amount_of_money_after_trial = value
-
-    @property
-    def end_date(self) -> Optional[str]:
-        """
-        | The date that the trial period ends in YYYYMMDD format.
-        
-        Type: str
-        """
-        return self.__end_date
-
-    @end_date.setter
-    def end_date(self, value: Optional[str]) -> None:
-        self.__end_date = value
-
-    @property
-    def is_recurring(self) -> Optional[bool]:
-        """
-        | The property specifying if there will be recurring charges throughout the trial period (when the trial period involves a temporary discounted rate).
-        | True = there will be recurring charges during the trial period
-        | False = there will not be recurring charges during the trial period
-        
-        Type: bool
-        """
-        return self.__is_recurring
-
-    @is_recurring.setter
-    def is_recurring(self, value: Optional[bool]) -> None:
-        self.__is_recurring = value
-
-    @property
-    def trial_period(self) -> Optional[TrialPeriod]:
-        """
-        | The object containing information on the trial period duration and the interval between payments during that period.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.trial_period.TrialPeriod`
-        """
-        return self.__trial_period
-
-    @trial_period.setter
-    def trial_period(self, value: Optional[TrialPeriod]) -> None:
-        self.__trial_period = value
-
-    @property
-    def trial_period_recurring(self) -> Optional[Frequency]:
-        """
-        | The object containing the frequency and interval between recurring payments.
-        
-        | Note:
-        
-        | This object should only be populated if the frequency of recurring payments between the trial and regular periods is different.
-        
-        | If you do not populated this object, then the same interval frequency and interval of recurringPaymentsData.recurringInterval will be used
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.frequency.Frequency`
-        """
-        return self.__trial_period_recurring
-
-    @trial_period_recurring.setter
-    def trial_period_recurring(self, value: Optional[Frequency]) -> None:
-        self.__trial_period_recurring = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(TrialInformation, self).to_dictionary()
-        if self.amount_of_money_after_trial is not None:
-            dictionary['amountOfMoneyAfterTrial'] = self.amount_of_money_after_trial.to_dictionary()
-        if self.end_date is not None:
-            dictionary['endDate'] = self.end_date
-        if self.is_recurring is not None:
-            dictionary['isRecurring'] = self.is_recurring
-        if self.trial_period is not None:
-            dictionary['trialPeriod'] = self.trial_period.to_dictionary()
-        if self.trial_period_recurring is not None:
-            dictionary['trialPeriodRecurring'] = self.trial_period_recurring.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'TrialInformation':
-        super(TrialInformation, self).from_dictionary(dictionary)
-        if 'amountOfMoneyAfterTrial' in dictionary:
-            if not isinstance(dictionary['amountOfMoneyAfterTrial'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amountOfMoneyAfterTrial']))
-            value = AmountOfMoney()
-            self.amount_of_money_after_trial = value.from_dictionary(dictionary['amountOfMoneyAfterTrial'])
-        if 'endDate' in dictionary:
-            self.end_date = dictionary['endDate']
-        if 'isRecurring' in dictionary:
-            self.is_recurring = dictionary['isRecurring']
-        if 'trialPeriod' in dictionary:
-            if not isinstance(dictionary['trialPeriod'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['trialPeriod']))
-            value = TrialPeriod()
-            self.trial_period = value.from_dictionary(dictionary['trialPeriod'])
-        if 'trialPeriodRecurring' in dictionary:
-            if not isinstance(dictionary['trialPeriodRecurring'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['trialPeriodRecurring']))
-            value = Frequency()
-            self.trial_period_recurring = value.from_dictionary(dictionary['trialPeriodRecurring'])
-        return self

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

@@ -1,59 +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 TrialPeriod(DataObject):
-    """
-    | The object containing information on the trial period duration and the interval between payments during that period.
-    """
-
-    __duration: Optional[int] = None
-    __interval: Optional[str] = None
-
-    @property
-    def duration(self) -> Optional[int]:
-        """
-        | The number of days, weeks, months, or years before the trial period ends.
-        
-        Type: int
-        """
-        return self.__duration
-
-    @duration.setter
-    def duration(self, value: Optional[int]) -> None:
-        self.__duration = value
-
-    @property
-    def interval(self) -> Optional[str]:
-        """
-        | The interval for the trial period to finish specified as days, weeks, months, quarters, or years.
-        
-        Type: str
-        """
-        return self.__interval
-
-    @interval.setter
-    def interval(self, value: Optional[str]) -> None:
-        self.__interval = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(TrialPeriod, self).to_dictionary()
-        if self.duration is not None:
-            dictionary['duration'] = self.duration
-        if self.interval is not None:
-            dictionary['interval'] = self.interval
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'TrialPeriod':
-        super(TrialPeriod, self).from_dictionary(dictionary)
-        if 'duration' in dictionary:
-            self.duration = dictionary['duration']
-        if 'interval' in dictionary:
-            self.interval = dictionary['interval']
-        return self

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

@@ -1,92 +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 TrustlyBankAccount(DataObject):
-
-    __account_last_digits: Optional[str] = None
-    __bank_name: Optional[str] = None
-    __clearinghouse: Optional[str] = None
-    __person_identification_number: Optional[str] = None
-
-    @property
-    def account_last_digits(self) -> Optional[str]:
-        """
-        | The last digits of the account number
-        
-        Type: str
-        """
-        return self.__account_last_digits
-
-    @account_last_digits.setter
-    def account_last_digits(self, value: Optional[str]) -> None:
-        self.__account_last_digits = value
-
-    @property
-    def bank_name(self) -> Optional[str]:
-        """
-        | The name of the bank
-        
-        Type: str
-        """
-        return self.__bank_name
-
-    @bank_name.setter
-    def bank_name(self, value: Optional[str]) -> None:
-        self.__bank_name = value
-
-    @property
-    def clearinghouse(self) -> Optional[str]:
-        """
-        | The country of the clearing house
-        
-        Type: str
-        """
-        return self.__clearinghouse
-
-    @clearinghouse.setter
-    def clearinghouse(self, value: Optional[str]) -> None:
-        self.__clearinghouse = value
-
-    @property
-    def person_identification_number(self) -> Optional[str]:
-        """
-        | The ID number of the account holder
-        
-        Type: str
-        """
-        return self.__person_identification_number
-
-    @person_identification_number.setter
-    def person_identification_number(self, value: Optional[str]) -> None:
-        self.__person_identification_number = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(TrustlyBankAccount, self).to_dictionary()
-        if self.account_last_digits is not None:
-            dictionary['accountLastDigits'] = self.account_last_digits
-        if self.bank_name is not None:
-            dictionary['bankName'] = self.bank_name
-        if self.clearinghouse is not None:
-            dictionary['clearinghouse'] = self.clearinghouse
-        if self.person_identification_number is not None:
-            dictionary['personIdentificationNumber'] = self.person_identification_number
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'TrustlyBankAccount':
-        super(TrustlyBankAccount, self).from_dictionary(dictionary)
-        if 'accountLastDigits' in dictionary:
-            self.account_last_digits = dictionary['accountLastDigits']
-        if 'bankName' in dictionary:
-            self.bank_name = dictionary['bankName']
-        if 'clearinghouse' in dictionary:
-            self.clearinghouse = dictionary['clearinghouse']
-        if 'personIdentificationNumber' in dictionary:
-            self.person_identification_number = dictionary['personIdentificationNumber']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/update_token_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.token_card import TokenCard
-from worldline.connect.sdk.v1.domain.token_e_wallet import TokenEWallet
-from worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit import TokenNonSepaDirectDebit
-from worldline.connect.sdk.v1.domain.token_sepa_direct_debit_without_creditor import TokenSepaDirectDebitWithoutCreditor
-
-
-class UpdateTokenRequest(DataObject):
-
-    __card: Optional[TokenCard] = None
-    __e_wallet: Optional[TokenEWallet] = None
-    __non_sepa_direct_debit: Optional[TokenNonSepaDirectDebit] = None
-    __payment_product_id: Optional[int] = None
-    __sepa_direct_debit: Optional[TokenSepaDirectDebitWithoutCreditor] = None
-
-    @property
-    def card(self) -> Optional[TokenCard]:
-        """
-        | Object containing card details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.token_card.TokenCard`
-        """
-        return self.__card
-
-    @card.setter
-    def card(self, value: Optional[TokenCard]) -> None:
-        self.__card = value
-
-    @property
-    def e_wallet(self) -> Optional[TokenEWallet]:
-        """
-        | Object containing eWallet details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.token_e_wallet.TokenEWallet`
-        """
-        return self.__e_wallet
-
-    @e_wallet.setter
-    def e_wallet(self, value: Optional[TokenEWallet]) -> None:
-        self.__e_wallet = value
-
-    @property
-    def non_sepa_direct_debit(self) -> Optional[TokenNonSepaDirectDebit]:
-        """
-        | Object containing the non SEPA Direct Debit details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit.TokenNonSepaDirectDebit`
-        """
-        return self.__non_sepa_direct_debit
-
-    @non_sepa_direct_debit.setter
-    def non_sepa_direct_debit(self, value: Optional[TokenNonSepaDirectDebit]) -> None:
-        self.__non_sepa_direct_debit = 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
-
-    @property
-    def sepa_direct_debit(self) -> Optional[TokenSepaDirectDebitWithoutCreditor]:
-        """
-        | Object containing the SEPA Direct Debit details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.token_sepa_direct_debit_without_creditor.TokenSepaDirectDebitWithoutCreditor`
-        """
-        return self.__sepa_direct_debit
-
-    @sepa_direct_debit.setter
-    def sepa_direct_debit(self, value: Optional[TokenSepaDirectDebitWithoutCreditor]) -> None:
-        self.__sepa_direct_debit = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(UpdateTokenRequest, self).to_dictionary()
-        if self.card is not None:
-            dictionary['card'] = self.card.to_dictionary()
-        if self.e_wallet is not None:
-            dictionary['eWallet'] = self.e_wallet.to_dictionary()
-        if self.non_sepa_direct_debit is not None:
-            dictionary['nonSepaDirectDebit'] = self.non_sepa_direct_debit.to_dictionary()
-        if self.payment_product_id is not None:
-            dictionary['paymentProductId'] = self.payment_product_id
-        if self.sepa_direct_debit is not None:
-            dictionary['sepaDirectDebit'] = self.sepa_direct_debit.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'UpdateTokenRequest':
-        super(UpdateTokenRequest, self).from_dictionary(dictionary)
-        if 'card' in dictionary:
-            if not isinstance(dictionary['card'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['card']))
-            value = TokenCard()
-            self.card = value.from_dictionary(dictionary['card'])
-        if 'eWallet' in dictionary:
-            if not isinstance(dictionary['eWallet'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['eWallet']))
-            value = TokenEWallet()
-            self.e_wallet = value.from_dictionary(dictionary['eWallet'])
-        if 'nonSepaDirectDebit' in dictionary:
-            if not isinstance(dictionary['nonSepaDirectDebit'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['nonSepaDirectDebit']))
-            value = TokenNonSepaDirectDebit()
-            self.non_sepa_direct_debit = value.from_dictionary(dictionary['nonSepaDirectDebit'])
-        if 'paymentProductId' in dictionary:
-            self.payment_product_id = dictionary['paymentProductId']
-        if 'sepaDirectDebit' in dictionary:
-            if not isinstance(dictionary['sepaDirectDebit'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sepaDirectDebit']))
-            value = TokenSepaDirectDebitWithoutCreditor()
-            self.sepa_direct_debit = value.from_dictionary(dictionary['sepaDirectDebit'])
-        return self

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

@@ -1,59 +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 UploadDisputeFileResponse(DataObject):
-    """
-    | Response of a file upload request
-    """
-
-    __dispute_id: Optional[str] = None
-    __file_id: Optional[str] = None
-
-    @property
-    def dispute_id(self) -> Optional[str]:
-        """
-        | Dispute ID that is associated with the created dispute.
-        
-        Type: str
-        """
-        return self.__dispute_id
-
-    @dispute_id.setter
-    def dispute_id(self, value: Optional[str]) -> None:
-        self.__dispute_id = value
-
-    @property
-    def file_id(self) -> Optional[str]:
-        """
-        | The file ID that is associated with the uploaded file. This ID can be used for further communication regarding the file and retrieval of aforementioned property.
-        
-        Type: str
-        """
-        return self.__file_id
-
-    @file_id.setter
-    def file_id(self, value: Optional[str]) -> None:
-        self.__file_id = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(UploadDisputeFileResponse, self).to_dictionary()
-        if self.dispute_id is not None:
-            dictionary['disputeId'] = self.dispute_id
-        if self.file_id is not None:
-            dictionary['fileId'] = self.file_id
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'UploadDisputeFileResponse':
-        super(UploadDisputeFileResponse, self).from_dictionary(dictionary)
-        if 'disputeId' in dictionary:
-            self.dispute_id = dictionary['disputeId']
-        if 'fileId' in dictionary:
-            self.file_id = dictionary['fileId']
-        return self

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

@@ -1,79 +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 ValidationBankAccountCheck(DataObject):
-
-    __code: Optional[str] = None
-    __description: Optional[str] = None
-    __result: Optional[str] = None
-
-    @property
-    def code(self) -> Optional[str]:
-        """
-        | Code of the bank account validation check
-        
-        Type: str
-        """
-        return self.__code
-
-    @code.setter
-    def code(self, value: Optional[str]) -> None:
-        self.__code = value
-
-    @property
-    def description(self) -> Optional[str]:
-        """
-        | Description of check performed
-        
-        Type: str
-        """
-        return self.__description
-
-    @description.setter
-    def description(self, value: Optional[str]) -> None:
-        self.__description = value
-
-    @property
-    def result(self) -> Optional[str]:
-        """
-        | Result of the bank account validation check performed, with the following possible results:
-        
-        * PASSED - The check passed
-        * ERROR - The check did not pass
-        * WARNING - Depending on your needs this either needs to be treated as a passed or error response. It depends on your business logic and for what purpose you want to use the validated bank account details.
-        * NOTCHECKED - This check was not performed, usually because one of the earlier checks already caused an error response to be triggered
-        
-        Type: str
-        """
-        return self.__result
-
-    @result.setter
-    def result(self, value: Optional[str]) -> None:
-        self.__result = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(ValidationBankAccountCheck, self).to_dictionary()
-        if self.code is not None:
-            dictionary['code'] = self.code
-        if self.description is not None:
-            dictionary['description'] = self.description
-        if self.result is not None:
-            dictionary['result'] = self.result
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'ValidationBankAccountCheck':
-        super(ValidationBankAccountCheck, self).from_dictionary(dictionary)
-        if 'code' in dictionary:
-            self.code = dictionary['code']
-        if 'description' in dictionary:
-            self.description = dictionary['description']
-        if 'result' in dictionary:
-            self.result = dictionary['result']
-        return self

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

@@ -1,119 +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.validation_bank_account_check import ValidationBankAccountCheck
-
-
-class ValidationBankAccountOutput(DataObject):
-
-    __checks: Optional[List[ValidationBankAccountCheck]] = None
-    __new_bank_name: Optional[str] = None
-    __reformatted_account_number: Optional[str] = None
-    __reformatted_bank_code: Optional[str] = None
-    __reformatted_branch_code: Optional[str] = None
-
-    @property
-    def checks(self) -> Optional[List[ValidationBankAccountCheck]]:
-        """
-        | Array of checks performed with the results of each check
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.validation_bank_account_check.ValidationBankAccountCheck`]
-        """
-        return self.__checks
-
-    @checks.setter
-    def checks(self, value: Optional[List[ValidationBankAccountCheck]]) -> None:
-        self.__checks = value
-
-    @property
-    def new_bank_name(self) -> Optional[str]:
-        """
-        | Bank name, matching the bank code of the request
-        
-        Type: str
-        """
-        return self.__new_bank_name
-
-    @new_bank_name.setter
-    def new_bank_name(self, value: Optional[str]) -> None:
-        self.__new_bank_name = value
-
-    @property
-    def reformatted_account_number(self) -> Optional[str]:
-        """
-        | Reformatted account number according to local clearing rules
-        
-        Type: str
-        """
-        return self.__reformatted_account_number
-
-    @reformatted_account_number.setter
-    def reformatted_account_number(self, value: Optional[str]) -> None:
-        self.__reformatted_account_number = value
-
-    @property
-    def reformatted_bank_code(self) -> Optional[str]:
-        """
-        | Reformatted bank code according to local clearing rules
-        
-        Type: str
-        """
-        return self.__reformatted_bank_code
-
-    @reformatted_bank_code.setter
-    def reformatted_bank_code(self, value: Optional[str]) -> None:
-        self.__reformatted_bank_code = value
-
-    @property
-    def reformatted_branch_code(self) -> Optional[str]:
-        """
-        | Reformatted branch code according to local clearing rules
-        
-        Type: str
-        """
-        return self.__reformatted_branch_code
-
-    @reformatted_branch_code.setter
-    def reformatted_branch_code(self, value: Optional[str]) -> None:
-        self.__reformatted_branch_code = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(ValidationBankAccountOutput, self).to_dictionary()
-        if self.checks is not None:
-            dictionary['checks'] = []
-            for element in self.checks:
-                if element is not None:
-                    dictionary['checks'].append(element.to_dictionary())
-        if self.new_bank_name is not None:
-            dictionary['newBankName'] = self.new_bank_name
-        if self.reformatted_account_number is not None:
-            dictionary['reformattedAccountNumber'] = self.reformatted_account_number
-        if self.reformatted_bank_code is not None:
-            dictionary['reformattedBankCode'] = self.reformatted_bank_code
-        if self.reformatted_branch_code is not None:
-            dictionary['reformattedBranchCode'] = self.reformatted_branch_code
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'ValidationBankAccountOutput':
-        super(ValidationBankAccountOutput, self).from_dictionary(dictionary)
-        if 'checks' in dictionary:
-            if not isinstance(dictionary['checks'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['checks']))
-            self.checks = []
-            for element in dictionary['checks']:
-                value = ValidationBankAccountCheck()
-                self.checks.append(value.from_dictionary(element))
-        if 'newBankName' in dictionary:
-            self.new_bank_name = dictionary['newBankName']
-        if 'reformattedAccountNumber' in dictionary:
-            self.reformatted_account_number = dictionary['reformattedAccountNumber']
-        if 'reformattedBankCode' in dictionary:
-            self.reformatted_bank_code = dictionary['reformattedBankCode']
-        if 'reformattedBranchCode' in dictionary:
-            self.reformatted_branch_code = dictionary['reformattedBranchCode']
-        return self