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

onlinepayments/sdk/domain/payment_details_response.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+from .hosted_checkout_specific_output import HostedCheckoutSpecificOutput
+from .operation_output import OperationOutput
+from .payment_output import PaymentOutput
+from .payment_status_output import PaymentStatusOutput
+
+
+class PaymentDetailsResponse(DataObject):
+
+    __operations: Optional[List[OperationOutput]] = None
+    __hosted_checkout_specific_output: Optional[HostedCheckoutSpecificOutput] = None
+    __id: Optional[str] = None
+    __payment_output: Optional[PaymentOutput] = None
+    __status: Optional[str] = None
+    __status_output: Optional[PaymentStatusOutput] = None
+
+    @property
+    def operations(self) -> Optional[List[OperationOutput]]:
+        """
+        | Object that contains the complete list of operations executed on the payment.
+
+        Type: list[:class:`onlinepayments.sdk.domain.operation_output.OperationOutput`]
+        """
+        return self.__operations
+
+    @operations.setter
+    def operations(self, value: Optional[List[OperationOutput]]) -> None:
+        self.__operations = value
+
+    @property
+    def hosted_checkout_specific_output(self) -> Optional[HostedCheckoutSpecificOutput]:
+        """
+        | Hosted Checkout specific information. Populated if the payment was created on the platform through a Hosted Checkout.
+
+        Type: :class:`onlinepayments.sdk.domain.hosted_checkout_specific_output.HostedCheckoutSpecificOutput`
+        """
+        return self.__hosted_checkout_specific_output
+
+    @hosted_checkout_specific_output.setter
+    def hosted_checkout_specific_output(self, value: Optional[HostedCheckoutSpecificOutput]) -> None:
+        self.__hosted_checkout_specific_output = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | This is our unique payment transaction identifier.
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def payment_output(self) -> Optional[PaymentOutput]:
+        """
+        | Object containing payment details
+
+        Type: :class:`onlinepayments.sdk.domain.payment_output.PaymentOutput`
+        """
+        return self.__payment_output
+
+    @payment_output.setter
+    def payment_output(self, value: Optional[PaymentOutput]) -> None:
+        self.__payment_output = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | Current high-level status of the payment in a human-readable form.
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    @property
+    def status_output(self) -> Optional[PaymentStatusOutput]:
+        """
+        | This object has the numeric representation of the current payment status, the timestamp of the last status change, and the performable action on the current payment resource. In case of failed payments and negative scenarios, detailed error information is listed.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_status_output.PaymentStatusOutput`
+        """
+        return self.__status_output
+
+    @status_output.setter
+    def status_output(self, value: Optional[PaymentStatusOutput]) -> None:
+        self.__status_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentDetailsResponse, self).to_dictionary()
+        if self.operations is not None:
+            dictionary['Operations'] = []
+            for element in self.operations:
+                if element is not None:
+                    dictionary['Operations'].append(element.to_dictionary())
+        if self.hosted_checkout_specific_output is not None:
+            dictionary['hostedCheckoutSpecificOutput'] = self.hosted_checkout_specific_output.to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.payment_output is not None:
+            dictionary['paymentOutput'] = self.payment_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) -> 'PaymentDetailsResponse':
+        super(PaymentDetailsResponse, self).from_dictionary(dictionary)
+        if 'Operations' in dictionary:
+            if not isinstance(dictionary['Operations'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['Operations']))
+            self.operations = []
+            for element in dictionary['Operations']:
+                value = OperationOutput()
+                self.operations.append(value.from_dictionary(element))
+        if 'hostedCheckoutSpecificOutput' in dictionary:
+            if not isinstance(dictionary['hostedCheckoutSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['hostedCheckoutSpecificOutput']))
+            value = HostedCheckoutSpecificOutput()
+            self.hosted_checkout_specific_output = value.from_dictionary(dictionary['hostedCheckoutSpecificOutput'])
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'paymentOutput' in dictionary:
+            if not isinstance(dictionary['paymentOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentOutput']))
+            value = PaymentOutput()
+            self.payment_output = value.from_dictionary(dictionary['paymentOutput'])
+        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 = PaymentStatusOutput()
+            self.status_output = value.from_dictionary(dictionary['statusOutput'])
+        return self

onlinepayments/sdk/domain/payment_error_response.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .api_error import APIError
+from .create_payment_response import CreatePaymentResponse
+from .data_object import DataObject
+
+
+class PaymentErrorResponse(DataObject):
+
+    __error_id: Optional[str] = None
+    __errors: Optional[List[APIError]] = None
+    __payment_result: Optional[CreatePaymentResponse] = 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]]:
+        """
+        Type: list[:class:`onlinepayments.sdk.domain.api_error.APIError`]
+        """
+        return self.__errors
+
+    @errors.setter
+    def errors(self, value: Optional[List[APIError]]) -> None:
+        self.__errors = value
+
+    @property
+    def payment_result(self) -> Optional[CreatePaymentResponse]:
+        """
+        | This object contains details about the created payment if one has been generated.
+
+        Type: :class:`onlinepayments.sdk.domain.create_payment_response.CreatePaymentResponse`
+        """
+        return self.__payment_result
+
+    @payment_result.setter
+    def payment_result(self, value: Optional[CreatePaymentResponse]) -> None:
+        self.__payment_result = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentErrorResponse, 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.payment_result is not None:
+            dictionary['paymentResult'] = self.payment_result.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentErrorResponse':
+        super(PaymentErrorResponse, 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 'paymentResult' in dictionary:
+            if not isinstance(dictionary['paymentResult'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentResult']))
+            value = CreatePaymentResponse()
+            self.payment_result = value.from_dictionary(dictionary['paymentResult'])
+        return self

onlinepayments/sdk/domain/payment_link_event.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentLinkEvent(DataObject):
+
+    __date_time: Optional[str] = None
+    __details: Optional[str] = None
+    __type: Optional[str] = None
+
+    @property
+    def date_time(self) -> Optional[str]:
+        """
+        | The date and time the change occurred. The date will contain the UTC offset.
+
+        Type: str
+        """
+        return self.__date_time
+
+    @date_time.setter
+    def date_time(self, value: Optional[str]) -> None:
+        self.__date_time = value
+
+    @property
+    def details(self) -> Optional[str]:
+        """
+        | Details of the events. Ex.: email address or phone number of the recipient.
+
+        Type: str
+        """
+        return self.__details
+
+    @details.setter
+    def details(self, value: Optional[str]) -> None:
+        self.__details = value
+
+    @property
+    def type(self) -> Optional[str]:
+        """
+        | The type of event that occurred.
+
+        Type: str
+        """
+        return self.__type
+
+    @type.setter
+    def type(self, value: Optional[str]) -> None:
+        self.__type = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentLinkEvent, self).to_dictionary()
+        if self.date_time is not None:
+            dictionary['dateTime'] = self.date_time
+        if self.details is not None:
+            dictionary['details'] = self.details
+        if self.type is not None:
+            dictionary['type'] = self.type
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentLinkEvent':
+        super(PaymentLinkEvent, self).from_dictionary(dictionary)
+        if 'dateTime' in dictionary:
+            self.date_time = dictionary['dateTime']
+        if 'details' in dictionary:
+            self.details = dictionary['details']
+        if 'type' in dictionary:
+            self.type = dictionary['type']
+        return self

onlinepayments/sdk/domain/payment_link_order_input.py

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+from .surcharge_for_payment_link import SurchargeForPaymentLink
+
+
+class PaymentLinkOrderInput(DataObject):
+    """
+    Deprecated; An object containing the details of the related payment input.  All properties in paymentLinkOrder are deprecated. Use corresponding values as noted below: | Property | Replacement | | - | - | | merchantReference | references/merchantReference | | amount | order/amountOfMoney | | surchargeSpecificInput | order/surchargeSpecificInput |
+    """
+
+    __amount: Optional[AmountOfMoney] = None
+    __merchant_reference: Optional[str] = None
+    __surcharge_specific_input: Optional[SurchargeForPaymentLink] = None
+
+    @property
+    def amount(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__amount
+
+    @amount.setter
+    def amount(self, value: Optional[AmountOfMoney]) -> None:
+        self.__amount = 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 surcharge_specific_input(self) -> Optional[SurchargeForPaymentLink]:
+        """
+        | Object containing details how surcharge will be applied to a payment link.
+
+        Type: :class:`onlinepayments.sdk.domain.surcharge_for_payment_link.SurchargeForPaymentLink`
+        """
+        return self.__surcharge_specific_input
+
+    @surcharge_specific_input.setter
+    def surcharge_specific_input(self, value: Optional[SurchargeForPaymentLink]) -> None:
+        self.__surcharge_specific_input = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentLinkOrderInput, self).to_dictionary()
+        if self.amount is not None:
+            dictionary['amount'] = self.amount.to_dictionary()
+        if self.merchant_reference is not None:
+            dictionary['merchantReference'] = self.merchant_reference
+        if self.surcharge_specific_input is not None:
+            dictionary['surchargeSpecificInput'] = self.surcharge_specific_input.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentLinkOrderInput':
+        super(PaymentLinkOrderInput, self).from_dictionary(dictionary)
+        if 'amount' in dictionary:
+            if not isinstance(dictionary['amount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amount']))
+            value = AmountOfMoney()
+            self.amount = value.from_dictionary(dictionary['amount'])
+        if 'merchantReference' in dictionary:
+            self.merchant_reference = dictionary['merchantReference']
+        if 'surchargeSpecificInput' in dictionary:
+            if not isinstance(dictionary['surchargeSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['surchargeSpecificInput']))
+            value = SurchargeForPaymentLink()
+            self.surcharge_specific_input = value.from_dictionary(dictionary['surchargeSpecificInput'])
+        return self

onlinepayments/sdk/domain/payment_link_order_output.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+from .surcharge_for_payment_link import SurchargeForPaymentLink
+
+
+class PaymentLinkOrderOutput(DataObject):
+
+    __amount: Optional[AmountOfMoney] = None
+    __merchant_reference: Optional[str] = None
+    __surcharge_specific_output: Optional[SurchargeForPaymentLink] = None
+
+    @property
+    def amount(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__amount
+
+    @amount.setter
+    def amount(self, value: Optional[AmountOfMoney]) -> None:
+        self.__amount = 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 surcharge_specific_output(self) -> Optional[SurchargeForPaymentLink]:
+        """
+        | Object containing details how surcharge will be applied to a payment link.
+
+        Type: :class:`onlinepayments.sdk.domain.surcharge_for_payment_link.SurchargeForPaymentLink`
+        """
+        return self.__surcharge_specific_output
+
+    @surcharge_specific_output.setter
+    def surcharge_specific_output(self, value: Optional[SurchargeForPaymentLink]) -> None:
+        self.__surcharge_specific_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentLinkOrderOutput, self).to_dictionary()
+        if self.amount is not None:
+            dictionary['amount'] = self.amount.to_dictionary()
+        if self.merchant_reference is not None:
+            dictionary['merchantReference'] = self.merchant_reference
+        if self.surcharge_specific_output is not None:
+            dictionary['surchargeSpecificOutput'] = self.surcharge_specific_output.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentLinkOrderOutput':
+        super(PaymentLinkOrderOutput, self).from_dictionary(dictionary)
+        if 'amount' in dictionary:
+            if not isinstance(dictionary['amount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amount']))
+            value = AmountOfMoney()
+            self.amount = value.from_dictionary(dictionary['amount'])
+        if 'merchantReference' in dictionary:
+            self.merchant_reference = dictionary['merchantReference']
+        if 'surchargeSpecificOutput' in dictionary:
+            if not isinstance(dictionary['surchargeSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['surchargeSpecificOutput']))
+            value = SurchargeForPaymentLink()
+            self.surcharge_specific_output = value.from_dictionary(dictionary['surchargeSpecificOutput'])
+        return self

onlinepayments/sdk/domain/payment_link_response.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from datetime import datetime
+from typing import List, Optional
+
+from .data_object import DataObject
+from .payment_link_event import PaymentLinkEvent
+from .payment_link_order_output import PaymentLinkOrderOutput
+
+
+class PaymentLinkResponse(DataObject):
+
+    __expiration_date: Optional[datetime] = None
+    __is_reusable_link: Optional[bool] = None
+    __payment_id: Optional[str] = None
+    __payment_link_events: Optional[List[PaymentLinkEvent]] = None
+    __payment_link_id: Optional[str] = None
+    __payment_link_order: Optional[PaymentLinkOrderOutput] = None
+    __qr_code_base64: Optional[str] = None
+    __recipient_name: Optional[str] = None
+    __redirection_url: Optional[str] = None
+    __status: Optional[str] = None
+
+    @property
+    def expiration_date(self) -> Optional[datetime]:
+        """
+        | The date after which the payment link will not be usable to complete the payment. The date will contain the UTC offset.
+
+        Type: datetime
+        """
+        return self.__expiration_date
+
+    @expiration_date.setter
+    def expiration_date(self, value: Optional[datetime]) -> None:
+        self.__expiration_date = value
+
+    @property
+    def is_reusable_link(self) -> Optional[bool]:
+        """
+        | Indicates if the payment link can be used multiple times. The default value for this property is false
+
+        Type: bool
+        """
+        return self.__is_reusable_link
+
+    @is_reusable_link.setter
+    def is_reusable_link(self, value: Optional[bool]) -> None:
+        self.__is_reusable_link = value
+
+    @property
+    def payment_id(self) -> Optional[str]:
+        """
+        | The unique payment transaction identifier. This id is only set when a payment was processed with this payment link.
+
+        Type: str
+        """
+        return self.__payment_id
+
+    @payment_id.setter
+    def payment_id(self, value: Optional[str]) -> None:
+        self.__payment_id = value
+
+    @property
+    def payment_link_events(self) -> Optional[List[PaymentLinkEvent]]:
+        """
+        Type: list[:class:`onlinepayments.sdk.domain.payment_link_event.PaymentLinkEvent`]
+        """
+        return self.__payment_link_events
+
+    @payment_link_events.setter
+    def payment_link_events(self, value: Optional[List[PaymentLinkEvent]]) -> None:
+        self.__payment_link_events = value
+
+    @property
+    def payment_link_id(self) -> Optional[str]:
+        """
+        | The unique link identifier.
+
+        Type: str
+        """
+        return self.__payment_link_id
+
+    @payment_link_id.setter
+    def payment_link_id(self, value: Optional[str]) -> None:
+        self.__payment_link_id = value
+
+    @property
+    def payment_link_order(self) -> Optional[PaymentLinkOrderOutput]:
+        """
+        | An object containing the details of the related payment output.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_link_order_output.PaymentLinkOrderOutput`
+        """
+        return self.__payment_link_order
+
+    @payment_link_order.setter
+    def payment_link_order(self, value: Optional[PaymentLinkOrderOutput]) -> None:
+        self.__payment_link_order = value
+
+    @property
+    def qr_code_base64(self) -> Optional[str]:
+        """
+        | Base64 encoded QR code image containing the payment link URL. This field is only included in the response when displayQRCode is set to true in the request.
+
+        Type: str
+        """
+        return self.__qr_code_base64
+
+    @qr_code_base64.setter
+    def qr_code_base64(self, value: Optional[str]) -> None:
+        self.__qr_code_base64 = value
+
+    @property
+    def recipient_name(self) -> Optional[str]:
+        """
+        | The payment link recipient name.
+
+        Type: str
+        """
+        return self.__recipient_name
+
+    @recipient_name.setter
+    def recipient_name(self, value: Optional[str]) -> None:
+        self.__recipient_name = value
+
+    @property
+    def redirection_url(self) -> Optional[str]:
+        """
+        | The URL that will redirect the customer to the Hosted Checkout page to process the payment.
+
+        Type: str
+        """
+        return self.__redirection_url
+
+    @redirection_url.setter
+    def redirection_url(self, value: Optional[str]) -> None:
+        self.__redirection_url = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | The state of the payment link:
+        
+        * ACTIVE: The payment link is ready to be used.
+        * PAID: The payment has been completed.
+        * CANCELLED: The payment link has been manually cancelled.
+        * EXPIRED: The payment link is not usable anymore.
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentLinkResponse, self).to_dictionary()
+        if self.expiration_date is not None:
+            dictionary['expirationDate'] = DataObject.format_datetime(self.expiration_date)
+        if self.is_reusable_link is not None:
+            dictionary['isReusableLink'] = self.is_reusable_link
+        if self.payment_id is not None:
+            dictionary['paymentId'] = self.payment_id
+        if self.payment_link_events is not None:
+            dictionary['paymentLinkEvents'] = []
+            for element in self.payment_link_events:
+                if element is not None:
+                    dictionary['paymentLinkEvents'].append(element.to_dictionary())
+        if self.payment_link_id is not None:
+            dictionary['paymentLinkId'] = self.payment_link_id
+        if self.payment_link_order is not None:
+            dictionary['paymentLinkOrder'] = self.payment_link_order.to_dictionary()
+        if self.qr_code_base64 is not None:
+            dictionary['qrCodeBase64'] = self.qr_code_base64
+        if self.recipient_name is not None:
+            dictionary['recipientName'] = self.recipient_name
+        if self.redirection_url is not None:
+            dictionary['redirectionUrl'] = self.redirection_url
+        if self.status is not None:
+            dictionary['status'] = self.status
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentLinkResponse':
+        super(PaymentLinkResponse, self).from_dictionary(dictionary)
+        if 'expirationDate' in dictionary:
+            self.expiration_date = DataObject.parse_datetime(dictionary['expirationDate'])
+        if 'isReusableLink' in dictionary:
+            self.is_reusable_link = dictionary['isReusableLink']
+        if 'paymentId' in dictionary:
+            self.payment_id = dictionary['paymentId']
+        if 'paymentLinkEvents' in dictionary:
+            if not isinstance(dictionary['paymentLinkEvents'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['paymentLinkEvents']))
+            self.payment_link_events = []
+            for element in dictionary['paymentLinkEvents']:
+                value = PaymentLinkEvent()
+                self.payment_link_events.append(value.from_dictionary(element))
+        if 'paymentLinkId' in dictionary:
+            self.payment_link_id = dictionary['paymentLinkId']
+        if 'paymentLinkOrder' in dictionary:
+            if not isinstance(dictionary['paymentLinkOrder'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentLinkOrder']))
+            value = PaymentLinkOrderOutput()
+            self.payment_link_order = value.from_dictionary(dictionary['paymentLinkOrder'])
+        if 'qrCodeBase64' in dictionary:
+            self.qr_code_base64 = dictionary['qrCodeBase64']
+        if 'recipientName' in dictionary:
+            self.recipient_name = dictionary['recipientName']
+        if 'redirectionUrl' in dictionary:
+            self.redirection_url = dictionary['redirectionUrl']
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        return self