System.DateTime.Equals(object)

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(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(CreatePaymentLinkRequest input)
        {
            if (input == null)
                return false;

            return
                (
                    this.AllowedPaymentMethods == input.AllowedPaymentMethods ||
                    this.AllowedPaymentMethods != null &&
                    input.AllowedPaymentMethods != null &&
                    this.AllowedPaymentMethods.SequenceEqual(input.AllowedPaymentMethods)
                ) &&
                (
                    this.Amount == input.Amount ||
                    this.Amount != null &&
                    this.Amount.Equals(input.Amount)
                ) &&
                (
                    this.ApplicationInfo == input.ApplicationInfo ||
                    this.ApplicationInfo != null &&
                    this.ApplicationInfo.Equals(input.ApplicationInfo)
                ) &&
                (
                    this.BillingAddress == input.BillingAddress ||
                    this.BillingAddress != null &&
                    this.BillingAddress.Equals(input.BillingAddress)
                ) &&
                (
                    this.BlockedPaymentMethods == input.BlockedPaymentMethods ||
                    this.BlockedPaymentMethods != null &&
                    input.BlockedPaymentMethods != null &&
                    this.BlockedPaymentMethods.SequenceEqual(input.BlockedPaymentMethods)
                ) &&
                (
                    this.CountryCode == input.CountryCode ||
                    this.CountryCode != null &&
                    this.CountryCode.Equals(input.CountryCode)
                ) &&
                (
                    this.DeliverAt == input.DeliverAt ||
                    this.DeliverAt != null &&
                    this.DeliverAt.Equals(input.DeliverAt)
                ) &&
                (
                    this.DeliveryAddress == input.DeliveryAddress ||
                    this.DeliveryAddress != null &&
                    this.DeliveryAddress.Equals(input.DeliveryAddress)
                ) &&
                (
                    this.Description == input.Description ||
                    this.Description != null &&
                    this.Description.Equals(input.Description)
                ) &&
                (
                    this.ExpiresAt == input.ExpiresAt ||
                    this.ExpiresAt != null &&
                    this.ExpiresAt.Equals(input.ExpiresAt)
                ) &&
                (
                    this.InstallmentOptions == input.InstallmentOptions ||
                    this.InstallmentOptions != null &&
                    input.InstallmentOptions != null &&
                    this.InstallmentOptions.SequenceEqual(input.InstallmentOptions)
                ) &&
                (
                    this.LineItems == input.LineItems ||
                    this.LineItems != null &&
                    input.LineItems != null &&
                    this.LineItems.SequenceEqual(input.LineItems)
                ) &&
                (
                    this.MerchantAccount == input.MerchantAccount ||
                    this.MerchantAccount != null &&
                    this.MerchantAccount.Equals(input.MerchantAccount)
                ) &&
                (
                    this.MerchantOrderReference == input.MerchantOrderReference ||
                    this.MerchantOrderReference != null &&
                    this.MerchantOrderReference.Equals(input.MerchantOrderReference)
                ) &&
                (
                    this.Metadata == input.Metadata ||
                    this.Metadata != null &&
                    input.Metadata != null &&
                    this.Metadata.SequenceEqual(input.Metadata)
                ) &&
                (
                    this.RecurringProcessingModel == input.RecurringProcessingModel ||
                    this.RecurringProcessingModel != null &&
                    this.RecurringProcessingModel.Equals(input.RecurringProcessingModel)
                ) &&
                (
                    this.Reference == input.Reference ||
                    this.Reference != null &&
                    this.Reference.Equals(input.Reference)
                ) &&
                (
                    this.ReturnUrl == input.ReturnUrl ||
                    this.ReturnUrl != null &&
                    this.ReturnUrl.Equals(input.ReturnUrl)
                ) &&
                (
                    this.Reusable == input.Reusable ||
                    this.Reusable != null &&
                    this.Reusable.Equals(input.Reusable)
                ) &&
                (
                    this.RiskData == input.RiskData ||
                    this.RiskData != null &&
                    this.RiskData.Equals(input.RiskData)
                ) &&
                (
                    this.ShopperEmail == input.ShopperEmail ||
                    this.ShopperEmail != null &&
                    this.ShopperEmail.Equals(input.ShopperEmail)
                ) &&
                (
                    this.ShopperLocale == input.ShopperLocale ||
                    this.ShopperLocale != null &&
                    this.ShopperLocale.Equals(input.ShopperLocale)
                ) &&
                (
                    this.ShopperName == input.ShopperName ||
                    this.ShopperName != null &&
                    this.ShopperName.Equals(input.ShopperName)
                ) &&
                (
                    this.ShopperReference == input.ShopperReference ||
                    this.ShopperReference != null &&
                    this.ShopperReference.Equals(input.ShopperReference)
                ) &&
                (
                    this.Splits == input.Splits ||
                    this.Splits != null &&
                    input.Splits != null &&
                    this.Splits.SequenceEqual(input.Splits)
                ) &&
                (
                    this.Store == input.Store ||
                    this.Store != null &&
                    this.Store.Equals(input.Store)
                ) &&
                (
                    this.StorePaymentMethod == input.StorePaymentMethod ||
                    this.StorePaymentMethod != null &&
                    this.StorePaymentMethod.Equals(input.StorePaymentMethod)
                );
        }

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(PaymentLinkResource input)
        {
            if (input == null)
                return false;

            return
                (
                    this.AllowedPaymentMethods == input.AllowedPaymentMethods ||
                    this.AllowedPaymentMethods != null &&
                    input.AllowedPaymentMethods != null &&
                    this.AllowedPaymentMethods.SequenceEqual(input.AllowedPaymentMethods)
                ) &&
                (
                    this.Amount == input.Amount ||
                    this.Amount != null &&
                    this.Amount.Equals(input.Amount)
                ) &&
                (
                    this.ApplicationInfo == input.ApplicationInfo ||
                    this.ApplicationInfo != null &&
                    this.ApplicationInfo.Equals(input.ApplicationInfo)
                ) &&
                (
                    this.BillingAddress == input.BillingAddress ||
                    this.BillingAddress != null &&
                    this.BillingAddress.Equals(input.BillingAddress)
                ) &&
                (
                    this.BlockedPaymentMethods == input.BlockedPaymentMethods ||
                    this.BlockedPaymentMethods != null &&
                    input.BlockedPaymentMethods != null &&
                    this.BlockedPaymentMethods.SequenceEqual(input.BlockedPaymentMethods)
                ) &&
                (
                    this.CountryCode == input.CountryCode ||
                    this.CountryCode != null &&
                    this.CountryCode.Equals(input.CountryCode)
                ) &&
                (
                    this.DeliverAt == input.DeliverAt ||
                    this.DeliverAt != null &&
                    this.DeliverAt.Equals(input.DeliverAt)
                ) &&
                (
                    this.DeliveryAddress == input.DeliveryAddress ||
                    this.DeliveryAddress != null &&
                    this.DeliveryAddress.Equals(input.DeliveryAddress)
                ) &&
                (
                    this.Description == input.Description ||
                    this.Description != null &&
                    this.Description.Equals(input.Description)
                ) &&
                (
                    this.ExpiresAt == input.ExpiresAt ||
                    this.ExpiresAt != null &&
                    this.ExpiresAt.Equals(input.ExpiresAt)
                ) &&
                (
                    this.Id == input.Id ||
                    this.Id != null &&
                    this.Id.Equals(input.Id)
                ) &&
                (
                    this.LineItems == input.LineItems ||
                    this.LineItems != null &&
                    input.LineItems != null &&
                    this.LineItems.SequenceEqual(input.LineItems)
                ) &&
                (
                    this.MerchantAccount == input.MerchantAccount ||
                    this.MerchantAccount != null &&
                    this.MerchantAccount.Equals(input.MerchantAccount)
                ) &&
                (
                    this.MerchantOrderReference == input.MerchantOrderReference ||
                    this.MerchantOrderReference != null &&
                    this.MerchantOrderReference.Equals(input.MerchantOrderReference)
                ) &&
                (
                    this.RecurringProcessingModel == input.RecurringProcessingModel ||
                    this.RecurringProcessingModel != null &&
                    this.RecurringProcessingModel.Equals(input.RecurringProcessingModel)
                ) &&
                (
                    this.Reference == input.Reference ||
                    this.Reference != null &&
                    this.Reference.Equals(input.Reference)
                ) &&
                (
                    this.ReturnUrl == input.ReturnUrl ||
                    this.ReturnUrl != null &&
                    this.ReturnUrl.Equals(input.ReturnUrl)
                ) &&
                (
                    this.Reusable == input.Reusable ||
                    this.Reusable != null &&
                    this.Reusable.Equals(input.Reusable)
                ) &&
                (
                    this.RiskData == input.RiskData ||
                    this.RiskData != null &&
                    this.RiskData.Equals(input.RiskData)
                ) &&
                (
                    this.ShopperEmail == input.ShopperEmail ||
                    this.ShopperEmail != null &&
                    this.ShopperEmail.Equals(input.ShopperEmail)
                ) &&
                (
                    this.ShopperLocale == input.ShopperLocale ||
                    this.ShopperLocale != null &&
                    this.ShopperLocale.Equals(input.ShopperLocale)
                ) &&
                (
                    this.ShopperName == input.ShopperName ||
                    this.ShopperName != null &&
                    this.ShopperName.Equals(input.ShopperName)
                ) &&
                (
                    this.ShopperReference == input.ShopperReference ||
                    this.ShopperReference != null &&
                    this.ShopperReference.Equals(input.ShopperReference)
                ) &&
                (
                    this.Splits == input.Splits ||
                    this.Splits != null &&
                    input.Splits != null &&
                    this.Splits.SequenceEqual(input.Splits)
                ) &&
                (
                    this.Status == input.Status ||
                    this.Status != null &&
                    this.Status.Equals(input.Status)
                ) &&
                (
                    this.Store == input.Store ||
                    this.Store != null &&
                    this.Store.Equals(input.Store)
                ) &&
                (
                    this.StorePaymentMethod == input.StorePaymentMethod ||
                    this.StorePaymentMethod != null &&
                    this.StorePaymentMethod.Equals(input.StorePaymentMethod)
                ) &&
                (
                    this.Url == input.Url ||
                    this.Url != null &&
                    this.Url.Equals(input.Url)
                );
        }

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

            return
                (
                    this.Contract == input.Contract ||
                    this.Contract != null &&
                    this.Contract.Equals(input.Contract)
                ) &&
                (
                    this.RecurringDetailName == input.RecurringDetailName ||
                    this.RecurringDetailName != null &&
                    this.RecurringDetailName.Equals(input.RecurringDetailName)
                ) &&
                (
                    this.RecurringExpiry == input.RecurringExpiry ||
                    this.RecurringExpiry != null &&
                    this.RecurringExpiry.Equals(input.RecurringExpiry)
                ) &&
                (
                    this.RecurringFrequency == input.RecurringFrequency ||
                    this.RecurringFrequency != null &&
                    this.RecurringFrequency.Equals(input.RecurringFrequency)
                ) &&
                (
                    this.TokenService == input.TokenService ||
                    this.TokenService != null &&
                    this.TokenService.Equals(input.TokenService)
                );
        }

