connect-sdk-python3 4.0.0__zip → 4.1.0__zip

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

@@ -1,180 +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_sepa_direct_debit_payment_method_specific_input import AbstractSepaDirectDebitPaymentMethodSpecificInput
-from worldline.connect.sdk.v1.domain.sepa_direct_debit_payment_product771_specific_input import SepaDirectDebitPaymentProduct771SpecificInput
-
-
-class SepaDirectDebitPaymentMethodSpecificInput(AbstractSepaDirectDebitPaymentMethodSpecificInput):
-
-    __date_collect: Optional[str] = None
-    __direct_debit_text: Optional[str] = None
-    __is_recurring: Optional[bool] = None
-    __payment_product771_specific_input: Optional[SepaDirectDebitPaymentProduct771SpecificInput] = None
-    __recurring_payment_sequence_indicator: Optional[str] = None
-    __requires_approval: Optional[bool] = None
-    __token: Optional[str] = None
-    __tokenize: Optional[bool] = None
-
-    @property
-    def date_collect(self) -> Optional[str]:
-        """
-        | Changed date for direct debit collection. Only relevant for legacy SEPA Direct Debit.
-        | Format: YYYYMMDD
-        
-        Type: str
-        """
-        return self.__date_collect
-
-    @date_collect.setter
-    def date_collect(self, value: Optional[str]) -> None:
-        self.__date_collect = value
-
-    @property
-    def direct_debit_text(self) -> Optional[str]:
-        """
-        | Description of the transaction that will appear on the customer bank statement to aid the customer in recognizing the transaction. Only relevant for legacy SEPA Direct Debit.
-        
-        Type: str
-        """
-        return self.__direct_debit_text
-
-    @direct_debit_text.setter
-    def direct_debit_text(self, value: Optional[str]) -> None:
-        self.__direct_debit_text = value
-
-    @property
-    def is_recurring(self) -> Optional[bool]:
-        """
-        | Indicates if this transaction is of a one-off or a recurring type. Only relevant for legacy SEPA Direct Debit.
-        
-        * true - This is recurring
-        * false - This is one-off
-        
-        Type: bool
-        """
-        return self.__is_recurring
-
-    @is_recurring.setter
-    def is_recurring(self, value: Optional[bool]) -> None:
-        self.__is_recurring = value
-
-    @property
-    def payment_product771_specific_input(self) -> Optional[SepaDirectDebitPaymentProduct771SpecificInput]:
-        """
-        | Object containing information specific to SEPA Direct Debit
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.sepa_direct_debit_payment_product771_specific_input.SepaDirectDebitPaymentProduct771SpecificInput`
-        """
-        return self.__payment_product771_specific_input
-
-    @payment_product771_specific_input.setter
-    def payment_product771_specific_input(self, value: Optional[SepaDirectDebitPaymentProduct771SpecificInput]) -> None:
-        self.__payment_product771_specific_input = value
-
-    @property
-    def recurring_payment_sequence_indicator(self) -> Optional[str]:
-        """
-        | Only relevant for legacy SEPA Direct Debit.
-        
-        * first = This transaction is the first of a series of recurring transactions
-        * recurring = This transaction is a subsequent transaction in a series of recurring transactions
-        * last = This transaction is the last transaction of a series of recurring transactions
-        
-        Type: str
-        """
-        return self.__recurring_payment_sequence_indicator
-
-    @recurring_payment_sequence_indicator.setter
-    def recurring_payment_sequence_indicator(self, value: Optional[str]) -> None:
-        self.__recurring_payment_sequence_indicator = value
-
-    @property
-    def requires_approval(self) -> Optional[bool]:
-        """
-        * true - The payment requires approval before the funds will be captured using the Approve payment or Capture payment API.
-        * false - The payment does not require approval, and the funds will be captured automatically.
-        
-        Type: bool
-        """
-        return self.__requires_approval
-
-    @requires_approval.setter
-    def requires_approval(self, value: Optional[bool]) -> None:
-        self.__requires_approval = value
-
-    @property
-    def token(self) -> Optional[str]:
-        """
-        | ID of the token that holds previously stored SEPA Direct Debit account and mandate data. Only relevant for legacy SEPA Direct Debit.
-        
-        Type: str
-        """
-        return self.__token
-
-    @token.setter
-    def token(self, value: Optional[str]) -> None:
-        self.__token = value
-
-    @property
-    def tokenize(self) -> Optional[bool]:
-        """
-        | Indicates if this transaction should be tokenized. Only relevant for legacy SEPA Direct Debit.
-        
-        * true - Tokenize the transaction
-        * false - Do not tokenize the transaction, unless it would be tokenized by other means such as auto-tokenization of recurring payments.
-        
-        Type: bool
-        """
-        return self.__tokenize
-
-    @tokenize.setter
-    def tokenize(self, value: Optional[bool]) -> None:
-        self.__tokenize = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(SepaDirectDebitPaymentMethodSpecificInput, self).to_dictionary()
-        if self.date_collect is not None:
-            dictionary['dateCollect'] = self.date_collect
-        if self.direct_debit_text is not None:
-            dictionary['directDebitText'] = self.direct_debit_text
-        if self.is_recurring is not None:
-            dictionary['isRecurring'] = self.is_recurring
-        if self.payment_product771_specific_input is not None:
-            dictionary['paymentProduct771SpecificInput'] = self.payment_product771_specific_input.to_dictionary()
-        if self.recurring_payment_sequence_indicator is not None:
-            dictionary['recurringPaymentSequenceIndicator'] = self.recurring_payment_sequence_indicator
-        if self.requires_approval is not None:
-            dictionary['requiresApproval'] = self.requires_approval
-        if self.token is not None:
-            dictionary['token'] = self.token
-        if self.tokenize is not None:
-            dictionary['tokenize'] = self.tokenize
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'SepaDirectDebitPaymentMethodSpecificInput':
-        super(SepaDirectDebitPaymentMethodSpecificInput, self).from_dictionary(dictionary)
-        if 'dateCollect' in dictionary:
-            self.date_collect = dictionary['dateCollect']
-        if 'directDebitText' in dictionary:
-            self.direct_debit_text = dictionary['directDebitText']
-        if 'isRecurring' in dictionary:
-            self.is_recurring = dictionary['isRecurring']
-        if 'paymentProduct771SpecificInput' in dictionary:
-            if not isinstance(dictionary['paymentProduct771SpecificInput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct771SpecificInput']))
-            value = SepaDirectDebitPaymentProduct771SpecificInput()
-            self.payment_product771_specific_input = value.from_dictionary(dictionary['paymentProduct771SpecificInput'])
-        if 'recurringPaymentSequenceIndicator' in dictionary:
-            self.recurring_payment_sequence_indicator = dictionary['recurringPaymentSequenceIndicator']
-        if 'requiresApproval' in dictionary:
-            self.requires_approval = dictionary['requiresApproval']
-        if 'token' in dictionary:
-            self.token = dictionary['token']
-        if 'tokenize' in dictionary:
-            self.tokenize = dictionary['tokenize']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/sepa_direct_debit_payment_method_specific_input_base.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_sepa_direct_debit_payment_method_specific_input import AbstractSepaDirectDebitPaymentMethodSpecificInput
-from worldline.connect.sdk.v1.domain.sepa_direct_debit_payment_product771_specific_input_base import SepaDirectDebitPaymentProduct771SpecificInputBase
-
-
-class SepaDirectDebitPaymentMethodSpecificInputBase(AbstractSepaDirectDebitPaymentMethodSpecificInput):
-
-    __payment_product771_specific_input: Optional[SepaDirectDebitPaymentProduct771SpecificInputBase] = None
-
-    @property
-    def payment_product771_specific_input(self) -> Optional[SepaDirectDebitPaymentProduct771SpecificInputBase]:
-        """
-        | Object containing information specific to SEPA Direct Debit
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.sepa_direct_debit_payment_product771_specific_input_base.SepaDirectDebitPaymentProduct771SpecificInputBase`
-        """
-        return self.__payment_product771_specific_input
-
-    @payment_product771_specific_input.setter
-    def payment_product771_specific_input(self, value: Optional[SepaDirectDebitPaymentProduct771SpecificInputBase]) -> None:
-        self.__payment_product771_specific_input = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(SepaDirectDebitPaymentMethodSpecificInputBase, self).to_dictionary()
-        if self.payment_product771_specific_input is not None:
-            dictionary['paymentProduct771SpecificInput'] = self.payment_product771_specific_input.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'SepaDirectDebitPaymentMethodSpecificInputBase':
-        super(SepaDirectDebitPaymentMethodSpecificInputBase, self).from_dictionary(dictionary)
-        if 'paymentProduct771SpecificInput' in dictionary:
-            if not isinstance(dictionary['paymentProduct771SpecificInput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct771SpecificInput']))
-            value = SepaDirectDebitPaymentProduct771SpecificInputBase()
-            self.payment_product771_specific_input = value.from_dictionary(dictionary['paymentProduct771SpecificInput'])
-        return self

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

