connect-sdk-python3 4.0.0__zip → 4.0.1__zip

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/third_party_data.py

@@ -0,0 +1,42 @@
+# -*- 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.payment_product863_third_party_data import PaymentProduct863ThirdPartyData
+
+
+class ThirdPartyData(DataObject):
+
+    __payment_product863: Optional[PaymentProduct863ThirdPartyData] = None
+
+    @property
+    def payment_product863(self) -> Optional[PaymentProduct863ThirdPartyData]:
+        """
+        | Contains the third party data for payment product 863 (WeChat Pay).
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_product863_third_party_data.PaymentProduct863ThirdPartyData`
+        """
+        return self.__payment_product863
+
+    @payment_product863.setter
+    def payment_product863(self, value: Optional[PaymentProduct863ThirdPartyData]) -> None:
+        self.__payment_product863 = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ThirdPartyData, self).to_dictionary()
+        if self.payment_product863 is not None:
+            dictionary['paymentProduct863'] = self.payment_product863.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ThirdPartyData':
+        super(ThirdPartyData, self).from_dictionary(dictionary)
+        if 'paymentProduct863' in dictionary:
+            if not isinstance(dictionary['paymentProduct863'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct863']))
+            value = PaymentProduct863ThirdPartyData()
+            self.payment_product863 = value.from_dictionary(dictionary['paymentProduct863'])
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/third_party_status_response.py

@@ -0,0 +1,43 @@
+# -*- 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 ThirdPartyStatusResponse(DataObject):
+
+    __third_party_status: Optional[str] = None
+
+    @property
+    def third_party_status(self) -> Optional[str]:
+        """
+        | The status returned by the third party.Possible values:
+        
+        * WAITING - The customer has not connected to the third party
+        * INITIALIZED - Authentication in progress
+        * AUTHORIZED - Payment in progress
+        * COMPLETED - The customer has completed the payment at the third party
+
+        Type: str
+        """
+        return self.__third_party_status
+
+    @third_party_status.setter
+    def third_party_status(self, value: Optional[str]) -> None:
+        self.__third_party_status = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ThirdPartyStatusResponse, self).to_dictionary()
+        if self.third_party_status is not None:
+            dictionary['thirdPartyStatus'] = self.third_party_status
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ThirdPartyStatusResponse':
+        super(ThirdPartyStatusResponse, self).from_dictionary(dictionary)
+        if 'thirdPartyStatus' in dictionary:
+            self.third_party_status = dictionary['thirdPartyStatus']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/three_d_secure.py

@@ -0,0 +1,67 @@
+# -*- 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_three_d_secure import AbstractThreeDSecure
+from worldline.connect.sdk.v1.domain.external_cardholder_authentication_data import ExternalCardholderAuthenticationData
+from worldline.connect.sdk.v1.domain.redirection_data import RedirectionData
+
+
+class ThreeDSecure(AbstractThreeDSecure):
+    """
+    | Object containing specific data regarding 3-D Secure
+    """
+
+    __external_cardholder_authentication_data: Optional[ExternalCardholderAuthenticationData] = None
+    __redirection_data: Optional[RedirectionData] = None
+
+    @property
+    def external_cardholder_authentication_data(self) -> Optional[ExternalCardholderAuthenticationData]:
+        """
+        | Object containing 3D secure details.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.external_cardholder_authentication_data.ExternalCardholderAuthenticationData`
+        """
+        return self.__external_cardholder_authentication_data
+
+    @external_cardholder_authentication_data.setter
+    def external_cardholder_authentication_data(self, value: Optional[ExternalCardholderAuthenticationData]) -> None:
+        self.__external_cardholder_authentication_data = value
+
+    @property
+    def redirection_data(self) -> Optional[RedirectionData]:
+        """
+        | Object containing browser specific redirection related data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.redirection_data.RedirectionData`
+        """
+        return self.__redirection_data
+
+    @redirection_data.setter
+    def redirection_data(self, value: Optional[RedirectionData]) -> None:
+        self.__redirection_data = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ThreeDSecure, self).to_dictionary()
+        if self.external_cardholder_authentication_data is not None:
+            dictionary['externalCardholderAuthenticationData'] = self.external_cardholder_authentication_data.to_dictionary()
+        if self.redirection_data is not None:
+            dictionary['redirectionData'] = self.redirection_data.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ThreeDSecure':
+        super(ThreeDSecure, self).from_dictionary(dictionary)
+        if 'externalCardholderAuthenticationData' in dictionary:
+            if not isinstance(dictionary['externalCardholderAuthenticationData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['externalCardholderAuthenticationData']))
+            value = ExternalCardholderAuthenticationData()
+            self.external_cardholder_authentication_data = value.from_dictionary(dictionary['externalCardholderAuthenticationData'])
+        if 'redirectionData' in dictionary:
+            if not isinstance(dictionary['redirectionData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectionData']))
+            value = RedirectionData()
+            self.redirection_data = value.from_dictionary(dictionary['redirectionData'])
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/three_d_secure_data.py

@@ -0,0 +1,82 @@
+# -*- 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 ThreeDSecureData(DataObject):
+    """
+    | Object containing data regarding the 3D Secure authentication
+    """
+
+    __acs_transaction_id: Optional[str] = None
+    __method: Optional[str] = None
+    __utc_timestamp: Optional[str] = None
+
+    @property
+    def acs_transaction_id(self) -> Optional[str]:
+        """
+        | The ACS Transaction ID for a prior 3-D Secure authenticated transaction (for example, the first recurring transaction that was authenticated with the customer)
+
+        Type: str
+        """
+        return self.__acs_transaction_id
+
+    @acs_transaction_id.setter
+    def acs_transaction_id(self, value: Optional[str]) -> None:
+        self.__acs_transaction_id = value
+
+    @property
+    def method(self) -> Optional[str]:
+        """
+        | Method of authentication used for this transaction.Possible values:
+        
+        * frictionless = The authentication went without a challenge
+        * challenged = Cardholder was challenged
+        * avs-verified = The authentication was verified by AVS
+        * other = Another issuer method was used to authenticate this transaction
+
+        Type: str
+        """
+        return self.__method
+
+    @method.setter
+    def method(self, value: Optional[str]) -> None:
+        self.__method = value
+
+    @property
+    def utc_timestamp(self) -> Optional[str]:
+        """
+        | Timestamp in UTC (YYYYMMDDHHmm) of the 3-D Secure authentication of this transaction
+
+        Type: str
+        """
+        return self.__utc_timestamp
+
+    @utc_timestamp.setter
+    def utc_timestamp(self, value: Optional[str]) -> None:
+        self.__utc_timestamp = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ThreeDSecureData, self).to_dictionary()
+        if self.acs_transaction_id is not None:
+            dictionary['acsTransactionId'] = self.acs_transaction_id
+        if self.method is not None:
+            dictionary['method'] = self.method
+        if self.utc_timestamp is not None:
+            dictionary['utcTimestamp'] = self.utc_timestamp
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ThreeDSecureData':
+        super(ThreeDSecureData, self).from_dictionary(dictionary)
+        if 'acsTransactionId' in dictionary:
+            self.acs_transaction_id = dictionary['acsTransactionId']
+        if 'method' in dictionary:
+            self.method = dictionary['method']
+        if 'utcTimestamp' in dictionary:
+            self.utc_timestamp = dictionary['utcTimestamp']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/three_d_secure_results.py

