import { country } from '@koshmoney/countries';
 
// Define sanctions tiers based on your compliance policy
// These sets should be loaded from your compliance data source and updated regularly
const COMPREHENSIVE_SANCTIONS = new Set(['IR', 'KP', 'CU', 'SY']);
const TARGETED_SANCTIONS = new Set(['RU', 'BY', 'MM', 'VE']);
const CRIMEA_REGION = new Set(['UA']); // Requires sub-region check
 
type SanctionsResult = {
  allowed: boolean;
  tier: 'comprehensive' | 'targeted' | 'region_restricted' | 'clear';
  reason: string;
  countryName: string | null;
};
 
function checkCountrySanctions(countryCode: string): SanctionsResult {
  if (!country.isValid(countryCode)) {
    return {
      allowed: false,
      tier: 'comprehensive',
      reason: 'Invalid country code',
      countryName: null,
    };
  }
 
  const code = countryCode.toUpperCase();
  const name = country.toName(code);
 
  if (COMPREHENSIVE_SANCTIONS.has(code)) {
    return {
      allowed: false,
      tier: 'comprehensive',
      reason: `${name} is subject to comprehensive OFAC sanctions`,
      countryName: name,
    };
  }
 
  if (TARGETED_SANCTIONS.has(code)) {
    return {
      allowed: true, // May be allowed, but requires enhanced screening
      tier: 'targeted',
      reason: `${name} is subject to targeted OFAC sanctions -- enhanced screening required`,
      countryName: name,
    };
  }
 
  return {
    allowed: true,
    tier: 'clear',
    reason: 'No country-level sanctions apply',
    countryName: name,
  };
}
 
checkCountrySanctions('IR');
// { allowed: false, tier: 'comprehensive',
//   reason: 'Iran is subject to comprehensive OFAC sanctions', countryName: 'Iran' }
 
checkCountrySanctions('RU');
// { allowed: true, tier: 'targeted',
//   reason: 'Russia is subject to targeted OFAC sanctions -- enhanced screening required',
//   countryName: 'Russia' }
 
checkCountrySanctions('DE');
// { allowed: true, tier: 'clear',
//   reason: 'No country-level sanctions apply', countryName: 'Germany' }

import { country } from '@koshmoney/countries';
import { membership } from '@koshmoney/countries/membership';
 
interface ComplianceProfile {
  sanctionsTier: 'blocked' | 'restricted' | 'clear';
  isEU: boolean;
  isSEPA: boolean;
  requiresEDD: boolean; // Enhanced Due Diligence
  paymentRailsAvailable: string[];
}
 
function getComplianceProfile(countryCode: string): ComplianceProfile | null {
  if (!country.isValid(countryCode)) return null;
 
  const code = countryCode.toUpperCase();
  const BLOCKED = new Set(['IR', 'KP', 'CU', 'SY']);
  const RESTRICTED = new Set(['RU', 'BY', 'MM', 'VE']);
 
  if (BLOCKED.has(code)) {
    return {
      sanctionsTier: 'blocked',
      isEU: false,
      isSEPA: false,
      requiresEDD: true,
      paymentRailsAvailable: [],
    };
  }
 
  const isEUMember = membership.isEU(code);
  const isSEPAMember = membership.isSEPA(code);
  const isRestricted = RESTRICTED.has(code);
 
  const rails: string[] = [];
  if (isSEPAMember) rails.push('SEPA', 'SEPA_INSTANT');
  if (!isRestricted) rails.push('SWIFT');
  if (!isRestricted) rails.push('CRYPTO');
 
  return {
    sanctionsTier: isRestricted ? 'restricted' : 'clear',
    isEU: isEUMember,
    isSEPA: isSEPAMember,
    requiresEDD: isRestricted,
    paymentRailsAvailable: rails,
  };
}
 
getComplianceProfile('FR');
// { sanctionsTier: 'clear', isEU: true, isSEPA: true,
//   requiresEDD: false, paymentRailsAvailable: ['SEPA', 'SEPA_INSTANT', 'SWIFT', 'CRYPTO'] }
 
