connect-sdk-python2 3.47.0__zip → 4.0.1__zip

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/mandate_sepa_direct_debit_with_mandate_id.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.mandate_sepa_direct_debit_without_creditor import MandateSepaDirectDebitWithoutCreditor
+
+
+class MandateSepaDirectDebitWithMandateId(MandateSepaDirectDebitWithoutCreditor):
+
+    __mandate_id = None
+
+    @property
+    def mandate_id(self):
+        """
+        | Unique mandate identifier
+
+        Type: str
+        """
+        return self.__mandate_id
+
+    @mandate_id.setter
+    def mandate_id(self, value):
+        self.__mandate_id = value
+
+    def to_dictionary(self):
+        dictionary = super(MandateSepaDirectDebitWithMandateId, self).to_dictionary()
+        if self.mandate_id is not None:
+            dictionary['mandateId'] = self.mandate_id
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(MandateSepaDirectDebitWithMandateId, self).from_dictionary(dictionary)
+        if 'mandateId' in dictionary:
+            self.mandate_id = dictionary['mandateId']
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/mandate_sepa_direct_debit_without_creditor.py

@@ -0,0 +1,142 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.bank_account_iban import BankAccountIban
+from worldline.connect.sdk.v1.domain.debtor import Debtor
+from worldline.connect.sdk.v1.domain.mandate_approval import MandateApproval
+
+
+class MandateSepaDirectDebitWithoutCreditor(DataObject):
+
+    __bank_account_iban = None
+    __customer_contract_identifier = None
+    __debtor = None
+    __is_recurring = None
+    __mandate_approval = None
+    __pre_notification = None
+
+    @property
+    def bank_account_iban(self):
+        """
+        | Object containing Account holder and IBAN information
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_iban.BankAccountIban`
+        """
+        return self.__bank_account_iban
+
+    @bank_account_iban.setter
+    def bank_account_iban(self, value):
+        self.__bank_account_iban = value
+
+    @property
+    def customer_contract_identifier(self):
+        """
+        | Identifies the contract between customer and merchant
+
+        Type: str
+        """
+        return self.__customer_contract_identifier
+
+    @customer_contract_identifier.setter
+    def customer_contract_identifier(self, value):
+        self.__customer_contract_identifier = value
+
+    @property
+    def debtor(self):
+        """
+        | Object containing information on the debtor
+
+        Type: :class:`worldline.connect.sdk.v1.domain.debtor.Debtor`
+        """
+        return self.__debtor
+
+    @debtor.setter
+    def debtor(self, value):
+        self.__debtor = value
+
+    @property
+    def is_recurring(self):
+        """
+        * true
+        * false
+
+        Type: bool
+        """
+        return self.__is_recurring
+
+    @is_recurring.setter
+    def is_recurring(self, value):
+        self.__is_recurring = value
+
+    @property
+    def mandate_approval(self):
+        """
+        | Object containing the details of the mandate approval
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mandate_approval.MandateApproval`
+        """
+        return self.__mandate_approval
+
+    @mandate_approval.setter
+    def mandate_approval(self, value):
+        self.__mandate_approval = value
+
+    @property
+    def pre_notification(self):
+        """
+        | Indicates whether a pre-notification should be sent to the customer.
+        
+        * do-not-send - Do not send a pre-notification
+        * send-on-first-collection - Send a pre-notification
+
+        Type: str
+        """
+        return self.__pre_notification
+
+    @pre_notification.setter
+    def pre_notification(self, value):
+        self.__pre_notification = value
+
+    def to_dictionary(self):
+        dictionary = super(MandateSepaDirectDebitWithoutCreditor, self).to_dictionary()
+        if self.bank_account_iban is not None:
+            dictionary['bankAccountIban'] = self.bank_account_iban.to_dictionary()
+        if self.customer_contract_identifier is not None:
+            dictionary['customerContractIdentifier'] = self.customer_contract_identifier
+        if self.debtor is not None:
+            dictionary['debtor'] = self.debtor.to_dictionary()
+        if self.is_recurring is not None:
+            dictionary['isRecurring'] = self.is_recurring
+        if self.mandate_approval is not None:
+            dictionary['mandateApproval'] = self.mandate_approval.to_dictionary()
+        if self.pre_notification is not None:
+            dictionary['preNotification'] = self.pre_notification
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(MandateSepaDirectDebitWithoutCreditor, self).from_dictionary(dictionary)
+        if 'bankAccountIban' in dictionary:
+            if not isinstance(dictionary['bankAccountIban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountIban']))
+            value = BankAccountIban()
+            self.bank_account_iban = value.from_dictionary(dictionary['bankAccountIban'])
+        if 'customerContractIdentifier' in dictionary:
+            self.customer_contract_identifier = dictionary['customerContractIdentifier']
+        if 'debtor' in dictionary:
+            if not isinstance(dictionary['debtor'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['debtor']))
+            value = Debtor()
+            self.debtor = value.from_dictionary(dictionary['debtor'])
+        if 'isRecurring' in dictionary:
+            self.is_recurring = dictionary['isRecurring']
+        if 'mandateApproval' in dictionary:
+            if not isinstance(dictionary['mandateApproval'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mandateApproval']))
+            value = MandateApproval()
+            self.mandate_approval = value.from_dictionary(dictionary['mandateApproval'])
+        if 'preNotification' in dictionary:
+            self.pre_notification = dictionary['preNotification']
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/merchant.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.seller import Seller
+
+
+class Merchant(DataObject):
+
+    __configuration_id = None
+    __contact_website_url = None
+    __seller = None
+    __website_url = None
+
+    @property
+    def configuration_id(self):
+        """
+        | In case your account has been setup with multiple configurations you can use this property to identify the one you would like to use for the transaction. Note that you can only submit preconfigured values in combination with the Worldline Online Payments Acceptance platform. In case no value is supplied a default value of 0 will be submitted to the Worldline Online Payments Acceptance platform. The Worldline Online Payments Acceptance platform internally refers to this as a PosId.
+
+        Type: str
+        """
+        return self.__configuration_id
+
+    @configuration_id.setter
+    def configuration_id(self, value):
+        self.__configuration_id = value
+
+    @property
+    def contact_website_url(self):
+        """
+        | URL to find contact or support details to contact in case of questions.
+
+        Type: str
+        """
+        return self.__contact_website_url
+
+    @contact_website_url.setter
+    def contact_website_url(self, value):
+        self.__contact_website_url = value
+
+    @property
+    def seller(self):
+        """
+        | Object containing seller details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.seller.Seller`
+        """
+        return self.__seller
+
+    @seller.setter
+    def seller(self, value):
+        self.__seller = value
+
+    @property
+    def website_url(self):
+        """
+        | The website from which the purchase was made. The '+' character is not allowed in this property for transactions that are processed by TechProcess Payment Platform.
+
+        Type: str
+        """
+        return self.__website_url
+
+    @website_url.setter
+    def website_url(self, value):
+        self.__website_url = value
+
+    def to_dictionary(self):
+        dictionary = super(Merchant, self).to_dictionary()
+        if self.configuration_id is not None:
+            dictionary['configurationId'] = self.configuration_id
+        if self.contact_website_url is not None:
+            dictionary['contactWebsiteUrl'] = self.contact_website_url
+        if self.seller is not None:
+            dictionary['seller'] = self.seller.to_dictionary()
+        if self.website_url is not None:
+            dictionary['websiteUrl'] = self.website_url
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(Merchant, self).from_dictionary(dictionary)
+        if 'configurationId' in dictionary:
+            self.configuration_id = dictionary['configurationId']
+        if 'contactWebsiteUrl' in dictionary:
+            self.contact_website_url = dictionary['contactWebsiteUrl']
+        if 'seller' in dictionary:
+            if not isinstance(dictionary['seller'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['seller']))
+            value = Seller()
+            self.seller = value.from_dictionary(dictionary['seller'])
+        if 'websiteUrl' in dictionary:
+            self.website_url = dictionary['websiteUrl']
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/merchant_action.py

@@ -0,0 +1,211 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.key_value_pair import KeyValuePair
+from worldline.connect.sdk.v1.domain.mobile_three_d_secure_challenge_parameters import MobileThreeDSecureChallengeParameters
+from worldline.connect.sdk.v1.domain.payment_product_field import PaymentProductField
+from worldline.connect.sdk.v1.domain.redirect_data import RedirectData
+from worldline.connect.sdk.v1.domain.third_party_data import ThirdPartyData
+
+
+class MerchantAction(DataObject):
+
+    __action_type = None
+    __form_fields = None
+    __mobile_three_d_secure_challenge_parameters = None
+    __redirect_data = None
+    __rendering_data = None
+    __show_data = None
+    __third_party_data = None
+
+    @property
+    def action_type(self):
+        """
+        | Action merchants needs to take in the online payment process. Possible values are:
+        
+        * REDIRECT - The customer needs to be redirected using the details found in redirectData
+        * SHOW_FORM - The customer needs to be shown a form with the fields found in formFields. You can submit the data entered by the user in a Complete payment <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/payments/complete.html> request. Additionally:
+        
+        * for payment product 3012 (Bancontact), to support payments via the Bancontact app, showData contains a QR code and URL intent.
+        * for payment product 863 (WeChat Pay), to support payments via the WeChat app, showData contains a QR code, URL intent, or signature and nonce combination. The showData property describes when each of these values can be returned.
+        | Note that WeChat Pay does not support completing payments.
+        
+        
+        * SHOW_INSTRUCTIONS - The customer needs to be shown payment instruction using the details found in showData. Alternatively the instructions can be rendered by us using the instructionsRenderingData
+        * SHOW_TRANSACTION_RESULTS - The customer needs to be shown the transaction results using the details found in showData
+        * MOBILE_THREEDS_CHALLENGE - The customer needs to complete a challenge as part of the 3D Secure authentication inside your mobile app. The details contained in mobileThreeDSecureChallengeParameters need to be provided to the EMVco certified Mobile SDK as a challengeParameters object.
+        * CALL_THIRD_PARTY - The merchant needs to call a third party using the data found in thirdPartyData
+
+        Type: str
+        """
+        return self.__action_type
+
+    @action_type.setter
+    def action_type(self, value):
+        self.__action_type = value
+
+    @property
+    def form_fields(self):
+        """
+        | Populated only when the actionType of the merchantAction is SHOW_FORM. In this case, this property contains the list of fields to render, in the format that is also used in the response of Get payment product <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/products/get.html>.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.payment_product_field.PaymentProductField`]
+        """
+        return self.__form_fields
+
+    @form_fields.setter
+    def form_fields(self, value):
+        self.__form_fields = value
+
+    @property
+    def mobile_three_d_secure_challenge_parameters(self):
+        """
+        | Populated only when the actionType of the merchantAction is MOBILE_THREEDS_CHALLENGE. In this case, this object contains the list of properties to provide to the EMVco certified Mobile SDK as a challengeParameters object.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mobile_three_d_secure_challenge_parameters.MobileThreeDSecureChallengeParameters`
+        """
+        return self.__mobile_three_d_secure_challenge_parameters
+
+    @mobile_three_d_secure_challenge_parameters.setter
+    def mobile_three_d_secure_challenge_parameters(self, value):
+        self.__mobile_three_d_secure_challenge_parameters = value
+
+    @property
+    def redirect_data(self):
+        """
+        | Object containing all data needed to redirect the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.redirect_data.RedirectData`
+        """
+        return self.__redirect_data
+
+    @redirect_data.setter
+    def redirect_data(self, value):
+        self.__redirect_data = value
+
+    @property
+    def rendering_data(self):
+        """
+        | This property contains the blob with data for the instructions rendering service.
+        
+        | This service will be available at the following endpoint:http(s)://{{merchant specific subdomain}}.{{base MyCheckout hosted payment pages domain}}/instructions/{{merchantId}}/{{clientSessionId}}
+        
+        | This instructions page rendering service accepts the following parameters:
+        
+        * instructionsRenderingData (required, the content of this property)
+        * locale (optional, if present overrides default locale, e.g. "en_GB")
+        * variant (optional, code of a variant, if present overrides default variant, e.g. "100")
+        * customerId (required for Pix, otherwise optional, the customerId from a client session)
+        
+        | You can offer a link to a customer to see an instructions page for a payment done earlier. Because of the size of the instructionsRenderingData this will need to be set in a web form as a value of a hidden field. Before presenting the link you need to obtain a clientSessionId by creating a session using the S2S API. You will need to use the MyCheckout hosted payment pages domain hosted in the same region as the API domain used for the createClientSession call.
+        
+        | The instructionsRenderingData is a String blob that is presented to you via the Server API as part of the merchantAction (if available, and non-redirect) in the JSON return values for the createPayment call or the getHostedCheckoutStatus call (merchantAction inside createdPaymentOutput when available).You are responsible to store the instructionsRenderingData blob in order to be able to present the instructions page at a later time, when this information might no longer be available through Server API calls.
+
+        Type: str
+        """
+        return self.__rendering_data
+
+    @rendering_data.setter
+    def rendering_data(self, value):
+        self.__rendering_data = value
+
+    @property
+    def show_data(self):
+        """
+        | This is returned for the SHOW_INSTRUCTION, the SHOW_TRANSACTION_RESULTS and the SHOW_FORM actionType.
+        | When returned for SHOW_TRANSACTION_RESULTS or SHOW_FORM, this contains an array of key value pairs of data that needs to be shown to the customer.
+        | Note: The returned value for the key BARCODE is a base64 encoded gif image. By prepending 'data:image/gif;base64,' this value can be used as the source of an HTML inline image.
+        
+        | For SHOW_FORM, for payment product 3012 (Bancontact), this contains a QR code and a URL intent that can be used to complete the payment in the Bancontact app.
+        | In this case, the key QRCODE contains a base64 encoded PNG image. By prepending 'data:image/png;base64,' this value can be used as the source of an HTML inline image on a desktop or tablet (intended to be scanned by an Android device with the Bancontact app). The key URLINTENT contains a URL intent that can be used as the link of an 'open the app' button on an Android device.
+        
+        | For SHOW_FORM, for payment product 863 (WeChat Pay), this contains the PaymentId that WeChat has assigned to the payment. In this case, the key WECHAT_PAYMENTID contains this PaymentId. In addition, this can contain different values depending on the integration type:
+        
+        * desktopQRCode - contains a QR code that can be used to complete the payment in the WeChat app. In this case, the key QRCODE contains a base64 encoded PNG image. By prepending 'data:image/png;base64,' this value can be used as the source of an HTML inline image on a desktop or tablet (intended to be scanned by a mobile device with the WeChat app).
+        * urlIntent - contains a URL intent that can be used to complete the payment in the WeChat app. In this case, the key URLINTENT contains a URL intent that can be used as the link of an 'open the app' button on a mobile device.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.key_value_pair.KeyValuePair`]
+        """
+        return self.__show_data
+
+    @show_data.setter
+    def show_data(self, value):
+        self.__show_data = value
+
+    @property
+    def third_party_data(self):
+        """
+        | This is returned for the CALL_THIRD_PARTY actionType.
+        | The payment product specific field of the payment product used for the payment will be populated with the third party data that should be used when calling the third party.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.third_party_data.ThirdPartyData`
+        """
+        return self.__third_party_data
+
+    @third_party_data.setter
+    def third_party_data(self, value):
+        self.__third_party_data = value
+
+    def to_dictionary(self):
+        dictionary = super(MerchantAction, self).to_dictionary()
+        if self.action_type is not None:
+            dictionary['actionType'] = self.action_type
+        if self.form_fields is not None:
+            dictionary['formFields'] = []
+            for element in self.form_fields:
+                if element is not None:
+                    dictionary['formFields'].append(element.to_dictionary())
+        if self.mobile_three_d_secure_challenge_parameters is not None:
+            dictionary['mobileThreeDSecureChallengeParameters'] = self.mobile_three_d_secure_challenge_parameters.to_dictionary()
+        if self.redirect_data is not None:
+            dictionary['redirectData'] = self.redirect_data.to_dictionary()
+        if self.rendering_data is not None:
+            dictionary['renderingData'] = self.rendering_data
+        if self.show_data is not None:
+            dictionary['showData'] = []
+            for element in self.show_data:
+                if element is not None:
+                    dictionary['showData'].append(element.to_dictionary())
+        if self.third_party_data is not None:
+            dictionary['thirdPartyData'] = self.third_party_data.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(MerchantAction, self).from_dictionary(dictionary)
+        if 'actionType' in dictionary:
+            self.action_type = dictionary['actionType']
+        if 'formFields' in dictionary:
+            if not isinstance(dictionary['formFields'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['formFields']))
+            self.form_fields = []
+            for element in dictionary['formFields']:
+                value = PaymentProductField()
+                self.form_fields.append(value.from_dictionary(element))
+        if 'mobileThreeDSecureChallengeParameters' in dictionary:
+            if not isinstance(dictionary['mobileThreeDSecureChallengeParameters'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mobileThreeDSecureChallengeParameters']))
+            value = MobileThreeDSecureChallengeParameters()
+            self.mobile_three_d_secure_challenge_parameters = value.from_dictionary(dictionary['mobileThreeDSecureChallengeParameters'])
+        if 'redirectData' in dictionary:
+            if not isinstance(dictionary['redirectData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectData']))
+            value = RedirectData()
+            self.redirect_data = value.from_dictionary(dictionary['redirectData'])
+        if 'renderingData' in dictionary:
+            self.rendering_data = dictionary['renderingData']
+        if 'showData' in dictionary:
+            if not isinstance(dictionary['showData'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['showData']))
+            self.show_data = []
+            for element in dictionary['showData']:
+                value = KeyValuePair()
+                self.show_data.append(value.from_dictionary(element))
+        if 'thirdPartyData' in dictionary:
+            if not isinstance(dictionary['thirdPartyData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['thirdPartyData']))
+            value = ThirdPartyData()
+            self.third_party_data = value.from_dictionary(dictionary['thirdPartyData'])
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/merchant_risk_assessment.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class MerchantRiskAssessment(DataObject):
+
+    __website_url = None
+
+    @property
+    def website_url(self):
+        """
+        | The website from which the purchase was made
+
+        Type: str
+        """
+        return self.__website_url
+
+    @website_url.setter
+    def website_url(self, value):
+        self.__website_url = value
+
+    def to_dictionary(self):
+        dictionary = super(MerchantRiskAssessment, self).to_dictionary()
+        if self.website_url is not None:
+            dictionary['websiteUrl'] = self.website_url
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(MerchantRiskAssessment, self).from_dictionary(dictionary)
+        if 'websiteUrl' in dictionary:
+            self.website_url = dictionary['websiteUrl']
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/microsoft_fraud_results.py

@@ -0,0 +1,144 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class MicrosoftFraudResults(DataObject):
+
+    __clause_name = None
+    __device_country_code = None
+    __device_id = None
+    __fraud_score = None
+    __policy_applied = None
+    __true_ip_address = None
+    __user_device_type = None
+
+    @property
+    def clause_name(self):
+        """
+        | Name of the clause within the applied policy that was triggered during the evaluation of this transaction.
+
+        Type: str
+        """
+        return self.__clause_name
+
+    @clause_name.setter
+    def clause_name(self, value):
+        self.__clause_name = value
+
+    @property
+    def device_country_code(self):
+        """
+        | The country of the customer determined by Microsoft Device Fingerprinting.
+
+        Type: str
+        """
+        return self.__device_country_code
+
+    @device_country_code.setter
+    def device_country_code(self, value):
+        self.__device_country_code = value
+
+    @property
+    def device_id(self):
+        """
+        | This is the device fingerprint value. Based on the amount of data that the device fingerprint collector script was able to collect, this will be a proxy ID for the device used by the customer. 
+
+        Type: str
+        """
+        return self.__device_id
+
+    @device_id.setter
+    def device_id(self, value):
+        self.__device_id = value
+
+    @property
+    def fraud_score(self):
+        """
+        | Result of the Microsoft Fraud Protection check. This contains the normalized fraud score from a scale of 0 to 100. A higher score indicates an increased risk of fraud.
+
+        Type: int
+        """
+        return self.__fraud_score
+
+    @fraud_score.setter
+    def fraud_score(self, value):
+        self.__fraud_score = value
+
+    @property
+    def policy_applied(self):
+        """
+        | Name of the policy that was applied on during the evaluation of this transaction.
+
+        Type: str
+        """
+        return self.__policy_applied
+
+    @policy_applied.setter
+    def policy_applied(self, value):
+        self.__policy_applied = value
+
+    @property
+    def true_ip_address(self):
+        """
+        | The true IP address as determined by Microsoft Device Fingerprinting.
+
+        Type: str
+        """
+        return self.__true_ip_address
+
+    @true_ip_address.setter
+    def true_ip_address(self, value):
+        self.__true_ip_address = value
+
+    @property
+    def user_device_type(self):
+        """
+        | The type of device used by the customer.
+
+        Type: str
+        """
+        return self.__user_device_type
+
+    @user_device_type.setter
+    def user_device_type(self, value):
+        self.__user_device_type = value
+
+    def to_dictionary(self):
+        dictionary = super(MicrosoftFraudResults, self).to_dictionary()
+        if self.clause_name is not None:
+            dictionary['clauseName'] = self.clause_name
+        if self.device_country_code is not None:
+            dictionary['deviceCountryCode'] = self.device_country_code
+        if self.device_id is not None:
+            dictionary['deviceId'] = self.device_id
+        if self.fraud_score is not None:
+            dictionary['fraudScore'] = self.fraud_score
+        if self.policy_applied is not None:
+            dictionary['policyApplied'] = self.policy_applied
+        if self.true_ip_address is not None:
+            dictionary['trueIpAddress'] = self.true_ip_address
+        if self.user_device_type is not None:
+            dictionary['userDeviceType'] = self.user_device_type
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(MicrosoftFraudResults, self).from_dictionary(dictionary)
+        if 'clauseName' in dictionary:
+            self.clause_name = dictionary['clauseName']
+        if 'deviceCountryCode' in dictionary:
+            self.device_country_code = dictionary['deviceCountryCode']
+        if 'deviceId' in dictionary:
+            self.device_id = dictionary['deviceId']
+        if 'fraudScore' in dictionary:
+            self.fraud_score = dictionary['fraudScore']
+        if 'policyApplied' in dictionary:
+            self.policy_applied = dictionary['policyApplied']
+        if 'trueIpAddress' in dictionary:
+            self.true_ip_address = dictionary['trueIpAddress']
+        if 'userDeviceType' in dictionary:
+            self.user_device_type = dictionary['userDeviceType']
+        return self