public bool Equals(GetAccountHolderResponse 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.AccountHolderStatus == input.AccountHolderStatus ||
                    (this.AccountHolderStatus != null &&
                    this.AccountHolderStatus.Equals(input.AccountHolderStatus))
                ) && 
                (
                    this.Accounts == input.Accounts ||
                    this.Accounts != null &&
                    input.Accounts != null &&
                    this.Accounts.SequenceEqual(input.Accounts)
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.InvalidFields == input.InvalidFields ||
                    this.InvalidFields != null &&
                    input.InvalidFields != null &&
                    this.InvalidFields.SequenceEqual(input.InvalidFields)
                ) && 
                (
                    this.LegalEnreplacedy == input.LegalEnreplacedy ||
                    this.LegalEnreplacedy.Equals(input.LegalEnreplacedy)
                ) && 
                (
                    this.PrimaryCurrency == input.PrimaryCurrency ||
                    (this.PrimaryCurrency != null &&
                    this.PrimaryCurrency.Equals(input.PrimaryCurrency))
                ) && 
                (
                    this.PspReference == input.PspReference ||
                    (this.PspReference != null &&
                    this.PspReference.Equals(input.PspReference))
                ) && 
                (
                    this.ResultCode == input.ResultCode ||
                    (this.ResultCode != null &&
                    this.ResultCode.Equals(input.ResultCode))
                ) && 
                (
                    this.SystemUpToDateTime == input.SystemUpToDateTime ||
                    (this.SystemUpToDateTime != null &&
                    this.SystemUpToDateTime.Equals(input.SystemUpToDateTime))
                ) && 
                (
                    this.Verification == input.Verification ||
                    (this.Verification != null &&
                    this.Verification.Equals(input.Verification))
                );
        }

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

            return
                (
                    this.Amount == input.Amount ||
                    (this.Amount != null &&
                    this.Amount.Equals(input.Amount))
                ) &&
                (
                    this.BankAccountDetail == input.BankAccountDetail ||
                    (this.BankAccountDetail != null &&
                    this.BankAccountDetail.Equals(input.BankAccountDetail))
                ) &&
                (
                    this.CaptureMerchantReference == input.CaptureMerchantReference ||
                    (this.CaptureMerchantReference != null &&
                    this.CaptureMerchantReference.Equals(input.CaptureMerchantReference))
                ) &&
                (
                    this.CapturePspReference == input.CapturePspReference ||
                    (this.CapturePspReference != null &&
                    this.CapturePspReference.Equals(input.CapturePspReference))
                ) &&
                (
                    this.CreationDate == input.CreationDate ||
                    (this.CreationDate != null &&
                    this.CreationDate.Equals(input.CreationDate))
                ) &&
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) &&
                (
                    this.DestinationAccountCode == input.DestinationAccountCode ||
                    (this.DestinationAccountCode != null &&
                    this.DestinationAccountCode.Equals(input.DestinationAccountCode))
                ) &&
                (
                    this.DisputePspReference == input.DisputePspReference ||
                    (this.DisputePspReference != null &&
                    this.DisputePspReference.Equals(input.DisputePspReference))
                ) &&
                (
                    this.DisputeReasonCode == input.DisputeReasonCode ||
                    (this.DisputeReasonCode != null &&
                    this.DisputeReasonCode.Equals(input.DisputeReasonCode))
                ) &&
                (
                    this.MerchantReference == input.MerchantReference ||
                    (this.MerchantReference != null &&
                    this.MerchantReference.Equals(input.MerchantReference))
                ) &&
                (
                    this.PaymentPspReference == input.PaymentPspReference ||
                    (this.PaymentPspReference != null &&
                    this.PaymentPspReference.Equals(input.PaymentPspReference))
                ) &&
                (
                    this.PayoutPspReference == input.PayoutPspReference ||
                    (this.PayoutPspReference != null &&
                    this.PayoutPspReference.Equals(input.PayoutPspReference))
                ) &&
                (
                    this.PspReference == input.PspReference ||
                    (this.PspReference != null &&
                    this.PspReference.Equals(input.PspReference))
                ) &&
                (
                    this.SourceAccountCode == input.SourceAccountCode ||
                    (this.SourceAccountCode != null &&
                    this.SourceAccountCode.Equals(input.SourceAccountCode))
                ) &&
                (
                    this.TransactionStatus == input.TransactionStatus ||
                    (this.TransactionStatus != null &&
                    this.TransactionStatus.Equals(input.TransactionStatus))
                ) &&
                (
                    this.TransferCode == input.TransferCode ||
                    (this.TransferCode != null &&
                    this.TransferCode.Equals(input.TransferCode))
                );
        }

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

            return 
                (
                    this.Event == input.Event ||
                    this.Event.Equals(input.Event)
                ) && 
                (
                    this.ExecutionDate == input.ExecutionDate ||
                    (this.ExecutionDate != null &&
                    this.ExecutionDate.Equals(input.ExecutionDate))
                ) && 
                (
                    this.Reason == input.Reason ||
                    (this.Reason != null &&
                    this.Reason.Equals(input.Reason))
                );
        }

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

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

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

            return
                (
                    this.Contract == input.Contract ||
                    (this.Contract != null &&
                    this.Contract.Equals(input.Contract))
                ) &&
                (
                    this.RecurringDetailName == input.RecurringDetailName ||
                    (this.RecurringDetailName != null &&
                    this.RecurringDetailName.Equals(input.RecurringDetailName))
                ) &&
                (
                    this.RecurringExpiry == input.RecurringExpiry ||
                    (this.RecurringExpiry != null &&
                    this.RecurringExpiry.Equals(input.RecurringExpiry))
                ) &&
                (
                    this.RecurringFrequency == input.RecurringFrequency ||
                    (this.RecurringFrequency != null &&
                    this.RecurringFrequency.Equals(input.RecurringFrequency))
                ) &&
                (
                    this.TokenService == input.TokenService ||
                    (this.TokenService != null &&
                    this.TokenService.Equals(input.TokenService))
                );
        }

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

            return 
                (
                    this.SocialSecurityNumber == other.SocialSecurityNumber ||
                    this.SocialSecurityNumber != null &&
                    this.SocialSecurityNumber.Equals(other.SocialSecurityNumber)
                ) && 
                (
                    this.FirstPspReference == other.FirstPspReference ||
                    this.FirstPspReference != null &&
                    this.FirstPspReference.Equals(other.FirstPspReference)
                ) && 
                (
                    this.CreationDate == other.CreationDate ||
                    this.CreationDate != null &&
                    this.CreationDate.Equals(other.CreationDate)
                ) && 
                (
                    this.Acquirer == other.Acquirer ||
                    this.Acquirer != null &&
                    this.Acquirer.Equals(other.Acquirer)
                ) && 
                
                (
                    this.Bank == other.Bank ||
                    this.Bank != null &&
                    this.Bank.Equals(other.Bank)
                ) && 
                (
                    this.ShopperName == other.ShopperName ||
                    this.ShopperName != null &&
                    this.ShopperName.Equals(other.ShopperName)
                ) && 
                (
                    this.AcquirerAccount == other.AcquirerAccount ||
                    this.AcquirerAccount != null &&
                    this.AcquirerAccount.Equals(other.AcquirerAccount)
                ) && 
                (
                    this.AliasType == other.AliasType ||
                    this.AliasType != null &&
                    this.AliasType.Equals(other.AliasType)
                ) && 
                (
                    this.Name == other.Name ||
                    this.Name != null &&
                    this.Name.Equals(other.Name)
                ) && 
                (
                    this.Variant == other.Variant ||
                    this.Variant != null &&
                    this.Variant.Equals(other.Variant)
                ) && 
                (
                    this.RecurringDetailReference == other.RecurringDetailReference ||
                    this.RecurringDetailReference != null &&
                    this.RecurringDetailReference.Equals(other.RecurringDetailReference)
                ) && 
                (
                    this.Alias == other.Alias ||
                    this.Alias != null &&
                    this.Alias.Equals(other.Alias)
                ) && 
                (
                    this.ContractTypes == other.ContractTypes ||
                    this.ContractTypes != null &&
                    this.ContractTypes.SequenceEqual(other.ContractTypes)
                ) && 
                (
                    this.PaymentMethodVariant == other.PaymentMethodVariant ||
                    this.PaymentMethodVariant != null &&
                    this.PaymentMethodVariant.Equals(other.PaymentMethodVariant)
                ) && 
                (
                    this.BillingAddress == other.BillingAddress ||
                    this.BillingAddress != null &&
                    this.BillingAddress.Equals(other.BillingAddress)
                ) && 
                (
                    this.AdditionalData == other.AdditionalData ||
                    this.AdditionalData != null &&
                    this.AdditionalData.SequenceEqual(other.AdditionalData)
                ) && 
                (
                    this.Card == other.Card ||
                    this.Card != null &&
                    this.Card.Equals(other.Card)
                );
        }

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

            return
                (
                    this.LastKnownShopperEmail == other.LastKnownShopperEmail ||
                    this.LastKnownShopperEmail != null &&
                    this.LastKnownShopperEmail.Equals(other.LastKnownShopperEmail)
                ) &&
                (
                    this.CreationDate == other.CreationDate ||
                    this.CreationDate != null &&
                    this.CreationDate.Equals(other.CreationDate)
                ) &&
                (
                    this.Details == other.Details ||
                    this.Details != null &&
                    other.Details != null &&
                    this.Details.Equals(other.Details)
                ) &&
                (
                    this.ShopperReference == other.ShopperReference ||
                    this.ShopperReference != null &&
                    this.ShopperReference.Equals(other.ShopperReference)
                );
        }

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

            return
                (
                    this.CanCertify == input.CanCertify ||
                    (this.CanCertify != null &&
                    this.CanCertify.Equals(input.CanCertify))) &&
                (
                    this.CanEncryptComms == input.CanEncryptComms ||
                    (this.CanEncryptComms != null &&
                    this.CanEncryptComms.Equals(input.CanEncryptComms))) &&
                (
                    this.CanEncryptStorage == input.CanEncryptStorage ||
                    (this.CanEncryptStorage != null &&
                    this.CanEncryptStorage.Equals(input.CanEncryptStorage))) &&
                (
                    this.CanSign == input.CanSign ||
                    (this.CanSign != null &&
                    this.CanSign.Equals(input.CanSign))) &&
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))) &&
                (
                    this.Emails == input.Emails ||
                    (this.Emails != null &&
                    this.Emails.SequenceEqual(input.Emails))) &&
                (
                    this.ExpiresAt == input.ExpiresAt ||
                    (this.ExpiresAt != null &&
                    this.ExpiresAt.Equals(input.ExpiresAt))) &&
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))) &&
                (
                    this.KeyId == input.KeyId ||
                    (this.KeyId != null &&
                    this.KeyId.Equals(input.KeyId))) &&
                (
                    this.PrimaryKeyId == input.PrimaryKeyId ||
                    (this.PrimaryKeyId != null &&
                    this.PrimaryKeyId.Equals(input.PrimaryKeyId))) &&
                (
                    this.PublicKey == input.PublicKey ||
                    (this.PublicKey != null &&
                    this.PublicKey.Equals(input.PublicKey))) &&
                (
                    this.Subkeys == input.Subkeys ||
                    (this.Subkeys != null &&
                    this.Subkeys.SequenceEqual(input.Subkeys)));
        }

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

            return
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))) &&
                (
                    this.Fingerprint == input.Fingerprint ||
                    (this.Fingerprint != null &&
                    this.Fingerprint.Equals(input.Fingerprint))) &&
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))) &&
                (
                    this.Key == input.Key ||
                    (this.Key != null &&
                    this.Key.Equals(input.Key))) &&
                (
                    this.replacedle == input.replacedle ||
                    (this.replacedle != null &&
                    this.replacedle.Equals(input.replacedle))) &&
                (
                    this.Url == input.Url ||
                    (this.Url != null &&
                    this.Url.Equals(input.Url)));
        }

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

            return
                (
                    this.CloneUrl == input.CloneUrl ||
                    (this.CloneUrl != null &&
                    this.CloneUrl.Equals(input.CloneUrl))) &&
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))) &&
                (
                    this.DefaultBranch == input.DefaultBranch ||
                    (this.DefaultBranch != null &&
                    this.DefaultBranch.Equals(input.DefaultBranch))) &&
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))) &&
                (
                    this.Empty == input.Empty ||
                    (this.Empty != null &&
                    this.Empty.Equals(input.Empty))) &&
                (
                    this.Fork == input.Fork ||
                    (this.Fork != null &&
                    this.Fork.Equals(input.Fork))) &&
                (
                    this.ForksCount == input.ForksCount ||
                    (this.ForksCount != null &&
                    this.ForksCount.Equals(input.ForksCount))) &&
                (
                    this.FullName == input.FullName ||
                    (this.FullName != null &&
                    this.FullName.Equals(input.FullName))) &&
                (
                    this.HtmlUrl == input.HtmlUrl ||
                    (this.HtmlUrl != null &&
                    this.HtmlUrl.Equals(input.HtmlUrl))) &&
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))) &&
                (
                    this.Mirror == input.Mirror ||
                    (this.Mirror != null &&
                    this.Mirror.Equals(input.Mirror))) &&
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))) &&
                (
                    this.OreplacedsuesCount == input.OreplacedsuesCount ||
                    (this.OreplacedsuesCount != null &&
                    this.OreplacedsuesCount.Equals(input.OreplacedsuesCount))) &&
                (
                    this.Owner == input.Owner ||
                    (this.Owner != null &&
                    this.Owner.Equals(input.Owner))) &&
                (
                    this.Parent == input.Parent ||
                    (this.Parent != null &&
                    this.Parent.Equals(input.Parent))) &&
                (
                    this.Permissions == input.Permissions ||
                    (this.Permissions != null &&
                    this.Permissions.Equals(input.Permissions))) &&
                (
                    this.IsPrivate == input.IsPrivate ||
                    (this.IsPrivate != null &&
                    this.IsPrivate.Equals(input.IsPrivate))) &&
                (
                    this.Size == input.Size ||
                    (this.Size != null &&
                    this.Size.Equals(input.Size))) &&
                (
                    this.SshUrl == input.SshUrl ||
                    (this.SshUrl != null &&
                    this.SshUrl.Equals(input.SshUrl))) &&
                (
                    this.StarsCount == input.StarsCount ||
                    (this.StarsCount != null &&
                    this.StarsCount.Equals(input.StarsCount))) &&
                (
                    this.UpdatedAt == input.UpdatedAt ||
                    (this.UpdatedAt != null &&
                    this.UpdatedAt.Equals(input.UpdatedAt))) &&
                (
                    this.WatchersCount == input.WatchersCount ||
                    (this.WatchersCount != null &&
                    this.WatchersCount.Equals(input.WatchersCount))) &&
                (
                    this.Website == input.Website ||
                    (this.Website != null &&
                    this.Website.Equals(input.Website)));
        }

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

            return
                (
                    this.Created == input.Created ||
                    (this.Created != null &&
                    this.Created.Equals(input.Created))) &&
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))) &&
                (
                    this.IssueId == input.IssueId ||
                    (this.IssueId != null &&
                    this.IssueId.Equals(input.IssueId))) &&
                (
                    this.Time == input.Time ||
                    (this.Time != null &&
                    this.Time.Equals(input.Time))) &&
                (
                    this.UserId == input.UserId ||
                    (this.UserId != null &&
                    this.UserId.Equals(input.UserId)));
        }

