connect-sdk-python3 4.0.0__zip → 4.0.1__zip

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

@@ -1,89 +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.order_status_output import OrderStatusOutput
-
-
-class PaymentStatusOutput(OrderStatusOutput):
-
-    __is_authorized: Optional[bool] = None
-    __is_refundable: Optional[bool] = None
-    __three_d_secure_status: Optional[str] = None
-
-    @property
-    def is_authorized(self) -> Optional[bool]:
-        """
-        | Indicates if the transaction has been authorized
-        
-        * true
-        * false
-        
-        Type: bool
-        """
-        return self.__is_authorized
-
-    @is_authorized.setter
-    def is_authorized(self, value: Optional[bool]) -> None:
-        self.__is_authorized = value
-
-    @property
-    def is_refundable(self) -> Optional[bool]:
-        """
-        | Flag indicating if the payment can be refunded
-        
-        * true
-        * false
-        
-        Type: bool
-        """
-        return self.__is_refundable
-
-    @is_refundable.setter
-    def is_refundable(self, value: Optional[bool]) -> None:
-        self.__is_refundable = value
-
-    @property
-    def three_d_secure_status(self) -> Optional[str]:
-        """
-        | The 3D Secure status, with the following possible values:
-        
-        * ENROLLED: the card is enrolled for 3D Secure authentication. The customer can be redirected to a 3D Secure access control server (ACS)
-        * NOT_ENROLLED: the card is not enrolled for 3D Secure authentication
-        * INVALID_PARES_OR_NOT_COMPLETED: the PARes is invalid, or the customer did not complete the 3D Secure authentication
-        * AUTHENTICATED: the customer has passed the 3D Secure authentication
-        * NOT_AUTHENTICATED: the customer failed the 3D Secure authentication
-        * NOT_PARTICIPATING: the cardholder has not set up their card for 2-step 3D Secure.
-        
-        | Note that this status will only be set for payments that make use of 2-step 3D Secure.
-        
-        Type: str
-        """
-        return self.__three_d_secure_status
-
-    @three_d_secure_status.setter
-    def three_d_secure_status(self, value: Optional[str]) -> None:
-        self.__three_d_secure_status = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PaymentStatusOutput, self).to_dictionary()
-        if self.is_authorized is not None:
-            dictionary['isAuthorized'] = self.is_authorized
-        if self.is_refundable is not None:
-            dictionary['isRefundable'] = self.is_refundable
-        if self.three_d_secure_status is not None:
-            dictionary['threeDSecureStatus'] = self.three_d_secure_status
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PaymentStatusOutput':
-        super(PaymentStatusOutput, self).from_dictionary(dictionary)
-        if 'isAuthorized' in dictionary:
-            self.is_authorized = dictionary['isAuthorized']
-        if 'isRefundable' in dictionary:
-            self.is_refundable = dictionary['isRefundable']
-        if 'threeDSecureStatus' in dictionary:
-            self.three_d_secure_status = dictionary['threeDSecureStatus']
-        return self

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

