connect-sdk-python3 4.0.0__zip → 4.1.0__zip

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

@@ -1,90 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import List, Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.installment_display_hints import InstallmentDisplayHints
-from worldline.connect.sdk.v1.domain.installments import Installments
-
-
-class InstallmentOptions(DataObject):
-    """
-    | Array containing installment options their details and characteristics
-    """
-
-    __display_hints: Optional[InstallmentDisplayHints] = None
-    __id: Optional[str] = None
-    __installment_plans: Optional[List[Installments]] = None
-
-    @property
-    def display_hints(self) -> Optional[InstallmentDisplayHints]:
-        """
-        | Object containing information for the client on how best to display the installment options
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.installment_display_hints.InstallmentDisplayHints`
-        """
-        return self.__display_hints
-
-    @display_hints.setter
-    def display_hints(self, value: Optional[InstallmentDisplayHints]) -> None:
-        self.__display_hints = value
-
-    @property
-    def id(self) -> Optional[str]:
-        """
-        | The ID of the installment option in our system
-        
-        Type: str
-        """
-        return self.__id
-
-    @id.setter
-    def id(self, value: Optional[str]) -> None:
-        self.__id = value
-
-    @property
-    def installment_plans(self) -> Optional[List[Installments]]:
-        """
-        | Object containing information about installment plans
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.installments.Installments`]
-        """
-        return self.__installment_plans
-
-    @installment_plans.setter
-    def installment_plans(self, value: Optional[List[Installments]]) -> None:
-        self.__installment_plans = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(InstallmentOptions, self).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.installment_plans is not None:
-            dictionary['installmentPlans'] = []
-            for element in self.installment_plans:
-                if element is not None:
-                    dictionary['installmentPlans'].append(element.to_dictionary())
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'InstallmentOptions':
-        super(InstallmentOptions, self).from_dictionary(dictionary)
-        if 'displayHints' in dictionary:
-            if not isinstance(dictionary['displayHints'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['displayHints']))
-            value = InstallmentDisplayHints()
-            self.display_hints = value.from_dictionary(dictionary['displayHints'])
-        if 'id' in dictionary:
-            self.id = dictionary['id']
-        if 'installmentPlans' in dictionary:
-            if not isinstance(dictionary['installmentPlans'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['installmentPlans']))
-            self.installment_plans = []
-            for element in dictionary['installmentPlans']:
-                value = Installments()
-                self.installment_plans.append(value.from_dictionary(element))
-        return self

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

@@ -1,50 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import List, Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.installment_options import InstallmentOptions
-
-
-class InstallmentOptionsResponse(DataObject):
-    """
-    | The response contains the details of the installment options
-    """
-
-    __installment_options: Optional[List[InstallmentOptions]] = None
-
-    @property
-    def installment_options(self) -> Optional[List[InstallmentOptions]]:
-        """
-        | Array containing installment options their details and characteristics
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.installment_options.InstallmentOptions`]
-        """
-        return self.__installment_options
-
-    @installment_options.setter
-    def installment_options(self, value: Optional[List[InstallmentOptions]]) -> None:
-        self.__installment_options = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(InstallmentOptionsResponse, self).to_dictionary()
-        if self.installment_options is not None:
-            dictionary['installmentOptions'] = []
-            for element in self.installment_options:
-                if element is not None:
-                    dictionary['installmentOptions'].append(element.to_dictionary())
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'InstallmentOptionsResponse':
-        super(InstallmentOptionsResponse, self).from_dictionary(dictionary)
-        if 'installmentOptions' in dictionary:
-            if not isinstance(dictionary['installmentOptions'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['installmentOptions']))
-            self.installment_options = []
-            for element in dictionary['installmentOptions']:
-                value = InstallmentOptions()
-                self.installment_options.append(value.from_dictionary(element))
-        return self

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