public string GetFormatDate(DateTime dt, char Separator)
        {
            if (!dt.Equals(DBNull.Value))
            {
                string tem = string.Format("yyyy{0}MM{1}dd", Separator, Separator);
                return dt.ToString(tem);
            }
            else
            {
                return GetFormatDate(DateTime.Now, Separator);
            }
        }

public string GetFormatTime(DateTime dt, char Separator)
        {
            if (!dt.Equals(DBNull.Value))
            {
                string tem = string.Format("hh{0}mm{1}ss", Separator, Separator);
                return dt.ToString(tem);
            }
            else
            {
                return GetFormatDate(DateTime.Now, Separator);
            }
        }

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

            return 
                (
                    this.CreateTime == other.CreateTime ||
                    this.CreateTime != null &&
                    this.CreateTime.Equals(other.CreateTime)
                ) && 
                (
                    this.CreateUserId == other.CreateUserId ||
                    this.CreateUserId != null &&
                    this.CreateUserId.Equals(other.CreateUserId)
                ) && 
                (
                    this.LastModifiedTime == other.LastModifiedTime ||
                    this.LastModifiedTime != null &&
                    this.LastModifiedTime.Equals(other.LastModifiedTime)
                ) && 
                (
                    this.LastModifiedUserId == other.LastModifiedUserId ||
                    this.LastModifiedUserId != null &&
                    this.LastModifiedUserId.Equals(other.LastModifiedUserId)
                );
        }

