Best Really Simple Systems CRM Phone Validation API & Email Verification Integration 2025

// Really Simple Systems CRM API integration with UK validation
const ReallySimpleClient = require('really-simple-systems-api');
const fetch = require('node-fetch');

class ReallySimpleValidationIntegration {
  constructor(rssConfig, lookupApiKey) {
    this.rss = new ReallySimpleClient({
      username: rssConfig.username,
      password: rssConfig.password,
      database: rssConfig.database
    });
    this.lookupApiKey = lookupApiKey;
    this.isAuthenticated = false;
  }
  
  async authenticate() {
    if (!this.isAuthenticated) {
      await this.rss.authenticate();
      this.isAuthenticated = true;
    }
  }
  
  async createValidatedContact(contactData, ukContext = {}) {
    try {
      await this.authenticate();
      
      // Perform UK/European optimized validation
      const validation = await this.validateContactInfo(contactData);
      
      // Calculate UK business quality metrics
      const ukMetrics = this.calculateUKMetrics(validation, contactData, ukContext);
      
      // Gather UK market intelligence data
      const ukIntelligence = await this.gatherUKIntelligence(contactData, validation);
      
      // Create contact in Really Simple Systems CRM with UK validation data
      const contact = await this.rss.contacts.create({
        firstName: contactData.firstName,
        lastName: contactData.lastName,
        companyName: contactData.company,
        jobTitle: contactData.jobTitle,
        
        // Contact information with UK validation
        emailAddress: validation.email?.isValid ? contactData.email : '',
        mobilePhone: validation.phone?.isValid && validation.phone.lineType === 'mobile' ? contactData.phone : '',
        workPhone: validation.phone?.isValid && validation.phone.lineType === 'landline' ? contactData.phone : '',
        
        // UK CRM validation fields
        validationStatus: this.getValidationStatus(validation),
        phoneValidationResult: validation.phone?.isValid ? 'Valid' : 'Invalid',
        phoneCarrier: validation.phone?.carrier || '',
        phoneLineType: validation.phone?.lineType || '',
        phoneRiskLevel: validation.phone?.riskLevel || 'Unknown',
        phoneLocation: validation.phone?.location || '',
        phoneCountry: validation.phone?.country || '',
        
        emailValidationResult: validation.email?.isValid ? 'Valid' : 'Invalid',
        emailDeliverable: validation.email?.deliverable ? 'Deliverable' : 'Not Deliverable',
        emailRiskLevel: validation.email?.riskLevel || 'Unknown',
        
        // UK business metrics
        contactQualityScore: ukMetrics.overallScore,
        ukBusinessFit: ukMetrics.ukBusinessFit,
        gdprComplianceScore: ukMetrics.gdprComplianceScore,
        europeanMarketValue: ukMetrics.europeanMarketValue,
        validationTimestamp: new Date().toISOString(),
        
        // UK market intelligence fields
        ukMarketSegment: ukIntelligence.marketSegment,
        businessType: ukIntelligence.businessType,
        regionFocus: ukIntelligence.regionFocus,
        complianceStatus: ukIntelligence.complianceStatus,
        
        // UK automation fields
        automationPath: this.determineUKAutomationPath(validation, ukMetrics),
        communicationMethod: this.recommendUKCommunication(validation),
        followUpApproach: this.recommendUKFollowUp(validation, ukMetrics),
        gdprConsent: this.assessGDPRRequirements(validation, ukContext)
      });
      
      // Create UK business opportunity for high-quality contacts
      if (ukMetrics.overallScore >= 75) {
        await this.createUKOpportunity(contact.id, validation, ukMetrics, ukIntelligence);
      }
      
      // Create UK-specific activities
      await this.createUKActivities(contact.id, validation, ukMetrics);
      
      // Add to UK automation workflows
      await this.addToUKWorkflows(contact.id, validation, ukMetrics, ukIntelligence);
      
      // Update UK business analytics
      await this.updateUKAnalytics(validation, ukMetrics);
      
      return {
        success: true,
        contactId: contact.id,
        validationResults: validation,
        ukMetrics: ukMetrics,
        ukIntelligence: ukIntelligence,
        ukStrategy: this.developUKStrategy(validation, ukMetrics, ukIntelligence),
        gdprCompliancePlan: this.createGDPRPlan(validation, ukMetrics, ukIntelligence)
      };
      
    } catch (error) {
      console.error('Really Simple Systems CRM contact creation failed:', error);
      return { success: false, error: error.message };
    }
  }
  
