int.Equals(object)

public override String GetDescription(Int32 id) {
            FieldInfo[] fields = GetFields();
            for (Int32 index = 0; (index < fields.Length); index = (index + 1)) {
                FieldInfo field = fields[index];
                if (id.Equals(field.GetValue(null))) {
                    Object descriptionAttr = field.GetCustomAttributes(typeof(DescriptionAttribute), false).FirstOrDefault();
                    if ((descriptionAttr != null)) {
                        return ((DescriptionAttribute)(descriptionAttr)).Description;
                    }
                    else {
                        return field.Name;
                    }
                }
            }
            return null;
        }

public override String GetKey(Int32 id) {
            FieldInfo[] fields = GetFields();
            for (Int32 index = 0; (index < fields.Length); index = (index + 1)) {
                FieldInfo field = fields[index];
                if (id.Equals(field.GetValue(null))) {
                    return field.Name;
                }
            }
            return null;
        }

public override String GetKey(Int32 id) {
            FieldInfo[] fields = typeof(SimpleLexicalStateId).GetFields((BindingFlags.Public | BindingFlags.Static));
            for (Int32 index = 0; (index < fields.Length); index = (index + 1)) {
                FieldInfo field = fields[index];
                if (id.Equals(field.GetValue(null))) {
                    return field.Name;
                }
            }
            return null;
        }

public override String GetDescription(Int32 id) {
            FieldInfo[] fields = typeof(SimpleTokenId).GetFields((BindingFlags.Public | BindingFlags.Static));
            for (Int32 index = 0; (index < fields.Length); index = (index + 1)) {
                FieldInfo field = fields[index];
                if (id.Equals(field.GetValue(null))) {
                    Object[] customAttributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
                    if (((customAttributes != null) 
                                && (customAttributes.Length > 0))) {
                        return ((DescriptionAttribute)(customAttributes[0])).Description;
                    }
                    else {
                        return field.Name;
                    }
                }
            }
            return null;
        }

public override String GetKey(Int32 id) {
            FieldInfo[] fields = typeof(SimpleAstNodeId).GetFields((BindingFlags.Public | BindingFlags.Static));
            for (Int32 index = 0; (index < fields.Length); index = (index + 1)) {
                FieldInfo field = fields[index];
                if (id.Equals(field.GetValue(null))) {
                    return field.Name;
                }
            }
            return null;
        }

public override String GetDescription(Int32 id) {
            FieldInfo[] fields = typeof(SimpleLexicalStateId).GetFields((BindingFlags.Public | BindingFlags.Static));
            for (Int32 index = 0; (index < fields.Length); index = (index + 1)) {
                FieldInfo field = fields[index];
                if (id.Equals(field.GetValue(null))) {
                    Object[] customAttributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
                    if (((customAttributes != null) 
                                && (customAttributes.Length > 0))) {
                        return ((DescriptionAttribute)(customAttributes[0])).Description;
                    }
                    else {
                        return field.Name;
                    }
                }
            }
            return null;
        }

public override String GetKey(Int32 id) {
            FieldInfo[] fields = typeof(SimpleTokenId).GetFields((BindingFlags.Public | BindingFlags.Static));
            for (Int32 index = 0; (index < fields.Length); index = (index + 1)) {
                FieldInfo field = fields[index];
                if (id.Equals(field.GetValue(null))) {
                    return field.Name;
                }
            }
            return null;
        }

public override String GetDescription(Int32 id) {
            FieldInfo[] fields = typeof(SimpleAstNodeId).GetFields((BindingFlags.Public | BindingFlags.Static));
            for (Int32 index = 0; (index < fields.Length); index = (index + 1)) {
                FieldInfo field = fields[index];
                if (id.Equals(field.GetValue(null))) {
                    Object[] customAttributes = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
                    if (((customAttributes != null) 
                                && (customAttributes.Length > 0))) {
                        return ((DescriptionAttribute)(customAttributes[0])).Description;
                    }
                    else {
                        return field.Name;
                    }
                }
            }
            return null;
        }

public bool Equals(AccountInfo input)
        {
            if (input == null)
                return false;

            return
                (
                    this.AccountAgeIndicator == input.AccountAgeIndicator ||
                    this.AccountAgeIndicator != null &&
                    this.AccountAgeIndicator.Equals(input.AccountAgeIndicator)
                ) &&
                (
                    this.AccountChangeDate == input.AccountChangeDate ||
                    this.AccountChangeDate != null &&
                    this.AccountChangeDate.Equals(input.AccountChangeDate)
                ) &&
                (
                    this.AccountChangeIndicator == input.AccountChangeIndicator ||
                    this.AccountChangeIndicator != null &&
                    this.AccountChangeIndicator.Equals(input.AccountChangeIndicator)
                ) &&
                (
                    this.AccountCreationDate == input.AccountCreationDate ||
                    this.AccountCreationDate != null &&
                    this.AccountCreationDate.Equals(input.AccountCreationDate)
                ) &&
                (
                    this.AccountType == input.AccountType ||
                    this.AccountType != null &&
                    this.AccountType.Equals(input.AccountType)
                ) &&
                (
                    this.AddCardAttemptsDay == input.AddCardAttemptsDay ||
                    this.AddCardAttemptsDay != null &&
                    this.AddCardAttemptsDay.Equals(input.AddCardAttemptsDay)
                ) &&
                (
                    this.DeliveryAddressUsageDate == input.DeliveryAddressUsageDate ||
                    this.DeliveryAddressUsageDate != null &&
                    this.DeliveryAddressUsageDate.Equals(input.DeliveryAddressUsageDate)
                ) &&
                (
                    this.DeliveryAddressUsageIndicator == input.DeliveryAddressUsageIndicator ||
                    this.DeliveryAddressUsageIndicator != null &&
                    this.DeliveryAddressUsageIndicator.Equals(input.DeliveryAddressUsageIndicator)
                ) &&
                (
                    this.HomePhone == input.HomePhone ||
                    this.HomePhone != null &&
                    this.HomePhone.Equals(input.HomePhone)
                ) &&
                (
                    this.MobilePhone == input.MobilePhone ||
                    this.MobilePhone != null &&
                    this.MobilePhone.Equals(input.MobilePhone)
                ) &&
                (
                    this.PreplacedwordChangeDate == input.PreplacedwordChangeDate ||
                    this.PreplacedwordChangeDate != null &&
                    this.PreplacedwordChangeDate.Equals(input.PreplacedwordChangeDate)
                ) &&
                (
                    this.PreplacedwordChangeIndicator == input.PreplacedwordChangeIndicator ||
                    this.PreplacedwordChangeIndicator != null &&
                    this.PreplacedwordChangeIndicator.Equals(input.PreplacedwordChangeIndicator)
                ) &&
                (
                    this.PastTransactionsDay == input.PastTransactionsDay ||
                    this.PastTransactionsDay != null &&
                    this.PastTransactionsDay.Equals(input.PastTransactionsDay)
                ) &&
                (
                    this.PastTransactionsYear == input.PastTransactionsYear ||
                    this.PastTransactionsYear != null &&
                    this.PastTransactionsYear.Equals(input.PastTransactionsYear)
                ) &&
                (
                    this.PaymentAccountAge == input.PaymentAccountAge ||
                    this.PaymentAccountAge != null &&
                    this.PaymentAccountAge.Equals(input.PaymentAccountAge)
                ) &&
                (
                    this.PaymentAccountIndicator == input.PaymentAccountIndicator ||
                    this.PaymentAccountIndicator != null &&
                    this.PaymentAccountIndicator.Equals(input.PaymentAccountIndicator)
                ) &&
                (
                    this.PurchasesLast6Months == input.PurchasesLast6Months ||
                    this.PurchasesLast6Months != null &&
                    this.PurchasesLast6Months.Equals(input.PurchasesLast6Months)
                ) &&
                (
                    this.SuspiciousActivity == input.SuspiciousActivity ||
                    this.SuspiciousActivity != null &&
                    this.SuspiciousActivity.Equals(input.SuspiciousActivity)
                ) &&
                (
                    this.WorkPhone == input.WorkPhone ||
                    this.WorkPhone != null &&
                    this.WorkPhone.Equals(input.WorkPhone)
                );
        }