public bool Equals(MergeCacheEntry other)
        {
            if (ReferenceEquals(null, other))
            {
                return false;
            }

            if (ReferenceEquals(this, other))
            {
                return true;
            }

            return CachedPath == other.CachedPath && OriginalUpdatedOn.Equals(other.OriginalUpdatedOn) && Merges.SequenceEqual(other.Merges);
        }

public void Test() {
            uint? rowLimit = 25;                                    // limit result sets to 25 rows, underlying table has over 1000 rows
            Int64? pInInt64 = 999999999999999999;                   // 18 digit long
            Decimal? pInDecimal = 79228162514264337593543950335M;   // 28 digit decimal (Decimal.MaxValue)
            String pInOutString = HELLO;
            DateTime? pOutDate;

            // List used as argument for Oracle replacedociative array
            IList<Int64?> pInOutListInt64, somePrimeNumbers = new List<Int64?> { 2, 3, 5, 7, 11, 13, 17, 19, 29, 31 };

            // DTO IList<T>s and a datatable to be hydrated from Oracle cursor
            IList<DtoImplemented> dtoInheritedResultSet;
            IList<DtoImplementedWithCustom> dtoImplementedResultSet;
            IList<DtoCustomMapByName> dtoOriginalMapByNameResultSet;
            IList<DtoCustomMapByPosition> dtoOriginalMapByPositionLResultSet;
            DataTable dataTable;

            // 1. Hydrate DTO IList<T> from typed result set by using DTO implementing package record interface.
            pInOutListInt64 = somePrimeNumbers; 
            dtoInheritedResultSet = XmplPkgExample.Instance.GetRowsTypedRet<DtoImplemented>(pInDecimal, ref pInOutString, ref pInOutListInt64, out pOutDate, rowLimit);
            Debug.replacedert(dtoInheritedResultSet.Count == rowLimit);
            Debug.replacedert(pInOutString.Equals(GOODBYE));                             // confirm OUT string arg from package function
            for (int i = 0; i < pInOutListInt64.Count; i++)
                Debug.replacedert(pInOutListInt64[i].Equals(somePrimeNumbers[i] * 7));   // confirm all values were multiplied by 7 in func
            Debug.replacedert(pOutDate.Equals(new DateTime(1999, 12, 31)));              // confirm OUT date arg from package function

            // 2. Hydrate DTO IList<T> from typed result set by using DTO implementing package record interface with additional properties.
            pInOutListInt64 = somePrimeNumbers;
            dtoImplementedResultSet = XmplPkgExample.Instance.GetRowsTypedRet<DtoImplementedWithCustom>(pInDecimal, ref pInOutString, ref pInOutListInt64, out pOutDate, rowLimit);
            Debug.replacedert(dtoImplementedResultSet.Count == rowLimit);
            Debug.replacedert(pInOutString.Equals(GOODBYE));                             // confirm OUT string arg from package function
            for (int i = 0; i < pInOutListInt64.Count; i++)
                Debug.replacedert(pInOutListInt64[i].Equals(somePrimeNumbers[i] * 7));   // confirm all values were multiplied by 7 in func
            Debug.replacedert(pOutDate.Equals(new DateTime(1999, 12, 31)));              // confirm OUT date arg from package function

            // 3. Hydrate DTO IList<T> from untyped result set by mapping column name to property name (default); 
            //      unmapped columns will be ignored (non-default).
            dtoOriginalMapByNameResultSet = XmplPkgExample.Instance.GetRowsUntypedRet<DtoCustomMapByName>(pInInt64, false, true, rowLimit);
            Debug.replacedert(dtoOriginalMapByNameResultSet.Count == rowLimit);

            // 4. Hydrate DTO IList<T> from untyped result set by mapping column name to property name (default); 
            //      an unmapped column will throw (default).
            try {
                dtoOriginalMapByNameResultSet = XmplPkgExample.Instance.GetRowsUntypedRet<DtoCustomMapByName>(pInInt64, false, false, rowLimit);
            } catch (Exception ex) {
                if (!ex.Message.StartsWith("Hydrator.BuildMappings")) Debug.replacedert(false);
            }

            // 5. Hydrate DTO IList<T> from untyped result set by mapping column position to property position (non-default); 
            //      unmapped columns will be ignored (non-default)
            dtoOriginalMapByPositionLResultSet = XmplPkgExample.Instance.GetRowsUntypedRet<DtoCustomMapByPosition>(pInInt64, true, true, rowLimit);

            // 6. Hydrate DTO IList<T> from untyped result set by mapping column position to property position (non-default); 
            //      an unmapped column will throw (default).
            try {
                dtoOriginalMapByPositionLResultSet = XmplPkgExample.Instance.GetRowsUntypedRet<DtoCustomMapByPosition>(pInInt64, true, false, rowLimit);
            } catch (Exception ex) {
                if (!ex.Message.StartsWith("Hydrator.BuildMappings")) Debug.replacedert(false);
            }

            // 7. Hydrate Datatable from all columns in untyped result set, column names are converted to DataTable captions.
            //      No DTO or generic required.
            dataTable = XmplPkgExample.Instance.GetRowsUntypedRet(pInInt64, true, rowLimit);
            Debug.replacedert(dataTable.Rows.Count == rowLimit);
            List<String> dataTableCaptions = new List<string> { "Id", "Col Integer", "Col Number", "Varchar2 Max Col", "Col Date", "Col Timestamp" };
            for (int i = 0; i < dataTableCaptions.Count; i++)
                Debug.replacedert(dataTable.Columns[i].Caption.Equals(dataTableCaptions[i]));  // confirm captions were created from column name
        }