@@ -1,154 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.amount_of_money import AmountOfMoney
-
-
-class Installments(DataObject):
-    """
-    | 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.
-    """
-
-    __amount_of_money_per_installment: Optional[AmountOfMoney] = None
-    __amount_of_money_total: Optional[AmountOfMoney] = None
-    __frequency_of_installments: Optional[str] = None
-    __installment_plan_code: Optional[int] = None
-    __interest_rate: Optional[str] = None
-    __number_of_installments: Optional[int] = None
-
-    @property
-    def amount_of_money_per_installment(self) -> Optional[AmountOfMoney]:
-        """
-        | The amount that will be paid per installment. The total amount of amountOfMoneyPerInstallment x numberOfInstallments can not be higher than the total amount of this transaction, although we will not validate that.
-        | For the payment product IDs BC Card (paymentProductId 8590), Hana Card (paymentProductId 8591), Hyundai Card (paymentProductId 8592), KB Card (paymentProductId 8593), Lotte Card (paymentProductId 8594), NH Card (paymentProductId 8595), Samsung Card (paymentProductId 8596) and Shinhan Card (paymentProductId 8597), this property is not used as the value is decided by the issuer.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.amount_of_money.AmountOfMoney`
-        """
-        return self.__amount_of_money_per_installment
-
-    @amount_of_money_per_installment.setter
-    def amount_of_money_per_installment(self, value: Optional[AmountOfMoney]) -> None:
-        self.__amount_of_money_per_installment = value
-
-    @property
-    def amount_of_money_total(self) -> Optional[AmountOfMoney]:
-        """
-        | Object containing the total amount and ISO currency code attributes
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.amount_of_money.AmountOfMoney`
-        """
-        return self.__amount_of_money_total
-
-    @amount_of_money_total.setter
-    def amount_of_money_total(self, value: Optional[AmountOfMoney]) -> None:
-        self.__amount_of_money_total = value
-
-    @property
-    def frequency_of_installments(self) -> Optional[str]:
-        """
-        | The frequency in which the installments will be collected from the customer. The possible values are:
-        
-        * daily
-        * weekly
-        * monthly (default)
-        * quarterly
-        
-        
-        | For the payment product IDs BC Card (paymentProductId 8590), Hana Card (paymentProductId 8591), Hyundai Card (paymentProductId 8592), KB Card (paymentProductId 8593), Lotte Card (paymentProductId 8594), NH Card (paymentProductId 8595), Samsung Card (paymentProductId 8596) and Shinhan Card (paymentProductId 8597), only the value monthly is valid.
-        
-        Type: str
-        """
-        return self.__frequency_of_installments
-
-    @frequency_of_installments.setter
-    def frequency_of_installments(self, value: Optional[str]) -> None:
-        self.__frequency_of_installments = value
-
-    @property
-    def installment_plan_code(self) -> Optional[int]:
-        """
-        | The code for the installment plan. The possible values are:
-        
-        * **43** No-interest, 3 month Installmentplan
-        * **46**No-interest, 6 month Installmentplan
-        * **49**No-interest, 9 month Installmentplan
-        * **52**No-interest, 12 month Installmentplan
-        
-        Type: int
-        """
-        return self.__installment_plan_code
-
-    @installment_plan_code.setter
-    def installment_plan_code(self, value: Optional[int]) -> None:
-        self.__installment_plan_code = value
-
-    @property
-    def interest_rate(self) -> Optional[str]:
-        """
-        | The interest rate paid for installments expressed in percentage. So for example 5.75 means 5.75%
-        | For the payment product IDs BC Card (paymentProductId 8590), Hana Card (paymentProductId 8591), Hyundai Card (paymentProductId 8592), KB Card (paymentProductId 8593), Lotte Card (paymentProductId 8594), NH Card (paymentProductId 8595), Samsung Card (paymentProductId 8596) and Shinhan Card (paymentProductId 8597), this property is not used as the value is decided by the issuer.
-        
-        Type: str
-        """
-        return self.__interest_rate
-
-    @interest_rate.setter
-    def interest_rate(self, value: Optional[str]) -> None:
-        self.__interest_rate = 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 at supported acquirers, or with specific payment products. Only used with some acquirers. In case you send in the details of this object, only the payment products (or  combination of card products and acquirers) that support installments will be shown on the MyCheckout hosted payment pages. If this property is not provided the customer will not see details on the installment plan in a HostedCheckout.
-        | For the payment product IDs BC Card (paymentProductId 8590), Hana Card (paymentProductId 8591), Hyundai Card (paymentProductId 8592), KB Card (paymentProductId 8593), Lotte Card (paymentProductId 8594), NH Card (paymentProductId 8595), Samsung Card (paymentProductId 8596) and Shinhan Card (paymentProductId 8597), there is a maximum of 12 installments.
-        
-        Type: int
-        """
-        return self.__number_of_installments
-
-    @number_of_installments.setter
-    def number_of_installments(self, value: Optional[int]) -> None:
-        self.__number_of_installments = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(Installments, self).to_dictionary()
-        if self.amount_of_money_per_installment is not None:
-            dictionary['amountOfMoneyPerInstallment'] = self.amount_of_money_per_installment.to_dictionary()
-        if self.amount_of_money_total is not None:
-            dictionary['amountOfMoneyTotal'] = self.amount_of_money_total.to_dictionary()
-        if self.frequency_of_installments is not None:
-            dictionary['frequencyOfInstallments'] = self.frequency_of_installments
-        if self.installment_plan_code is not None:
-            dictionary['installmentPlanCode'] = self.installment_plan_code
-        if self.interest_rate is not None:
-            dictionary['interestRate'] = self.interest_rate
-        if self.number_of_installments is not None:
-            dictionary['numberOfInstallments'] = self.number_of_installments
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'Installments':
-        super(Installments, self).from_dictionary(dictionary)
-        if 'amountOfMoneyPerInstallment' in dictionary:
-            if not isinstance(dictionary['amountOfMoneyPerInstallment'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amountOfMoneyPerInstallment']))
-            value = AmountOfMoney()
-            self.amount_of_money_per_installment = value.from_dictionary(dictionary['amountOfMoneyPerInstallment'])
-        if 'amountOfMoneyTotal' in dictionary:
-            if not isinstance(dictionary['amountOfMoneyTotal'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amountOfMoneyTotal']))
-            value = AmountOfMoney()
-            self.amount_of_money_total = value.from_dictionary(dictionary['amountOfMoneyTotal'])
-        if 'frequencyOfInstallments' in dictionary:
-            self.frequency_of_installments = dictionary['frequencyOfInstallments']
-        if 'installmentPlanCode' in dictionary:
-            self.installment_plan_code = dictionary['installmentPlanCode']
-        if 'interestRate' in dictionary:
-            self.interest_rate = dictionary['interestRate']
-        if 'numberOfInstallments' in dictionary:
-            self.number_of_installments = dictionary['numberOfInstallments']
-        return self

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

@@ -1,38 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.v1.domain.abstract_payment_method_specific_input import AbstractPaymentMethodSpecificInput
-
-
-class InvoicePaymentMethodSpecificInput(AbstractPaymentMethodSpecificInput):
-
-    __additional_reference: Optional[str] = None
-
-    @property
-    def additional_reference(self) -> Optional[str]:
-        """
-        | Your (additional) reference identifier for this transaction. Data supplied in this property will also be returned in our report files, allowing you to reconcile the incoming funds.
-        
-        Type: str
-        """
-        return self.__additional_reference
-
-    @additional_reference.setter
-    def additional_reference(self, value: Optional[str]) -> None:
-        self.__additional_reference = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(InvoicePaymentMethodSpecificInput, self).to_dictionary()
-        if self.additional_reference is not None:
-            dictionary['additionalReference'] = self.additional_reference
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'InvoicePaymentMethodSpecificInput':
-        super(InvoicePaymentMethodSpecificInput, self).from_dictionary(dictionary)
-        if 'additionalReference' in dictionary:
-            self.additional_reference = dictionary['additionalReference']
-        return self

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

@@ -1,42 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.v1.domain.abstract_payment_method_specific_output import AbstractPaymentMethodSpecificOutput
-from worldline.connect.sdk.v1.domain.fraud_results import FraudResults
-
-
-class InvoicePaymentMethodSpecificOutput(AbstractPaymentMethodSpecificOutput):
-
-    __fraud_results: Optional[FraudResults] = None
-
-    @property
-    def fraud_results(self) -> Optional[FraudResults]:
-        """
-        | Object containing the results of the fraud screening
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.fraud_results.FraudResults`
-        """
-        return self.__fraud_results
-
-    @fraud_results.setter
-    def fraud_results(self, value: Optional[FraudResults]) -> None:
-        self.__fraud_results = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(InvoicePaymentMethodSpecificOutput, self).to_dictionary()
-        if self.fraud_results is not None:
-            dictionary['fraudResults'] = self.fraud_results.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'InvoicePaymentMethodSpecificOutput':
-        super(InvoicePaymentMethodSpecificOutput, self).from_dictionary(dictionary)
-        if 'fraudResults' in dictionary:
-            if not isinstance(dictionary['fraudResults'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraudResults']))
-            value = FraudResults()
-            self.fraud_results = value.from_dictionary(dictionary['fraudResults'])
-        return self

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

@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class KeyValuePair(DataObject):
-
-    __key: Optional[str] = None
-    __value: Optional[str] = None
-
-    @property
-    def key(self) -> Optional[str]:
-        """
-        | Name of the key or property
-        
-        Type: str
-        """
-        return self.__key
-
-    @key.setter
-    def key(self, value: Optional[str]) -> None:
-        self.__key = value
-
-    @property
-    def value(self) -> Optional[str]:
-        """
-        | Value of the key or property
-        
-        Type: str
-        """
-        return self.__value
-
-    @value.setter
-    def value(self, value: Optional[str]) -> None:
-        self.__value = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(KeyValuePair, self).to_dictionary()
-        if self.key is not None:
-            dictionary['key'] = self.key
-        if self.value is not None:
-            dictionary['value'] = self.value
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'KeyValuePair':
-        super(KeyValuePair, self).from_dictionary(dictionary)
-        if 'key' in dictionary:
-            self.key = dictionary['key']
-        if 'value' in dictionary:
-            self.value = dictionary['value']
-        return self

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

@@ -1,57 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class LabelTemplateElement(DataObject):
-
-    __attribute_key: Optional[str] = None
-    __mask: Optional[str] = None
-
-    @property
-    def attribute_key(self) -> Optional[str]:
-        """
-        | Name of the attribute that is shown to the customer on selection pages or screens
-        
-        Type: str
-        """
-        return self.__attribute_key
-
-    @attribute_key.setter
-    def attribute_key(self, value: Optional[str]) -> None:
-        self.__attribute_key = value
-
-    @property
-    def mask(self) -> Optional[str]:
-        """
-        | Regular mask for the attributeKey
-        | Note: The mask is optional as not every field has a mask
-        
-        Type: str
-        """
-        return self.__mask
-
-    @mask.setter
-    def mask(self, value: Optional[str]) -> None:
-        self.__mask = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(LabelTemplateElement, self).to_dictionary()
-        if self.attribute_key is not None:
-            dictionary['attributeKey'] = self.attribute_key
-        if self.mask is not None:
-            dictionary['mask'] = self.mask
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'LabelTemplateElement':
-        super(LabelTemplateElement, self).from_dictionary(dictionary)
-        if 'attributeKey' in dictionary:
-            self.attribute_key = dictionary['attributeKey']
-        if 'mask' in dictionary:
-            self.mask = dictionary['mask']
-        return self

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

@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class LengthValidator(DataObject):
-
-    __max_length: Optional[int] = None
-    __min_length: Optional[int] = None
-
-    @property
-    def max_length(self) -> Optional[int]:
-        """
-        | The maximum allowed length
-        
-        Type: int
-        """
-        return self.__max_length
-
-    @max_length.setter
-    def max_length(self, value: Optional[int]) -> None:
-        self.__max_length = value
-
-    @property
-    def min_length(self) -> Optional[int]:
-        """
-        | The minimum allowed length
-        
-        Type: int
-        """
-        return self.__min_length
-
-    @min_length.setter
-    def min_length(self, value: Optional[int]) -> None:
-        self.__min_length = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(LengthValidator, self).to_dictionary()
-        if self.max_length is not None:
-            dictionary['maxLength'] = self.max_length
-        if self.min_length is not None:
-            dictionary['minLength'] = self.min_length
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'LengthValidator':
-        super(LengthValidator, self).from_dictionary(dictionary)
-        if 'maxLength' in dictionary:
-            self.max_length = dictionary['maxLength']
-        if 'minLength' in dictionary:
-            self.min_length = dictionary['minLength']
-        return self

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

@@ -1,83 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class Level3SummaryData(DataObject):
-    """
-    Deprecated; Use ShoppingCart.amountBreakdown instead
-    """
-
-    __discount_amount: Optional[int] = None
-    __duty_amount: Optional[int] = None
-    __shipping_amount: Optional[int] = None
-
-    @property
-    def discount_amount(self) -> Optional[int]:
-        """
-        | Discount on the entire transaction, with the last 2 digits are implied decimal places
-        
-        Type: int
-        
-        Deprecated; Use ShoppingCart.amountBreakdown with type DISCOUNT instead
-        """
-        return self.__discount_amount
-
-    @discount_amount.setter
-    def discount_amount(self, value: Optional[int]) -> None:
-        self.__discount_amount = value
-
-    @property
-    def duty_amount(self) -> Optional[int]:
-        """
-        | Duty on the entire transaction, with the last 2 digits are implied decimal places
-        
-        Type: int
-        
-        Deprecated; Use ShoppingCart.amountBreakdown with type DUTY instead
-        """
-        return self.__duty_amount
-
-    @duty_amount.setter
-    def duty_amount(self, value: Optional[int]) -> None:
-        self.__duty_amount = value
-
-    @property
-    def shipping_amount(self) -> Optional[int]:
-        """
-        | Shippingcost on the entire transaction, with the last 2 digits are implied decimal places
-        
-        Type: int
-        
-        Deprecated; Use ShoppingCart.amountBreakdown with type SHIPPING instead
-        """
-        return self.__shipping_amount
-
-    @shipping_amount.setter
-    def shipping_amount(self, value: Optional[int]) -> None:
-        self.__shipping_amount = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(Level3SummaryData, self).to_dictionary()
-        if self.discount_amount is not None:
-            dictionary['discountAmount'] = self.discount_amount
-        if self.duty_amount is not None:
-            dictionary['dutyAmount'] = self.duty_amount
-        if self.shipping_amount is not None:
-            dictionary['shippingAmount'] = self.shipping_amount
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'Level3SummaryData':
-        super(Level3SummaryData, self).from_dictionary(dictionary)
-        if 'discountAmount' in dictionary:
-            self.discount_amount = dictionary['discountAmount']
-        if 'dutyAmount' in dictionary:
-            self.duty_amount = dictionary['dutyAmount']
-        if 'shippingAmount' in dictionary:
-            self.shipping_amount = dictionary['shippingAmount']
-        return self