public bool Equals(BrowserInfo input)
        {
            if (input == null)
                return false;

            return
                (
                    this.AcceptHeader == input.AcceptHeader ||
                    this.AcceptHeader != null &&
                    this.AcceptHeader.Equals(input.AcceptHeader)
                ) &&
                (
                    this.ColorDepth == input.ColorDepth ||
                    this.ColorDepth != null &&
                    this.ColorDepth.Equals(input.ColorDepth)
                ) &&
                (
                    this.JavaEnabled == input.JavaEnabled ||
                    this.JavaEnabled != null &&
                    this.JavaEnabled.Equals(input.JavaEnabled)
                ) &&
                (
                    this.JavaScriptEnabled == input.JavaScriptEnabled ||
                    this.JavaScriptEnabled != null &&
                    this.JavaScriptEnabled.Equals(input.JavaScriptEnabled)
                ) &&
                (
                    this.Language == input.Language ||
                    this.Language != null &&
                    this.Language.Equals(input.Language)
                ) &&
                (
                    this.ScreenHeight == input.ScreenHeight ||
                    this.ScreenHeight != null &&
                    this.ScreenHeight.Equals(input.ScreenHeight)
                ) &&
                (
                    this.ScreenWidth == input.ScreenWidth ||
                    this.ScreenWidth != null &&
                    this.ScreenWidth.Equals(input.ScreenWidth)
                ) &&
                (
                    this.TimeZoneOffset == input.TimeZoneOffset ||
                    this.TimeZoneOffset != null &&
                    this.TimeZoneOffset.Equals(input.TimeZoneOffset)
                ) &&
                (
                    this.UserAgent == input.UserAgent ||
                    this.UserAgent != null &&
                    this.UserAgent.Equals(input.UserAgent)
                );
        }

public bool Equals(FraudCheckResult input)
        {
            if (input == null)
                return false;

            return
                (
                    this.AccountScore == input.AccountScore ||
                    (this.AccountScore != null &&
                    this.AccountScore.Equals(input.AccountScore))
                ) &&
                (
                    this.CheckId == input.CheckId ||
                    (this.CheckId != null &&
                    this.CheckId.Equals(input.CheckId))
                ) &&
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                );
        }

public bool Equals(FraudResult input)
        {
            if (input == null)
                return false;

            return
                (
                    this.AccountScore == input.AccountScore ||
                    (this.AccountScore != null &&
                    this.AccountScore.Equals(input.AccountScore))
                ) &&
                (
                    this.Results == input.Results ||
                    this.Results != null &&
                    this.Results.SequenceEqual(input.Results)
                );
        }

public bool Equals(Installments input)
        {
            if (input == null)
                return false;

            return
                (
                    this.Plan == input.Plan ||
                    this.Plan != null &&
                    this.Plan.Equals(input.Plan)
                ) &&
                (
                    this.Value == input.Value ||
                    this.Value != null &&
                    this.Value.Equals(input.Value)
                );
        }

public bool Equals(MerchantRiskIndicator input)
        {
            if (input == null)
                return false;

            return
                (
                    this.AddressMatch == input.AddressMatch ||
                    this.AddressMatch != null &&
                    this.AddressMatch.Equals(input.AddressMatch)
                ) &&
                (
                    this.DeliveryAddressIndicator == input.DeliveryAddressIndicator ||
                    this.DeliveryAddressIndicator != null &&
                    this.DeliveryAddressIndicator.Equals(input.DeliveryAddressIndicator)
                ) &&
                (
                    this.DeliveryEmail == input.DeliveryEmail ||
                    this.DeliveryEmail != null &&
                    this.DeliveryEmail.Equals(input.DeliveryEmail)
                ) &&
                (
                    this.DeliveryTimeframe == input.DeliveryTimeframe ||
                    this.DeliveryTimeframe != null &&
                    this.DeliveryTimeframe.Equals(input.DeliveryTimeframe)
                ) &&
                (
                    this.GiftCardAmount == input.GiftCardAmount ||
                    this.GiftCardAmount != null &&
                    this.GiftCardAmount.Equals(input.GiftCardAmount)
                ) &&
                (
                    this.GiftCardCount == input.GiftCardCount ||
                    this.GiftCardCount != null &&
                    this.GiftCardCount.Equals(input.GiftCardCount)
                ) &&
                (
                    this.PreOrderDate == input.PreOrderDate ||
                    this.PreOrderDate != null &&
                    this.PreOrderDate.Equals(input.PreOrderDate)
                ) &&
                (
                    this.PreOrderPurchase == input.PreOrderPurchase ||
                    this.PreOrderPurchase != null &&
                    this.PreOrderPurchase.Equals(input.PreOrderPurchase)
                ) &&
                (
                    this.ReorderItems == input.ReorderItems ||
                    this.ReorderItems != null &&
                    this.ReorderItems.Equals(input.ReorderItems)
                );
        }

public bool Equals(CheckoutOneTimePreplacedcodeAction input)
        {
            if (input == null)
                return false;

            return
                (
                    this.PaymentData == input.PaymentData ||
                    this.PaymentData != null &&
                    this.PaymentData.Equals(input.PaymentData)
                ) &&
                (
                    this.PaymentMethodType == input.PaymentMethodType ||
                    this.PaymentMethodType != null &&
                    this.PaymentMethodType.Equals(input.PaymentMethodType)
                ) &&
                (
                    this.Redirect == input.Redirect ||
                    this.Redirect != null &&
                    this.Redirect.Equals(input.Redirect)
                ) &&
                (
                    this.ResendInterval == input.ResendInterval ||
                    this.ResendInterval != null &&
                    this.ResendInterval.Equals(input.ResendInterval)
                ) &&
                (
                    this.ResendMaxAttempts == input.ResendMaxAttempts ||
                    this.ResendMaxAttempts != null &&
                    this.ResendMaxAttempts.Equals(input.ResendMaxAttempts)
                ) &&
                (
                    this.ResendUrl == input.ResendUrl ||
                    this.ResendUrl != null &&
                    this.ResendUrl.Equals(input.ResendUrl)
                ) &&
                (
                    this.Url == input.Url ||
                    this.Url != null &&
                    this.Url.Equals(input.Url)
                );
        }