public void Test() {
            uint? rowLimit = 25;                                    // limit result sets to 25 rows, underlying table has over 1000 rows
            Int64? pInInt64 = 999999999999999999;                   // 18 digit long
            Decimal? pInDecimal = 79228162514264337593543950335M;   // 28 digit decimal (Decimal.MaxValue)
            String pInOutString = HELLO;
            DateTime? pOutDate;

            // List used as argument for Oracle replacedociative array
            IList<Int64?> pInOutListInt64, somePrimeNumbers = new List<Int64?> { 2, 3, 5, 7, 11, 13, 17, 19, 29, 31 };

            // 1a. Hydrate DTO IList<T> from typed result set by using DTO implementing package record interface.
            pInOutListInt64 = somePrimeNumbers;
            Debug.replacedert(XmplPkgExample.Instance.GetRowsTypedRet<DtoImplemented>(pInDecimal, ref pInOutString, ref pInOutListInt64, out pOutDate, rowLimit).Count == rowLimit);
            Debug.replacedert(pInOutString.Equals(GOODBYE));                             // confirm OUT string arg from package function
            for (int i = 0; i < pInOutListInt64.Count; i++)
                Debug.replacedert(pInOutListInt64[i].Equals(somePrimeNumbers[i] * 7));   // confirm all values were multiplied by 7 in func
            Debug.replacedert(pOutDate.Equals(new DateTime(1999, 12, 31)));              // confirm OUT date arg from package function

            // 1b. Hydrate DTO IList<T> from typed result set by using DTO positional record implementing package record interface.
            pInOutListInt64 = somePrimeNumbers;
            Debug.replacedert(XmplPkgExample.Instance.GetRowsTypedRet<DtoImplementedPositionalRecord>(pInDecimal, ref pInOutString, ref pInOutListInt64, out pOutDate, rowLimit).Count == rowLimit);
            Debug.replacedert(pInOutString.Equals(GOODBYE));                             // confirm OUT string arg from package function
            for (int i = 0; i < pInOutListInt64.Count; i++)
                Debug.replacedert(pInOutListInt64[i].Equals(somePrimeNumbers[i] * 7));   // confirm all values were multiplied by 7 in func
            Debug.replacedert(pOutDate.Equals(new DateTime(1999, 12, 31)));              // confirm OUT date arg from package function

            // 2. Hydrate DTO IList<T> from typed result set by using DTO implementing package record interface with additional properties.
            pInOutListInt64 = somePrimeNumbers;
            Debug.replacedert(XmplPkgExample.Instance.GetRowsTypedRet<DtoImplementedWithCustom>(pInDecimal, ref pInOutString, ref pInOutListInt64, out pOutDate, rowLimit).Count == rowLimit);
            Debug.replacedert(pInOutString.Equals(GOODBYE));                             // confirm OUT string arg from package function
            for (int i = 0; i < pInOutListInt64.Count; i++)
                Debug.replacedert(pInOutListInt64[i].Equals(somePrimeNumbers[i] * 7));   // confirm all values were multiplied by 7 in func
            Debug.replacedert(pOutDate.Equals(new DateTime(1999, 12, 31)));              // confirm OUT date arg from package function

            // 3a. Hydrate DTO IList<T> from untyped result set by mapping column name to property name using custom positional record DTO; 
            //      unmapped columns will be ignored.
            Debug.replacedert(XmplPkgExample.Instance.GetRowsUntypedRet<DtoImplementedPositionalRecord>(pInInt64, 
                mapColumnToObjectPropertyByPosition: false,         // map by name 
                allowUnmappedColumnsToBeExcluded: true,  
                rowLimit).Count == rowLimit);

            // 3b. Hydrate DTO IList<T> from untyped result set by mapping column name to property name using custom DTO; 
            //      unmapped columns will be ignored (arg non-default).
            Debug.replacedert(XmplPkgExample.Instance.GetRowsUntypedRet<DtoCustomMapByName>(pInInt64,
                mapColumnToObjectPropertyByPosition: false,         // map by name 
                allowUnmappedColumnsToBeExcluded: true,
                rowLimit).Count == rowLimit);

            // 4. Hydrate DTO IList<T> from untyped result set by mapping column name to property name custom DTO; 
            //      an unmapped column will throw.
            try {
                XmplPkgExample.Instance.GetRowsUntypedRet<DtoCustomMapByName>(pInInt64,
                    mapColumnToObjectPropertyByPosition: false,     // map by name 
                    allowUnmappedColumnsToBeExcluded: false, 
                    rowLimit);
                Debug.replacedert(false);
            } catch (Exception ex) {
                if (!ex.Message.StartsWith("Hydrator.BuildMappings")) Debug.replacedert(false);
            }

            // 5. Hydrate DTO IList<T> from untyped result set by mapping column position to property position using custom DTO with position attributes; 
            //      unmapped columns will be ignored (non-default)
            Debug.replacedert(XmplPkgExample.Instance.GetRowsUntypedRet<DtoCustomMapByPosition>(pInInt64,
                mapColumnToObjectPropertyByPosition: false,         // map by position
                allowUnmappedColumnsToBeExcluded: true,
                rowLimit).Count == rowLimit);

            // 6. Hydrate DTO IList<T> from untyped result set by mapping column position to property position using custom DTO with position attributes; 
            //      an unmapped column will throw (default).
            try {
                XmplPkgExample.Instance.GetRowsUntypedRet<DtoCustomMapByPosition>(pInInt64,
                    mapColumnToObjectPropertyByPosition: false,     // map by position
                    allowUnmappedColumnsToBeExcluded: false,
                    rowLimit);
                Debug.replacedert(false);
            } catch (Exception ex) {
                if (!ex.Message.StartsWith("Hydrator.BuildMappings")) Debug.replacedert(false);
            }

            // 7. Hydrate Datatable from all columns in untyped result set, column names are converted to DataTable captions.
            //      No DTO or generic required.
            DataTable dataTable = XmplPkgExample.Instance.GetRowsUntypedRet(pInInt64, true, rowLimit);
            Debug.replacedert(dataTable.Rows.Count == rowLimit);
            List<String> dataTableCaptions = new List<string> { "Id", "Col Integer", "Col Number", "Varchar2 Max Col", "Col Date", "Col Timestamp" };
            for (int i = 0; i < dataTableCaptions.Count; i++)
                Debug.replacedert(dataTable.Columns[i].Caption.Equals(dataTableCaptions[i]));  // confirm captions were created from column name
        }

public override bool Equals(object obj)
			{
				if (obj is SYSTEMTIME)
					return ((SYSTEMTIME)obj) == this;
				if (obj is DateTime)
					return ((DateTime)this).Equals(obj);
				return base.Equals(obj);
			}