getComplianceProfile('RU');
// { sanctionsTier: 'restricted', isEU: false, isSEPA: false,
//   requiresEDD: true, paymentRailsAvailable: [] }
 
getComplianceProfile('IR');
// { sanctionsTier: 'blocked', isEU: false, isSEPA: false,
//   requiresEDD: true, paymentRailsAvailable: [] }

import { country } from '@koshmoney/countries';
import { membership } from '@koshmoney/countries/membership';
 
// ---- Configuration (load from your compliance data source) ----
 
interface SanctionsConfig {
  comprehensiveSanctions: Set<string>;
  targetedSanctions: Set<string>;
  fatfBlacklist: Set<string>;
  fatfGreylist: Set<string>;
}
 
function loadSanctionsConfig(): SanctionsConfig {
  // In production, load this from a database, API, or compliance feed
  // Updated regularly by your compliance team
  return {
    comprehensiveSanctions: new Set(['IR', 'KP', 'CU', 'SY']),
    targetedSanctions: new Set(['RU', 'BY', 'MM', 'VE']),
    fatfBlacklist: new Set(['IR', 'KP', 'MM']),
    fatfGreylist: new Set([
      'BF', 'CM', 'CD', 'HT', 'KE', 'ML', 'MZ', 'NG',
      'PH', 'SN', 'SS', 'TZ', 'VN', 'YE',
    ]),
  };
}
 
// ---- Screening Logic ----
 
type RiskLevel = 'blocked' | 'high' | 'elevated' | 'standard';
 
interface ScreeningResult {
  countryCode: string;
  countryName: string | null;
  riskLevel: RiskLevel;
  flags: string[];
  requiresManualReview: boolean;
  blocked: boolean;
}
 
function screenCountry(
  countryCode: string,
  config: SanctionsConfig
): ScreeningResult {
  const flags: string[] = [];
 
  if (!country.isValid(countryCode)) {
    return {
      countryCode,
      countryName: null,
      riskLevel: 'blocked',
      flags: ['INVALID_COUNTRY_CODE'],
      requiresManualReview: false,
      blocked: true,
    };
  }
 
  const code = countryCode.toUpperCase();
  const name = country.toName(code);
 
  // Layer 1: Comprehensive sanctions -- block immediately
  if (config.comprehensiveSanctions.has(code)) {
    flags.push('OFAC_COMPREHENSIVE');
    return {
      countryCode: code,
      countryName: name,
      riskLevel: 'blocked',
      flags,
      requiresManualReview: false,
      blocked: true,
    };
  }
 
  // Layer 2: Targeted sanctions -- high risk, may require manual review
  if (config.targetedSanctions.has(code)) {
    flags.push('OFAC_TARGETED');
  }
 
  // Layer 3: FATF blacklist/greylist
  if (config.fatfBlacklist.has(code)) {
    flags.push('FATF_BLACKLIST');
  } else if (config.fatfGreylist.has(code)) {
    flags.push('FATF_GREYLIST');
  }
 
  // Determine overall risk level
  let riskLevel: RiskLevel = 'standard';
  if (flags.includes('OFAC_TARGETED') || flags.includes('FATF_BLACKLIST')) {
    riskLevel = 'high';
  } else if (flags.includes('FATF_GREYLIST')) {
    riskLevel = 'elevated';
  }
 
  return {
    countryCode: code,
    countryName: name,
    riskLevel,
    flags,
    requiresManualReview: riskLevel === 'high',
    blocked: false,
  };
}
 
// ---- Usage ----
 
const config = loadSanctionsConfig();
 
screenCountry('IR', config);
// { countryCode: 'IR', countryName: 'Iran', riskLevel: 'blocked',
//   flags: ['OFAC_COMPREHENSIVE'], requiresManualReview: false, blocked: true }
 
screenCountry('RU', config);
// { countryCode: 'RU', countryName: 'Russia', riskLevel: 'high',
//   flags: ['OFAC_TARGETED'], requiresManualReview: true, blocked: false }
 
screenCountry('NG', config);
// { countryCode: 'NG', countryName: 'Nigeria', riskLevel: 'elevated',
//   flags: ['FATF_GREYLIST'], requiresManualReview: false, blocked: false }
 