public bool Equals(InstallmentOption input)
        {
            if (input == null)
                return false;

            return
                (
                    this.MaxValue == input.MaxValue ||
                    this.MaxValue != null &&
                    this.MaxValue.Equals(input.MaxValue)
                ) &&
                (
                    this.Plans == input.Plans ||
                    this.Plans != null &&
                    input.Plans != null &&
                    this.Plans.SequenceEqual(input.Plans)
                );
        }

public bool Equals(Installments2 input)
        {
            if (input == null)
                return false;

            return
                this.MaxNumberOfInstallments == input.MaxNumberOfInstallments ||
                this.MaxNumberOfInstallments != null &&
                this.MaxNumberOfInstallments.Equals(input.MaxNumberOfInstallments);
        }

public bool Equals(ForexQuote input)
        {
            if (input == null)
                return false;

            return
                (
                    this.Account == input.Account ||
                    this.Account != null &&
                    this.Account.Equals(input.Account)
                ) &&
                (
                    this.AccountType == input.AccountType ||
                    this.AccountType != null &&
                    this.AccountType.Equals(input.AccountType)
                ) &&
                (
                    this.BaseAmount == input.BaseAmount ||
                    this.BaseAmount != null &&
                    this.BaseAmount.Equals(input.BaseAmount)
                ) &&
                (
                    this.BasePoints == input.BasePoints ||
                    this.BasePoints != null &&
                    this.BasePoints.Equals(input.BasePoints)
                ) &&
                (
                    this.Buy == input.Buy ||
                    this.Buy != null &&
                    this.Buy.Equals(input.Buy)
                ) &&
                (
                    this.Interbank == input.Interbank ||
                    this.Interbank != null &&
                    this.Interbank.Equals(input.Interbank)
                ) &&
                (
                    this.Reference == input.Reference ||
                    this.Reference != null &&
                    this.Reference.Equals(input.Reference)
                ) &&
                (
                    this.Sell == input.Sell ||
                    this.Sell != null &&
                    this.Sell.Equals(input.Sell)
                ) &&
                (
                    this.Signature == input.Signature ||
                    this.Signature != null &&
                    this.Signature.Equals(input.Signature)
                ) &&
                (
                    this.Source == input.Source ||
                    this.Source != null &&
                    this.Source.Equals(input.Source)
                ) &&
                (
                    this.Type == input.Type ||
                    this.Type != null &&
                    this.Type.Equals(input.Type)
                ) &&
                (
                    this.ValidTill == input.ValidTill ||
                    this.ValidTill != null &&
                    this.ValidTill.Equals(input.ValidTill)
                );
        }

public bool Equals(RiskData input)
        {
            if (input == null)
                return false;

            return
                (
                    this.ClientData == input.ClientData ||
                    this.ClientData != null &&
                    this.ClientData.Equals(input.ClientData)
                ) &&
                (
                    this.CustomFields == input.CustomFields ||
                    this.CustomFields != null &&
                    input.CustomFields != null &&
                    this.CustomFields.SequenceEqual(input.CustomFields)
                ) &&
                (
                    this.FraudOffset == input.FraudOffset ||
                    this.FraudOffset != null &&
                    this.FraudOffset.Equals(input.FraudOffset)
                ) &&
                (
                    this.ProfileReference == input.ProfileReference ||
                    this.ProfileReference != null &&
                    this.ProfileReference.Equals(input.ProfileReference)
                );
        }

public bool Equals(ErrorFieldType input)
        {
            if (input == null)
                return false;

            return
                (
                    this.ErrorCode == input.ErrorCode ||
                    (this.ErrorCode != null &&
                    this.ErrorCode.Equals(input.ErrorCode))
                ) &&
                (
                    this.ErrorDescription == input.ErrorDescription ||
                    (this.ErrorDescription != null &&
                    this.ErrorDescription.Equals(input.ErrorDescription))
                ) &&
                (
                    this.FieldType == input.FieldType ||
                    (this.FieldType != null &&
                    this.FieldType.Equals(input.FieldType))
                );
        }

public bool Equals(ThreeDS2RequestData input)
        {
            if (input == null)
                return false;

            return
                (
                    this.AcquirerBIN == input.AcquirerBIN ||
                    this.AcquirerBIN != null &&
                    this.AcquirerBIN.Equals(input.AcquirerBIN)
                ) &&
                (
                    this.AcquirerMerchantID == input.AcquirerMerchantID ||
                    this.AcquirerMerchantID != null &&
                    this.AcquirerMerchantID.Equals(input.AcquirerMerchantID)
                ) &&
                (
                    this.AuthenticationOnly == input.AuthenticationOnly ||
                    this.AuthenticationOnly != null &&
                    this.AuthenticationOnly.Equals(input.AuthenticationOnly)
                ) &&
                (
                    this.ChallengeIndicator == input.ChallengeIndicator ||
                    this.ChallengeIndicator != null &&
                    this.ChallengeIndicator.Equals(input.ChallengeIndicator)
                ) &&
                (
                    this.DeviceChannel == input.DeviceChannel ||
                    this.DeviceChannel != null &&
                    this.DeviceChannel.Equals(input.DeviceChannel)
                ) &&
                (
                    this.DeviceRenderOptions == input.DeviceRenderOptions ||
                    this.DeviceRenderOptions != null &&
                    this.DeviceRenderOptions.Equals(input.DeviceRenderOptions)
                ) &&
                (
                    this.Mcc == input.Mcc ||
                    this.Mcc != null &&
                    this.Mcc.Equals(input.Mcc)
                ) &&
                (
                    this.MerchantName == input.MerchantName ||
                    this.MerchantName != null &&
                    this.MerchantName.Equals(input.MerchantName)
                ) &&
                (
                    this.MessageVersion == input.MessageVersion ||
                    this.MessageVersion != null &&
                    this.MessageVersion.Equals(input.MessageVersion)
                ) &&
                (
                    this.NotificationURL == input.NotificationURL ||
                    this.NotificationURL != null &&
                    this.NotificationURL.Equals(input.NotificationURL)
                ) &&
                (
                    this.SdkAppID == input.SdkAppID ||
                    this.SdkAppID != null &&
                    this.SdkAppID.Equals(input.SdkAppID)
                ) &&
                (
                    this.SdkEncData == input.SdkEncData ||
                    this.SdkEncData != null &&
                    this.SdkEncData.Equals(input.SdkEncData)
                ) &&
                (
                    this.SdkEphemPubKey == input.SdkEphemPubKey ||
                    this.SdkEphemPubKey != null &&
                    this.SdkEphemPubKey.Equals(input.SdkEphemPubKey)
                ) &&
                (
                    this.SdkMaxTimeout == input.SdkMaxTimeout ||
                    this.SdkMaxTimeout != null &&
                    this.SdkMaxTimeout.Equals(input.SdkMaxTimeout)
                ) &&
                (
                    this.SdkReferenceNumber == input.SdkReferenceNumber ||
                    this.SdkReferenceNumber != null &&
                    this.SdkReferenceNumber.Equals(input.SdkReferenceNumber)
                ) &&
                (
                    this.SdkTransID == input.SdkTransID ||
                    this.SdkTransID != null &&
                    this.SdkTransID.Equals(input.SdkTransID)
                ) &&
                (
                    this.ThreeDSCompInd == input.ThreeDSCompInd ||
                    this.ThreeDSCompInd != null &&
                    this.ThreeDSCompInd.Equals(input.ThreeDSCompInd)
                ) &&
                (
                    this.ThreeDSRequestorID == input.ThreeDSRequestorID ||
                    this.ThreeDSRequestorID != null &&
                    this.ThreeDSRequestorID.Equals(input.ThreeDSRequestorID)
                ) &&
                (
                    this.ThreeDSRequestorName == input.ThreeDSRequestorName ||
                    this.ThreeDSRequestorName != null &&
                    this.ThreeDSRequestorName.Equals(input.ThreeDSRequestorName)
                ) &&
                (
                    this.ThreeDSRequestorURL == input.ThreeDSRequestorURL ||
                    this.ThreeDSRequestorURL != null &&
                    this.ThreeDSRequestorURL.Equals(input.ThreeDSRequestorURL)
                ) &&
                (
                    this.TransactionType == input.TransactionType ||
                    this.TransactionType != null &&
                    this.TransactionType.Equals(input.TransactionType)
                ) &&
                (
                    this.WhiteListStatus == input.WhiteListStatus ||
                    this.WhiteListStatus != null &&
                    this.WhiteListStatus.Equals(input.WhiteListStatus)
                );
        }