@@ -1,82 +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
-from worldline.connect.sdk.v1.domain.payment_product771_specific_output import PaymentProduct771SpecificOutput
-
-
-class SepaDirectDebitPaymentMethodSpecificOutput(AbstractPaymentMethodSpecificOutput):
-
-    __fraud_results: Optional[FraudResults] = None
-    __payment_product771_specific_output: Optional[PaymentProduct771SpecificOutput] = None
-    __token: Optional[str] = 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
-
-    @property
-    def payment_product771_specific_output(self) -> Optional[PaymentProduct771SpecificOutput]:
-        """
-        | Output that is SEPA Direct Debit specific (i.e. the used mandate)
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_product771_specific_output.PaymentProduct771SpecificOutput`
-        """
-        return self.__payment_product771_specific_output
-
-    @payment_product771_specific_output.setter
-    def payment_product771_specific_output(self, value: Optional[PaymentProduct771SpecificOutput]) -> None:
-        self.__payment_product771_specific_output = value
-
-    @property
-    def token(self) -> Optional[str]:
-        """
-        | ID of the token. This property is populated for the GlobalCollect payment platform when the payment was done with a token or when the payment was tokenized.
-        
-        Type: str
-        """
-        return self.__token
-
-    @token.setter
-    def token(self, value: Optional[str]) -> None:
-        self.__token = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(SepaDirectDebitPaymentMethodSpecificOutput, self).to_dictionary()
-        if self.fraud_results is not None:
-            dictionary['fraudResults'] = self.fraud_results.to_dictionary()
-        if self.payment_product771_specific_output is not None:
-            dictionary['paymentProduct771SpecificOutput'] = self.payment_product771_specific_output.to_dictionary()
-        if self.token is not None:
-            dictionary['token'] = self.token
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'SepaDirectDebitPaymentMethodSpecificOutput':
-        super(SepaDirectDebitPaymentMethodSpecificOutput, 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'])
-        if 'paymentProduct771SpecificOutput' in dictionary:
-            if not isinstance(dictionary['paymentProduct771SpecificOutput'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct771SpecificOutput']))
-            value = PaymentProduct771SpecificOutput()
-            self.payment_product771_specific_output = value.from_dictionary(dictionary['paymentProduct771SpecificOutput'])
-        if 'token' in dictionary:
-            self.token = dictionary['token']
-        return self

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

@@ -1,63 +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_sepa_direct_debit_payment_product771_specific_input import AbstractSepaDirectDebitPaymentProduct771SpecificInput
-from worldline.connect.sdk.v1.domain.create_mandate_with_return_url import CreateMandateWithReturnUrl
-
-
-class SepaDirectDebitPaymentProduct771SpecificInput(AbstractSepaDirectDebitPaymentProduct771SpecificInput):
-    """
-    | Object containing information specific to SEPA Direct Debit for Create Payments.
-    """
-
-    __existing_unique_mandate_reference: Optional[str] = None
-    __mandate: Optional[CreateMandateWithReturnUrl] = None
-
-    @property
-    def existing_unique_mandate_reference(self) -> Optional[str]:
-        """
-        | The unique reference of the existing mandate to use in this payment.
-        
-        Type: str
-        """
-        return self.__existing_unique_mandate_reference
-
-    @existing_unique_mandate_reference.setter
-    def existing_unique_mandate_reference(self, value: Optional[str]) -> None:
-        self.__existing_unique_mandate_reference = value
-
-    @property
-    def mandate(self) -> Optional[CreateMandateWithReturnUrl]:
-        """
-        | Object containing information to create a SEPA Direct Debit mandate.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.create_mandate_with_return_url.CreateMandateWithReturnUrl`
-        """
-        return self.__mandate
-
-    @mandate.setter
-    def mandate(self, value: Optional[CreateMandateWithReturnUrl]) -> None:
-        self.__mandate = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(SepaDirectDebitPaymentProduct771SpecificInput, self).to_dictionary()
-        if self.existing_unique_mandate_reference is not None:
-            dictionary['existingUniqueMandateReference'] = self.existing_unique_mandate_reference
-        if self.mandate is not None:
-            dictionary['mandate'] = self.mandate.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'SepaDirectDebitPaymentProduct771SpecificInput':
-        super(SepaDirectDebitPaymentProduct771SpecificInput, self).from_dictionary(dictionary)
-        if 'existingUniqueMandateReference' in dictionary:
-            self.existing_unique_mandate_reference = dictionary['existingUniqueMandateReference']
-        if 'mandate' in dictionary:
-            if not isinstance(dictionary['mandate'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mandate']))
-            value = CreateMandateWithReturnUrl()
-            self.mandate = value.from_dictionary(dictionary['mandate'])
-        return self

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

@@ -1,63 +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_sepa_direct_debit_payment_product771_specific_input import AbstractSepaDirectDebitPaymentProduct771SpecificInput
-from worldline.connect.sdk.v1.domain.create_mandate_base import CreateMandateBase
-
-
-class SepaDirectDebitPaymentProduct771SpecificInputBase(AbstractSepaDirectDebitPaymentProduct771SpecificInput):
-    """
-    | Object containing information specific to SEPA Direct Debit for Hosted Checkouts.
-    """
-
-    __existing_unique_mandate_reference: Optional[str] = None
-    __mandate: Optional[CreateMandateBase] = None
-
-    @property
-    def existing_unique_mandate_reference(self) -> Optional[str]:
-        """
-        | The unique reference of the existing mandate to use in this payment.
-        
-        Type: str
-        """
-        return self.__existing_unique_mandate_reference
-
-    @existing_unique_mandate_reference.setter
-    def existing_unique_mandate_reference(self, value: Optional[str]) -> None:
-        self.__existing_unique_mandate_reference = value
-
-    @property
-    def mandate(self) -> Optional[CreateMandateBase]:
-        """
-        | Object containing information to create a SEPA Direct Debit mandate.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.create_mandate_base.CreateMandateBase`
-        """
-        return self.__mandate
-
-    @mandate.setter
-    def mandate(self, value: Optional[CreateMandateBase]) -> None:
-        self.__mandate = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(SepaDirectDebitPaymentProduct771SpecificInputBase, self).to_dictionary()
-        if self.existing_unique_mandate_reference is not None:
-            dictionary['existingUniqueMandateReference'] = self.existing_unique_mandate_reference
-        if self.mandate is not None:
-            dictionary['mandate'] = self.mandate.to_dictionary()
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'SepaDirectDebitPaymentProduct771SpecificInputBase':
-        super(SepaDirectDebitPaymentProduct771SpecificInputBase, self).from_dictionary(dictionary)
-        if 'existingUniqueMandateReference' in dictionary:
-            self.existing_unique_mandate_reference = dictionary['existingUniqueMandateReference']
-        if 'mandate' in dictionary:
-            if not isinstance(dictionary['mandate'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mandate']))
-            value = CreateMandateBase()
-            self.mandate = value.from_dictionary(dictionary['mandate'])
-        return self

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

@@ -1,67 +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.payment_product_filters_client_session import PaymentProductFiltersClientSession
-
-
-class SessionRequest(DataObject):
-
-    __payment_product_filters: Optional[PaymentProductFiltersClientSession] = None
-    __tokens: Optional[List[str]] = None
-
-    @property
-    def payment_product_filters(self) -> Optional[PaymentProductFiltersClientSession]:
-        """
-        | Restrict the payment products available for payment completion by restricting to and excluding certain payment products and payment product groups.
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.payment_product_filters_client_session.PaymentProductFiltersClientSession`
-        """
-        return self.__payment_product_filters
-
-    @payment_product_filters.setter
-    def payment_product_filters(self, value: Optional[PaymentProductFiltersClientSession]) -> None:
-        self.__payment_product_filters = value
-
-    @property
-    def tokens(self) -> Optional[List[str]]:
-        """
-        | List of previously stored tokens linked to the customer that wants to checkout.
-        
-        Type: list[str]
-        """
-        return self.__tokens
-
-    @tokens.setter
-    def tokens(self, value: Optional[List[str]]) -> None:
-        self.__tokens = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(SessionRequest, self).to_dictionary()
-        if self.payment_product_filters is not None:
-            dictionary['paymentProductFilters'] = self.payment_product_filters.to_dictionary()
-        if self.tokens is not None:
-            dictionary['tokens'] = []
-            for element in self.tokens:
-                if element is not None:
-                    dictionary['tokens'].append(element)
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'SessionRequest':
-        super(SessionRequest, self).from_dictionary(dictionary)
-        if 'paymentProductFilters' in dictionary:
-            if not isinstance(dictionary['paymentProductFilters'], dict):
-                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProductFilters']))
-            value = PaymentProductFiltersClientSession()
-            self.payment_product_filters = value.from_dictionary(dictionary['paymentProductFilters'])
-        if 'tokens' in dictionary:
-            if not isinstance(dictionary['tokens'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['tokens']))
-            self.tokens = []
-            for element in dictionary['tokens']:
-                self.tokens.append(element)
-        return self

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

@@ -1,149 +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
-
-
-class SessionResponse(DataObject):
-
-    __asset_url: Optional[str] = None
-    __client_api_url: Optional[str] = None
-    __client_session_id: Optional[str] = None
-    __customer_id: Optional[str] = None
-    __invalid_tokens: Optional[List[str]] = None
-    __region: Optional[str] = None
-
-    @property
-    def asset_url(self) -> Optional[str]:
-        """
-        | The datacenter-specific base url for assets. This value needs to be passed to the Client SDK to make sure that the client software connects to the right datacenter.
-        
-        Type: str
-        """
-        return self.__asset_url
-
-    @asset_url.setter
-    def asset_url(self, value: Optional[str]) -> None:
-        self.__asset_url = value
-
-    @property
-    def client_api_url(self) -> Optional[str]:
-        """
-        | The datacenter-specific base url for client requests. This value needs to be passed to the Client SDK to make sure that the client software connects to the right datacenter.
-        
-        Type: str
-        """
-        return self.__client_api_url
-
-    @client_api_url.setter
-    def client_api_url(self, value: Optional[str]) -> None:
-        self.__client_api_url = value
-
-    @property
-    def client_session_id(self) -> Optional[str]:
-        """
-        | The identifier of the session that has been created.
-        
-        Type: str
-        """
-        return self.__client_session_id
-
-    @client_session_id.setter
-    def client_session_id(self, value: Optional[str]) -> None:
-        self.__client_session_id = value
-
-    @property
-    def customer_id(self) -> Optional[str]:
-        """
-        | The session is build up around the customer in the form of the customerId. All of the Client APIs use this customerId in the URI to identify the customer.
-        
-        Type: str
-        """
-        return self.__customer_id
-
-    @customer_id.setter
-    def customer_id(self, value: Optional[str]) -> None:
-        self.__customer_id = value
-
-    @property
-    def invalid_tokens(self) -> Optional[List[str]]:
-        """
-        | Tokens that are submitted in the request are validated. In case any of the tokens can't be used anymore they are returned in this array. You should most likely remove those tokens from your system.
-        
-        Type: list[str]
-        """
-        return self.__invalid_tokens
-
-    @invalid_tokens.setter
-    def invalid_tokens(self, value: Optional[List[str]]) -> None:
-        self.__invalid_tokens = value
-
-    @property
-    def region(self) -> Optional[str]:
-        """
-        | Possible values:
-        
-        * EU - datacenter located in Amsterdam
-        * US - datacenter located in Miami
-        * AMS - datacenter located in Amsterdam
-        * PAR - datacenter located in Paris
-        
-        | When a session is created it is created in a specific datacenter. Any subsequent calls using the Client API need to be datacenter specific. The datacenters are identified by this region value. This value needs to be passed to the Client SDK to make sure that the client software connects to the right datacenter. This only applies if your clients use a version older than the ones listed below:
-        
-        * JavaScript Client SDK v3.6.0
-        * iOS ObjectiveC Client SDK v3.10.0
-        * iOS Swift Client SDK v2.2.0
-        * Android Client SDK v3.10.0
-        
-        | In case of the iOS and Android SDKs the version of the SDK used will be tightly coupled with the versions of your app that is still in active use. You are advised to pass this value to your clients in case you are unsure of the version used in your clients.
-        
-        Type: str
-        """
-        return self.__region
-
-    @region.setter
-    def region(self, value: Optional[str]) -> None:
-        self.__region = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(SessionResponse, self).to_dictionary()
-        if self.asset_url is not None:
-            dictionary['assetUrl'] = self.asset_url
-        if self.client_api_url is not None:
-            dictionary['clientApiUrl'] = self.client_api_url
-        if self.client_session_id is not None:
-            dictionary['clientSessionId'] = self.client_session_id
-        if self.customer_id is not None:
-            dictionary['customerId'] = self.customer_id
-        if self.invalid_tokens is not None:
-            dictionary['invalidTokens'] = []
-            for element in self.invalid_tokens:
-                if element is not None:
-                    dictionary['invalidTokens'].append(element)
-        if self.region is not None:
-            dictionary['region'] = self.region
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'SessionResponse':
-        super(SessionResponse, self).from_dictionary(dictionary)
-        if 'assetUrl' in dictionary:
-            self.asset_url = dictionary['assetUrl']
-        if 'clientApiUrl' in dictionary:
-            self.client_api_url = dictionary['clientApiUrl']
-        if 'clientSessionId' in dictionary:
-            self.client_session_id = dictionary['clientSessionId']
-        if 'customerId' in dictionary:
-            self.customer_id = dictionary['customerId']
-        if 'invalidTokens' in dictionary:
-            if not isinstance(dictionary['invalidTokens'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['invalidTokens']))
-            self.invalid_tokens = []
-            for element in dictionary['invalidTokens']:
-                self.invalid_tokens.append(element)
-        if 'region' in dictionary:
-            self.region = dictionary['region']
-        return self