connect-sdk-python3 4.0.0__zip → 4.1.0__zip

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/account_on_file.py

@@ -0,0 +1,109 @@
+# -*- 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.account_on_file_attribute import AccountOnFileAttribute
+from worldline.connect.sdk.v1.domain.account_on_file_display_hints import AccountOnFileDisplayHints
+
+
+class AccountOnFile(DataObject):
+    """
+    | Elements from the AccountsOnFile array
+    """
+
+    __attributes: Optional[List[AccountOnFileAttribute]] = None
+    __display_hints: Optional[AccountOnFileDisplayHints] = None
+    __id: Optional[int] = None
+    __payment_product_id: Optional[int] = None
+
+    @property
+    def attributes(self) -> Optional[List[AccountOnFileAttribute]]:
+        """
+        | Array containing the details of the stored token
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.account_on_file_attribute.AccountOnFileAttribute`]
+        """
+        return self.__attributes
+
+    @attributes.setter
+    def attributes(self, value: Optional[List[AccountOnFileAttribute]]) -> None:
+        self.__attributes = value
+
+    @property
+    def display_hints(self) -> Optional[AccountOnFileDisplayHints]:
+        """
+        | Object containing information for the client on how best to display this field
+
+        Type: :class:`worldline.connect.sdk.v1.domain.account_on_file_display_hints.AccountOnFileDisplayHints`
+        """
+        return self.__display_hints
+
+    @display_hints.setter
+    def display_hints(self, value: Optional[AccountOnFileDisplayHints]) -> None:
+        self.__display_hints = value
+
+    @property
+    def id(self) -> Optional[int]:
+        """
+        | ID of the account on file record
+
+        Type: int
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[int]) -> None:
+        self.__id = 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(AccountOnFile, self).to_dictionary()
+        if self.attributes is not None:
+            dictionary['attributes'] = []
+            for element in self.attributes:
+                if element is not None:
+                    dictionary['attributes'].append(element.to_dictionary())
+        if self.display_hints is not None:
+            dictionary['displayHints'] = self.display_hints.to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AccountOnFile':
+        super(AccountOnFile, self).from_dictionary(dictionary)
+        if 'attributes' in dictionary:
+            if not isinstance(dictionary['attributes'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['attributes']))
+            self.attributes = []
+            for element in dictionary['attributes']:
+                value = AccountOnFileAttribute()
+                self.attributes.append(value.from_dictionary(element))
+        if 'displayHints' in dictionary:
+            if not isinstance(dictionary['displayHints'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['displayHints']))
+            value = AccountOnFileDisplayHints()
+            self.display_hints = value.from_dictionary(dictionary['displayHints'])
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/account_on_file_attribute.py

@@ -0,0 +1,62 @@
+# -*- 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.key_value_pair import KeyValuePair
+
+
+class AccountOnFileAttribute(KeyValuePair):
+
+    __must_write_reason: Optional[str] = None
+    __status: Optional[str] = None
+
+    @property
+    def must_write_reason(self) -> Optional[str]:
+        """
+        | The reason why the status is MUST_WRITE. Currently only "IN_THE_PAST" is possible as value (for expiry date), but this can be extended with new values in the future.
+
+        Type: str
+        """
+        return self.__must_write_reason
+
+    @must_write_reason.setter
+    def must_write_reason(self, value: Optional[str]) -> None:
+        self.__must_write_reason = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | Possible values:
+        
+        * READ_ONLY - attribute cannot be updated and should be presented in that way to the user
+        * CAN_WRITE - attribute can be updated and should be presented as an editable field, for example an expiration date that will expire very soon
+        * MUST_WRITE - attribute should be updated and must be presented as an editable field, for example an expiration date that has already expired
+        
+        | Any updated values that are entered for CAN_WRITE or MUST_WRITE will be used to update the values stored in the token.
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(AccountOnFileAttribute, self).to_dictionary()
+        if self.must_write_reason is not None:
+            dictionary['mustWriteReason'] = self.must_write_reason
+        if self.status is not None:
+            dictionary['status'] = self.status
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AccountOnFileAttribute':
+        super(AccountOnFileAttribute, self).from_dictionary(dictionary)
+        if 'mustWriteReason' in dictionary:
+            self.must_write_reason = dictionary['mustWriteReason']
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/account_on_file_display_hints.py

@@ -0,0 +1,65 @@
+# -*- 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.label_template_element import LabelTemplateElement
+
+
+class AccountOnFileDisplayHints(DataObject):
+
+    __label_template: Optional[List[LabelTemplateElement]] = None
+    __logo: Optional[str] = None
+
+    @property
+    def label_template(self) -> Optional[List[LabelTemplateElement]]:
+        """
+        | Array of attribute keys and their mask
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.label_template_element.LabelTemplateElement`]
+        """
+        return self.__label_template
+
+    @label_template.setter
+    def label_template(self, value: Optional[List[LabelTemplateElement]]) -> None:
+        self.__label_template = value
+
+    @property
+    def logo(self) -> Optional[str]:
+        """
+        | Partial URL that you can reference for the image of this payment product. You can use our server-side resize functionality by appending '?size={{width}}x{{height}}' to the full URL, where width and height are specified in pixels. The resized image will always keep its correct aspect ratio.
+
+        Type: str
+        """
+        return self.__logo
+
+    @logo.setter
+    def logo(self, value: Optional[str]) -> None:
+        self.__logo = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(AccountOnFileDisplayHints, self).to_dictionary()
+        if self.label_template is not None:
+            dictionary['labelTemplate'] = []
+            for element in self.label_template:
+                if element is not None:
+                    dictionary['labelTemplate'].append(element.to_dictionary())
+        if self.logo is not None:
+            dictionary['logo'] = self.logo
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AccountOnFileDisplayHints':
+        super(AccountOnFileDisplayHints, self).from_dictionary(dictionary)
+        if 'labelTemplate' in dictionary:
+            if not isinstance(dictionary['labelTemplate'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['labelTemplate']))
+            self.label_template = []
+            for element in dictionary['labelTemplate']:
+                value = LabelTemplateElement()
+                self.label_template.append(value.from_dictionary(element))
+        if 'logo' in dictionary:
+            self.logo = dictionary['logo']
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/additional_order_input.py

@@ -0,0 +1,217 @@
+# -*- 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.account_funding_recipient import AccountFundingRecipient
+from worldline.connect.sdk.v1.domain.airline_data import AirlineData
+from worldline.connect.sdk.v1.domain.installments import Installments
+from worldline.connect.sdk.v1.domain.level3_summary_data import Level3SummaryData
+from worldline.connect.sdk.v1.domain.loan_recipient import LoanRecipient
+from worldline.connect.sdk.v1.domain.lodging_data import LodgingData
+from worldline.connect.sdk.v1.domain.order_type_information import OrderTypeInformation
+
+
+class AdditionalOrderInput(DataObject):
+
+    __account_funding_recipient: Optional[AccountFundingRecipient] = None
+    __airline_data: Optional[AirlineData] = None
+    __installments: Optional[Installments] = None
+    __level3_summary_data: Optional[Level3SummaryData] = None
+    __loan_recipient: Optional[LoanRecipient] = None
+    __lodging_data: Optional[LodgingData] = None
+    __number_of_installments: Optional[int] = None
+    __order_date: Optional[str] = None
+    __type_information: Optional[OrderTypeInformation] = None
+
+    @property
+    def account_funding_recipient(self) -> Optional[AccountFundingRecipient]:
+        """
+        | Object containing specific data regarding the recipient of an account funding transaction
+
+        Type: :class:`worldline.connect.sdk.v1.domain.account_funding_recipient.AccountFundingRecipient`
+        """
+        return self.__account_funding_recipient
+
+    @account_funding_recipient.setter
+    def account_funding_recipient(self, value: Optional[AccountFundingRecipient]) -> None:
+        self.__account_funding_recipient = value
+
+    @property
+    def airline_data(self) -> Optional[AirlineData]:
+        """
+        | Object that holds airline specific data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.airline_data.AirlineData`
+        """
+        return self.__airline_data
+
+    @airline_data.setter
+    def airline_data(self, value: Optional[AirlineData]) -> None:
+        self.__airline_data = value
+
+    @property
+    def installments(self) -> Optional[Installments]:
+        """
+        | Object containing data related to installments which can be used for card payments and only with some acquirers. In case you send in the details of this object, only the combination of card products and acquirers that do support installments will be shown on the MyCheckout hosted payment pages.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.installments.Installments`
+        """
+        return self.__installments
+
+    @installments.setter
+    def installments(self, value: Optional[Installments]) -> None:
+        self.__installments = value
+
+    @property
+    def level3_summary_data(self) -> Optional[Level3SummaryData]:
+        """
+        | Object that holds Level3 summary data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.level3_summary_data.Level3SummaryData`
+
+        Deprecated; Use Order.shoppingCart.amountBreakdown instead
+        """
+        return self.__level3_summary_data
+
+    @level3_summary_data.setter
+    def level3_summary_data(self, value: Optional[Level3SummaryData]) -> None:
+        self.__level3_summary_data = value
+
+    @property
+    def loan_recipient(self) -> Optional[LoanRecipient]:
+        """
+        | Object containing specific data regarding the recipient of a loan in the UK
+
+        Type: :class:`worldline.connect.sdk.v1.domain.loan_recipient.LoanRecipient`
+
+        Deprecated; No replacement
+        """
+        return self.__loan_recipient
+
+    @loan_recipient.setter
+    def loan_recipient(self, value: Optional[LoanRecipient]) -> None:
+        self.__loan_recipient = value
+
+    @property
+    def lodging_data(self) -> Optional[LodgingData]:
+        """
+        | Object that holds lodging specific data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.lodging_data.LodgingData`
+        """
+        return self.__lodging_data
+
+    @lodging_data.setter
+    def lodging_data(self, value: Optional[LodgingData]) -> None:
+        self.__lodging_data = value
+
+    @property
+    def number_of_installments(self) -> Optional[int]:
+        """
+        | The number of installments in which this transaction will be paid, which can be used for card payments. Only used with some acquirers. In case you send in the details of this object, only the combination of card products and acquirers that do support installments will be shown on the MyCheckout hosted payment pages.
+
+        Type: int
+
+        Deprecated; Use installments.numberOfInstallments instead
+        """
+        return self.__number_of_installments
+
+    @number_of_installments.setter
+    def number_of_installments(self, value: Optional[int]) -> None:
+        self.__number_of_installments = value
+
+    @property
+    def order_date(self) -> Optional[str]:
+        """
+        | Date and time of order
+        | Format: YYYYMMDDHH24MISS
+
+        Type: str
+        """
+        return self.__order_date
+
+    @order_date.setter
+    def order_date(self, value: Optional[str]) -> None:
+        self.__order_date = value
+
+    @property
+    def type_information(self) -> Optional[OrderTypeInformation]:
+        """
+        | Object that holds the purchase and usage type indicators
+
+        Type: :class:`worldline.connect.sdk.v1.domain.order_type_information.OrderTypeInformation`
+        """
+        return self.__type_information
+
+    @type_information.setter
+    def type_information(self, value: Optional[OrderTypeInformation]) -> None:
+        self.__type_information = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(AdditionalOrderInput, self).to_dictionary()
+        if self.account_funding_recipient is not None:
+            dictionary['accountFundingRecipient'] = self.account_funding_recipient.to_dictionary()
+        if self.airline_data is not None:
+            dictionary['airlineData'] = self.airline_data.to_dictionary()
+        if self.installments is not None:
+            dictionary['installments'] = self.installments.to_dictionary()
+        if self.level3_summary_data is not None:
+            dictionary['level3SummaryData'] = self.level3_summary_data.to_dictionary()
+        if self.loan_recipient is not None:
+            dictionary['loanRecipient'] = self.loan_recipient.to_dictionary()
+        if self.lodging_data is not None:
+            dictionary['lodgingData'] = self.lodging_data.to_dictionary()
+        if self.number_of_installments is not None:
+            dictionary['numberOfInstallments'] = self.number_of_installments
+        if self.order_date is not None:
+            dictionary['orderDate'] = self.order_date
+        if self.type_information is not None:
+            dictionary['typeInformation'] = self.type_information.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AdditionalOrderInput':
+        super(AdditionalOrderInput, self).from_dictionary(dictionary)
+        if 'accountFundingRecipient' in dictionary:
+            if not isinstance(dictionary['accountFundingRecipient'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['accountFundingRecipient']))
+            value = AccountFundingRecipient()
+            self.account_funding_recipient = value.from_dictionary(dictionary['accountFundingRecipient'])
+        if 'airlineData' in dictionary:
+            if not isinstance(dictionary['airlineData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['airlineData']))
+            value = AirlineData()
+            self.airline_data = value.from_dictionary(dictionary['airlineData'])
+        if 'installments' in dictionary:
+            if not isinstance(dictionary['installments'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['installments']))
+            value = Installments()
+            self.installments = value.from_dictionary(dictionary['installments'])
+        if 'level3SummaryData' in dictionary:
+            if not isinstance(dictionary['level3SummaryData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['level3SummaryData']))
+            value = Level3SummaryData()
+            self.level3_summary_data = value.from_dictionary(dictionary['level3SummaryData'])
+        if 'loanRecipient' in dictionary:
+            if not isinstance(dictionary['loanRecipient'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['loanRecipient']))
+            value = LoanRecipient()
+            self.loan_recipient = value.from_dictionary(dictionary['loanRecipient'])
+        if 'lodgingData' in dictionary:
+            if not isinstance(dictionary['lodgingData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['lodgingData']))
+            value = LodgingData()
+            self.lodging_data = value.from_dictionary(dictionary['lodgingData'])
+        if 'numberOfInstallments' in dictionary:
+            self.number_of_installments = dictionary['numberOfInstallments']
+        if 'orderDate' in dictionary:
+            self.order_date = dictionary['orderDate']
+        if 'typeInformation' in dictionary:
+            if not isinstance(dictionary['typeInformation'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['typeInformation']))
+            value = OrderTypeInformation()
+            self.type_information = value.from_dictionary(dictionary['typeInformation'])
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/additional_order_input_airline_data.py

@@ -0,0 +1,64 @@
+# -*- 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.airline_data import AirlineData
+from worldline.connect.sdk.v1.domain.lodging_data import LodgingData
+
+
+class AdditionalOrderInputAirlineData(DataObject):
+
+    __airline_data: Optional[AirlineData] = None
+    __lodging_data: Optional[LodgingData] = None
+
+    @property
+    def airline_data(self) -> Optional[AirlineData]:
+        """
+        | Object that holds airline specific data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.airline_data.AirlineData`
+        """
+        return self.__airline_data
+
+    @airline_data.setter
+    def airline_data(self, value: Optional[AirlineData]) -> None:
+        self.__airline_data = value
+
+    @property
+    def lodging_data(self) -> Optional[LodgingData]:
+        """
+        | Object that holds lodging specific data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.lodging_data.LodgingData`
+        """
+        return self.__lodging_data
+
+    @lodging_data.setter
+    def lodging_data(self, value: Optional[LodgingData]) -> None:
+        self.__lodging_data = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(AdditionalOrderInputAirlineData, self).to_dictionary()
+        if self.airline_data is not None:
+            dictionary['airlineData'] = self.airline_data.to_dictionary()
+        if self.lodging_data is not None:
+            dictionary['lodgingData'] = self.lodging_data.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'AdditionalOrderInputAirlineData':
+        super(AdditionalOrderInputAirlineData, self).from_dictionary(dictionary)
+        if 'airlineData' in dictionary:
+            if not isinstance(dictionary['airlineData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['airlineData']))
+            value = AirlineData()
+            self.airline_data = value.from_dictionary(dictionary['airlineData'])
+        if 'lodgingData' in dictionary:
+            if not isinstance(dictionary['lodgingData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['lodgingData']))
+            value = LodgingData()
+            self.lodging_data = value.from_dictionary(dictionary['lodgingData'])
+        return self

connect-sdk-python3-4.1.0/worldline/connect/sdk/v1/domain/address.py

@@ -0,0 +1,171 @@
+# -*- 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 Address(DataObject):
+
+    __additional_info: Optional[str] = None
+    __city: Optional[str] = None
+    __country_code: Optional[str] = None
+    __house_number: Optional[str] = None
+    __state: Optional[str] = None
+    __state_code: Optional[str] = None
+    __street: Optional[str] = None
+    __zip: Optional[str] = None
+
+    @property
+    def additional_info(self) -> Optional[str]:
+        """
+        | Additional address information. The additionalInfo is truncated after 10 characters for payments, refunds or payouts that are processed by the WL Online Payment Acceptance platform
+
+        Type: str
+        """
+        return self.__additional_info
+
+    @additional_info.setter
+    def additional_info(self, value: Optional[str]) -> None:
+        self.__additional_info = value
+
+    @property
+    def city(self) -> Optional[str]:
+        """
+        | City
+        | Note: For payments with product 1503 the maximum length is not 40 but 20.
+
+        Type: str
+        """
+        return self.__city
+
+    @city.setter
+    def city(self, value: Optional[str]) -> None:
+        self.__city = value
+
+    @property
+    def country_code(self) -> Optional[str]:
+        """
+        | ISO 3166-1 alpha-2 country code
+
+        Type: str
+        """
+        return self.__country_code
+
+    @country_code.setter
+    def country_code(self, value: Optional[str]) -> None:
+        self.__country_code = value
+
+    @property
+    def house_number(self) -> Optional[str]:
+        """
+        | House number. The houseNumber is truncated after 10 characters for payments, refunds or payouts that are processed by the WL Online Payment Acceptance platform
+
+        Type: str
+        """
+        return self.__house_number
+
+    @house_number.setter
+    def house_number(self, value: Optional[str]) -> None:
+        self.__house_number = value
+
+    @property
+    def state(self) -> Optional[str]:
+        """
+        | Full name of the state or province
+
+        Type: str
+        """
+        return self.__state
+
+    @state.setter
+    def state(self, value: Optional[str]) -> None:
+        self.__state = value
+
+    @property
+    def state_code(self) -> Optional[str]:
+        """
+        | ISO 3166-2 alpha-3 state code
+        | Notes:
+        
+        * The maximum length for 3-D Secure version 2 is AN3 for payments that are processed by the GlobalCollect platform
+        * The maximum length for paymentProductId 1503 (Boleto) is AN2 for payments that are processed by the GlobalCollect platform
+        * The maximum length is 3 for payments that are processed by the WL Online Payment Acceptance platform
+
+        Type: str
+        """
+        return self.__state_code
+
+    @state_code.setter
+    def state_code(self, value: Optional[str]) -> None:
+        self.__state_code = value
+
+    @property
+    def street(self) -> Optional[str]:
+        """
+        | Streetname
+
+        Type: str
+        """
+        return self.__street
+
+    @street.setter
+    def street(self, value: Optional[str]) -> None:
+        self.__street = value
+
+    @property
+    def zip(self) -> Optional[str]:
+        """
+        | Zip code
+        | Note: For payments with product 1503 the maximum length is not 10 but 8.
+
+        Type: str
+        """
+        return self.__zip
+
+    @zip.setter
+    def zip(self, value: Optional[str]) -> None:
+        self.__zip = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Address, self).to_dictionary()
+        if self.additional_info is not None:
+            dictionary['additionalInfo'] = self.additional_info
+        if self.city is not None:
+            dictionary['city'] = self.city
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.house_number is not None:
+            dictionary['houseNumber'] = self.house_number
+        if self.state is not None:
+            dictionary['state'] = self.state
+        if self.state_code is not None:
+            dictionary['stateCode'] = self.state_code
+        if self.street is not None:
+            dictionary['street'] = self.street
+        if self.zip is not None:
+            dictionary['zip'] = self.zip
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Address':
+        super(Address, self).from_dictionary(dictionary)
+        if 'additionalInfo' in dictionary:
+            self.additional_info = dictionary['additionalInfo']
+        if 'city' in dictionary:
+            self.city = dictionary['city']
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'houseNumber' in dictionary:
+            self.house_number = dictionary['houseNumber']
+        if 'state' in dictionary:
+            self.state = dictionary['state']
+        if 'stateCode' in dictionary:
+            self.state_code = dictionary['stateCode']
+        if 'street' in dictionary:
+            self.street = dictionary['street']
+        if 'zip' in dictionary:
+            self.zip = dictionary['zip']
+        return self