screenCountry('US', config);
// { countryCode: 'US', countryName: 'United States', riskLevel: 'standard',
//   flags: [], requiresManualReview: false, blocked: false }

import { country } from '@koshmoney/countries';
 
interface Transaction {
  id: string;
  senderCountry: string;
  recipientCountry: string;
  amount: number;
  currency: string;
}
 
interface TransactionScreeningResult {
  transactionId: string;
  senderScreening: ScreeningResult;
  recipientScreening: ScreeningResult;
  overallDecision: 'approve' | 'review' | 'block';
  reasons: string[];
}
 
function screenTransaction(
  tx: Transaction,
  config: SanctionsConfig
): TransactionScreeningResult {
  const senderResult = screenCountry(tx.senderCountry, config);
  const recipientResult = screenCountry(tx.recipientCountry, config);
 
  const reasons: string[] = [];
  let decision: 'approve' | 'review' | 'block' = 'approve';
 
  // If either side is blocked, block the transaction
  if (senderResult.blocked || recipientResult.blocked) {
    decision = 'block';
    if (senderResult.blocked) {
      reasons.push(`Sender country ${senderResult.countryName} is comprehensively sanctioned`);
    }
    if (recipientResult.blocked) {
      reasons.push(`Recipient country ${recipientResult.countryName} is comprehensively sanctioned`);
    }
  }
  // If either side requires manual review, flag for review
  else if (senderResult.requiresManualReview || recipientResult.requiresManualReview) {
    decision = 'review';
    reasons.push(...senderResult.flags.map(f => `Sender: ${f}`));
    reasons.push(...recipientResult.flags.map(f => `Recipient: ${f}`));
  }
 
  return {
    transactionId: tx.id,
    senderScreening: senderResult,
    recipientScreening: recipientResult,
    overallDecision: decision,
    reasons,
  };
}

import { country } from '@koshmoney/countries';
 
type SanctionsRegime = 'OFAC' | 'EU' | 'UN';
 
interface RegimeConfig {
  blocked: Set<string>;
  restricted: Set<string>;
}
 
// Each regime has its own blocked and restricted lists
const REGIMES: Record<SanctionsRegime, RegimeConfig> = {
  OFAC: {
    blocked: new Set(['IR', 'KP', 'CU', 'SY']),
    restricted: new Set(['RU', 'BY', 'MM', 'VE']),
  },
  EU: {
    blocked: new Set(['KP', 'SY', 'RU', 'BY']),
    restricted: new Set(['IR', 'MM', 'VE']),
  },
  UN: {
    blocked: new Set(['KP']),
    restricted: new Set(['IR', 'SO', 'YE', 'SS', 'CF', 'CD', 'ML', 'LY']),
  },
};
 
interface MultiRegimeResult {
  countryCode: string;
  countryName: string | null;
  blockedBy: SanctionsRegime[];
  restrictedBy: SanctionsRegime[];
  clearInAll: boolean;
}
 
function screenAllRegimes(
  countryCode: string,
  applicableRegimes: SanctionsRegime[]
): MultiRegimeResult {
  const code = countryCode.toUpperCase();
  const name = country.isValid(code) ? country.toName(code) : null;
 
  const blockedBy: SanctionsRegime[] = [];
  const restrictedBy: SanctionsRegime[] = [];
 
  for (const regime of applicableRegimes) {
    const config = REGIMES[regime];
    if (config.blocked.has(code)) {
      blockedBy.push(regime);
    } else if (config.restricted.has(code)) {
      restrictedBy.push(regime);
    }
  }
 
  return {
    countryCode: code,
    countryName: name,
    blockedBy,
    restrictedBy,
    clearInAll: blockedBy.length === 0 && restrictedBy.length === 0,
  };
}
 
// A U.S. company with EU operations must comply with both
screenAllRegimes('CU', ['OFAC', 'EU']);
// { countryCode: 'CU', countryName: 'Cuba', blockedBy: ['OFAC'],
//   restrictedBy: [], clearInAll: false }
 