@@ -0,0 +1,275 @@
+# -*- 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
+from worldline.connect.sdk.v1.domain.exemption_output import ExemptionOutput
+from worldline.connect.sdk.v1.domain.sdk_data_output import SdkDataOutput
+from worldline.connect.sdk.v1.domain.three_d_secure_data import ThreeDSecureData
+
+
+class ThreeDSecureResults(DataObject):
+    """
+    | Object containing the 3-D Secure specific results
+    """
+
+    __acs_transaction_id: Optional[str] = None
+    __applied_exemption: Optional[str] = None
+    __authentication_amount: Optional[AmountOfMoney] = None
+    __cavv: Optional[str] = None
+    __directory_server_transaction_id: Optional[str] = None
+    __eci: Optional[str] = None
+    __exemption_output: Optional[ExemptionOutput] = None
+    __scheme_risk_score: Optional[int] = None
+    __sdk_data: Optional[SdkDataOutput] = None
+    __three_d_secure_data: Optional[ThreeDSecureData] = None
+    __three_d_secure_version: Optional[str] = None
+    __three_d_server_transaction_id: Optional[str] = None
+    __xid: Optional[str] = None
+
+    @property
+    def acs_transaction_id(self) -> Optional[str]:
+        """
+        | Identifier of the authenticated transaction at the ACS/Issuer
+
+        Type: str
+        """
+        return self.__acs_transaction_id
+
+    @acs_transaction_id.setter
+    def acs_transaction_id(self, value: Optional[str]) -> None:
+        self.__acs_transaction_id = value
+
+    @property
+    def applied_exemption(self) -> Optional[str]:
+        """
+        | Exemption code from Carte Bancaire (130) (unknown possible values so far -free format)
+
+        Type: str
+        """
+        return self.__applied_exemption
+
+    @applied_exemption.setter
+    def applied_exemption(self, value: Optional[str]) -> None:
+        self.__applied_exemption = value
+
+    @property
+    def authentication_amount(self) -> Optional[AmountOfMoney]:
+        """
+        | The amount for which this transaction has been authenticated.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__authentication_amount
+
+    @authentication_amount.setter
+    def authentication_amount(self, value: Optional[AmountOfMoney]) -> None:
+        self.__authentication_amount = value
+
+    @property
+    def cavv(self) -> Optional[str]:
+        """
+        | CAVV or AVV result indicating authentication validation value
+
+        Type: str
+        """
+        return self.__cavv
+
+    @cavv.setter
+    def cavv(self, value: Optional[str]) -> None:
+        self.__cavv = value
+
+    @property
+    def directory_server_transaction_id(self) -> Optional[str]:
+        """
+        | The 3-D Secure Directory Server transaction ID that is used for the 3D Authentication
+
+        Type: str
+        """
+        return self.__directory_server_transaction_id
+
+    @directory_server_transaction_id.setter
+    def directory_server_transaction_id(self, value: Optional[str]) -> None:
+        self.__directory_server_transaction_id = value
+
+    @property
+    def eci(self) -> Optional[str]:
+        """
+        | Indicates Authentication validation results returned after AuthenticationValidation
+
+        Type: str
+        """
+        return self.__eci
+
+    @eci.setter
+    def eci(self, value: Optional[str]) -> None:
+        self.__eci = value
+
+    @property
+    def exemption_output(self) -> Optional[ExemptionOutput]:
+        """
+        | Object containing exemption output
+
+        Type: :class:`worldline.connect.sdk.v1.domain.exemption_output.ExemptionOutput`
+        """
+        return self.__exemption_output
+
+    @exemption_output.setter
+    def exemption_output(self, value: Optional[ExemptionOutput]) -> None:
+        self.__exemption_output = value
+
+    @property
+    def scheme_risk_score(self) -> Optional[int]:
+        """
+        | Global score calculated by the Carte Bancaire (130) Scoring platform. Possible values from 0 to 99
+
+        Type: int
+        """
+        return self.__scheme_risk_score
+
+    @scheme_risk_score.setter
+    def scheme_risk_score(self, value: Optional[int]) -> None:
+        self.__scheme_risk_score = value
+
+    @property
+    def sdk_data(self) -> Optional[SdkDataOutput]:
+        """
+        | Object containing 3-D Secure in-app SDK data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.sdk_data_output.SdkDataOutput`
+        """
+        return self.__sdk_data
+
+    @sdk_data.setter
+    def sdk_data(self, value: Optional[SdkDataOutput]) -> None:
+        self.__sdk_data = value
+
+    @property
+    def three_d_secure_data(self) -> Optional[ThreeDSecureData]:
+        """
+        | Object containing data regarding the 3-D Secure authentication
+
+        Type: :class:`worldline.connect.sdk.v1.domain.three_d_secure_data.ThreeDSecureData`
+        """
+        return self.__three_d_secure_data
+
+    @three_d_secure_data.setter
+    def three_d_secure_data(self, value: Optional[ThreeDSecureData]) -> None:
+        self.__three_d_secure_data = value
+
+    @property
+    def three_d_secure_version(self) -> Optional[str]:
+        """
+        | The 3-D Secure version used for the authentication.
+        
+        | This property is used in the communication with the acquirer
+
+        Type: str
+        """
+        return self.__three_d_secure_version
+
+    @three_d_secure_version.setter
+    def three_d_secure_version(self, value: Optional[str]) -> None:
+        self.__three_d_secure_version = value
+
+    @property
+    def three_d_server_transaction_id(self) -> Optional[str]:
+        """
+        | The 3-D Secure Server transaction ID that is used for the 3-D Secure version 2 Authentication.
+
+        Type: str
+        """
+        return self.__three_d_server_transaction_id
+
+    @three_d_server_transaction_id.setter
+    def three_d_server_transaction_id(self, value: Optional[str]) -> None:
+        self.__three_d_server_transaction_id = value
+
+    @property
+    def xid(self) -> Optional[str]:
+        """
+        | Transaction ID for the Authentication
+
+        Type: str
+        """
+        return self.__xid
+
+    @xid.setter
+    def xid(self, value: Optional[str]) -> None:
+        self.__xid = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ThreeDSecureResults, self).to_dictionary()
+        if self.acs_transaction_id is not None:
+            dictionary['acsTransactionId'] = self.acs_transaction_id
+        if self.applied_exemption is not None:
+            dictionary['appliedExemption'] = self.applied_exemption
+        if self.authentication_amount is not None:
+            dictionary['authenticationAmount'] = self.authentication_amount.to_dictionary()
+        if self.cavv is not None:
+            dictionary['cavv'] = self.cavv
+        if self.directory_server_transaction_id is not None:
+            dictionary['directoryServerTransactionId'] = self.directory_server_transaction_id
+        if self.eci is not None:
+            dictionary['eci'] = self.eci
+        if self.exemption_output is not None:
+            dictionary['exemptionOutput'] = self.exemption_output.to_dictionary()
+        if self.scheme_risk_score is not None:
+            dictionary['schemeRiskScore'] = self.scheme_risk_score
+        if self.sdk_data is not None:
+            dictionary['sdkData'] = self.sdk_data.to_dictionary()
+        if self.three_d_secure_data is not None:
+            dictionary['threeDSecureData'] = self.three_d_secure_data.to_dictionary()
+        if self.three_d_secure_version is not None:
+            dictionary['threeDSecureVersion'] = self.three_d_secure_version
+        if self.three_d_server_transaction_id is not None:
+            dictionary['threeDServerTransactionId'] = self.three_d_server_transaction_id
+        if self.xid is not None:
+            dictionary['xid'] = self.xid
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ThreeDSecureResults':
+        super(ThreeDSecureResults, self).from_dictionary(dictionary)
+        if 'acsTransactionId' in dictionary:
+            self.acs_transaction_id = dictionary['acsTransactionId']
+        if 'appliedExemption' in dictionary:
+            self.applied_exemption = dictionary['appliedExemption']
+        if 'authenticationAmount' in dictionary:
+            if not isinstance(dictionary['authenticationAmount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['authenticationAmount']))
+            value = AmountOfMoney()
+            self.authentication_amount = value.from_dictionary(dictionary['authenticationAmount'])
+        if 'cavv' in dictionary:
+            self.cavv = dictionary['cavv']
+        if 'directoryServerTransactionId' in dictionary:
+            self.directory_server_transaction_id = dictionary['directoryServerTransactionId']
+        if 'eci' in dictionary:
+            self.eci = dictionary['eci']
+        if 'exemptionOutput' in dictionary:
+            if not isinstance(dictionary['exemptionOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['exemptionOutput']))
+            value = ExemptionOutput()
+            self.exemption_output = value.from_dictionary(dictionary['exemptionOutput'])
+        if 'schemeRiskScore' in dictionary:
+            self.scheme_risk_score = dictionary['schemeRiskScore']
+        if 'sdkData' in dictionary:
+            if not isinstance(dictionary['sdkData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sdkData']))
+            value = SdkDataOutput()
+            self.sdk_data = value.from_dictionary(dictionary['sdkData'])
+        if 'threeDSecureData' in dictionary:
+            if not isinstance(dictionary['threeDSecureData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['threeDSecureData']))
+            value = ThreeDSecureData()
+            self.three_d_secure_data = value.from_dictionary(dictionary['threeDSecureData'])
+        if 'threeDSecureVersion' in dictionary:
+            self.three_d_secure_version = dictionary['threeDSecureVersion']
+        if 'threeDServerTransactionId' in dictionary:
+            self.three_d_server_transaction_id = dictionary['threeDServerTransactionId']
+        if 'xid' in dictionary:
+            self.xid = dictionary['xid']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/token_card.py

@@ -0,0 +1,64 @@
+# -*- 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_token import AbstractToken
+from worldline.connect.sdk.v1.domain.customer_token import CustomerToken
+from worldline.connect.sdk.v1.domain.token_card_data import TokenCardData
+
+
+class TokenCard(AbstractToken):
+
+    __customer: Optional[CustomerToken] = None
+    __data: Optional[TokenCardData] = None
+
+    @property
+    def customer(self) -> Optional[CustomerToken]:
+        """
+        | Object containing the details of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.customer_token.CustomerToken`
+        """
+        return self.__customer
+
+    @customer.setter
+    def customer(self, value: Optional[CustomerToken]) -> None:
+        self.__customer = value
+
+    @property
+    def data(self) -> Optional[TokenCardData]:
+        """
+        | Object containing the card tokenizable details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.token_card_data.TokenCardData`
+        """
+        return self.__data
+
+    @data.setter
+    def data(self, value: Optional[TokenCardData]) -> None:
+        self.__data = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(TokenCard, self).to_dictionary()
+        if self.customer is not None:
+            dictionary['customer'] = self.customer.to_dictionary()
+        if self.data is not None:
+            dictionary['data'] = self.data.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'TokenCard':
+        super(TokenCard, self).from_dictionary(dictionary)
+        if 'customer' in dictionary:
+            if not isinstance(dictionary['customer'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customer']))
+            value = CustomerToken()
+            self.customer = value.from_dictionary(dictionary['customer'])
+        if 'data' in dictionary:
+            if not isinstance(dictionary['data'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['data']))
+            value = TokenCardData()
+            self.data = value.from_dictionary(dictionary['data'])
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/token_card_data.py

@@ -0,0 +1,79 @@
+# -*- 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.card_without_cvv import CardWithoutCvv
+
+
+class TokenCardData(DataObject):
+
+    __card_without_cvv: Optional[CardWithoutCvv] = None
+    __first_transaction_date: Optional[str] = None
+    __provider_reference: Optional[str] = None
+
+    @property
+    def card_without_cvv(self) -> Optional[CardWithoutCvv]:
+        """
+        | Object containing the card details (without CVV)
+
+        Type: :class:`worldline.connect.sdk.v1.domain.card_without_cvv.CardWithoutCvv`
+        """
+        return self.__card_without_cvv
+
+    @card_without_cvv.setter
+    def card_without_cvv(self, value: Optional[CardWithoutCvv]) -> None:
+        self.__card_without_cvv = value
+
+    @property
+    def first_transaction_date(self) -> Optional[str]:
+        """
+        | Date of the first transaction (for ATOS)
+        | Format: YYYYMMDD
+
+        Type: str
+        """
+        return self.__first_transaction_date
+
+    @first_transaction_date.setter
+    def first_transaction_date(self, value: Optional[str]) -> None:
+        self.__first_transaction_date = value
+
+    @property
+    def provider_reference(self) -> Optional[str]:
+        """
+        | Reference of the provider (of the first transaction) - used to store the ATOS Transaction Certificate
+
+        Type: str
+        """
+        return self.__provider_reference
+
+    @provider_reference.setter
+    def provider_reference(self, value: Optional[str]) -> None:
+        self.__provider_reference = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(TokenCardData, self).to_dictionary()
+        if self.card_without_cvv is not None:
+            dictionary['cardWithoutCvv'] = self.card_without_cvv.to_dictionary()
+        if self.first_transaction_date is not None:
+            dictionary['firstTransactionDate'] = self.first_transaction_date
+        if self.provider_reference is not None:
+            dictionary['providerReference'] = self.provider_reference
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'TokenCardData':
+        super(TokenCardData, self).from_dictionary(dictionary)
+        if 'cardWithoutCvv' in dictionary:
+            if not isinstance(dictionary['cardWithoutCvv'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardWithoutCvv']))
+            value = CardWithoutCvv()
+            self.card_without_cvv = value.from_dictionary(dictionary['cardWithoutCvv'])
+        if 'firstTransactionDate' in dictionary:
+            self.first_transaction_date = dictionary['firstTransactionDate']
+        if 'providerReference' in dictionary:
+            self.provider_reference = dictionary['providerReference']
+        return self