public override bool Equals(object obj) => obj is time_t s ? Equals(s) : Value.Equals(obj);

public override bool Equals(object obj) => obj is DATE s ? Equals(s) : (obj is DateTime b ? Value.Equals(b) : Value.Equals(obj));

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

            return 
                (
                    this.SceneId == input.SceneId ||
                    (this.SceneId != null &&
                    this.SceneId.Equals(input.SceneId))
                ) && 
                (
                    this.SceneName == input.SceneName ||
                    (this.SceneName != null &&
                    this.SceneName.Equals(input.SceneName))
                ) && 
                (
                    this.SceneIcon == input.SceneIcon ||
                    (this.SceneIcon != null &&
                    this.SceneIcon.Equals(input.SceneIcon))
                ) && 
                (
                    this.SceneColor == input.SceneColor ||
                    (this.SceneColor != null &&
                    this.SceneColor.Equals(input.SceneColor))
                ) && 
                (
                    this.LocationId == input.LocationId ||
                    (this.LocationId != null &&
                    this.LocationId.Equals(input.LocationId))
                ) && 
                (
                    this.CreatedBy == input.CreatedBy ||
                    (this.CreatedBy != null &&
                    this.CreatedBy.Equals(input.CreatedBy))
                ) &&
                (
                    this.CreatedDate == input.CreatedDate ||
                    (this.CreatedDate != null &&
                    this.CreatedDate.Equals(input.CreatedDate))
                ) &&
                (
                    this.LastUpdatedDate == input.LastUpdatedDate ||
                    (this.LastUpdatedDate != null &&
                    this.LastUpdatedDate.Equals(input.LastUpdatedDate))
                ) &&
                (
                    this.LastExecutedDate == input.LastExecutedDate ||
                    (this.LastExecutedDate != null &&
                    this.LastExecutedDate.Equals(input.LastExecutedDate))
                ) &&
                (
                    this.Editable == input.Editable ||
                    this.Editable.Equals(input.Editable)
                ) && 
                (
                    this.ApiVersion == input.ApiVersion ||
                    (this.ApiVersion != null &&
                    this.ApiVersion.Equals(input.ApiVersion))
                );
        }

private void SetSelectedDateTime()
        {
            if (_textBox != null)
            {
                if (!string.IsNullOrEmpty(_textBox.Text))
                {
                    var s = _textBox.Text;

                    if (SelectedDateTime != null)
                    {
                        var selectedTime = DateTimeToString(SelectedDateTime.Value);

                        if (string.Compare(selectedTime, s, StringComparison.Ordinal) == 0)
                        {
                            return;
                        }
                    }

                    var d = SetTextBoxValue(s);
                    if (!SelectedDateTime.Equals(d))
                    {
                        SetCurrentValue(SelectedDateTimeProperty, d);
                        SetCurrentValue(DisplayDateTimeProperty, d);
                    }
                }
                else
                {
                    if (SelectedDateTime.HasValue)
                    {
                        SetCurrentValue(SelectedDateTimeProperty, null);
                    }
                }
            }
            else
            {
                var d = SetTextBoxValue(_defaultText);
                if (!SelectedDateTime.Equals(d))
                {
                    SetCurrentValue(SelectedDateTimeProperty, d);
                }
            }
        }

private void SetSelectedTime()
        {
            if (_textBox != null)
            {
                if (!string.IsNullOrEmpty(_textBox.Text))
                {
                    var s = _textBox.Text;

                    if (SelectedTime != null)
                    {
                        var selectedTime = DateTimeToString(SelectedTime.Value);

                        if (string.Compare(selectedTime, s, StringComparison.Ordinal) == 0)
                        {
                            return;
                        }
                    }

                    var d = SetTextBoxValue(s);
                    if (!SelectedTime.Equals(d))
                    {
                        SetCurrentValue(SelectedTimeProperty, d);
                        SetCurrentValue(DisplayTimeProperty, d);
                    }
                }
                else
                {
                    if (SelectedTime.HasValue)
                    {
                        SetCurrentValue(SelectedTimeProperty, null);
                    }
                }
            }
            else
            {
                var d = SetTextBoxValue(_defaultText);
                if (!SelectedTime.Equals(d))
                {
                    SetCurrentValue(SelectedTimeProperty, d);
                }
            }
        }