@@ -1,126 +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.address import Address
-from worldline.connect.sdk.v1.domain.company_information import CompanyInformation
-from worldline.connect.sdk.v1.domain.contact_details_base import ContactDetailsBase
-from worldline.connect.sdk.v1.domain.personal_name import PersonalName
-
-
-class PayoutCustomer(DataObject):
-
-    __address: Optional[Address] = None
-    __company_information: Optional[CompanyInformation] = None
-    __contact_details: Optional[ContactDetailsBase] = None
-    __merchant_customer_id: Optional[str] = None
-    __name: Optional[PersonalName] = None
-
-    @property
-    def address(self) -> Optional[Address]:
-        """
-        | Object containing address details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.address.Address`
-        """
-        return self.__address
-
-    @address.setter
-    def address(self, value: Optional[Address]) -> None:
-        self.__address = value
-
-    @property
-    def company_information(self) -> Optional[CompanyInformation]:
-        """
-        | Object containing company information
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.company_information.CompanyInformation`
-        """
-        return self.__company_information
-
-    @company_information.setter
-    def company_information(self, value: Optional[CompanyInformation]) -> None:
-        self.__company_information = value
-
-    @property
-    def contact_details(self) -> Optional[ContactDetailsBase]:
-        """
-        | Object containing contact details like email address and phone number
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.contact_details_base.ContactDetailsBase`
-        """
-        return self.__contact_details
-
-    @contact_details.setter
-    def contact_details(self, value: Optional[ContactDetailsBase]) -> None:
-        self.__contact_details = value
-
-    @property
-    def merchant_customer_id(self) -> Optional[str]:
-        """
-        | Your identifier for the customer. It can be used as a search criteria in the GlobalCollect Payment Console and is also included in the GlobalCollect report files. It is used in the fraud-screening process for payments on the Ogone Payment Platform.
-        
-        Type: str
-        """
-        return self.__merchant_customer_id
-
-    @merchant_customer_id.setter
-    def merchant_customer_id(self, value: Optional[str]) -> None:
-        self.__merchant_customer_id = value
-
-    @property
-    def name(self) -> Optional[PersonalName]:
-        """
-        | Object containing PersonalName object
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.personal_name.PersonalName`
-        """
-        return self.__name
-
-    @name.setter
-    def name(self, value: Optional[PersonalName]) -> None:
-        self.__name = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PayoutCustomer, self).to_dictionary()
-        if self.address is not None:
-            dictionary['address'] = self.address.to_dictionary()
-        if self.company_information is not None:
-            dictionary['companyInformation'] = self.company_information.to_dictionary()
-        if self.contact_details is not None:
-            dictionary['contactDetails'] = self.contact_details.to_dictionary()
-        if self.merchant_customer_id is not None:
-            dictionary['merchantCustomerId'] = self.merchant_customer_id
-        if self.name is not None:
-            dictionary['name'] = self.name.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PayoutCustomer':
-        super(PayoutCustomer, self).from_dictionary(dictionary)
-        if 'address' in dictionary:
-            if not isinstance(dictionary['address'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['address']))
-            value = Address()
-            self.address = value.from_dictionary(dictionary['address'])
-        if 'companyInformation' in dictionary:
-            if not isinstance(dictionary['companyInformation'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['companyInformation']))
-            value = CompanyInformation()
-            self.company_information = value.from_dictionary(dictionary['companyInformation'])
-        if 'contactDetails' in dictionary:
-            if not isinstance(dictionary['contactDetails'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['contactDetails']))
-            value = ContactDetailsBase()
-            self.contact_details = value.from_dictionary(dictionary['contactDetails'])
-        if 'merchantCustomerId' in dictionary:
-            self.merchant_customer_id = dictionary['merchantCustomerId']
-        if 'name' in dictionary:
-            if not isinstance(dictionary['name'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['name']))
-            value = PersonalName()
-            self.name = value.from_dictionary(dictionary['name'])
-        return self

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