public bool Equals(AccountPayoutState input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.AllowPayout == input.AllowPayout ||
                    (this.AllowPayout != null &&
                    this.AllowPayout.Equals(input.AllowPayout))
                ) && 
                (
                    this.DisableReason == input.DisableReason ||
                    (this.DisableReason != null &&
                    this.DisableReason.Equals(input.DisableReason))
                ) && 
                (
                    this.Disabled == input.Disabled ||
                    (this.Disabled != null &&
                    this.Disabled.Equals(input.Disabled))
                ) && 
                (
                    this.NotAllowedReason == input.NotAllowedReason ||
                    (this.NotAllowedReason != null &&
                    this.NotAllowedReason.Equals(input.NotAllowedReason))
                ) && 
                (
                    this.PayoutLimit == input.PayoutLimit ||
                    (this.PayoutLimit != null &&
                    ((Object) this.PayoutLimit).Equals(input.PayoutLimit))
                ) && 
                (
                    this.TierNumber == input.TierNumber ||
                    (this.TierNumber != null &&
                    this.TierNumber.Equals(input.TierNumber))
                );
        }

public bool Equals(AccountProcessingState input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.DisableReason == input.DisableReason ||
                    (this.DisableReason != null &&
                    this.DisableReason.Equals(input.DisableReason))
                ) && 
                (
                    this.Disabled == input.Disabled ||
                    (this.Disabled != null &&
                    this.Disabled.Equals(input.Disabled))
                ) && 
                (
                    this.ProcessedFrom == input.ProcessedFrom ||
                    (this.ProcessedFrom != null &&
                    ((Object) this.ProcessedFrom).Equals(input.ProcessedFrom))
                ) && 
                (
                    this.ProcessedTo == input.ProcessedTo ||
                    (this.ProcessedTo != null &&
                    ((Object) this.ProcessedTo).Equals(input.ProcessedTo))
                ) && 
                (
                    this.TierNumber == input.TierNumber ||
                    (this.TierNumber != null &&
                    this.TierNumber.Equals(input.TierNumber))
                );
        }

public bool Equals(CreateAccountHolderRequest input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.AccountHolderCode == input.AccountHolderCode ||
                    (this.AccountHolderCode != null &&
                    this.AccountHolderCode.Equals(input.AccountHolderCode))
                ) && 
                (
                    this.AccountHolderDetails == input.AccountHolderDetails ||
                    (this.AccountHolderDetails != null &&
                    this.AccountHolderDetails.Equals(input.AccountHolderDetails))
                ) && 
                (
                    this.CreateDefaultAccount == input.CreateDefaultAccount ||
                    (this.CreateDefaultAccount != null &&
                    this.CreateDefaultAccount.Equals(input.CreateDefaultAccount))
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.LegalEnreplacedy == input.LegalEnreplacedy ||
                    this.LegalEnreplacedy.Equals(input.LegalEnreplacedy)
                ) && 
                (
                    this.PrimaryCurrency == input.PrimaryCurrency ||
                    (this.PrimaryCurrency != null &&
                    this.PrimaryCurrency.Equals(input.PrimaryCurrency))
                ) && 
                (
                    this.ProcessingTier == input.ProcessingTier ||
                    (this.ProcessingTier != null &&
                    this.ProcessingTier.Equals(input.ProcessingTier))
                );
        }

public bool Equals(KYCCheckSummary input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.KycCheckCode == input.KycCheckCode ||
                    (this.KycCheckCode != null &&
                    this.KycCheckCode.Equals(input.KycCheckCode))
                ) && 
                (
                    this.KycCheckDescription == input.KycCheckDescription ||
                    (this.KycCheckDescription != null &&
                    this.KycCheckDescription.Equals(input.KycCheckDescription))
                );
        }

public bool Equals(PerformVerificationRequest input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.AccountHolderCode == input.AccountHolderCode ||
                    (this.AccountHolderCode != null &&
                    this.AccountHolderCode.Equals(input.AccountHolderCode))
                ) && 
                (
                    this.AccountStateType == input.AccountStateType ||
                    this.AccountStateType.Equals(input.AccountStateType)
                ) && 
                (
                    this.Tier == input.Tier ||
                    (this.Tier != null &&
                    this.Tier.Equals(input.Tier))
                );
        }

public bool Equals(TransactionListForAccount input)
        {
            if (input == null)
                return false;

            return
                (
                    this.AccountCode == input.AccountCode ||
                    (this.AccountCode != null &&
                    this.AccountCode.Equals(input.AccountCode))
                ) &&
                (
                    this.Page == input.Page ||
                    (this.Page != null &&
                    this.Page.Equals(input.Page))
                );
        }

public bool Equals(UpdateAccountHolderRequest input)
        {
            if (input == null)
                return false;

            return 
                (
                    this.AccountHolderCode == input.AccountHolderCode ||
                    (this.AccountHolderCode != null &&
                    this.AccountHolderCode.Equals(input.AccountHolderCode))
                ) && 
                (
                    this.AccountHolderDetails == input.AccountHolderDetails ||
                    (this.AccountHolderDetails != null &&
                    this.AccountHolderDetails.Equals(input.AccountHolderDetails))
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.LegalEnreplacedy == input.LegalEnreplacedy ||
                    (this.LegalEnreplacedy != null &&
                    this.LegalEnreplacedy.Equals(input.LegalEnreplacedy))
                ) && 
                (
                    this.PrimaryCurrency == input.PrimaryCurrency ||
                    (this.PrimaryCurrency != null &&
                    this.PrimaryCurrency.Equals(input.PrimaryCurrency))
                ) && 
                (
                    this.ProcessingTier == input.ProcessingTier ||
                    (this.ProcessingTier != null &&
                    this.ProcessingTier.Equals(input.ProcessingTier))
                );
        }