screenAllRegimes('RU', ['OFAC', 'EU', 'UN']);
// { countryCode: 'RU', countryName: 'Russia', blockedBy: ['EU'],
//   restrictedBy: ['OFAC'], clearInAll: false }
 
screenAllRegimes('DE', ['OFAC', 'EU', 'UN']);
// { countryCode: 'DE', countryName: 'Germany', blockedBy: [],
//   restrictedBy: [], clearInAll: true }

// WRONG: Hardcoded list that will go stale
const SANCTIONED = ['IR', 'KP', 'CU', 'SY'];
 
// CORRECT: Load from a configurable data source
const sanctionsConfig = await loadSanctionsConfig(); // From database, API, or config service

// INCOMPLETE: Country check alone is not sufficient
function isAllowed(countryCode: string): boolean {
  return !SANCTIONED_COUNTRIES.has(countryCode);
}
 
// BETTER: Country check + entity screening
async function screenUser(
  countryCode: string,
  fullName: string,
  dateOfBirth: string
): Promise<{ allowed: boolean; flags: string[] }> {
  const flags: string[] = [];
 
  // Layer 1: Country screening
  const countryResult = screenCountry(countryCode, config);
  if (countryResult.blocked) {
    return { allowed: false, flags: ['SANCTIONED_COUNTRY'] };
  }
  if (countryResult.riskLevel === 'high') {
    flags.push('HIGH_RISK_COUNTRY');
  }
 
  // Layer 2: Entity screening (use a dedicated SDN screening service)
  const sdnResult = await sdnScreeningService.check({ fullName, dateOfBirth });
  if (sdnResult.match) {
    return { allowed: false, flags: ['SDN_MATCH'] };
  }
  if (sdnResult.potentialMatch) {
    flags.push('SDN_POTENTIAL_MATCH');
  }
 
  return { allowed: true, flags };
}

// WRONG: Blocking all of Ukraine
const SANCTIONED = new Set(['IR', 'KP', 'CU', 'SY', 'UA']);
 
// CORRECT: Ukraine is not sanctioned; specific regions are
// You need additional data (IP geolocation, address) to identify
// users in Crimea, Donetsk, or Luhansk
function isRegionalSanction(countryCode: string, region?: string): boolean {
  if (countryCode === 'UA' && region) {
    const sanctionedRegions = new Set(['crimea', 'donetsk', 'luhansk']);
    return sanctionedRegions.has(region.toLowerCase());
  }
  return false;
}

interface ComplianceLog {
  timestamp: Date;
  action: 'COUNTRY_SCREEN' | 'ENTITY_SCREEN' | 'TRANSACTION_SCREEN';
  input: Record<string, string>;
  result: ScreeningResult;
  sanctionsDataVersion: string; // Track which version of sanctions data was used
  decision: 'approve' | 'review' | 'block';
}
 
function logScreeningDecision(log: ComplianceLog): void {
  // Persist to your compliance audit table
  // This is NOT optional -- regulators will ask for it
  complianceAuditRepository.save(log);
}

import { country } from '@koshmoney/countries';
 
function assessRussiaUkraineRisk(
  countryCode: string,
  address?: { region?: string }
): 'blocked' | 'restricted' | 'standard' {
  const code = countryCode.toUpperCase();
 
  // Ukraine: check for sanctioned regions
  if (code === 'UA' && address?.region) {
    const sanctionedRegions = ['crimea', 'donetsk', 'luhansk', 'sevastopol'];
    if (sanctionedRegions.some(r => address.region!.toLowerCase().includes(r))) {
      return 'blocked';
    }
    return 'standard';
  }
 
  // Russia: targeted sanctions (not comprehensive)
  if (code === 'RU') {
    return 'restricted';
  }
 
  return 'standard';
}

npm install @koshmoney/countries

import { country } from '@koshmoney/countries';
import { membership } from '@koshmoney/countries/membership';
 
// Validate country codes in your screening pipeline
country.isValid('IR'); // true
 
// Combine sanctions checks with membership data
membership.isEU('RU'); // false
membership.isSEPA('RU'); // false
 
// Get all memberships for compliance profiling
membership.getMemberships('DE');
// { EU: true, SEPA: true, EEA: true, Eurozone: true, Schengen: true }