@@ -1,86 +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.payout_customer import PayoutCustomer
-from worldline.connect.sdk.v1.domain.payout_references import PayoutReferences
-
-
-class PayoutDetails(DataObject):
-
-    __amount_of_money: Optional[AmountOfMoney] = None
-    __customer: Optional[PayoutCustomer] = None
-    __references: Optional[PayoutReferences] = 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 customer(self) -> Optional[PayoutCustomer]:
-        """
-        | Object containing the details of the customer.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payout_customer.PayoutCustomer`
-        """
-        return self.__customer
-
-    @customer.setter
-    def customer(self, value: Optional[PayoutCustomer]) -> None:
-        self.__customer = value
-
-    @property
-    def references(self) -> Optional[PayoutReferences]:
-        """
-        | Object that holds all reference properties that are linked to this transaction
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payout_references.PayoutReferences`
-        """
-        return self.__references
-
-    @references.setter
-    def references(self, value: Optional[PayoutReferences]) -> None:
-        self.__references = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PayoutDetails, self).to_dictionary()
-        if self.amount_of_money is not None:
-            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
-        if self.customer is not None:
-            dictionary['customer'] = self.customer.to_dictionary()
-        if self.references is not None:
-            dictionary['references'] = self.references.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PayoutDetails':
-        super(PayoutDetails, 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 'customer' in dictionary:
-            if not isinstance(dictionary['customer'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customer']))
-            value = PayoutCustomer()
-            self.customer = value.from_dictionary(dictionary['customer'])
-        if 'references' in dictionary:
-            if not isinstance(dictionary['references'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['references']))
-            value = PayoutReferences()
-            self.references = value.from_dictionary(dictionary['references'])
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/payout_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.payout_result import PayoutResult
-
-
-class PayoutErrorResponse(DataObject):
-
-    __error_id: Optional[str] = None
-    __errors: Optional[List[APIError]] = None
-    __payout_result: Optional[PayoutResult] = 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 payout_result(self) -> Optional[PayoutResult]:
-        """
-        | Object that contains details on the created payout in case one has been created
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payout_result.PayoutResult`
-        """
-        return self.__payout_result
-
-    @payout_result.setter
-    def payout_result(self, value: Optional[PayoutResult]) -> None:
-        self.__payout_result = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PayoutErrorResponse, 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.payout_result is not None:
-            dictionary['payoutResult'] = self.payout_result.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PayoutErrorResponse':
-        super(PayoutErrorResponse, 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 'payoutResult' in dictionary:
-            if not isinstance(dictionary['payoutResult'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payoutResult']))
-            value = PayoutResult()
-            self.payout_result = value.from_dictionary(dictionary['payoutResult'])
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/payout_merchant.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 PayoutMerchant(DataObject):
-
-    __configuration_id: Optional[str] = None
-
-    @property
-    def configuration_id(self) -> Optional[str]:
-        """
-        | In case your account has been setup with multiple configurations you can use this property to identify the one you would like to use for the transaction. Note that you can only submit preconfigured values in combination with the Worldline Online Payments Acceptance platform. In case no value is supplied a default value of 0 will be submitted to the Worldline Online Payments Acceptance platform. The Worldline Online Payments Acceptance platform internally refers to this as a PosId.
-        
-        Type: str
-        """
-        return self.__configuration_id
-
-    @configuration_id.setter
-    def configuration_id(self, value: Optional[str]) -> None:
-        self.__configuration_id = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PayoutMerchant, self).to_dictionary()
-        if self.configuration_id is not None:
-            dictionary['configurationId'] = self.configuration_id
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PayoutMerchant':
-        super(PayoutMerchant, self).from_dictionary(dictionary)
-        if 'configurationId' in dictionary:
-            self.configuration_id = dictionary['configurationId']
-        return self

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

@@ -1,77 +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 PayoutRecipient(DataObject):
-    """
-    | Object containing the details of the recipient of the payout
-    """
-
-    __first_name: Optional[str] = None
-    __surname: Optional[str] = None
-    __surname_prefix: Optional[str] = None
-
-    @property
-    def first_name(self) -> Optional[str]:
-        """
-        | Given name(s) or first name(s) of the customer
-        
-        Type: str
-        """
-        return self.__first_name
-
-    @first_name.setter
-    def first_name(self, value: Optional[str]) -> None:
-        self.__first_name = value
-
-    @property
-    def surname(self) -> Optional[str]:
-        """
-        | Surname(s) or last name(s) of the customer
-        
-        Type: str
-        """
-        return self.__surname
-
-    @surname.setter
-    def surname(self, value: Optional[str]) -> None:
-        self.__surname = value
-
-    @property
-    def surname_prefix(self) -> Optional[str]:
-        """
-        | Middle name - In between first name and surname - of the customer
-        
-        Type: str
-        """
-        return self.__surname_prefix
-
-    @surname_prefix.setter
-    def surname_prefix(self, value: Optional[str]) -> None:
-        self.__surname_prefix = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PayoutRecipient, self).to_dictionary()
-        if self.first_name is not None:
-            dictionary['firstName'] = self.first_name
-        if self.surname is not None:
-            dictionary['surname'] = self.surname
-        if self.surname_prefix is not None:
-            dictionary['surnamePrefix'] = self.surname_prefix
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PayoutRecipient':
-        super(PayoutRecipient, self).from_dictionary(dictionary)
-        if 'firstName' in dictionary:
-            self.first_name = dictionary['firstName']
-        if 'surname' in dictionary:
-            self.surname = dictionary['surname']
-        if 'surnamePrefix' in dictionary:
-            self.surname_prefix = dictionary['surnamePrefix']
-        return self

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

@@ -1,75 +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 PayoutReferences(DataObject):
-
-    __invoice_number: Optional[str] = None
-    __merchant_order_id: Optional[int] = None
-    __merchant_reference: Optional[str] = None
-
-    @property
-    def invoice_number(self) -> Optional[str]:
-        """
-        | Your invoice number (on printed invoice) that is also returned in our report files
-        
-        Type: str
-        """
-        return self.__invoice_number
-
-    @invoice_number.setter
-    def invoice_number(self, value: Optional[str]) -> None:
-        self.__invoice_number = value
-
-    @property
-    def merchant_order_id(self) -> Optional[int]:
-        """
-        | Order Identifier generated by the merchant
-        | Note: This does not need to have a unique value for each transaction
-        
-        Type: int
-        """
-        return self.__merchant_order_id
-
-    @merchant_order_id.setter
-    def merchant_order_id(self, value: Optional[int]) -> None:
-        self.__merchant_order_id = value
-
-    @property
-    def merchant_reference(self) -> Optional[str]:
-        """
-        | Note that the maximum length of this field for transactions processed on the GlobalCollect platform is 30. Your unique reference of the transaction that is also returned in our report files. This is almost always used for your reconciliation of our report files.
-        
-        Type: str
-        """
-        return self.__merchant_reference
-
-    @merchant_reference.setter
-    def merchant_reference(self, value: Optional[str]) -> None:
-        self.__merchant_reference = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(PayoutReferences, self).to_dictionary()
-        if self.invoice_number is not None:
-            dictionary['invoiceNumber'] = self.invoice_number
-        if self.merchant_order_id is not None:
-            dictionary['merchantOrderId'] = self.merchant_order_id
-        if self.merchant_reference is not None:
-            dictionary['merchantReference'] = self.merchant_reference
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'PayoutReferences':
-        super(PayoutReferences, self).from_dictionary(dictionary)
-        if 'invoiceNumber' in dictionary:
-            self.invoice_number = dictionary['invoiceNumber']
-        if 'merchantOrderId' in dictionary:
-            self.merchant_order_id = dictionary['merchantOrderId']
-        if 'merchantReference' in dictionary:
-            self.merchant_reference = dictionary['merchantReference']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/payout_result.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.abstract_order_status import AbstractOrderStatus
-from worldline.connect.sdk.v1.domain.order_output import OrderOutput
-from worldline.connect.sdk.v1.domain.order_status_output import OrderStatusOutput
-
-
-class PayoutResult(AbstractOrderStatus):
-
-    __payout_output: Optional[OrderOutput] = None
-    __status: Optional[str] = None
-    __status_output: Optional[OrderStatusOutput] = None
-
-    @property
-    def payout_output(self) -> Optional[OrderOutput]:
-        """
-        | Object containing payout details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.order_output.OrderOutput`
-        """
-        return self.__payout_output
-
-    @payout_output.setter
-    def payout_output(self, value: Optional[OrderOutput]) -> None:
-        self.__payout_output = value
-
-    @property
-    def status(self) -> Optional[str]:
-        """
-        | Current high-level status of the payouts in a human-readable form. Possible values are :
-        
-        * CREATED - The transaction has been created. This is the initial state once a new payout is created.
-        * PENDING_APPROVAL - The transaction is awaiting approval from you to proceed with the paying out of the funds
-        * REJECTED - The transaction has been rejected
-        * PAYOUT_REQUESTED - The transaction is in the queue to be payed out to the customer
-        * ACCOUNT_CREDITED - We have successfully credited the customer
-        * REJECTED_CREDIT - The credit to the account of the customer was rejected by the bank
-        * CANCELLED - You have cancelled the transaction
-        * REVERSED - The payout has been reversed and the money is returned to your balance
-        
-        
-        | 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 payout status, timestamp of last status change and performable action on the current payout resource.
-        | In case of a rejected payout, 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(PayoutResult, self).to_dictionary()
-        if self.payout_output is not None:
-            dictionary['payoutOutput'] = self.payout_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) -> 'PayoutResult':
-        super(PayoutResult, self).from_dictionary(dictionary)
-        if 'payoutOutput' in dictionary:
-            if not isinstance(dictionary['payoutOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payoutOutput']))
-            value = OrderOutput()
-            self.payout_output = value.from_dictionary(dictionary['payoutOutput'])
-        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