onlinepayments-sdk-python3 4.23.0__zip → 5.0.0__zip

{onlinepayments-sdk-python3-4.23.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/amount_of_money.py

@@ -1,36 +1,36 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from onlinepayments.sdk.data_object import DataObject
+from typing import Optional
+
+from .data_object import DataObject
 
 
 class AmountOfMoney(DataObject):
-    """
-    | Object containing amount and ISO currency code attributes
-    """
 
-    __amount = None
-    __currency_code = None
+    __amount: Optional[int] = None
+    __currency_code: Optional[str] = None
 
     @property
-    def amount(self) -> int:
+    def amount(self) -> Optional[int]:
         """
         | Amount in the smallest currency unit, i.e.:
-        | * EUR is a 2-decimals currency, the value 1234 will result in EUR 12.34
-        | * KWD is a 3-decimals currency, the value 1234 will result in KWD 1.234
-        | * JPY is a zero-decimal currency, the value 1234 will result in JPY 1234
+        
+        * EUR is a 2-decimals currency, the value 1234 will result in EUR 12.34
+        * KWD is a 3-decimals currency, the value 1234 will result in KWD 1.234
+        * JPY is a zero-decimal currency, the value 1234 will result in JPY 1234
 
         Type: int
         """
         return self.__amount
 
     @amount.setter
-    def amount(self, value: int):
+    def amount(self, value: Optional[int]) -> None:
         self.__amount = value
 
     @property
-    def currency_code(self) -> str:
+    def currency_code(self) -> Optional[str]:
         """
         | Three-letter ISO currency code representing the currency for the amount
 
@@ -39,10 +39,10 @@ class AmountOfMoney(DataObject):
         return self.__currency_code
 
     @currency_code.setter
-    def currency_code(self, value: str):
+    def currency_code(self, value: Optional[str]) -> None:
         self.__currency_code = value
 
-    def to_dictionary(self):
+    def to_dictionary(self) -> dict:
         dictionary = super(AmountOfMoney, self).to_dictionary()
         if self.amount is not None:
             dictionary['amount'] = self.amount
@@ -50,7 +50,7 @@ class AmountOfMoney(DataObject):
             dictionary['currencyCode'] = self.currency_code
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'AmountOfMoney':
         super(AmountOfMoney, self).from_dictionary(dictionary)
         if 'amount' in dictionary:
             self.amount = dictionary['amount']

{onlinepayments-sdk-python3-4.23.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/api_error.py

@@ -1,56 +1,57 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from onlinepayments.sdk.data_object import DataObject
+from typing import Optional
+
+from .data_object import DataObject
 
 
 class APIError(DataObject):
-    """
-    | Contains detailed information on one single error.
-    """
-
-    __category = None
-    __code = None
-    __error_code = None
-    __http_status_code = None
-    __id = None
-    __message = None
-    __property_name = None
-    __retriable = None
+
+    __category: Optional[str] = None
+    __code: Optional[str] = None
+    __error_code: Optional[str] = None
+    __http_status_code: Optional[int] = None
+    __id: Optional[str] = None
+    __message: Optional[str] = None
+    __property_name: Optional[str] = None
+    __retriable: Optional[bool] = None
 
     @property
-    def category(self) -> str:
+    def category(self) -> Optional[str]:
         """
         | Category the error belongs to. The category should give an indication of the type of error you are dealing with. Possible values:
-        | * DIRECT_PLATFORM_ERROR - indicating that a functional error has occurred in the platform.
-        | * PAYMENT_PLATFORM_ERROR - indicating that a functional error has occurred in the payment platform.
-        | * IO_ERROR - indicating that a technical error has occurred within the payment platform or between the payment platform and third party systems.
+        
+        * DIRECT_PLATFORM_ERROR - indicating that a functional error has occurred in the platform.
+        * PAYMENT_PLATFORM_ERROR - indicating that a functional error has occurred in the payment platform.
+        * IO_ERROR - indicating that a technical error has occurred within the payment platform or between the payment platform and third party systems.
 
         Type: str
         """
         return self.__category
 
     @category.setter
-    def category(self, value: str):
+    def category(self, value: Optional[str]) -> None:
         self.__category = value
 
     @property
-    def code(self) -> str:
+    def code(self) -> Optional[str]:
         """
-        | Deprecated: Use errorCode instead.
-        | Error code
+        | Deprecated: Use errorCode instead. Error code
 
         Type: str
+
+        Deprecated; Use errorCode instead. Error code
         """
         return self.__code
 
     @code.setter
-    def code(self, value: str):
+    def code(self, value: Optional[str]) -> None:
         self.__code = value
 
     @property
-    def error_code(self) -> str:
+    def error_code(self) -> Optional[str]:
         """
         | Error code
 
@@ -59,11 +60,11 @@ class APIError(DataObject):
         return self.__error_code
 
     @error_code.setter
-    def error_code(self, value: str):
+    def error_code(self, value: Optional[str]) -> None:
         self.__error_code = value
 
     @property
-    def http_status_code(self) -> int:
+    def http_status_code(self) -> Optional[int]:
         """
         | HTTP status code for this error that can be used to determine the type of error
 
@@ -72,11 +73,11 @@ class APIError(DataObject):
         return self.__http_status_code
 
     @http_status_code.setter
-    def http_status_code(self, value: int):
+    def http_status_code(self, value: Optional[int]) -> None:
         self.__http_status_code = value
 
     @property
-    def id(self) -> str:
+    def id(self) -> Optional[str]:
         """
         | ID of the error. This is a short human-readable message that briefly describes the error.
 
@@ -85,11 +86,11 @@ class APIError(DataObject):
         return self.__id
 
     @id.setter
-    def id(self, value: str):
+    def id(self, value: Optional[str]) -> None:
         self.__id = value
 
     @property
-    def message(self) -> str:
+    def message(self) -> Optional[str]:
         """
         | Human-readable error message that is not meant to be relayed to customer as it might tip off people who are trying to commit fraud
 
@@ -98,44 +99,44 @@ class APIError(DataObject):
         return self.__message
 
     @message.setter
-    def message(self, value: str):
+    def message(self, value: Optional[str]) -> None:
         self.__message = value
 
     @property
-    def property_name(self) -> str:
+    def property_name(self) -> Optional[str]:
         """
         | Returned only if the error relates to a value that was missing or incorrect.
-        
+        |
         | Contains a location path to the value as a JSonata query.
-        
+        |
         | Some common examples:
-        | * a.b selects the value of property b of root property a,
-        | * a[1] selects the first element of the array in root property a,
-        | * a[b='some value'] selects all elements of the array in root property a that have a property b with value 'some value'.
+        
+        * a.b selects the value of property b of root property a,
+        * a[1] selects the first element of the array in root property a,
+        * a[b='some value'] selects all elements of the array in root property a that have a property b with value 'some value'.
 
         Type: str
         """
         return self.__property_name
 
     @property_name.setter
-    def property_name(self, value: str):
+    def property_name(self, value: Optional[str]) -> None:
         self.__property_name = value
 
     @property
-    def retriable(self) -> bool:
+    def retriable(self) -> Optional[bool]:
         """
-        | Flag indicating if the request is retriable. 
-        | Retriable requests mean that a technical error happened and that the same request can safely be sent again with a new idempotence key.
+        | Flag indicating if the request is retriable. Retriable requests mean that a technical error happened and that the same request can safely be sent again with a new idempotence key.
 
         Type: bool
         """
         return self.__retriable
 
     @retriable.setter
-    def retriable(self, value: bool):
+    def retriable(self, value: Optional[bool]) -> None:
         self.__retriable = value
 
-    def to_dictionary(self):
+    def to_dictionary(self) -> dict:
         dictionary = super(APIError, self).to_dictionary()
         if self.category is not None:
             dictionary['category'] = self.category
@@ -155,7 +156,7 @@ class APIError(DataObject):
             dictionary['retriable'] = self.retriable
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'APIError':
         super(APIError, self).from_dictionary(dictionary)
         if 'category' in dictionary:
             self.category = dictionary['category']

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/domain/apple_pay_line_item.py

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ApplePayLineItem(DataObject):
+
+    __amount: Optional[str] = None
+    __label: Optional[str] = None
+    __payment_timing: Optional[str] = None
+    __recurring_payment_end_date: Optional[str] = None
+    __recurring_payment_interval_count: Optional[int] = None
+    __recurring_payment_interval_unit: Optional[str] = None
+    __recurring_payment_start_date: Optional[str] = None
+
+    @property
+    def amount(self) -> Optional[str]:
+        """
+        | A required value that’s the monetary amount of the line item.
+
+        Type: str
+        """
+        return self.__amount
+
+    @amount.setter
+    def amount(self, value: Optional[str]) -> None:
+        self.__amount = value
+
+    @property
+    def label(self) -> Optional[str]:
+        """
+        | A required value that’s a short, localized description of the line item.
+
+        Type: str
+        """
+        return self.__label
+
+    @label.setter
+    def label(self, value: Optional[str]) -> None:
+        self.__label = value
+
+    @property
+    def payment_timing(self) -> Optional[str]:
+        """
+        | The time that the payment occurs as part of a successful transaction.
+
+        Type: str
+        """
+        return self.__payment_timing
+
+    @payment_timing.setter
+    def payment_timing(self, value: Optional[str]) -> None:
+        self.__payment_timing = value
+
+    @property
+    def recurring_payment_end_date(self) -> Optional[str]:
+        """
+        | The date of the final payment. Example 2022-01-01T00:00:00
+
+        Type: str
+        """
+        return self.__recurring_payment_end_date
+
+    @recurring_payment_end_date.setter
+    def recurring_payment_end_date(self, value: Optional[str]) -> None:
+        self.__recurring_payment_end_date = value
+
+    @property
+    def recurring_payment_interval_count(self) -> Optional[int]:
+        """
+        | The number of interval units that make up the total payment interval.
+
+        Type: int
+        """
+        return self.__recurring_payment_interval_count
+
+    @recurring_payment_interval_count.setter
+    def recurring_payment_interval_count(self, value: Optional[int]) -> None:
+        self.__recurring_payment_interval_count = value
+
+    @property
+    def recurring_payment_interval_unit(self) -> Optional[str]:
+        """
+        | The amount of time — in calendar units, such as day, month, or year — that represents a fraction of the total payment interval.
+
+        Type: str
+        """
+        return self.__recurring_payment_interval_unit
+
+    @recurring_payment_interval_unit.setter
+    def recurring_payment_interval_unit(self, value: Optional[str]) -> None:
+        self.__recurring_payment_interval_unit = value
+
+    @property
+    def recurring_payment_start_date(self) -> Optional[str]:
+        """
+        | The date of the first payment. Example 2022-01-01T00:00:00
+
+        Type: str
+        """
+        return self.__recurring_payment_start_date
+
+    @recurring_payment_start_date.setter
+    def recurring_payment_start_date(self, value: Optional[str]) -> None:
+        self.__recurring_payment_start_date = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApplePayLineItem, self).to_dictionary()
+        if self.amount is not None:
+            dictionary['amount'] = self.amount
+        if self.label is not None:
+            dictionary['label'] = self.label
+        if self.payment_timing is not None:
+            dictionary['paymentTiming'] = self.payment_timing
+        if self.recurring_payment_end_date is not None:
+            dictionary['recurringPaymentEndDate'] = self.recurring_payment_end_date
+        if self.recurring_payment_interval_count is not None:
+            dictionary['recurringPaymentIntervalCount'] = self.recurring_payment_interval_count
+        if self.recurring_payment_interval_unit is not None:
+            dictionary['recurringPaymentIntervalUnit'] = self.recurring_payment_interval_unit
+        if self.recurring_payment_start_date is not None:
+            dictionary['recurringPaymentStartDate'] = self.recurring_payment_start_date
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApplePayLineItem':
+        super(ApplePayLineItem, self).from_dictionary(dictionary)
+        if 'amount' in dictionary:
+            self.amount = dictionary['amount']
+        if 'label' in dictionary:
+            self.label = dictionary['label']
+        if 'paymentTiming' in dictionary:
+            self.payment_timing = dictionary['paymentTiming']
+        if 'recurringPaymentEndDate' in dictionary:
+            self.recurring_payment_end_date = dictionary['recurringPaymentEndDate']
+        if 'recurringPaymentIntervalCount' in dictionary:
+            self.recurring_payment_interval_count = dictionary['recurringPaymentIntervalCount']
+        if 'recurringPaymentIntervalUnit' in dictionary:
+            self.recurring_payment_interval_unit = dictionary['recurringPaymentIntervalUnit']
+        if 'recurringPaymentStartDate' in dictionary:
+            self.recurring_payment_start_date = dictionary['recurringPaymentStartDate']
+        return self

onlinepayments_sdk_python3-5.0.0/onlinepayments/sdk/domain/apple_pay_recurring_payment_request.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .apple_pay_line_item import ApplePayLineItem
+from .data_object import DataObject
+
+
+class ApplePayRecurringPaymentRequest(DataObject):
+
+    __billing_agreement: Optional[str] = None
+    __management_url: Optional[str] = None
+    __payment_description: Optional[str] = None
+    __regular_billing: Optional[ApplePayLineItem] = None
+    __trial_billing: Optional[ApplePayLineItem] = None
+
+    @property
+    def billing_agreement(self) -> Optional[str]:
+        """
+        | A localized billing agreement that the payment sheet displays to the user before the user authorizes the payment.
+
+        Type: str
+        """
+        return self.__billing_agreement
+
+    @billing_agreement.setter
+    def billing_agreement(self, value: Optional[str]) -> None:
+        self.__billing_agreement = value
+
+    @property
+    def management_url(self) -> Optional[str]:
+        """
+        | A URL to a web page where the user can update or delete the payment method for the recurring payment.
+
+        Type: str
+        """
+        return self.__management_url
+
+    @management_url.setter
+    def management_url(self, value: Optional[str]) -> None:
+        self.__management_url = value
+
+    @property
+    def payment_description(self) -> Optional[str]:
+        """
+        | A description of the recurring payment that Apple Pay displays to the user in the payment sheet.
+
+        Type: str
+        """
+        return self.__payment_description
+
+    @payment_description.setter
+    def payment_description(self, value: Optional[str]) -> None:
+        self.__payment_description = value
+
+    @property
+    def regular_billing(self) -> Optional[ApplePayLineItem]:
+        """
+        | Object containing specific data regarding Apple Pay recurring payment.
+
+        Type: :class:`onlinepayments.sdk.domain.apple_pay_line_item.ApplePayLineItem`
+        """
+        return self.__regular_billing
+
+    @regular_billing.setter
+    def regular_billing(self, value: Optional[ApplePayLineItem]) -> None:
+        self.__regular_billing = value
+
+    @property
+    def trial_billing(self) -> Optional[ApplePayLineItem]:
+        """
+        | Object containing specific data regarding Apple Pay recurring payment.
+
+        Type: :class:`onlinepayments.sdk.domain.apple_pay_line_item.ApplePayLineItem`
+        """
+        return self.__trial_billing
+
+    @trial_billing.setter
+    def trial_billing(self, value: Optional[ApplePayLineItem]) -> None:
+        self.__trial_billing = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ApplePayRecurringPaymentRequest, self).to_dictionary()
+        if self.billing_agreement is not None:
+            dictionary['billingAgreement'] = self.billing_agreement
+        if self.management_url is not None:
+            dictionary['managementUrl'] = self.management_url
+        if self.payment_description is not None:
+            dictionary['paymentDescription'] = self.payment_description
+        if self.regular_billing is not None:
+            dictionary['regularBilling'] = self.regular_billing.to_dictionary()
+        if self.trial_billing is not None:
+            dictionary['trialBilling'] = self.trial_billing.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ApplePayRecurringPaymentRequest':
+        super(ApplePayRecurringPaymentRequest, self).from_dictionary(dictionary)
+        if 'billingAgreement' in dictionary:
+            self.billing_agreement = dictionary['billingAgreement']
+        if 'managementUrl' in dictionary:
+            self.management_url = dictionary['managementUrl']
+        if 'paymentDescription' in dictionary:
+            self.payment_description = dictionary['paymentDescription']
+        if 'regularBilling' in dictionary:
+            if not isinstance(dictionary['regularBilling'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['regularBilling']))
+            value = ApplePayLineItem()
+            self.regular_billing = value.from_dictionary(dictionary['regularBilling'])
+        if 'trialBilling' in dictionary:
+            if not isinstance(dictionary['trialBilling'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['trialBilling']))
+            value = ApplePayLineItem()
+            self.trial_billing = value.from_dictionary(dictionary['trialBilling'])
+        return self

{onlinepayments-sdk-python3-4.23.0 → onlinepayments_sdk_python3-5.0.0}/onlinepayments/sdk/domain/bank_account_iban.py

@@ -1,40 +1,36 @@
 # -*- coding: utf-8 -*-
 #
-# This class was auto-generated.
+# This file was automatically generated.
 #
-from onlinepayments.sdk.data_object import DataObject
+from typing import Optional
+
+from .data_object import DataObject
 
 
 class BankAccountIban(DataObject):
-    """
-    | Object containing IBAN information
-    """
 
-    __iban = None
+    __iban: Optional[str] = None
 
     @property
-    def iban(self) -> str:
+    def iban(self) -> Optional[str]:
         """
-        | The IBAN is the International Bank Account Number. It is an internationally agreed format for the BBAN and includes the ISO country code and two check digits.
-        | Required for the creation of a Payout
-        | Required for Create and Update token.
-        | Required for Create mandate and Create payment with mandate calls.
+        | The IBAN is the International Bank Account Number. It is an internationally agreed format for the BBAN and includes the ISO country code and two check digits. Required for the creation of a Payout Required for Create and Update token. Required for Create mandate and Create payment with mandate calls.
 
         Type: str
         """
         return self.__iban
 
     @iban.setter
-    def iban(self, value: str):
+    def iban(self, value: Optional[str]) -> None:
         self.__iban = value
 
-    def to_dictionary(self):
+    def to_dictionary(self) -> dict:
         dictionary = super(BankAccountIban, self).to_dictionary()
         if self.iban is not None:
             dictionary['iban'] = self.iban
         return dictionary
 
-    def from_dictionary(self, dictionary):
+    def from_dictionary(self, dictionary: dict) -> 'BankAccountIban':
         super(BankAccountIban, self).from_dictionary(dictionary)
         if 'iban' in dictionary:
             self.iban = dictionary['iban']