public bool Equals(FraudResult other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.AccountScore == other.AccountScore ||
                    this.AccountScore != null &&
                    this.AccountScore.Equals(other.AccountScore)
                );
        }

public bool Equals(Installments other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Value == other.Value ||
                    this.Value != null &&
                    this.Value.Equals(other.Value)
                );
        }

public DynamoDBEntry ToEntry(object value) => default(int).Equals(value) ? null : (DynamoDBEntry) (int) value;

public bool Equals(Bearer other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return
                (
                    this.TokenType == other.TokenType ||
                    this.TokenType != null &&
                    this.TokenType.Equals(other.TokenType)
                ) &&
                (
                    this.ExpiresIn == other.ExpiresIn ||
                    this.ExpiresIn != null &&
                    this.ExpiresIn.Equals(other.ExpiresIn)
                ) &&
                (
                    this.AccessToken == other.AccessToken ||
                    this.AccessToken != null &&
                    this.AccessToken.Equals(other.AccessToken)
                ) &&
                (
                    this.RefreshToken == other.RefreshToken ||
                    this.RefreshToken != null &&
                    this.RefreshToken.Equals(other.RefreshToken)
                );
        }

public bool Equals(Engine other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Id == other.Id ||
                    this.Id != null &&
                    this.Id.Equals(other.Id)
                ) && 
                (
                    this.Resource == other.Resource ||
                    this.Resource != null &&
                    this.Resource.Equals(other.Resource)
                ) && 
                (
                    this.IsPublic == other.IsPublic ||
                    this.IsPublic != null &&
                    this.IsPublic.Equals(other.IsPublic)
                ) && 
                (
                    this.Version == other.Version ||
                    this.Version != null &&
                    this.Version.Equals(other.Version)
                ) && 
                (
                    this.Timestamp == other.Timestamp ||
                    this.Timestamp != null &&
                    this.Timestamp.Equals(other.Timestamp)
                ) && 
                (
                    this.Description == other.Description ||
                    this.Description != null &&
                    this.Description.Equals(other.Description)
                );
        }

public bool Equals(FolderAttributes other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Name == other.Name ||
                    this.Name != null &&
                    this.Name.Equals(other.Name)
                ) && 
                (
                    this.DisplayName == other.DisplayName ||
                    this.DisplayName != null &&
                    this.DisplayName.Equals(other.DisplayName)
                ) && 
                (
                    this.ObjectCount == other.ObjectCount ||
                    this.ObjectCount != null &&
                    this.ObjectCount.Equals(other.ObjectCount)
                ) && 
                (
                    this.Extension == other.Extension ||
                    this.Extension != null &&
                    this.Extension.Equals(other.Extension)
                );
        }

public bool Equals(JobThumbnailOutputPayloadAdvanced other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Width == other.Width ||
                    this.Width != null &&
                    this.Width.Equals(other.Width)
                ) && 
                (
                    this.Height == other.Height ||
                    this.Height != null &&
                    this.Height.Equals(other.Height)
                );
        }

public bool Equals(MetadataCollection other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Objectid == other.Objectid ||
                    this.Objectid != null &&
                    this.Objectid.Equals(other.Objectid)
                ) && 
                (
                    this.Name == other.Name ||
                    this.Name != null &&
                    this.Name.Equals(other.Name)
                ) && 
                (
                    this.Properties == other.Properties ||
                    this.Properties != null &&
                    this.Properties.Equals(other.Properties)
                );
        }

public bool Equals(MetadataObject other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Objectid == other.Objectid ||
                    this.Objectid != null &&
                    this.Objectid.Equals(other.Objectid)
                ) && 
                (
                    this.Name == other.Name ||
                    this.Name != null &&
                    this.Name.Equals(other.Name)
                ) && 
                (
                    this.Objects == other.Objects ||
                    this.Objects != null &&
                    this.Objects.SequenceEqual(other.Objects)
                );
        }

public bool Equals(ObjectFullDetails other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.BucketKey == other.BucketKey ||
                    this.BucketKey != null &&
                    this.BucketKey.Equals(other.BucketKey)
                ) && 
                (
                    this.ObjectId == other.ObjectId ||
                    this.ObjectId != null &&
                    this.ObjectId.Equals(other.ObjectId)
                ) && 
                (
                    this.ObjectKey == other.ObjectKey ||
                    this.ObjectKey != null &&
                    this.ObjectKey.Equals(other.ObjectKey)
                ) && 
                (
                    this.Sha1 == other.Sha1 ||
                    this.Sha1 != null &&
                    this.Sha1.Equals(other.Sha1)
                ) && 
                (
                    this.Size == other.Size ||
                    this.Size != null &&
                    this.Size.Equals(other.Size)
                ) && 
                (
                    this.ContentType == other.ContentType ||
                    this.ContentType != null &&
                    this.ContentType.Equals(other.ContentType)
                ) && 
                (
                    this.Location == other.Location ||
                    this.Location != null &&
                    this.Location.Equals(other.Location)
                ) && 
                (
                    this.BlockSizes == other.BlockSizes ||
                    this.BlockSizes != null &&
                    this.BlockSizes.SequenceEqual(other.BlockSizes)
                ) && 
                (
                    this.Deltas == other.Deltas ||
                    this.Deltas != null &&
                    this.Deltas.SequenceEqual(other.Deltas)
                );
        }

public bool Equals(ObjectFullDetailsDeltas other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Position == other.Position ||
                    this.Position != null &&
                    this.Position.Equals(other.Position)
                ) && 
                (
                    this.Sha1 == other.Sha1 ||
                    this.Sha1 != null &&
                    this.Sha1.Equals(other.Sha1)
                );
        }

public bool Equals(ObjectDetails other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.BucketKey == other.BucketKey ||
                    this.BucketKey != null &&
                    this.BucketKey.Equals(other.BucketKey)
                ) && 
                (
                    this.ObjectId == other.ObjectId ||
                    this.ObjectId != null &&
                    this.ObjectId.Equals(other.ObjectId)
                ) && 
                (
                    this.ObjectKey == other.ObjectKey ||
                    this.ObjectKey != null &&
                    this.ObjectKey.Equals(other.ObjectKey)
                ) && 
                (
                    this.Sha1 == other.Sha1 ||
                    this.Sha1 != null &&
                    this.Sha1.Equals(other.Sha1)
                ) && 
                (
                    this.Size == other.Size ||
                    this.Size != null &&
                    this.Size.Equals(other.Size)
                ) && 
                (
                    this.ContentType == other.ContentType ||
                    this.ContentType != null &&
                    this.ContentType.Equals(other.ContentType)
                ) && 
                (
                    this.Location == other.Location ||
                    this.Location != null &&
                    this.Location.Equals(other.Location)
                );
        }

