onlinepayments-sdk-python3 7.4.1__py3-none-any.whl

onlinepayments/sdk/domain/payment_product_field_validators.py

@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .empty_validator import EmptyValidator
+from .fixed_list_validator import FixedListValidator
+from .length_validator import LengthValidator
+from .range_validator import RangeValidator
+from .regular_expression_validator import RegularExpressionValidator
+
+
+class PaymentProductFieldValidators(DataObject):
+
+    __email_address: Optional[EmptyValidator] = None
+    __expiration_date: Optional[EmptyValidator] = None
+    __fixed_list: Optional[FixedListValidator] = None
+    __iban: Optional[EmptyValidator] = None
+    __length: Optional[LengthValidator] = None
+    __luhn: Optional[EmptyValidator] = None
+    __range: Optional[RangeValidator] = None
+    __regular_expression: Optional[RegularExpressionValidator] = None
+    __terms_and_conditions: Optional[EmptyValidator] = None
+
+    @property
+    def email_address(self) -> Optional[EmptyValidator]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.empty_validator.EmptyValidator`
+        """
+        return self.__email_address
+
+    @email_address.setter
+    def email_address(self, value: Optional[EmptyValidator]) -> None:
+        self.__email_address = value
+
+    @property
+    def expiration_date(self) -> Optional[EmptyValidator]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.empty_validator.EmptyValidator`
+        """
+        return self.__expiration_date
+
+    @expiration_date.setter
+    def expiration_date(self, value: Optional[EmptyValidator]) -> None:
+        self.__expiration_date = value
+
+    @property
+    def fixed_list(self) -> Optional[FixedListValidator]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.fixed_list_validator.FixedListValidator`
+        """
+        return self.__fixed_list
+
+    @fixed_list.setter
+    def fixed_list(self, value: Optional[FixedListValidator]) -> None:
+        self.__fixed_list = value
+
+    @property
+    def iban(self) -> Optional[EmptyValidator]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.empty_validator.EmptyValidator`
+        """
+        return self.__iban
+
+    @iban.setter
+    def iban(self, value: Optional[EmptyValidator]) -> None:
+        self.__iban = value
+
+    @property
+    def length(self) -> Optional[LengthValidator]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.length_validator.LengthValidator`
+        """
+        return self.__length
+
+    @length.setter
+    def length(self, value: Optional[LengthValidator]) -> None:
+        self.__length = value
+
+    @property
+    def luhn(self) -> Optional[EmptyValidator]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.empty_validator.EmptyValidator`
+        """
+        return self.__luhn
+
+    @luhn.setter
+    def luhn(self, value: Optional[EmptyValidator]) -> None:
+        self.__luhn = value
+
+    @property
+    def range(self) -> Optional[RangeValidator]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.range_validator.RangeValidator`
+        """
+        return self.__range
+
+    @range.setter
+    def range(self, value: Optional[RangeValidator]) -> None:
+        self.__range = value
+
+    @property
+    def regular_expression(self) -> Optional[RegularExpressionValidator]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.regular_expression_validator.RegularExpressionValidator`
+        """
+        return self.__regular_expression
+
+    @regular_expression.setter
+    def regular_expression(self, value: Optional[RegularExpressionValidator]) -> None:
+        self.__regular_expression = value
+
+    @property
+    def terms_and_conditions(self) -> Optional[EmptyValidator]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.empty_validator.EmptyValidator`
+        """
+        return self.__terms_and_conditions
+
+    @terms_and_conditions.setter
+    def terms_and_conditions(self, value: Optional[EmptyValidator]) -> None:
+        self.__terms_and_conditions = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductFieldValidators, self).to_dictionary()
+        if self.email_address is not None:
+            dictionary['emailAddress'] = self.email_address.to_dictionary()
+        if self.expiration_date is not None:
+            dictionary['expirationDate'] = self.expiration_date.to_dictionary()
+        if self.fixed_list is not None:
+            dictionary['fixedList'] = self.fixed_list.to_dictionary()
+        if self.iban is not None:
+            dictionary['iban'] = self.iban.to_dictionary()
+        if self.length is not None:
+            dictionary['length'] = self.length.to_dictionary()
+        if self.luhn is not None:
+            dictionary['luhn'] = self.luhn.to_dictionary()
+        if self.range is not None:
+            dictionary['range'] = self.range.to_dictionary()
+        if self.regular_expression is not None:
+            dictionary['regularExpression'] = self.regular_expression.to_dictionary()
+        if self.terms_and_conditions is not None:
+            dictionary['termsAndConditions'] = self.terms_and_conditions.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldValidators':
+        super(PaymentProductFieldValidators, self).from_dictionary(dictionary)
+        if 'emailAddress' in dictionary:
+            if not isinstance(dictionary['emailAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['emailAddress']))
+            value = EmptyValidator()
+            self.email_address = value.from_dictionary(dictionary['emailAddress'])
+        if 'expirationDate' in dictionary:
+            if not isinstance(dictionary['expirationDate'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['expirationDate']))
+            value = EmptyValidator()
+            self.expiration_date = value.from_dictionary(dictionary['expirationDate'])
+        if 'fixedList' in dictionary:
+            if not isinstance(dictionary['fixedList'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fixedList']))
+            value = FixedListValidator()
+            self.fixed_list = value.from_dictionary(dictionary['fixedList'])
+        if 'iban' in dictionary:
+            if not isinstance(dictionary['iban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['iban']))
+            value = EmptyValidator()
+            self.iban = value.from_dictionary(dictionary['iban'])
+        if 'length' in dictionary:
+            if not isinstance(dictionary['length'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['length']))
+            value = LengthValidator()
+            self.length = value.from_dictionary(dictionary['length'])
+        if 'luhn' in dictionary:
+            if not isinstance(dictionary['luhn'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['luhn']))
+            value = EmptyValidator()
+            self.luhn = value.from_dictionary(dictionary['luhn'])
+        if 'range' in dictionary:
+            if not isinstance(dictionary['range'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['range']))
+            value = RangeValidator()
+            self.range = value.from_dictionary(dictionary['range'])
+        if 'regularExpression' in dictionary:
+            if not isinstance(dictionary['regularExpression'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['regularExpression']))
+            value = RegularExpressionValidator()
+            self.regular_expression = value.from_dictionary(dictionary['regularExpression'])
+        if 'termsAndConditions' in dictionary:
+            if not isinstance(dictionary['termsAndConditions'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['termsAndConditions']))
+            value = EmptyValidator()
+            self.terms_and_conditions = value.from_dictionary(dictionary['termsAndConditions'])
+        return self

onlinepayments/sdk/domain/payment_product_filter.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+
+
+class PaymentProductFilter(DataObject):
+
+    __groups: Optional[List[str]] = None
+    __products: Optional[List[int]] = None
+
+    @property
+    def groups(self) -> Optional[List[str]]:
+        """
+        | List containing all payment product groups that should either be restricted to in or excluded from the payment context. Currently, there is only one group, called 'cards'.
+
+        Type: list[str]
+        """
+        return self.__groups
+
+    @groups.setter
+    def groups(self, value: Optional[List[str]]) -> None:
+        self.__groups = value
+
+    @property
+    def products(self) -> Optional[List[int]]:
+        """
+        Type: list[int]
+        """
+        return self.__products
+
+    @products.setter
+    def products(self, value: Optional[List[int]]) -> None:
+        self.__products = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductFilter, self).to_dictionary()
+        if self.groups is not None:
+            dictionary['groups'] = []
+            for element in self.groups:
+                if element is not None:
+                    dictionary['groups'].append(element)
+        if self.products is not None:
+            dictionary['products'] = []
+            for element in self.products:
+                if element is not None:
+                    dictionary['products'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFilter':
+        super(PaymentProductFilter, self).from_dictionary(dictionary)
+        if 'groups' in dictionary:
+            if not isinstance(dictionary['groups'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['groups']))
+            self.groups = []
+            for element in dictionary['groups']:
+                self.groups.append(element)
+        if 'products' in dictionary:
+            if not isinstance(dictionary['products'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['products']))
+            self.products = []
+            for element in dictionary['products']:
+                self.products.append(element)
+        return self

onlinepayments/sdk/domain/payment_product_filter_hosted_tokenization.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+
+
+class PaymentProductFilterHostedTokenization(DataObject):
+
+    __products: Optional[List[int]] = None
+
+    @property
+    def products(self) -> Optional[List[int]]:
+        """
+        Type: list[int]
+        """
+        return self.__products
+
+    @products.setter
+    def products(self, value: Optional[List[int]]) -> None:
+        self.__products = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductFilterHostedTokenization, self).to_dictionary()
+        if self.products is not None:
+            dictionary['products'] = []
+            for element in self.products:
+                if element is not None:
+                    dictionary['products'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFilterHostedTokenization':
+        super(PaymentProductFilterHostedTokenization, self).from_dictionary(dictionary)
+        if 'products' in dictionary:
+            if not isinstance(dictionary['products'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['products']))
+            self.products = []
+            for element in dictionary['products']:
+                self.products.append(element)
+        return self

onlinepayments/sdk/domain/payment_product_filters_hosted_checkout.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_product_filter import PaymentProductFilter
+
+
+class PaymentProductFiltersHostedCheckout(DataObject):
+
+    __exclude: Optional[PaymentProductFilter] = None
+    __restrict_to: Optional[PaymentProductFilter] = None
+
+    @property
+    def exclude(self) -> Optional[PaymentProductFilter]:
+        """
+        | The payment product ids to be be excluded or restricted to from the payment products available for the payment. Note that you can add exclusions on top of the 'restrictTo' filter.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_filter.PaymentProductFilter`
+        """
+        return self.__exclude
+
+    @exclude.setter
+    def exclude(self, value: Optional[PaymentProductFilter]) -> None:
+        self.__exclude = value
+
+    @property
+    def restrict_to(self) -> Optional[PaymentProductFilter]:
+        """
+        | The payment product ids to be be excluded or restricted to from the payment products available for the payment. Note that you can add exclusions on top of the 'restrictTo' filter.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_filter.PaymentProductFilter`
+        """
+        return self.__restrict_to
+
+    @restrict_to.setter
+    def restrict_to(self, value: Optional[PaymentProductFilter]) -> None:
+        self.__restrict_to = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductFiltersHostedCheckout, self).to_dictionary()
+        if self.exclude is not None:
+            dictionary['exclude'] = self.exclude.to_dictionary()
+        if self.restrict_to is not None:
+            dictionary['restrictTo'] = self.restrict_to.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFiltersHostedCheckout':
+        super(PaymentProductFiltersHostedCheckout, self).from_dictionary(dictionary)
+        if 'exclude' in dictionary:
+            if not isinstance(dictionary['exclude'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['exclude']))
+            value = PaymentProductFilter()
+            self.exclude = value.from_dictionary(dictionary['exclude'])
+        if 'restrictTo' in dictionary:
+            if not isinstance(dictionary['restrictTo'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['restrictTo']))
+            value = PaymentProductFilter()
+            self.restrict_to = value.from_dictionary(dictionary['restrictTo'])
+        return self

onlinepayments/sdk/domain/payment_product_filters_hosted_tokenization.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_product_filter_hosted_tokenization import PaymentProductFilterHostedTokenization
+
+
+class PaymentProductFiltersHostedTokenization(DataObject):
+
+    __exclude: Optional[PaymentProductFilterHostedTokenization] = None
+    __restrict_to: Optional[PaymentProductFilterHostedTokenization] = None
+
+    @property
+    def exclude(self) -> Optional[PaymentProductFilterHostedTokenization]:
+        """
+        | The payment product ids to be be excluded or restricted to from the payment products available for the payment. Note that you can add exclusions on top of the 'restrictTo' filter.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_filter_hosted_tokenization.PaymentProductFilterHostedTokenization`
+        """
+        return self.__exclude
+
+    @exclude.setter
+    def exclude(self, value: Optional[PaymentProductFilterHostedTokenization]) -> None:
+        self.__exclude = value
+
+    @property
+    def restrict_to(self) -> Optional[PaymentProductFilterHostedTokenization]:
+        """
+        | The payment product ids to be be excluded or restricted to from the payment products available for the payment. Note that you can add exclusions on top of the 'restrictTo' filter.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_filter_hosted_tokenization.PaymentProductFilterHostedTokenization`
+        """
+        return self.__restrict_to
+
+    @restrict_to.setter
+    def restrict_to(self, value: Optional[PaymentProductFilterHostedTokenization]) -> None:
+        self.__restrict_to = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductFiltersHostedTokenization, self).to_dictionary()
+        if self.exclude is not None:
+            dictionary['exclude'] = self.exclude.to_dictionary()
+        if self.restrict_to is not None:
+            dictionary['restrictTo'] = self.restrict_to.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFiltersHostedTokenization':
+        super(PaymentProductFiltersHostedTokenization, self).from_dictionary(dictionary)
+        if 'exclude' in dictionary:
+            if not isinstance(dictionary['exclude'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['exclude']))
+            value = PaymentProductFilterHostedTokenization()
+            self.exclude = value.from_dictionary(dictionary['exclude'])
+        if 'restrictTo' in dictionary:
+            if not isinstance(dictionary['restrictTo'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['restrictTo']))
+            value = PaymentProductFilterHostedTokenization()
+            self.restrict_to = value.from_dictionary(dictionary['restrictTo'])
+        return self

onlinepayments/sdk/domain/payment_product_group.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .account_on_file import AccountOnFile
+from .data_object import DataObject
+from .payment_product_display_hints import PaymentProductDisplayHints
+
+
+class PaymentProductGroup(DataObject):
+
+    __account_on_file: Optional[AccountOnFile] = None
+    __display_hints: Optional[PaymentProductDisplayHints] = None
+    __display_hints_list: Optional[List[PaymentProductDisplayHints]] = None
+    __id: Optional[str] = None
+
+    @property
+    def account_on_file(self) -> Optional[AccountOnFile]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.account_on_file.AccountOnFile`
+        """
+        return self.__account_on_file
+
+    @account_on_file.setter
+    def account_on_file(self, value: Optional[AccountOnFile]) -> None:
+        self.__account_on_file = value
+
+    @property
+    def display_hints(self) -> Optional[PaymentProductDisplayHints]:
+        """
+        | Object containing display hints like the order of the product when shown in a list, the name of the product and the logo
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_display_hints.PaymentProductDisplayHints`
+        """
+        return self.__display_hints
+
+    @display_hints.setter
+    def display_hints(self, value: Optional[PaymentProductDisplayHints]) -> None:
+        self.__display_hints = value
+
+    @property
+    def display_hints_list(self) -> Optional[List[PaymentProductDisplayHints]]:
+        """
+        Type: list[:class:`onlinepayments.sdk.domain.payment_product_display_hints.PaymentProductDisplayHints`]
+        """
+        return self.__display_hints_list
+
+    @display_hints_list.setter
+    def display_hints_list(self, value: Optional[List[PaymentProductDisplayHints]]) -> None:
+        self.__display_hints_list = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | The ID of the payment product group in our system
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductGroup, self).to_dictionary()
+        if self.account_on_file is not None:
+            dictionary['accountOnFile'] = self.account_on_file.to_dictionary()
+        if self.display_hints is not None:
+            dictionary['displayHints'] = self.display_hints.to_dictionary()
+        if self.display_hints_list is not None:
+            dictionary['displayHintsList'] = []
+            for element in self.display_hints_list:
+                if element is not None:
+                    dictionary['displayHintsList'].append(element.to_dictionary())
+        if self.id is not None:
+            dictionary['id'] = self.id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductGroup':
+        super(PaymentProductGroup, self).from_dictionary(dictionary)
+        if 'accountOnFile' in dictionary:
+            if not isinstance(dictionary['accountOnFile'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['accountOnFile']))
+            value = AccountOnFile()
+            self.account_on_file = value.from_dictionary(dictionary['accountOnFile'])
+        if 'displayHints' in dictionary:
+            if not isinstance(dictionary['displayHints'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['displayHints']))
+            value = PaymentProductDisplayHints()
+            self.display_hints = value.from_dictionary(dictionary['displayHints'])
+        if 'displayHintsList' in dictionary:
+            if not isinstance(dictionary['displayHintsList'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['displayHintsList']))
+            self.display_hints_list = []
+            for element in dictionary['displayHintsList']:
+                value = PaymentProductDisplayHints()
+                self.display_hints_list.append(value.from_dictionary(element))
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        return self

onlinepayments/sdk/domain/payment_product_networks_response.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+
+
+class PaymentProductNetworksResponse(DataObject):
+
+    __networks: Optional[List[str]] = None
+
+    @property
+    def networks(self) -> Optional[List[str]]:
+        """
+        Type: list[str]
+        """
+        return self.__networks
+
+    @networks.setter
+    def networks(self, value: Optional[List[str]]) -> None:
+        self.__networks = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductNetworksResponse, self).to_dictionary()
+        if self.networks is not None:
+            dictionary['networks'] = []
+            for element in self.networks:
+                if element is not None:
+                    dictionary['networks'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductNetworksResponse':
+        super(PaymentProductNetworksResponse, self).from_dictionary(dictionary)
+        if 'networks' in dictionary:
+            if not isinstance(dictionary['networks'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['networks']))
+            self.networks = []
+            for element in dictionary['networks']:
+                self.networks.append(element)
+        return self

onlinepayments/sdk/domain/payment_references.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentReferences(DataObject):
+
+    __merchant_parameters: Optional[str] = None
+    __merchant_reference: Optional[str] = None
+    __operation_group_reference: Optional[str] = None
+
+    @property
+    def merchant_parameters(self) -> Optional[str]:
+        """
+        | It allows you to store additional parameters for the transaction in the format you prefer (e.g.-> key-value query string, JSON, etc.) These parameters are then echoed back to you in API GET calls and Webhook notifications. This field must not contain any personal data.
+
+        Type: str
+        """
+        return self.__merchant_parameters
+
+    @merchant_parameters.setter
+    def merchant_parameters(self, value: Optional[str]) -> None:
+        self.__merchant_parameters = value
+
+    @property
+    def merchant_reference(self) -> Optional[str]:
+        """
+        | 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. It is highly recommended to provide a single MerchantReference per unique order on your side
+
+        Type: str
+        """
+        return self.__merchant_reference
+
+    @merchant_reference.setter
+    def merchant_reference(self, value: Optional[str]) -> None:
+        self.__merchant_reference = value
+
+    @property
+    def operation_group_reference(self) -> Optional[str]:
+        """
+        | An identifier for a group of transactions. This reference helps to link multiple related transactions together, facilitating easier reconciliation and tracking.
+
+        Type: str
+        """
+        return self.__operation_group_reference
+
+    @operation_group_reference.setter
+    def operation_group_reference(self, value: Optional[str]) -> None:
+        self.__operation_group_reference = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentReferences, self).to_dictionary()
+        if self.merchant_parameters is not None:
+            dictionary['merchantParameters'] = self.merchant_parameters
+        if self.merchant_reference is not None:
+            dictionary['merchantReference'] = self.merchant_reference
+        if self.operation_group_reference is not None:
+            dictionary['operationGroupReference'] = self.operation_group_reference
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentReferences':
+        super(PaymentReferences, self).from_dictionary(dictionary)
+        if 'merchantParameters' in dictionary:
+            self.merchant_parameters = dictionary['merchantParameters']
+        if 'merchantReference' in dictionary:
+            self.merchant_reference = dictionary['merchantReference']
+        if 'operationGroupReference' in dictionary:
+            self.operation_group_reference = dictionary['operationGroupReference']
+        return self