connect-sdk-python3 4.0.0__zip → 4.1.0__zip

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

@@ -1,205 +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.additional_order_input import AdditionalOrderInput
-from worldline.connect.sdk.v1.domain.amount_of_money import AmountOfMoney
-from worldline.connect.sdk.v1.domain.customer import Customer
-from worldline.connect.sdk.v1.domain.line_item import LineItem
-from worldline.connect.sdk.v1.domain.order_references import OrderReferences
-from worldline.connect.sdk.v1.domain.seller import Seller
-from worldline.connect.sdk.v1.domain.shipping import Shipping
-from worldline.connect.sdk.v1.domain.shopping_cart import ShoppingCart
-
-
-class Order(DataObject):
-
-    __additional_input: Optional[AdditionalOrderInput] = None
-    __amount_of_money: Optional[AmountOfMoney] = None
-    __customer: Optional[Customer] = None
-    __items: Optional[List[LineItem]] = None
-    __references: Optional[OrderReferences] = None
-    __seller: Optional[Seller] = None
-    __shipping: Optional[Shipping] = None
-    __shopping_cart: Optional[ShoppingCart] = None
-
-    @property
-    def additional_input(self) -> Optional[AdditionalOrderInput]:
-        """
-        | Object containing additional input on the order
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.additional_order_input.AdditionalOrderInput`
-        """
-        return self.__additional_input
-
-    @additional_input.setter
-    def additional_input(self, value: Optional[AdditionalOrderInput]) -> None:
-        self.__additional_input = value
-
-    @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[Customer]:
-        """
-        | Object containing the details of the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.customer.Customer`
-        """
-        return self.__customer
-
-    @customer.setter
-    def customer(self, value: Optional[Customer]) -> None:
-        self.__customer = value
-
-    @property
-    def items(self) -> Optional[List[LineItem]]:
-        """
-        | Shopping cart data
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.line_item.LineItem`]
-        
-        Deprecated; Use shoppingCart.items instead
-        """
-        return self.__items
-
-    @items.setter
-    def items(self, value: Optional[List[LineItem]]) -> None:
-        self.__items = value
-
-    @property
-    def references(self) -> Optional[OrderReferences]:
-        """
-        | Object that holds all reference properties that are linked to this transaction
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.order_references.OrderReferences`
-        """
-        return self.__references
-
-    @references.setter
-    def references(self, value: Optional[OrderReferences]) -> None:
-        self.__references = value
-
-    @property
-    def seller(self) -> Optional[Seller]:
-        """
-        | Object containing seller details
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.seller.Seller`
-        
-        Deprecated; Use Merchant.seller instead
-        """
-        return self.__seller
-
-    @seller.setter
-    def seller(self, value: Optional[Seller]) -> None:
-        self.__seller = value
-
-    @property
-    def shipping(self) -> Optional[Shipping]:
-        """
-        | Object containing information regarding shipping / delivery
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.shipping.Shipping`
-        """
-        return self.__shipping
-
-    @shipping.setter
-    def shipping(self, value: Optional[Shipping]) -> None:
-        self.__shipping = value
-
-    @property
-    def shopping_cart(self) -> Optional[ShoppingCart]:
-        """
-        | Shopping cart data, including items and specific amounts.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.shopping_cart.ShoppingCart`
-        """
-        return self.__shopping_cart
-
-    @shopping_cart.setter
-    def shopping_cart(self, value: Optional[ShoppingCart]) -> None:
-        self.__shopping_cart = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(Order, self).to_dictionary()
-        if self.additional_input is not None:
-            dictionary['additionalInput'] = self.additional_input.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.items is not None:
-            dictionary['items'] = []
-            for element in self.items:
-                if element is not None:
-                    dictionary['items'].append(element.to_dictionary())
-        if self.references is not None:
-            dictionary['references'] = self.references.to_dictionary()
-        if self.seller is not None:
-            dictionary['seller'] = self.seller.to_dictionary()
-        if self.shipping is not None:
-            dictionary['shipping'] = self.shipping.to_dictionary()
-        if self.shopping_cart is not None:
-            dictionary['shoppingCart'] = self.shopping_cart.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'Order':
-        super(Order, self).from_dictionary(dictionary)
-        if 'additionalInput' in dictionary:
-            if not isinstance(dictionary['additionalInput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['additionalInput']))
-            value = AdditionalOrderInput()
-            self.additional_input = value.from_dictionary(dictionary['additionalInput'])
-        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 = Customer()
-            self.customer = value.from_dictionary(dictionary['customer'])
-        if 'items' in dictionary:
-            if not isinstance(dictionary['items'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['items']))
-            self.items = []
-            for element in dictionary['items']:
-                value = LineItem()
-                self.items.append(value.from_dictionary(element))
-        if 'references' in dictionary:
-            if not isinstance(dictionary['references'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['references']))
-            value = OrderReferences()
-            self.references = value.from_dictionary(dictionary['references'])
-        if 'seller' in dictionary:
-            if not isinstance(dictionary['seller'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['seller']))
-            value = Seller()
-            self.seller = value.from_dictionary(dictionary['seller'])
-        if 'shipping' in dictionary:
-            if not isinstance(dictionary['shipping'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shipping']))
-            value = Shipping()
-            self.shipping = value.from_dictionary(dictionary['shipping'])
-        if 'shoppingCart' in dictionary:
-            if not isinstance(dictionary['shoppingCart'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shoppingCart']))
-            value = ShoppingCart()
-            self.shopping_cart = value.from_dictionary(dictionary['shoppingCart'])
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/order_approve_payment.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.additional_order_input_airline_data import AdditionalOrderInputAirlineData
-from worldline.connect.sdk.v1.domain.customer_approve_payment import CustomerApprovePayment
-from worldline.connect.sdk.v1.domain.order_references_approve_payment import OrderReferencesApprovePayment
-
-
-class OrderApprovePayment(DataObject):
-
-    __additional_input: Optional[AdditionalOrderInputAirlineData] = None
-    __customer: Optional[CustomerApprovePayment] = None
-    __references: Optional[OrderReferencesApprovePayment] = None
-
-    @property
-    def additional_input(self) -> Optional[AdditionalOrderInputAirlineData]:
-        """
-        | Object containing additional input on the order
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.additional_order_input_airline_data.AdditionalOrderInputAirlineData`
-        """
-        return self.__additional_input
-
-    @additional_input.setter
-    def additional_input(self, value: Optional[AdditionalOrderInputAirlineData]) -> None:
-        self.__additional_input = value
-
-    @property
-    def customer(self) -> Optional[CustomerApprovePayment]:
-        """
-        | Object containing data related to the customer
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.customer_approve_payment.CustomerApprovePayment`
-        """
-        return self.__customer
-
-    @customer.setter
-    def customer(self, value: Optional[CustomerApprovePayment]) -> None:
-        self.__customer = value
-
-    @property
-    def references(self) -> Optional[OrderReferencesApprovePayment]:
-        """
-        | Object that holds all reference properties that are linked to this transaction
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.order_references_approve_payment.OrderReferencesApprovePayment`
-        """
-        return self.__references
-
-    @references.setter
-    def references(self, value: Optional[OrderReferencesApprovePayment]) -> None:
-        self.__references = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(OrderApprovePayment, self).to_dictionary()
-        if self.additional_input is not None:
-            dictionary['additionalInput'] = self.additional_input.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) -> 'OrderApprovePayment':
-        super(OrderApprovePayment, self).from_dictionary(dictionary)
-        if 'additionalInput' in dictionary:
-            if not isinstance(dictionary['additionalInput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['additionalInput']))
-            value = AdditionalOrderInputAirlineData()
-            self.additional_input = value.from_dictionary(dictionary['additionalInput'])
-        if 'customer' in dictionary:
-            if not isinstance(dictionary['customer'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customer']))
-            value = CustomerApprovePayment()
-            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 = OrderReferencesApprovePayment()
-            self.references = value.from_dictionary(dictionary['references'])
-        return self

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

@@ -1,100 +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
-
-
-class OrderInvoiceData(DataObject):
-
-    __additional_data: Optional[str] = None
-    __invoice_date: Optional[str] = None
-    __invoice_number: Optional[str] = None
-    __text_qualifiers: Optional[List[str]] = None
-
-    @property
-    def additional_data(self) -> Optional[str]:
-        """
-        | Additional data for printed invoices
-        
-        Type: str
-        """
-        return self.__additional_data
-
-    @additional_data.setter
-    def additional_data(self, value: Optional[str]) -> None:
-        self.__additional_data = value
-
-    @property
-    def invoice_date(self) -> Optional[str]:
-        """
-        | Date and time on invoice
-        | Format: YYYYMMDDHH24MISS
-        
-        Type: str
-        """
-        return self.__invoice_date
-
-    @invoice_date.setter
-    def invoice_date(self, value: Optional[str]) -> None:
-        self.__invoice_date = value
-
-    @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 text_qualifiers(self) -> Optional[List[str]]:
-        """
-        | Array of 3 text qualifiers, each with a max length of 10 characters
-        
-        Type: list[str]
-        """
-        return self.__text_qualifiers
-
-    @text_qualifiers.setter
-    def text_qualifiers(self, value: Optional[List[str]]) -> None:
-        self.__text_qualifiers = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(OrderInvoiceData, self).to_dictionary()
-        if self.additional_data is not None:
-            dictionary['additionalData'] = self.additional_data
-        if self.invoice_date is not None:
-            dictionary['invoiceDate'] = self.invoice_date
-        if self.invoice_number is not None:
-            dictionary['invoiceNumber'] = self.invoice_number
-        if self.text_qualifiers is not None:
-            dictionary['textQualifiers'] = []
-            for element in self.text_qualifiers:
-                if element is not None:
-                    dictionary['textQualifiers'].append(element)
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'OrderInvoiceData':
-        super(OrderInvoiceData, self).from_dictionary(dictionary)
-        if 'additionalData' in dictionary:
-            self.additional_data = dictionary['additionalData']
-        if 'invoiceDate' in dictionary:
-            self.invoice_date = dictionary['invoiceDate']
-        if 'invoiceNumber' in dictionary:
-            self.invoice_number = dictionary['invoiceNumber']
-        if 'textQualifiers' in dictionary:
-            if not isinstance(dictionary['textQualifiers'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['textQualifiers']))
-            self.text_qualifiers = []
-            for element in dictionary['textQualifiers']:
-                self.text_qualifiers.append(element)
-        return self

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

@@ -1,239 +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 OrderLineDetails(DataObject):
-
-    __discount_amount: Optional[int] = None
-    __google_product_category_id: Optional[int] = None
-    __line_amount_total: Optional[int] = None
-    __product_category: Optional[str] = None
-    __product_code: Optional[str] = None
-    __product_name: Optional[str] = None
-    __product_price: Optional[int] = None
-    __product_sku: Optional[str] = None
-    __product_type: Optional[str] = None
-    __quantity: Optional[int] = None
-    __tax_amount: Optional[int] = None
-    __unit: Optional[str] = None
-
-    @property
-    def discount_amount(self) -> Optional[int]:
-        """
-        | Discount on the line item, with the last two digits implied as decimal places
-        
-        Type: int
-        """
-        return self.__discount_amount
-
-    @discount_amount.setter
-    def discount_amount(self, value: Optional[int]) -> None:
-        self.__discount_amount = value
-
-    @property
-    def google_product_category_id(self) -> Optional[int]:
-        """
-        | The Google product category ID for the item.
-        
-        Type: int
-        """
-        return self.__google_product_category_id
-
-    @google_product_category_id.setter
-    def google_product_category_id(self, value: Optional[int]) -> None:
-        self.__google_product_category_id = value
-
-    @property
-    def line_amount_total(self) -> Optional[int]:
-        """
-        | Total amount for the line item
-        
-        Type: int
-        """
-        return self.__line_amount_total
-
-    @line_amount_total.setter
-    def line_amount_total(self, value: Optional[int]) -> None:
-        self.__line_amount_total = value
-
-    @property
-    def product_category(self) -> Optional[str]:
-        """
-        | The category of the product (i.e. home appliance). This property can be used for fraud screening on the Ogone Platform.
-        
-        Type: str
-        """
-        return self.__product_category
-
-    @product_category.setter
-    def product_category(self, value: Optional[str]) -> None:
-        self.__product_category = value
-
-    @property
-    def product_code(self) -> Optional[str]:
-        """
-        | Product or UPC Code, left justified
-        | Note: Must not be all spaces or all zeros
-        
-        Type: str
-        """
-        return self.__product_code
-
-    @product_code.setter
-    def product_code(self, value: Optional[str]) -> None:
-        self.__product_code = value
-
-    @property
-    def product_name(self) -> Optional[str]:
-        """
-        | The name of the product. The '+' character is not allowed in this property for transactions that are processed by TechProcess Payment Platform.
-        
-        Type: str
-        """
-        return self.__product_name
-
-    @product_name.setter
-    def product_name(self, value: Optional[str]) -> None:
-        self.__product_name = value
-
-    @property
-    def product_price(self) -> Optional[int]:
-        """
-        | The price of one unit of the product, the value should be zero or greater
-        
-        Type: int
-        """
-        return self.__product_price
-
-    @product_price.setter
-    def product_price(self, value: Optional[int]) -> None:
-        self.__product_price = value
-
-    @property
-    def product_sku(self) -> Optional[str]:
-        """
-        | Product SKU number
-        
-        Type: str
-        """
-        return self.__product_sku
-
-    @product_sku.setter
-    def product_sku(self, value: Optional[str]) -> None:
-        self.__product_sku = value
-
-    @property
-    def product_type(self) -> Optional[str]:
-        """
-        | Code used to classify items that are purchased
-        | Note: Must not be all spaces or all zeros
-        
-        Type: str
-        """
-        return self.__product_type
-
-    @product_type.setter
-    def product_type(self, value: Optional[str]) -> None:
-        self.__product_type = value
-
-    @property
-    def quantity(self) -> Optional[int]:
-        """
-        | Quantity of the units being purchased, should be greater than zero
-        | Note: Must not be all spaces or all zeros
-        
-        Type: int
-        """
-        return self.__quantity
-
-    @quantity.setter
-    def quantity(self, value: Optional[int]) -> None:
-        self.__quantity = value
-
-    @property
-    def tax_amount(self) -> Optional[int]:
-        """
-        | Tax on the line item, with the last two digits implied as decimal places
-        
-        Type: int
-        """
-        return self.__tax_amount
-
-    @tax_amount.setter
-    def tax_amount(self, value: Optional[int]) -> None:
-        self.__tax_amount = value
-
-    @property
-    def unit(self) -> Optional[str]:
-        """
-        | Indicates the line item unit of measure; for example: each, kit, pair, gallon, month, etc.
-        
-        Type: str
-        """
-        return self.__unit
-
-    @unit.setter
-    def unit(self, value: Optional[str]) -> None:
-        self.__unit = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(OrderLineDetails, self).to_dictionary()
-        if self.discount_amount is not None:
-            dictionary['discountAmount'] = self.discount_amount
-        if self.google_product_category_id is not None:
-            dictionary['googleProductCategoryId'] = self.google_product_category_id
-        if self.line_amount_total is not None:
-            dictionary['lineAmountTotal'] = self.line_amount_total
-        if self.product_category is not None:
-            dictionary['productCategory'] = self.product_category
-        if self.product_code is not None:
-            dictionary['productCode'] = self.product_code
-        if self.product_name is not None:
-            dictionary['productName'] = self.product_name
-        if self.product_price is not None:
-            dictionary['productPrice'] = self.product_price
-        if self.product_sku is not None:
-            dictionary['productSku'] = self.product_sku
-        if self.product_type is not None:
-            dictionary['productType'] = self.product_type
-        if self.quantity is not None:
-            dictionary['quantity'] = self.quantity
-        if self.tax_amount is not None:
-            dictionary['taxAmount'] = self.tax_amount
-        if self.unit is not None:
-            dictionary['unit'] = self.unit
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'OrderLineDetails':
-        super(OrderLineDetails, self).from_dictionary(dictionary)
-        if 'discountAmount' in dictionary:
-            self.discount_amount = dictionary['discountAmount']
-        if 'googleProductCategoryId' in dictionary:
-            self.google_product_category_id = dictionary['googleProductCategoryId']
-        if 'lineAmountTotal' in dictionary:
-            self.line_amount_total = dictionary['lineAmountTotal']
-        if 'productCategory' in dictionary:
-            self.product_category = dictionary['productCategory']
-        if 'productCode' in dictionary:
-            self.product_code = dictionary['productCode']
-        if 'productName' in dictionary:
-            self.product_name = dictionary['productName']
-        if 'productPrice' in dictionary:
-            self.product_price = dictionary['productPrice']
-        if 'productSku' in dictionary:
-            self.product_sku = dictionary['productSku']
-        if 'productType' in dictionary:
-            self.product_type = dictionary['productType']
-        if 'quantity' in dictionary:
-            self.quantity = dictionary['quantity']
-        if 'taxAmount' in dictionary:
-            self.tax_amount = dictionary['taxAmount']
-        if 'unit' in dictionary:
-            self.unit = dictionary['unit']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/order_output.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.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.amount_of_money import AmountOfMoney
-from worldline.connect.sdk.v1.domain.payment_references import PaymentReferences
-
-
-class OrderOutput(DataObject):
-
-    __amount_of_money: Optional[AmountOfMoney] = None
-    __references: Optional[PaymentReferences] = 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 references(self) -> Optional[PaymentReferences]:
-        """
-        | Object that holds all reference properties that are linked to this transaction
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_references.PaymentReferences`
-        """
-        return self.__references
-
-    @references.setter
-    def references(self, value: Optional[PaymentReferences]) -> None:
-        self.__references = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(OrderOutput, self).to_dictionary()
-        if self.amount_of_money is not None:
-            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
-        if self.references is not None:
-            dictionary['references'] = self.references.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'OrderOutput':
-        super(OrderOutput, 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 'references' in dictionary:
-            if not isinstance(dictionary['references'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['references']))
-            value = PaymentReferences()
-            self.references = value.from_dictionary(dictionary['references'])
-        return self