public bool Equals(PostBucketsSigned other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.MinutesExpiration == other.MinutesExpiration ||
                    this.MinutesExpiration != null &&
                    this.MinutesExpiration.Equals(other.MinutesExpiration)
                );
        }

public bool Equals(VersionAttributes other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Name == other.Name ||
                    this.Name != null &&
                    this.Name.Equals(other.Name)
                ) && 
                (
                    this.DisplayName == other.DisplayName ||
                    this.DisplayName != null &&
                    this.DisplayName.Equals(other.DisplayName)
                ) && 
                (
                    this.VersionNumber == other.VersionNumber ||
                    this.VersionNumber != null &&
                    this.VersionNumber.Equals(other.VersionNumber)
                ) && 
                (
                    this.MimeType == other.MimeType ||
                    this.MimeType != null &&
                    this.MimeType.Equals(other.MimeType)
                ) && 
                (
                    this.FileType == other.FileType ||
                    this.FileType != null &&
                    this.FileType.Equals(other.FileType)
                ) && 
                (
                    this.StorageSize == other.StorageSize ||
                    this.StorageSize != null &&
                    this.StorageSize.Equals(other.StorageSize)
                ) && 
                (
                    this.Extension == other.Extension ||
                    this.Extension != null &&
                    this.Extension.Equals(other.Extension)
                );
        }

SolveResults Compute (string cubeMap, string equiMap, int w)
        {
            var rc = new SolveResults();
            Boolean converted = false;
            string equiFileLoc = string.Empty;
  
            if (!File.Exists(cubeMap))
            {
                AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Cubemap file path does not exist.");
                rc.Converted = converted;
                rc.EquiFileLoc = equiFileLoc;
                return rc;
            }

            else if (cubeMap == equiMap)
            {
                AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Cubemap file path and equirectangular file path are the same. Cubemap not converted.");
                rc.Converted = converted;
                rc.EquiFileLoc = equiFileLoc;
                return rc;
            }

            else
            {
                if (File.Exists(equiMap))
                {
                    AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Existing file overwritten: " + equiMap);
                }

                if (!Directory.Exists(Path.GetDirectoryName(equiMap)))
                {
                    Directory.CreateDirectory(Path.GetDirectoryName(equiMap));
                }

                try
                {
                    using (Bitmap bm = new Bitmap(cubeMap))
                    {
                        Bitmap equi = new Bitmap(bm.Width, bm.Height, bm.PixelFormat);
                        if ((w < 1) || (w.Equals(null)))
                        {
                            w = bm.Width;
                        }
                        equi = ConvertCubicToEquirectangular(bm,w);
                        equi.Save(equiMap);
                        equi.Dispose();
                        bm.Dispose();
                        equiFileLoc = equiMap;
                        converted = true;
                    }
                }

                catch
                {
                    AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Could not load image from file path: " + cubeMap);
                }

                rc.Converted = converted;
                rc.EquiFileLoc = equiFileLoc;

                return rc;
            }

        }

public override bool IsDBNull(int ordinal)
            => _wrappedDataReader.IsDBNull(ordinal) ||
               JetConfiguration.IntegerNullValue != null && ((int) JetConfiguration.IntegerNullValue).Equals(GetValue(ordinal));

public bool Equals(Account other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Id == other.Id ||
                    this.Id != null &&
                    this.Id.Equals(other.Id)
                ) && 
                (
                    this.Alias == other.Alias ||
                    this.Alias != null &&
                    this.Alias.Equals(other.Alias)
                ) && 
                (
                    this.Currency == other.Currency ||
                    this.Currency != null &&
                    this.Currency.Equals(other.Currency)
                ) && 
                (
                    this.Balance == other.Balance ||
                    this.Balance != null &&
                    this.Balance.Equals(other.Balance)
                ) && 
                (
                    this.CreatedByUserID == other.CreatedByUserID ||
                    this.CreatedByUserID != null &&
                    this.CreatedByUserID.Equals(other.CreatedByUserID)
                ) && 
                (
                    this.CreatedTime == other.CreatedTime ||
                    this.CreatedTime != null &&
                    this.CreatedTime.Equals(other.CreatedTime)
                ) && 
                (
                    this.Pl == other.Pl ||
                    this.Pl != null &&
                    this.Pl.Equals(other.Pl)
                ) && 
                (
                    this.ResettablePL == other.ResettablePL ||
                    this.ResettablePL != null &&
                    this.ResettablePL.Equals(other.ResettablePL)
                ) && 
                (
                    this.ResettabledPLTime == other.ResettabledPLTime ||
                    this.ResettabledPLTime != null &&
                    this.ResettabledPLTime.Equals(other.ResettabledPLTime)
                ) && 
                (
                    this.MarginRate == other.MarginRate ||
                    this.MarginRate != null &&
                    this.MarginRate.Equals(other.MarginRate)
                ) && 
                (
                    this.MarginCallEnterTime == other.MarginCallEnterTime ||
                    this.MarginCallEnterTime != null &&
                    this.MarginCallEnterTime.Equals(other.MarginCallEnterTime)
                ) && 
                (
                    this.MarginCallExtensionCount == other.MarginCallExtensionCount ||
                    this.MarginCallExtensionCount != null &&
                    this.MarginCallExtensionCount.Equals(other.MarginCallExtensionCount)
                ) && 
                (
                    this.LastMarginCallExtensionTime == other.LastMarginCallExtensionTime ||
                    this.LastMarginCallExtensionTime != null &&
                    this.LastMarginCallExtensionTime.Equals(other.LastMarginCallExtensionTime)
                ) && 
                (
                    this.OpenTradeCount == other.OpenTradeCount ||
                    this.OpenTradeCount != null &&
                    this.OpenTradeCount.Equals(other.OpenTradeCount)
                ) && 
                (
                    this.OpenPositionCount == other.OpenPositionCount ||
                    this.OpenPositionCount != null &&
                    this.OpenPositionCount.Equals(other.OpenPositionCount)
                ) && 
                (
                    this.PendingOrderCount == other.PendingOrderCount ||
                    this.PendingOrderCount != null &&
                    this.PendingOrderCount.Equals(other.PendingOrderCount)
                ) && 
                (
                    this.HedgingEnabled == other.HedgingEnabled ||
                    this.HedgingEnabled != null &&
                    this.HedgingEnabled.Equals(other.HedgingEnabled)
                ) && 
                (
                    this.UnrealizedPL == other.UnrealizedPL ||
                    this.UnrealizedPL != null &&
                    this.UnrealizedPL.Equals(other.UnrealizedPL)
                ) && 
                (
                    this.NAV == other.NAV ||
                    this.NAV != null &&
                    this.NAV.Equals(other.NAV)
                ) && 
                (
                    this.MarginUsed == other.MarginUsed ||
                    this.MarginUsed != null &&
                    this.MarginUsed.Equals(other.MarginUsed)
                ) && 
                (
                    this.MarginAvailable == other.MarginAvailable ||
                    this.MarginAvailable != null &&
                    this.MarginAvailable.Equals(other.MarginAvailable)
                ) && 
                (
                    this.PositionValue == other.PositionValue ||
                    this.PositionValue != null &&
                    this.PositionValue.Equals(other.PositionValue)
                ) && 
                (
                    this.MarginCloseoutUnrealizedPL == other.MarginCloseoutUnrealizedPL ||
                    this.MarginCloseoutUnrealizedPL != null &&
                    this.MarginCloseoutUnrealizedPL.Equals(other.MarginCloseoutUnrealizedPL)
                ) && 
                (
                    this.MarginCloseoutNAV == other.MarginCloseoutNAV ||
                    this.MarginCloseoutNAV != null &&
                    this.MarginCloseoutNAV.Equals(other.MarginCloseoutNAV)
                ) && 
                (
                    this.MarginCloseoutMarginUsed == other.MarginCloseoutMarginUsed ||
                    this.MarginCloseoutMarginUsed != null &&
                    this.MarginCloseoutMarginUsed.Equals(other.MarginCloseoutMarginUsed)
                ) && 
                (
                    this.MarginCloseoutPercent == other.MarginCloseoutPercent ||
                    this.MarginCloseoutPercent != null &&
                    this.MarginCloseoutPercent.Equals(other.MarginCloseoutPercent)
                ) && 
                (
                    this.MarginCloseoutPositionValue == other.MarginCloseoutPositionValue ||
                    this.MarginCloseoutPositionValue != null &&
                    this.MarginCloseoutPositionValue.Equals(other.MarginCloseoutPositionValue)
                ) && 
                (
                    this.WithdrawalLimit == other.WithdrawalLimit ||
                    this.WithdrawalLimit != null &&
                    this.WithdrawalLimit.Equals(other.WithdrawalLimit)
                ) && 
                (
                    this.MarginCallMarginUsed == other.MarginCallMarginUsed ||
                    this.MarginCallMarginUsed != null &&
                    this.MarginCallMarginUsed.Equals(other.MarginCallMarginUsed)
                ) && 
                (
                    this.MarginCallPercent == other.MarginCallPercent ||
                    this.MarginCallPercent != null &&
                    this.MarginCallPercent.Equals(other.MarginCallPercent)
                ) && 
                (
                    this.LastTransactionID == other.LastTransactionID ||
                    this.LastTransactionID != null &&
                    this.LastTransactionID.Equals(other.LastTransactionID)
                ) && 
                (
                    this.Trades == other.Trades ||
                    this.Trades != null &&
                    this.Trades.SequenceEqual(other.Trades)
                ) && 
                (
                    this.Positions == other.Positions ||
                    this.Positions != null &&
                    this.Positions.SequenceEqual(other.Positions)
                ) && 
                (
                    this.Orders == other.Orders ||
                    this.Orders != null &&
                    this.Orders.SequenceEqual(other.Orders)
                );
        }