  async validateContactInfo(contactData) {
    const results = {};
    
    // UK/European optimized phone validation
    if (contactData.phone) {
      const phoneResponse = await fetch('https://app.1lookup.io/api/v1/phone', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.lookupApiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ 
          phone: contactData.phone,
          include_carrier_details: true,
          include_location_details: true,
          include_risk_assessment: true,
          include_uk_context: true,
          include_european_metrics: true,
          include_gdpr_analysis: true
        })
      });
      
      if (phoneResponse.ok) {
        const phoneData = await phoneResponse.json();
        results.phone = {
          isValid: phoneData.data.classification.is_valid,
          carrier: phoneData.data.carrier_details?.name,
          lineType: phoneData.data.carrier_details?.type,
          networkType: phoneData.data.carrier_details?.network_type,
          riskLevel: phoneData.data.risk_assessment?.risk_level,
          riskScore: phoneData.data.risk_assessment?.risk_score,
          location: phoneData.data.location_details?.city,
          state: phoneData.data.location_details?.state,
          country: phoneData.data.location_details?.country,
          timezone: phoneData.data.location_details?.timezone,
          ukContext: phoneData.data.uk_context,
          europeanMetrics: phoneData.data.european_metrics,
          gdprAnalysis: phoneData.data.gdpr_analysis,
          reachabilityScore: phoneData.data.classification.reachability_score,
          ukCompatibility: this.assessUKCompatibility(phoneData.data)
        };
      }
    }
    
    // UK/European optimized email validation
    if (contactData.email) {
      const emailResponse = await fetch('https://app.1lookup.io/api/v1/email', {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.lookupApiKey}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ 
          email: contactData.email,
          include_domain_details: true,
          include_risk_assessment: true,
          include_deliverability_check: true,
          include_uk_business_analysis: true,
          include_european_compliance: true,
          include_gdpr_assessment: true
        })
      });
      
      if (emailResponse.ok) {
        const emailData = await emailResponse.json();
        results.email = {
          isValid: emailData.data.classification.is_valid,
          deliverable: emailData.data.classification.deliverable,
          riskLevel: emailData.data.risk_assessment?.risk_level,
          riskScore: emailData.data.risk_assessment?.risk_score,
          domain: emailData.data.domain_details?.domain,
          domainAge: emailData.data.domain_details?.age_days,
          domainReputation: emailData.data.domain_details?.reputation,
          ukBusinessAnalysis: emailData.data.uk_business_analysis,
          europeanCompliance: emailData.data.european_compliance,
          gdprAssessment: emailData.data.gdpr_assessment,
          businessValue: emailData.data.uk_business_analysis?.business_value,
          deliverabilityConfidence: emailData.data.classification.deliverability_confidence
        };
      }
    }
    
    return results;
  }
  
  calculateUKMetrics(validation, contactData, ukContext) {
    let overallScore = 0;
    let componentScores = {};
    
    // Phone validation scoring for UK business
    if (validation.phone) {
      let phoneScore = 0;
      
      if (validation.phone.isValid) {
        phoneScore += 38; // Base validity for UK CRM
        
        // UK business risk assessment
        switch (validation.phone.riskLevel) {
          case 'Low': phoneScore += 24; break;
          case 'Medium': phoneScore += 13; break;
          case 'High': phoneScore -= 5; break;
        }
        
        // UK compatibility scoring
        phoneScore += validation.phone.ukCompatibility * 16;
        
        // UK context integration
        if (validation.phone.ukContext?.business_suitability === 'High') {
          phoneScore += 14;
        } else if (validation.phone.ukContext?.business_suitability === 'Medium') {
          phoneScore += 9;
        }
        
        // Line type for UK business
        if (validation.phone.lineType === 'mobile') {
          phoneScore += 16; // Mobile preferred in UK market
        } else if (validation.phone.lineType === 'landline') {
          phoneScore += 13; // UK business landlines valuable
        }
        
        // European metrics integration
        phoneScore += validation.phone.europeanMetrics?.market_fit * 0.08 || 4;
        
        // GDPR compliance bonus
        if (validation.phone.gdprAnalysis?.compliant) {
          phoneScore += 8;
        }
        
      } else {
        phoneScore -= 14; // Invalid phone impacts UK business
      }
      
      componentScores.phone = Math.max(0, Math.min(100, phoneScore));
      overallScore += componentScores.phone * 0.57; // 57% weight
    }
    
    // Email validation scoring for UK business
    if (validation.email) {
      let emailScore = 0;
      
      if (validation.email.isValid) {
        emailScore += 33; // Base validity
        
        // Deliverability for UK marketing
        if (validation.email.deliverable) {
          emailScore += 23;
          emailScore += validation.email.deliverabilityConfidence * 8;
        }
        
        // UK business analysis
        emailScore += validation.email.ukBusinessAnalysis?.relevance_score * 0.14 || 7;
        
        // Business value for UK market
        emailScore += validation.email.businessValue * 0.11 || 5;
        
        // European compliance scoring
        emailScore += validation.email.europeanCompliance?.score * 0.1 || 5;
        
        // GDPR assessment
        if (validation.email.gdprAssessment?.compliant) {
          emailScore += 10;
        }
        
        // Domain quality for UK business trust
        if (validation.email.domainAge > 365) {
          emailScore += 8;
        }
        
        if (validation.email.domainReputation === 'High') {
          emailScore += 7;
        }
        
      } else {
        emailScore -= 12;
      }
      
      componentScores.email = Math.max(0, Math.min(100, emailScore));
      overallScore += componentScores.email * 0.43; // 43% weight
    }
    
    // Calculate UK business specific metrics
    const ukBusinessFit = this.calculateUKBusinessFit(validation, ukContext);
    const gdprComplianceScore = this.calculateGDPRComplianceScore(validation);
    const europeanMarketValue = this.calculateEuropeanMarketValue(validation, contactData);
    const ukAutomationReadiness = this.calculateUKAutomationReadiness(validation, ukContext);
    
    return {
      overallScore: Math.round(overallScore),
      componentScores: componentScores,
      ukBusinessFit: ukBusinessFit,
      gdprComplianceScore: gdprComplianceScore,
      europeanMarketValue: europeanMarketValue,
      ukAutomationReadiness: ukAutomationReadiness,
      calculationTimestamp: new Date().toISOString(),
      ukVersion: '2025.1'
    };
  }
  
  async gatherUKIntelligence(contactData, validation) {
    // Gather UK market intelligence data
    const intelligence = {
      marketSegment: 'Unknown',
      businessType: 'Unknown',
      regionFocus: 'UK',
      complianceStatus: 'Unknown'
    };
    
    // Market segment analysis
    if (validation.phone?.ukContext?.market_segment) {
      intelligence.marketSegment = validation.phone.ukContext.market_segment;
    } else if (contactData.company) {
      intelligence.marketSegment = this.inferMarketSegment(contactData.company);
    }
    
    // Business type classification
    if (validation.email?.ukBusinessAnalysis?.business_type) {
      intelligence.businessType = validation.email.ukBusinessAnalysis.business_type;
    } else {
      intelligence.businessType = this.classifyBusinessType(contactData);
    }
    
    // Region focus determination
    if (validation.phone?.country === 'GB' || validation.phone?.country === 'UK') {
      intelligence.regionFocus = 'UK_Domestic';
    } else if (validation.phone?.europeanMetrics?.eu_member) {
      intelligence.regionFocus = 'EU_Market';
    } else {
      intelligence.regionFocus = 'International';
    }
    
    // GDPR compliance status
    if (validation.phone?.gdprAnalysis?.compliant && validation.email?.gdprAssessment?.compliant) {
      intelligence.complianceStatus = 'Fully_Compliant';
    } else if (validation.phone?.gdprAnalysis?.compliant || validation.email?.gdprAssessment?.compliant) {
      intelligence.complianceStatus = 'Partially_Compliant';
    } else {
      intelligence.complianceStatus = 'Compliance_Review_Needed';
    }
    
    return intelligence;
  }
  
  determineUKAutomationPath(validation, ukMetrics) {
    const paths = [];
    
    if (ukMetrics.ukAutomationReadiness >= 85) {
      paths.push('Full_UK_Automation');
    }
    
    if (validation.phone?.ukCompatibility >= 0.8) {
      paths.push('UK_Phone_Automation');
    }
    
    if (validation.email?.europeanCompliance?.automation_ready) {
      paths.push('GDPR_Compliant_Email_Automation');
    }
    
    if (ukMetrics.gdprComplianceScore >= 90) {
      paths.push('Compliance_First_Automation');
    } else {
      paths.push('Manual_Compliance_Review');
    }
    
    return paths.join(', ');
  }
  
  recommendUKCommunication(validation) {
    const methods = [];
    
    if (validation.phone?.isValid && validation.phone.ukContext?.preferred_method === 'phone') {
      methods.push('Phone_Call');
      
      if (validation.phone.lineType === 'mobile') {
        methods.push('SMS');
      }
    }
    
    if (validation.email?.deliverable && validation.email.gdprAssessment?.marketing_allowed) {
      methods.push('Email_Marketing');
    }
    
    if (methods.length === 0) {
      methods.push('Manual_Research');
    }
    
    return methods.join(', ');
  }
  
  recommendUKFollowUp(validation, ukMetrics) {
    let approach = 'Standard_UK_Approach';
    
    if (ukMetrics.ukBusinessFit >= 85 && ukMetrics.gdprComplianceScore >= 90) {
      approach = 'Premium_UK_Service';
    } else if (ukMetrics.europeanMarketValue >= 75) {
      approach = 'European_Market_Focus';
    } else if (ukMetrics.gdprComplianceScore < 70) {
      approach = 'Compliance_First_Approach';
    }
    
    return approach;
  }
  
  assessGDPRRequirements(validation, ukContext) {
    const requirements = [];
    
    // Phone GDPR requirements
    if (validation.phone?.gdprAnalysis?.consent_required) {
      requirements.push('Phone_Consent_Required');
    }
    
    // Email GDPR requirements
    if (validation.email?.gdprAssessment?.consent_required) {
      requirements.push('Email_Consent_Required');
    }
    
    // Marketing permissions
    if (ukContext.marketingIntent && !validation.email?.gdprAssessment?.marketing_allowed) {
      requirements.push('Marketing_Consent_Required');
    }
    
    return requirements.length > 0 ? requirements.join(', ') : 'No_Additional_Consent_Required';
  }
  
  async createUKOpportunity(contactId, validation, ukMetrics, ukIntelligence) {
    try {
      const opportunity = await this.rss.opportunities.create({
        name: `UK Quality Lead - Score: ${ukMetrics.overallScore}`,
        contactId: contactId,
        stage: 'Prospecting',
        value: this.estimateUKValue(ukMetrics, ukIntelligence),
        currency: 'GBP',
        probability: Math.min(90, ukMetrics.overallScore),
        
        // UK opportunity fields
        validationScore: ukMetrics.overallScore,
        ukBusinessFit: ukMetrics.ukBusinessFit,
        gdprCompliance: ukMetrics.gdprComplianceScore,
        europeanValue: ukMetrics.europeanMarketValue,
        marketSegment: ukIntelligence.marketSegment,
        regionFocus: ukIntelligence.regionFocus
      });
      
      return opportunity.id;
    } catch (error) {
      console.error('Failed to create UK opportunity:', error);
      return null;
    }
  }
  
  async createUKActivities(contactId, validation, ukMetrics) {
    const activities = [];
    
    // Create UK business specific activities
    if (ukMetrics.ukBusinessFit >= 80) {
      activities.push({
        type: 'Call',
        contactId: contactId,
        subject: 'UK Business Priority Contact',
        description: `UK Fit Score: ${ukMetrics.ukBusinessFit} - High priority UK business contact`,
        dueDate: new Date(Date.now() + 4 * 60 * 60 * 1000), // 4 hours
        priority: 'High'
      });
    }
    
    if (ukMetrics.gdprComplianceScore < 80) {
      activities.push({
        type: 'Task',
        contactId: contactId,
        subject: 'GDPR Compliance Review',
        description: 'Review and ensure GDPR compliance before outreach',
        dueDate: new Date(Date.now() + 2 * 60 * 60 * 1000), // 2 hours
        priority: 'High'
      });
    }
    
    if (ukMetrics.europeanMarketValue >= 75) {
      activities.push({
        type: 'Task',
        contactId: contactId,
        subject: 'European Market Opportunity Assessment',
        description: 'Assess potential for European market expansion',
        dueDate: new Date(Date.now() + 8 * 60 * 60 * 1000), // 8 hours
        priority: 'Medium'
      });
    }
    
    // Create activities in Really Simple Systems
    for (const activity of activities) {
      try {
        await this.rss.activities.create(activity);
      } catch (error) {
        console.error('Failed to create UK activity:', error);
      }
    }
  }
  
  developUKStrategy(validation, ukMetrics, ukIntelligence) {
    return {
      primaryMarket: ukIntelligence.regionFocus,
      businessApproach: ukMetrics.ukBusinessFit >= 75 ? 'UK_Specialized_Service' : 'General_European_Service',
      complianceStrategy: ukMetrics.gdprComplianceScore >= 90 ? 'Compliance_Ready' : 'Compliance_First',
      communicationChannels: this.recommendUKCommunication(validation).split(', '),
      timeframe: ukMetrics.ukBusinessFit >= 80 ? '2-3 weeks' : '1-2 months',
      expectedValue: this.estimateUKValue(ukMetrics, ukIntelligence),
      riskMitigation: this.identifyUKRisks(validation, ukMetrics),
      successProbability: Math.min(95, ukMetrics.overallScore)
    };
  }
  
  createGDPRPlan(validation, ukMetrics, ukIntelligence) {
    return {
      complianceStatus: ukIntelligence.complianceStatus,
      requiredConsents: this.assessGDPRRequirements(validation, { marketingIntent: true }).split(', '),
      dataProcessingBasis: this.determineProcessingBasis(validation, ukMetrics),
      retentionPeriod: '3 years', // Standard UK business retention
      dataSubjectRights: [
        'Right_to_Access',
        'Right_to_Rectification', 
        'Right_to_Erasure',
        'Right_to_Data_Portability'
      ],
      complianceActions: this.generateComplianceActions(validation, ukMetrics),
      reviewSchedule: 'Quarterly',
      documentationRequired: this.identifyRequiredDocumentation(validation, ukMetrics)
    };
  }
  
  // Helper methods
  assessUKCompatibility(phoneData) {
    let compatibility = 0.4;
    
    if (phoneData.classification.is_valid) compatibility += 0.2;
    if (phoneData.risk_assessment?.risk_level === 'Low') compatibility += 0.15;
    if (phoneData.uk_context?.business_suitability === 'High') compatibility += 0.15;
    if (phoneData.gdpr_analysis?.compliant) compatibility += 0.1;
    
    return Math.min(1.0, compatibility);
  }
  
  calculateUKBusinessFit(validation, ukContext) {
    let fit = 35;
    
    if (validation.phone?.ukContext?.business_suitability === 'High') {
      fit += 30;
    } else if (validation.phone?.ukContext?.business_suitability === 'Medium') {
      fit += 20;
    }
    
    if (validation.email?.ukBusinessAnalysis?.market_relevance >= 80) {
      fit += 25;
    }
    
    if (ukContext.ukBusiness) fit += 15;
    if (validation.phone?.country === 'GB') fit += 10;
    
    return Math.min(100, fit);
  }
  
  calculateGDPRComplianceScore(validation) {
    let score = 50; // Base compliance
    
    if (validation.phone?.gdprAnalysis?.compliant) score += 25;
    if (validation.email?.gdprAssessment?.compliant) score += 25;
    if (validation.phone?.gdprAnalysis?.consent_documented) score += 10;
    if (validation.email?.gdprAssessment?.opt_in_confirmed) score += 10;
    
    return Math.min(100, score);
  }
  
  calculateEuropeanMarketValue(validation, contactData) {
    let value = 30;
    
    if (validation.phone?.europeanMetrics?.market_potential >= 80) {
      value += 35;
    }
    
    if (validation.email?.europeanCompliance?.market_value >= 75) {
      value += 25;
    }
    
    if (contactData.company && this.isEuropeanCompany(contactData.company)) {
      value += 20;
    }
    
    return Math.min(100, value);
  }
  
  calculateUKAutomationReadiness(validation, ukContext) {
    let readiness = 25;
    
    if (validation.phone?.gdprAnalysis?.automation_ready) readiness += 30;
    if (validation.email?.gdprAssessment?.automation_compliant) readiness += 25;
    if (ukContext.automationApproved) readiness += 20;
    if (validation.phone?.ukCompatibility >= 0.8) readiness += 15;
    
    return Math.min(100, readiness);
  }
  
  inferMarketSegment(company) {
    const companyLower = company.toLowerCase();
    
    if (companyLower.includes('tech') || companyLower.includes('software')) {
      return 'Technology';
    } else if (companyLower.includes('finance') || companyLower.includes('bank')) {
      return 'Financial_Services';
    } else if (companyLower.includes('retail') || companyLower.includes('shop')) {
      return 'Retail';
    } else {
      return 'General_Business';
    }
  }
  
  classifyBusinessType(contactData) {
    if (contactData.jobTitle?.toLowerCase().includes('director') || 
        contactData.jobTitle?.toLowerCase().includes('manager')) {
      return 'Enterprise_Contact';
    } else if (contactData.company) {
      return 'Business_Contact';
    } else {
      return 'Individual_Contact';
    }
  }
  
  determineProcessingBasis(validation, ukMetrics) {
    if (ukMetrics.gdprComplianceScore >= 90) {
      return 'Legitimate_Interest';
    } else {
      return 'Consent_Required';
    }
  }
  
  generateComplianceActions(validation, ukMetrics) {
    const actions = [];
    
    if (ukMetrics.gdprComplianceScore < 80) {
      actions.push('Obtain_Explicit_Consent');
    }
    
    if (!validation.phone?.gdprAnalysis?.consent_documented) {
      actions.push('Document_Phone_Consent');
    }
    
    if (!validation.email?.gdprAssessment?.opt_in_confirmed) {
      actions.push('Confirm_Email_Opt_In');
    }
    
    return actions;
  }
  
  identifyRequiredDocumentation(validation, ukMetrics) {
    const docs = [
      'Privacy_Policy',
      'Data_Processing_Agreement',
      'Consent_Records'
    ];
    
    if (ukMetrics.gdprComplianceScore < 90) {
      docs.push('Compliance_Assessment');
    }
    
    if (validation.phone?.gdprAnalysis?.data_transfer_required) {
      docs.push('Data_Transfer_Agreement');
    }
    
    return docs;
  }
  
  identifyUKRisks(validation, ukMetrics) {
    const risks = [];
    
    if (ukMetrics.gdprComplianceScore < 70) {
      risks.push('GDPR_Non_Compliance_Risk');
    }
    
    if (validation.phone?.riskLevel === 'High') {
      risks.push('Phone_Security_Risk');
    }
    
    if (validation.email?.riskLevel === 'High') {
      risks.push('Email_Security_Risk');
    }
    
    return risks;
  }
  
  isEuropeanCompany(company) {
    const europeanIndicators = ['.co.uk', '.eu', '.de', '.fr', '.it', '.es', 'ltd', 'plc', 'gmbh'];
    const companyLower = company.toLowerCase();
    
    return europeanIndicators.some(indicator => companyLower.includes(indicator));
  }
  
  estimateUKValue(ukMetrics, ukIntelligence) {
    const baseValue = 2500; // UK market base value in GBP
    const multiplier = ukMetrics.ukBusinessFit / 100;
    const complianceBonus = ukMetrics.gdprComplianceScore * 5;
    const marketBonus = ukMetrics.europeanMarketValue * 8;
    
    return Math.round(baseValue * multiplier + complianceBonus + marketBonus);
  }
  
  async updateUKAnalytics(validation, ukMetrics) {
    // Update UK business analytics
    const analytics = {
      timestamp: new Date().toISOString(),
      phoneValidationRate: validation.phone?.isValid ? 1 : 0,
      emailValidationRate: validation.email?.isValid ? 1 : 0,
      avgQualityScore: ukMetrics.overallScore,
      ukBusinessFitRate: ukMetrics.ukBusinessFit,
      gdprComplianceRate: ukMetrics.gdprComplianceScore,
      europeanMarketValue: ukMetrics.europeanMarketValue
    };
    
    console.log('Updated UK CRM analytics:', analytics);
  }
  
  getValidationStatus(validation) {
    const phoneValid = validation.phone?.isValid || false;
    const emailValid = validation.email?.isValid || false;
    
    if (phoneValid && emailValid) return 'Fully_Validated';
    if (phoneValid || emailValid) return 'Partially_Validated';
    return 'Validation_Required';
  }
}

// Usage example
const reallySimpleIntegration = new ReallySimpleValidationIntegration({
  username: process.env.RSS_USERNAME,
  password: process.env.RSS_PASSWORD,
  database: process.env.RSS_DATABASE
}, process.env.LOOKUP_API_KEY);

// Create UK business validated contact
const result = await reallySimpleIntegration.createValidatedContact({
  firstName: 'James',
  lastName: 'Smith',
  email: 'james@ukbusiness.co.uk',
  phone: '+441234567890',
  company: 'UK Business Solutions Ltd',
  jobTitle: 'Managing Director'
}, {
  ukBusiness: true,
  businessSize: 'medium',
  marketingIntent: true,
  automationApproved: true,
  gdprCompliant: true
});

console.log('Really Simple Systems CRM UK validation result:', result);