private void SetSelectedDate()
        {
            if (this._textBox != null)
            {
                if (!string.IsNullOrEmpty(this._textBox.Text))
                {
                    string s = this._textBox.Text;

                    if (this.SelectedDate != null)
                    {
                        // If the string value of the SelectedDate and the TextBox string value are equal,
                        // we do not parse the string again
                        // if we do an extra parse, we lose data in M/d/yy format
                        // ex: SelectedDate = DateTime(1008,12,19) but when "12/19/08" is parsed it is interpreted as DateTime(2008,12,19)
                        string selectedDate = DateTimeToString(this.SelectedDate.Value);

                        if (selectedDate == s)
                        {
                            return;
                        }
                    }

                    DateTime? d = SetTextBoxValue(s);
                    if (!this.SelectedDate.Equals(d))
                    {
                        this.SelectedDate = d;
                        this.DisplayDate = d.Value;
                    }
                }
                else
                {
                    if (this.SelectedDate != null)
                    {
                        this.SelectedDate = null;
                    }
                }
            }
            else
            {
                DateTime? d = SetTextBoxValue(_defaultText);
                if (!this.SelectedDate.Equals(d))
                {
                    this.SelectedDate = d;
                }
            }
        }

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

            return 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.LocationId == input.LocationId ||
                    (this.LocationId != null &&
                    this.LocationId.Equals(input.LocationId))
                ) && 
                (
                    this.Address == input.Address ||
                    (this.Address != null &&
                    this.Address.Equals(input.Address))
                ) && 
                (
                    this.ArrTime == input.ArrTime ||
                    (this.ArrTime != null &&
                    this.ArrTime.Equals(input.ArrTime))
                ) && 
                (
                    this.EndTime == input.EndTime ||
                    (this.EndTime != null &&
                    this.EndTime.Equals(input.EndTime))
                ) && 
                (
                    this.EndDateTime == input.EndDateTime ||
                    (this.EndDateTime != null &&
                    this.EndDateTime.Equals(input.EndDateTime))
                ) && 
                (
                    this.ArrDateTime == input.ArrDateTime ||
                    (this.ArrDateTime != null &&
                    this.ArrDateTime.Equals(input.ArrDateTime))
                ) && 
                (
                    this.WaitingTime == input.WaitingTime ||
                    (this.WaitingTime != null &&
                    this.WaitingTime.Equals(input.WaitingTime))
                ) && 
                (
                    this.PreparationTime == input.PreparationTime ||
                    (this.PreparationTime != null &&
                    this.PreparationTime.Equals(input.PreparationTime))
                ) && 
                (
                    this.Distance == input.Distance ||
                    (this.Distance != null &&
                    this.Distance.Equals(input.Distance))
                ) && 
                (
                    this.DrivingTime == input.DrivingTime ||
                    (this.DrivingTime != null &&
                    this.DrivingTime.Equals(input.DrivingTime))
                ) && 
                (
                    this.LoadBefore == input.LoadBefore ||
                    this.LoadBefore != null &&
                    input.LoadBefore != null &&
                    this.LoadBefore.SequenceEqual(input.LoadBefore)
                ) && 
                (
                    this.LoadAfter == input.LoadAfter ||
                    this.LoadAfter != null &&
                    input.LoadAfter != null &&
                    this.LoadAfter.SequenceEqual(input.LoadAfter)
                );
        }

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

            return base.Equals(input) && 
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))
                ) && base.Equals(input) && 
                (
                    this.UpdatedAt == input.UpdatedAt ||
                    (this.UpdatedAt != null &&
                    this.UpdatedAt.Equals(input.UpdatedAt))
                ) && base.Equals(input) && 
                (
                    this.OrgID == input.OrgID ||
                    (this.OrgID != null &&
                    this.OrgID.Equals(input.OrgID))
                ) && base.Equals(input) && 
                (
                    this.Permissions == input.Permissions ||
                    this.Permissions != null &&
                    this.Permissions.SequenceEqual(input.Permissions)
                ) && base.Equals(input) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && base.Equals(input) && 
                (
                    this.Token == input.Token ||
                    (this.Token != null &&
                    this.Token.Equals(input.Token))
                ) && base.Equals(input) && 
                (
                    this.UserID == input.UserID ||
                    (this.UserID != null &&
                    this.UserID.Equals(input.UserID))
                ) && base.Equals(input) && 
                (
                    this.User == input.User ||
                    (this.User != null &&
                    this.User.Equals(input.User))
                ) && base.Equals(input) && 
                (
                    this.Org == input.Org ||
                    (this.Org != null &&
                    this.Org.Equals(input.Org))
                ) && base.Equals(input) && 
                (
                    
                    (this.Links != null &&
                    this.Links.Equals(input.Links))
                );
        }

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

            return 
                (
                    
                    (this.Links != null &&
                    this.Links.Equals(input.Links))
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.OrgID == input.OrgID ||
                    (this.OrgID != null &&
                    this.OrgID.Equals(input.OrgID))
                ) && 
                (
                    this.Rp == input.Rp ||
                    (this.Rp != null &&
                    this.Rp.Equals(input.Rp))
                ) && 
                (
                    this.SchemaType == input.SchemaType ||
                    (this.SchemaType != null &&
                    this.SchemaType.Equals(input.SchemaType))
                ) && 
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))
                ) && 
                (
                    this.UpdatedAt == input.UpdatedAt ||
                    (this.UpdatedAt != null &&
                    this.UpdatedAt.Equals(input.UpdatedAt))
                ) && 
                (
                    this.RetentionRules == input.RetentionRules ||
                    this.RetentionRules != null &&
                    this.RetentionRules.SequenceEqual(input.RetentionRules)
                ) && 
                (
                    this.Labels == input.Labels ||
                    this.Labels != null &&
                    this.Labels.SequenceEqual(input.Labels)
                );
        }

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

            return 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.OrgID == input.OrgID ||
                    (this.OrgID != null &&
                    this.OrgID.Equals(input.OrgID))
                ) && 
                (
                    this.TaskID == input.TaskID ||
                    (this.TaskID != null &&
                    this.TaskID.Equals(input.TaskID))
                ) && 
                (
                    this.OwnerID == input.OwnerID ||
                    (this.OwnerID != null &&
                    this.OwnerID.Equals(input.OwnerID))
                ) && 
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))
                ) && 
                (
                    this.UpdatedAt == input.UpdatedAt ||
                    (this.UpdatedAt != null &&
                    this.UpdatedAt.Equals(input.UpdatedAt))
                ) && 
                (
                    
                    (this.Query != null &&
                    this.Query.Equals(input.Query))
                ) && 
                (
                    this.Status == input.Status ||
                    (this.Status != null &&
                    this.Status.Equals(input.Status))
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.LatestCompleted == input.LatestCompleted ||
                    (this.LatestCompleted != null &&
                    this.LatestCompleted.Equals(input.LatestCompleted))
                ) && 
                (
                    this.LastRunStatus == input.LastRunStatus ||
                    (this.LastRunStatus != null &&
                    this.LastRunStatus.Equals(input.LastRunStatus))
                ) && 
                (
                    this.LastRunError == input.LastRunError ||
                    (this.LastRunError != null &&
                    this.LastRunError.Equals(input.LastRunError))
                ) && 
                (
                    this.Labels == input.Labels ||
                    this.Labels != null &&
                    this.Labels.SequenceEqual(input.Labels)
                ) && 
                (
                    
                    (this.Links != null &&
                    this.Links.Equals(input.Links))
                );
        }

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

            return 
                (
                    this.Start == input.Start ||
                    (this.Start != null &&
                    this.Start.Equals(input.Start))
                ) && 
                (
                    this.Stop == input.Stop ||
                    (this.Stop != null &&
                    this.Stop.Equals(input.Stop))
                ) && 
                (
                    this.Predicate == input.Predicate ||
                    (this.Predicate != null &&
                    this.Predicate.Equals(input.Predicate))
                );
        }

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

            return 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                ) && 
                (
                    this.TemplateID == input.TemplateID ||
                    (this.TemplateID != null &&
                    this.TemplateID.Equals(input.TemplateID))
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.Version == input.Version ||
                    (this.Version != null &&
                    this.Version.Equals(input.Version))
                ) && 
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))
                ) && 
                (
                    this.UpdatedAt == input.UpdatedAt ||
                    (this.UpdatedAt != null &&
                    this.UpdatedAt.Equals(input.UpdatedAt))
                );
        }

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

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

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

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

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

            return 
                (
                    this.Time == input.Time ||
                    (this.Time != null &&
                    this.Time.Equals(input.Time))
                ) && 
                (
                    this.Message == input.Message ||
                    (this.Message != null &&
                    this.Message.Equals(input.Message))
                ) && 
                (
                    this.RunID == input.RunID ||
                    (this.RunID != null &&
                    this.RunID.Equals(input.RunID))
                );
        }

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

            return 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.OrgID == input.OrgID ||
                    (this.OrgID != null &&
                    this.OrgID.Equals(input.OrgID))
                ) && 
                (
                    this.UserID == input.UserID ||
                    (this.UserID != null &&
                    this.UserID.Equals(input.UserID))
                ) && 
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))
                ) && 
                (
                    this.UpdatedAt == input.UpdatedAt ||
                    (this.UpdatedAt != null &&
                    this.UpdatedAt.Equals(input.UpdatedAt))
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Status == input.Status ||
                    (this.Status != null &&
                    this.Status.Equals(input.Status))
                ) && 
                (
                    this.Labels == input.Labels ||
                    this.Labels != null &&
                    this.Labels.SequenceEqual(input.Labels)
                ) && 
                (
                    
                    (this.Links != null &&
                    this.Links.Equals(input.Links))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                );
        }

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

            return 
                (
                    
                    (this.Links != null &&
                    this.Links.Equals(input.Links))
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))
                ) && 
                (
                    this.UpdatedAt == input.UpdatedAt ||
                    (this.UpdatedAt != null &&
                    this.UpdatedAt.Equals(input.UpdatedAt))
                ) && 
                (
                    this.Status == input.Status ||
                    (this.Status != null &&
                    this.Status.Equals(input.Status))
                );
        }

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

            return 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.TaskID == input.TaskID ||
                    (this.TaskID != null &&
                    this.TaskID.Equals(input.TaskID))
                ) && 
                (
                    this.Status == input.Status ||
                    (this.Status != null &&
                    this.Status.Equals(input.Status))
                ) && 
                (
                    this.ScheduledFor == input.ScheduledFor ||
                    (this.ScheduledFor != null &&
                    this.ScheduledFor.Equals(input.ScheduledFor))
                ) && 
                (
                    this.Log == input.Log ||
                    this.Log != null &&
                    this.Log.SequenceEqual(input.Log)
                ) && 
                (
                    this.StartedAt == input.StartedAt ||
                    (this.StartedAt != null &&
                    this.StartedAt.Equals(input.StartedAt))
                ) && 
                (
                    this.FinishedAt == input.FinishedAt ||
                    (this.FinishedAt != null &&
                    this.FinishedAt.Equals(input.FinishedAt))
                ) && 
                (
                    this.RequestedAt == input.RequestedAt ||
                    (this.RequestedAt != null &&
                    this.RequestedAt.Equals(input.RequestedAt))
                ) && 
                (
                    
                    (this.Links != null &&
                    this.Links.Equals(input.Links))
                );
        }

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

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

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

            return 
                (
                    this.LatestCompleted == input.LatestCompleted ||
                    (this.LatestCompleted != null &&
                    this.LatestCompleted.Equals(input.LatestCompleted))
                ) && 
                (
                    this.LastRunStatus == input.LastRunStatus ||
                    (this.LastRunStatus != null &&
                    this.LastRunStatus.Equals(input.LastRunStatus))
                ) && 
                (
                    this.LastRunError == input.LastRunError ||
                    (this.LastRunError != null &&
                    this.LastRunError.Equals(input.LastRunError))
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.EndpointID == input.EndpointID ||
                    (this.EndpointID != null &&
                    this.EndpointID.Equals(input.EndpointID))
                ) && 
                (
                    this.OrgID == input.OrgID ||
                    (this.OrgID != null &&
                    this.OrgID.Equals(input.OrgID))
                ) && 
                (
                    this.TaskID == input.TaskID ||
                    (this.TaskID != null &&
                    this.TaskID.Equals(input.TaskID))
                ) && 
                (
                    this.OwnerID == input.OwnerID ||
                    (this.OwnerID != null &&
                    this.OwnerID.Equals(input.OwnerID))
                ) && 
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))
                ) && 
                (
                    this.UpdatedAt == input.UpdatedAt ||
                    (this.UpdatedAt != null &&
                    this.UpdatedAt.Equals(input.UpdatedAt))
                ) && 
                (
                    this.Status == input.Status ||
                    (this.Status != null &&
                    this.Status.Equals(input.Status))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.SleepUntil == input.SleepUntil ||
                    (this.SleepUntil != null &&
                    this.SleepUntil.Equals(input.SleepUntil))
                ) && 
                (
                    this.Every == input.Every ||
                    (this.Every != null &&
                    this.Every.Equals(input.Every))
                ) && 
                (
                    this.Offset == input.Offset ||
                    (this.Offset != null &&
                    this.Offset.Equals(input.Offset))
                ) && 
                (
                    this.RunbookLink == input.RunbookLink ||
                    (this.RunbookLink != null &&
                    this.RunbookLink.Equals(input.RunbookLink))
                ) && 
                (
                    this.LimitEvery == input.LimitEvery ||
                    (this.LimitEvery != null &&
                    this.LimitEvery.Equals(input.LimitEvery))
                ) && 
                (
                    this.Limit == input.Limit ||
                    (this.Limit != null &&
                    this.Limit.Equals(input.Limit))
                ) && 
                (
                    this.TagRules == input.TagRules ||
                    this.TagRules != null &&
                    this.TagRules.SequenceEqual(input.TagRules)
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.StatusRules == input.StatusRules ||
                    this.StatusRules != null &&
                    this.StatusRules.SequenceEqual(input.StatusRules)
                ) && 
                (
                    this.Labels == input.Labels ||
                    this.Labels != null &&
                    this.Labels.SequenceEqual(input.Labels)
                ) && 
                (
                    
                    (this.Links != null &&
                    this.Links.Equals(input.Links))
                );
        }

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

            return 
                (
                    
                    (this.Extern != null &&
                    this.Extern.Equals(input.Extern))
                ) && 
                (
                    this._Query == input._Query ||
                    (this._Query != null &&
                    this._Query.Equals(input._Query))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                ) && 
                (
                    this.Params == input.Params ||
                    this.Params != null &&
                    this.Params.SequenceEqual(input.Params)
                ) && 
                (
                    
                    (this.Dialect != null &&
                    this.Dialect.Equals(input.Dialect))
                ) && 
                (
                    this.Now == input.Now ||
                    (this.Now != null &&
                    this.Now.Equals(input.Now))
                );
        }

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

            return 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.Type == input.Type ||
                    (this.Type != null &&
                    this.Type.Equals(input.Type))
                ) && 
                (
                    this.OrgID == input.OrgID ||
                    (this.OrgID != null &&
                    this.OrgID.Equals(input.OrgID))
                ) && 
                (
                    this.Org == input.Org ||
                    (this.Org != null &&
                    this.Org.Equals(input.Org))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.Status == input.Status ||
                    (this.Status != null &&
                    this.Status.Equals(input.Status))
                ) && 
                (
                    this.Labels == input.Labels ||
                    this.Labels != null &&
                    this.Labels.SequenceEqual(input.Labels)
                ) && 
                (
                    this.AuthorizationID == input.AuthorizationID ||
                    (this.AuthorizationID != null &&
                    this.AuthorizationID.Equals(input.AuthorizationID))
                ) && 
                (
                    this.Flux == input.Flux ||
                    (this.Flux != null &&
                    this.Flux.Equals(input.Flux))
                ) && 
                (
                    this.Every == input.Every ||
                    (this.Every != null &&
                    this.Every.Equals(input.Every))
                ) && 
                (
                    this.Cron == input.Cron ||
                    (this.Cron != null &&
                    this.Cron.Equals(input.Cron))
                ) && 
                (
                    this.Offset == input.Offset ||
                    (this.Offset != null &&
                    this.Offset.Equals(input.Offset))
                ) && 
                (
                    this.LatestCompleted == input.LatestCompleted ||
                    (this.LatestCompleted != null &&
                    this.LatestCompleted.Equals(input.LatestCompleted))
                ) && 
                (
                    this.LastRunStatus == input.LastRunStatus ||
                    (this.LastRunStatus != null &&
                    this.LastRunStatus.Equals(input.LastRunStatus))
                ) && 
                (
                    this.LastRunError == input.LastRunError ||
                    (this.LastRunError != null &&
                    this.LastRunError.Equals(input.LastRunError))
                ) && 
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))
                ) && 
                (
                    this.UpdatedAt == input.UpdatedAt ||
                    (this.UpdatedAt != null &&
                    this.UpdatedAt.Equals(input.UpdatedAt))
                ) && 
                (
                    
                    (this.Links != null &&
                    this.Links.Equals(input.Links))
                );
        }

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

            return 
                (
                    this.Status == input.Status ||
                    (this.Status != null &&
                    this.Status.Equals(input.Status))
                ) && 
                (
                    this.Started == input.Started ||
                    (this.Started != null &&
                    this.Started.Equals(input.Started))
                ) && 
                (
                    this.Up == input.Up ||
                    (this.Up != null &&
                    this.Up.Equals(input.Up))
                );
        }

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

            return 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.StartTime == input.StartTime ||
                    (this.StartTime != null &&
                    this.StartTime.Equals(input.StartTime))
                ) && 
                (
                    this.EndTime == input.EndTime ||
                    (this.EndTime != null &&
                    this.EndTime.Equals(input.EndTime))
                ) && 
                (
                    this.DeletedAt == input.DeletedAt ||
                    (this.DeletedAt != null &&
                    this.DeletedAt.Equals(input.DeletedAt))
                ) && 
                (
                    this.TruncatedAt == input.TruncatedAt ||
                    (this.TruncatedAt != null &&
                    this.TruncatedAt.Equals(input.TruncatedAt))
                ) && 
                (
                    this.Shards == input.Shards ||
                    this.Shards != null &&
                    this.Shards.SequenceEqual(input.Shards)
                );
        }

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

            return 
                (
                    
                    (this.Links != null &&
                    this.Links.Equals(input.Links))
                ) && 
                (
                    this.Id == input.Id ||
                    (this.Id != null &&
                    this.Id.Equals(input.Id))
                ) && 
                (
                    this.OrgID == input.OrgID ||
                    (this.OrgID != null &&
                    this.OrgID.Equals(input.OrgID))
                ) && 
                (
                    this.Name == input.Name ||
                    (this.Name != null &&
                    this.Name.Equals(input.Name))
                ) && 
                (
                    this.Description == input.Description ||
                    (this.Description != null &&
                    this.Description.Equals(input.Description))
                ) && 
                (
                    this.Selected == input.Selected ||
                    this.Selected != null &&
                    this.Selected.SequenceEqual(input.Selected)
                ) && 
                (
                    this.Labels == input.Labels ||
                    this.Labels != null &&
                    this.Labels.SequenceEqual(input.Labels)
                ) && 
                (
                    
                    (this.Arguments != null &&
                    this.Arguments.Equals(input.Arguments))
                ) && 
                (
                    this.CreatedAt == input.CreatedAt ||
                    (this.CreatedAt != null &&
                    this.CreatedAt.Equals(input.CreatedAt))
                ) && 
                (
                    this.UpdatedAt == input.UpdatedAt ||
                    (this.UpdatedAt != null &&
                    this.UpdatedAt.Equals(input.UpdatedAt))
                );
        }

public override bool Equals(object obj)
        {
            if(obj.GetType() == typeof(Moment)) return Value.Equals(((Moment)obj).Value);

            return Value.Equals(obj);
        }

See More Examples