public bool Equals(AccountSummary other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Id == other.Id ||
                    this.Id != null &&
                    this.Id.Equals(other.Id)
                ) && 
                (
                    this.Alias == other.Alias ||
                    this.Alias != null &&
                    this.Alias.Equals(other.Alias)
                ) && 
                (
                    this.Currency == other.Currency ||
                    this.Currency != null &&
                    this.Currency.Equals(other.Currency)
                ) && 
                (
                    this.Balance == other.Balance ||
                    this.Balance != null &&
                    this.Balance.Equals(other.Balance)
                ) && 
                (
                    this.CreatedByUserID == other.CreatedByUserID ||
                    this.CreatedByUserID != null &&
                    this.CreatedByUserID.Equals(other.CreatedByUserID)
                ) && 
                (
                    this.CreatedTime == other.CreatedTime ||
                    this.CreatedTime != null &&
                    this.CreatedTime.Equals(other.CreatedTime)
                ) && 
                (
                    this.Pl == other.Pl ||
                    this.Pl != null &&
                    this.Pl.Equals(other.Pl)
                ) && 
                (
                    this.ResettablePL == other.ResettablePL ||
                    this.ResettablePL != null &&
                    this.ResettablePL.Equals(other.ResettablePL)
                ) && 
                (
                    this.ResettabledPLTime == other.ResettabledPLTime ||
                    this.ResettabledPLTime != null &&
                    this.ResettabledPLTime.Equals(other.ResettabledPLTime)
                ) && 
                (
                    this.MarginRate == other.MarginRate ||
                    this.MarginRate != null &&
                    this.MarginRate.Equals(other.MarginRate)
                ) && 
                (
                    this.MarginCallEnterTime == other.MarginCallEnterTime ||
                    this.MarginCallEnterTime != null &&
                    this.MarginCallEnterTime.Equals(other.MarginCallEnterTime)
                ) && 
                (
                    this.MarginCallExtensionCount == other.MarginCallExtensionCount ||
                    this.MarginCallExtensionCount != null &&
                    this.MarginCallExtensionCount.Equals(other.MarginCallExtensionCount)
                ) && 
                (
                    this.LastMarginCallExtensionTime == other.LastMarginCallExtensionTime ||
                    this.LastMarginCallExtensionTime != null &&
                    this.LastMarginCallExtensionTime.Equals(other.LastMarginCallExtensionTime)
                ) && 
                (
                    this.OpenTradeCount == other.OpenTradeCount ||
                    this.OpenTradeCount != null &&
                    this.OpenTradeCount.Equals(other.OpenTradeCount)
                ) && 
                (
                    this.OpenPositionCount == other.OpenPositionCount ||
                    this.OpenPositionCount != null &&
                    this.OpenPositionCount.Equals(other.OpenPositionCount)
                ) && 
                (
                    this.PendingOrderCount == other.PendingOrderCount ||
                    this.PendingOrderCount != null &&
                    this.PendingOrderCount.Equals(other.PendingOrderCount)
                ) && 
                (
                    this.HedgingEnabled == other.HedgingEnabled ||
                    this.HedgingEnabled != null &&
                    this.HedgingEnabled.Equals(other.HedgingEnabled)
                ) && 
                (
                    this.UnrealizedPL == other.UnrealizedPL ||
                    this.UnrealizedPL != null &&
                    this.UnrealizedPL.Equals(other.UnrealizedPL)
                ) && 
                (
                    this.NAV == other.NAV ||
                    this.NAV != null &&
                    this.NAV.Equals(other.NAV)
                ) && 
                (
                    this.MarginUsed == other.MarginUsed ||
                    this.MarginUsed != null &&
                    this.MarginUsed.Equals(other.MarginUsed)
                ) && 
                (
                    this.MarginAvailable == other.MarginAvailable ||
                    this.MarginAvailable != null &&
                    this.MarginAvailable.Equals(other.MarginAvailable)
                ) && 
                (
                    this.PositionValue == other.PositionValue ||
                    this.PositionValue != null &&
                    this.PositionValue.Equals(other.PositionValue)
                ) && 
                (
                    this.MarginCloseoutUnrealizedPL == other.MarginCloseoutUnrealizedPL ||
                    this.MarginCloseoutUnrealizedPL != null &&
                    this.MarginCloseoutUnrealizedPL.Equals(other.MarginCloseoutUnrealizedPL)
                ) && 
                (
                    this.MarginCloseoutNAV == other.MarginCloseoutNAV ||
                    this.MarginCloseoutNAV != null &&
                    this.MarginCloseoutNAV.Equals(other.MarginCloseoutNAV)
                ) && 
                (
                    this.MarginCloseoutMarginUsed == other.MarginCloseoutMarginUsed ||
                    this.MarginCloseoutMarginUsed != null &&
                    this.MarginCloseoutMarginUsed.Equals(other.MarginCloseoutMarginUsed)
                ) && 
                (
                    this.MarginCloseoutPercent == other.MarginCloseoutPercent ||
                    this.MarginCloseoutPercent != null &&
                    this.MarginCloseoutPercent.Equals(other.MarginCloseoutPercent)
                ) && 
                (
                    this.MarginCloseoutPositionValue == other.MarginCloseoutPositionValue ||
                    this.MarginCloseoutPositionValue != null &&
                    this.MarginCloseoutPositionValue.Equals(other.MarginCloseoutPositionValue)
                ) && 
                (
                    this.WithdrawalLimit == other.WithdrawalLimit ||
                    this.WithdrawalLimit != null &&
                    this.WithdrawalLimit.Equals(other.WithdrawalLimit)
                ) && 
                (
                    this.MarginCallMarginUsed == other.MarginCallMarginUsed ||
                    this.MarginCallMarginUsed != null &&
                    this.MarginCallMarginUsed.Equals(other.MarginCallMarginUsed)
                ) && 
                (
                    this.MarginCallPercent == other.MarginCallPercent ||
                    this.MarginCallPercent != null &&
                    this.MarginCallPercent.Equals(other.MarginCallPercent)
                ) && 
                (
                    this.LastTransactionID == other.LastTransactionID ||
                    this.LastTransactionID != null &&
                    this.LastTransactionID.Equals(other.LastTransactionID)
                );
        }

public bool Equals(ClientConfigureRejectTransaction other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Id == other.Id ||
                    this.Id != null &&
                    this.Id.Equals(other.Id)
                ) && 
                (
                    this.Time == other.Time ||
                    this.Time != null &&
                    this.Time.Equals(other.Time)
                ) && 
                (
                    this.UserID == other.UserID ||
                    this.UserID != null &&
                    this.UserID.Equals(other.UserID)
                ) && 
                (
                    this.AccountID == other.AccountID ||
                    this.AccountID != null &&
                    this.AccountID.Equals(other.AccountID)
                ) && 
                (
                    this.BatchID == other.BatchID ||
                    this.BatchID != null &&
                    this.BatchID.Equals(other.BatchID)
                ) && 
                (
                    this.RequestID == other.RequestID ||
                    this.RequestID != null &&
                    this.RequestID.Equals(other.RequestID)
                ) && 
                (
                    this.Type == other.Type ||
                    this.Type != null &&
                    this.Type.Equals(other.Type)
                ) && 
                (
                    this.Alias == other.Alias ||
                    this.Alias != null &&
                    this.Alias.Equals(other.Alias)
                ) && 
                (
                    this.MarginRate == other.MarginRate ||
                    this.MarginRate != null &&
                    this.MarginRate.Equals(other.MarginRate)
                ) && 
                (
                    this.RejectReason == other.RejectReason ||
                    this.RejectReason != null &&
                    this.RejectReason.Equals(other.RejectReason)
                );
        }

public bool Equals(DailyFinancingTransaction other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Id == other.Id ||
                    this.Id != null &&
                    this.Id.Equals(other.Id)
                ) && 
                (
                    this.Time == other.Time ||
                    this.Time != null &&
                    this.Time.Equals(other.Time)
                ) && 
                (
                    this.UserID == other.UserID ||
                    this.UserID != null &&
                    this.UserID.Equals(other.UserID)
                ) && 
                (
                    this.AccountID == other.AccountID ||
                    this.AccountID != null &&
                    this.AccountID.Equals(other.AccountID)
                ) && 
                (
                    this.BatchID == other.BatchID ||
                    this.BatchID != null &&
                    this.BatchID.Equals(other.BatchID)
                ) && 
                (
                    this.RequestID == other.RequestID ||
                    this.RequestID != null &&
                    this.RequestID.Equals(other.RequestID)
                ) && 
                (
                    this.Type == other.Type ||
                    this.Type != null &&
                    this.Type.Equals(other.Type)
                ) && 
                (
                    this.Financing == other.Financing ||
                    this.Financing != null &&
                    this.Financing.Equals(other.Financing)
                ) && 
                (
                    this.AccountBalance == other.AccountBalance ||
                    this.AccountBalance != null &&
                    this.AccountBalance.Equals(other.AccountBalance)
                ) && 
                (
                    this.AccountFinancingMode == other.AccountFinancingMode ||
                    this.AccountFinancingMode != null &&
                    this.AccountFinancingMode.Equals(other.AccountFinancingMode)
                ) && 
                (
                    this.PositionFinancings == other.PositionFinancings ||
                    this.PositionFinancings != null &&
                    this.PositionFinancings.SequenceEqual(other.PositionFinancings)
                );
        }

public bool Equals(DelayedTradeClosureTransaction other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Id == other.Id ||
                    this.Id != null &&
                    this.Id.Equals(other.Id)
                ) && 
                (
                    this.Time == other.Time ||
                    this.Time != null &&
                    this.Time.Equals(other.Time)
                ) && 
                (
                    this.UserID == other.UserID ||
                    this.UserID != null &&
                    this.UserID.Equals(other.UserID)
                ) && 
                (
                    this.AccountID == other.AccountID ||
                    this.AccountID != null &&
                    this.AccountID.Equals(other.AccountID)
                ) && 
                (
                    this.BatchID == other.BatchID ||
                    this.BatchID != null &&
                    this.BatchID.Equals(other.BatchID)
                ) && 
                (
                    this.RequestID == other.RequestID ||
                    this.RequestID != null &&
                    this.RequestID.Equals(other.RequestID)
                ) && 
                (
                    this.Type == other.Type ||
                    this.Type != null &&
                    this.Type.Equals(other.Type)
                ) && 
                (
                    this.Reason == other.Reason ||
                    this.Reason != null &&
                    this.Reason.Equals(other.Reason)
                ) && 
                (
                    this.TradeIDs == other.TradeIDs ||
                    this.TradeIDs != null &&
                    this.TradeIDs.Equals(other.TradeIDs)
                );
        }

public bool Equals(AccountProperties other)
        {
            // credit: http://stackoverflow.com/a/10454552/677735
            if (other == null)
                return false;

            return 
                (
                    this.Id == other.Id ||
                    this.Id != null &&
                    this.Id.Equals(other.Id)
                ) && 
                (
                    this.Mt4AccountID == other.Mt4AccountID ||
                    this.Mt4AccountID != null &&
                    this.Mt4AccountID.Equals(other.Mt4AccountID)
                ) && 
                (
                    this.Tags == other.Tags ||
                    this.Tags != null &&
                    this.Tags.SequenceEqual(other.Tags)
                );
        }