@vesant-sdk/fraud 0.1.1-next.f221d37 → 0.1.2-dev.254dc8c

package/dist/index.js

@@ -121,8 +121,321 @@ var TransactionStatus = {
   Failure: "$failure",
   Pending: "$pending"
 };
+var SiftPaymentTypeValues = [
+  "$cash",
+  "$check",
+  "$credit_card",
+  "$crypto_currency",
+  "$debit_card",
+  "$digital_wallet",
+  "$electronic_fund_transfer",
+  "$financing",
+  "$gift_card",
+  "$invoice",
+  "$in_app_purchase",
+  "$money_order",
+  "$points",
+  "$prepaid_card",
+  "$store_credit",
+  "$third_party_processor",
+  "$voucher",
+  "$sepa_credit",
+  "$sepa_instant_credit",
+  "$sepa_direct_debit",
+  "$ach_credit",
+  "$ach_debit",
+  "$wire_credit",
+  "$wire_debit"
+];
+var PaymentType = {
+  Cash: "$cash",
+  Check: "$check",
+  CreditCard: "$credit_card",
+  CryptoCurrency: "$crypto_currency",
+  DebitCard: "$debit_card",
+  DigitalWallet: "$digital_wallet",
+  ElectronicFundTransfer: "$electronic_fund_transfer",
+  Financing: "$financing",
+  GiftCard: "$gift_card",
+  Invoice: "$invoice",
+  InAppPurchase: "$in_app_purchase",
+  MoneyOrder: "$money_order",
+  Points: "$points",
+  PrepaidCard: "$prepaid_card",
+  StoreCredit: "$store_credit",
+  ThirdPartyProcessor: "$third_party_processor",
+  Voucher: "$voucher",
+  SepaCredit: "$sepa_credit",
+  SepaInstantCredit: "$sepa_instant_credit",
+  SepaDirectDebit: "$sepa_direct_debit",
+  AchCredit: "$ach_credit",
+  AchDebit: "$ach_debit",
+  WireCredit: "$wire_credit",
+  WireDebit: "$wire_debit"
+};
+var SiftWalletTypeValues = ["$crypto", "$digital", "$fiat"];
+var WalletType = {
+  Crypto: "$crypto",
+  Digital: "$digital",
+  Fiat: "$fiat"
+};
+
+// src/types/rule-signals.ts
+var LOGIN_RULE_SIGNAL_KEYS = ["ip_country_mismatch"];
+var UPDATE_ACCOUNT_RULE_SIGNAL_KEYS = [
+  "two_fa_enabled",
+  "two_fa_disabled",
+  "two_fa_method_changed"
+];
+var TRANSACTION_RULE_SIGNAL_KEYS = [
+  "payment_method",
+  "is_first_deposit",
+  "cumulative_deposit_amount",
+  "deposit_count",
+  "failed_deposit_count",
+  "is_first_withdrawal",
+  "withdrawal_method_differs",
+  "cumulative_withdrawal_amount",
+  "withdrawal_count",
+  "hours_since_last_deposit",
+  "days_since_last_activity",
+  "hours_since_account_creation"
+];
+
+// src/normalization/payment-methods.ts
+var PAYMENT_TYPE_ALIASES = {
+  bank_account: "$electronic_fund_transfer",
+  electronic_fund_transfer: "$electronic_fund_transfer",
+  credit_card: "$credit_card",
+  crypto_currency: "$crypto_currency",
+  debit_card: "$debit_card",
+  digital_wallet: "$digital_wallet",
+  cash: "$cash",
+  check: "$check",
+  financing: "$financing",
+  gift_card: "$gift_card",
+  invoice: "$invoice",
+  in_app_purchase: "$in_app_purchase",
+  money_order: "$money_order",
+  points: "$points",
+  prepaid_card: "$prepaid_card",
+  store_credit: "$store_credit",
+  third_party_processor: "$third_party_processor",
+  voucher: "$voucher",
+  sepa_credit: "$sepa_credit",
+  sepa_instant_credit: "$sepa_instant_credit",
+  sepa_direct_debit: "$sepa_direct_debit",
+  ach_credit: "$ach_credit",
+  ach_debit: "$ach_debit",
+  wire_credit: "$wire_credit",
+  wire_debit: "$wire_debit"
+};
+var SIFT_PAYMENT_METHOD_WHITELIST = /* @__PURE__ */ new Set([
+  "payment_type",
+  "payment_gateway",
+  "card_bin",
+  "card_last4",
+  "avs_result_code",
+  "cvv_result_code",
+  "verification_status",
+  "routing_number",
+  "account_holder_name",
+  "account_number_last5",
+  "bank_name",
+  "bank_country",
+  "wallet_address",
+  "wallet_type",
+  "paypal_payer_id",
+  "paypal_payer_email"
+]);
+var DEPRECATED_PAYMENT_METHOD_KEYS = [
+  "account_number_last4",
+  "account_id",
+  "wallet_address_last4",
+  "crypto_currency",
+  "network"
+];
+var METADATA_STRIP_KEYS = /* @__PURE__ */ new Set([
+  "account_id",
+  "wallet_address_last4",
+  "crypto_currency",
+  "network"
+]);
+function isDevEnvironment() {
+  return typeof process !== "undefined" && process.env?.NODE_ENV !== "production";
+}
+function warnDeprecatedKey(key) {
+  if (!isDevEnvironment()) return;
+  const messages = {
+    account_number_last4: "[vesant-sdk/fraud] account_number_last4 is not a Sift field; use account_number_last5",
+    account_id: "[vesant-sdk/fraud] account_id is not a Sift field; moved to metadata",
+    wallet_address_last4: "[vesant-sdk/fraud] wallet_address_last4 is not a Sift field; moved to metadata",
+    crypto_currency: "[vesant-sdk/fraud] crypto_currency is not a Sift field on payment_method; moved to metadata",
+    network: "[vesant-sdk/fraud] network is not a Sift field on payment_method; moved to metadata"
+  };
+  const message = messages[key];
+  if (message) {
+    console.warn(message);
+  }
+}
+function normalizeSiftPaymentType(value) {
+  if (value === void 0 || value === null) return void 0;
+  const trimmed = String(value).trim();
+  if (trimmed === "") return void 0;
+  const normalized = trimmed.startsWith("$") ? trimmed.slice(1) : trimmed;
+  const alias = PAYMENT_TYPE_ALIASES[normalized.toLowerCase()];
+  if (alias) return alias;
+  const withPrefix = `$${normalized}`;
+  if (SiftPaymentTypeValues.includes(withPrefix)) {
+    return withPrefix;
+  }
+  return void 0;
+}
+function toSiftAccountNumberLast5(value) {
+  if (value === void 0 || value === null) return void 0;
+  const digits = String(value).replace(/\D/g, "");
+  if (digits.length === 0) return void 0;
+  if (digits.length >= 5) return digits.slice(-5);
+  return digits.padStart(5, "0");
+}
+function collectMetadataExtra(metadataExtras, key, value) {
+  if (value === void 0) return;
+  metadataExtras[key] = value;
+}
+function normalizeSiftPaymentMethod(raw) {
+  const metadataExtras = {};
+  const method = {};
+  const rawPaymentType = raw.payment_type !== void 0 ? String(raw.payment_type) : raw.$payment_type !== void 0 ? String(raw.$payment_type) : void 0;
+  const normalizedType = normalizeSiftPaymentType(rawPaymentType);
+  if (rawPaymentType !== void 0 && normalizedType === void 0) {
+    return null;
+  }
+  if (normalizedType !== void 0) {
+    method.payment_type = normalizedType;
+  }
+  for (const key of DEPRECATED_PAYMENT_METHOD_KEYS) {
+    if (key in raw) warnDeprecatedKey(key);
+  }
+  const accountLast4 = raw.account_number_last4 ?? raw.$account_number_last4;
+  const accountLast5 = raw.account_number_last5 ?? raw.$account_number_last5;
+  const resolvedLast5 = toSiftAccountNumberLast5(accountLast5 ?? accountLast4);
+  if (resolvedLast5 !== void 0) {
+    method.account_number_last5 = resolvedLast5;
+  }
+  for (const [key, value] of Object.entries(raw)) {
+    if (key === "payment_type" || key === "$payment_type") continue;
+    if (key === "account_number_last4" || key === "$account_number_last4") continue;
+    if (key === "account_number_last5" || key === "$account_number_last5") continue;
+    const plainKey = key.startsWith("$") ? key.slice(1) : key;
+    if (METADATA_STRIP_KEYS.has(plainKey)) {
+      if (plainKey === "account_id") {
+        collectMetadataExtra(metadataExtras, "linkmoney_account_id", String(value));
+      } else {
+        collectMetadataExtra(metadataExtras, plainKey, value);
+      }
+      continue;
+    }
+    if (!SIFT_PAYMENT_METHOD_WHITELIST.has(plainKey)) {
+      collectMetadataExtra(metadataExtras, `payment_method_${plainKey}`, value);
+      continue;
+    }
+    if (plainKey === "payment_type") {
+      continue;
+    }
+    method[plainKey] = value;
+  }
+  const hasMetadata = Object.keys(metadataExtras).length > 0;
+  return {
+    method,
+    ...hasMetadata ? { metadataExtras } : {}
+  };
+}
+function mergeAccountIds(target, accountId) {
+  const existing = target.linkmoney_account_ids;
+  if (Array.isArray(existing)) {
+    existing.push(accountId);
+    return;
+  }
+  if (typeof target.linkmoney_account_id === "string") {
+    target.linkmoney_account_ids = [target.linkmoney_account_id, accountId];
+    delete target.linkmoney_account_id;
+    return;
+  }
+  target.linkmoney_account_id = accountId;
+}
+function normalizeSiftPaymentMethods(methods) {
+  if (methods === void 0) return {};
+  const normalized = [];
+  const metadata = {};
+  for (const raw of methods) {
+    const result = normalizeSiftPaymentMethod(raw);
+    if (result === null) continue;
+    normalized.push(result.method);
+    if (result.metadataExtras) {
+      for (const [key, value] of Object.entries(result.metadataExtras)) {
+        if (key === "linkmoney_account_id" && typeof value === "string") {
+          mergeAccountIds(metadata, value);
+        } else if (key in metadata && Array.isArray(metadata[key]) && Array.isArray(value)) {
+          metadata[key] = [...metadata[key], ...value];
+        } else if (!(key in metadata)) {
+          metadata[key] = value;
+        }
+      }
+    }
+  }
+  const hasMetadata = Object.keys(metadata).length > 0;
+  return {
+    payment_methods: normalized,
+    ...hasMetadata ? { metadata } : {}
+  };
+}
+
+// src/normalization/sift-keys.ts
+function siftKey(key) {
+  return key.startsWith("$") ? key : `$${key}`;
+}
+function toSiftKeyedObject(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => toSiftKeyedObject(item));
+  }
+  if (typeof value === "object") {
+    const out = {};
+    for (const [key, nested] of Object.entries(value)) {
+      out[siftKey(key)] = toSiftKeyedObject(nested);
+    }
+    return out;
+  }
+  return value;
+}
 
 // src/normalization/normalize.ts
+var BASE_SIFT_FIELD_KEYS = [
+  "session_id",
+  "user_email",
+  "name",
+  "phone",
+  "sift_payment_method",
+  "payment_methods",
+  "billing_address",
+  "shipping_address",
+  "app",
+  "browser",
+  "verification_phone_number",
+  "order_id",
+  "exchange_rate",
+  "expedited_shipping",
+  "shipping_method",
+  "shipping_carrier",
+  "shipping_tracking_numbers",
+  "brand_name",
+  "site_country",
+  "site_domain",
+  "ip",
+  "skip_payment_method_normalization"
+];
 function mergeMetadata(base, extras) {
   return { ...base, ...extras };
 }
@@ -145,17 +458,152 @@ function applySiftMetadata(body, metadata, siftMetadata, onlyWhenNonEmpty = fals
   }
   return body;
 }
+function collectRuleSignals(request, keys) {
+  const signals = {};
+  for (const key of keys) {
+    const value = request[key];
+    if (value !== void 0) {
+      signals[key] = value;
+    }
+  }
+  return signals;
+}
+function buildBaseSiftMetadata(body) {
+  const {
+    event_type,
+    session_id,
+    user_email,
+    name,
+    phone,
+    sift_payment_method,
+    payment_methods,
+    billing_address,
+    shipping_address,
+    app,
+    browser,
+    verification_phone_number,
+    order_id,
+    amount,
+    currency_code,
+    exchange_rate,
+    expedited_shipping,
+    shipping_method,
+    shipping_carrier,
+    shipping_tracking_numbers,
+    brand_name,
+    site_country,
+    site_domain,
+    ip,
+    metadata,
+    skip_payment_method_normalization
+  } = body;
+  const siftMetadata = {
+    ...metadata ?? {}
+  };
+  if (session_id !== void 0) siftMetadata.$session_id = session_id;
+  if (user_email !== void 0) siftMetadata.$user_email = user_email;
+  if (name !== void 0) siftMetadata.$name = name;
+  if (phone !== void 0) siftMetadata.$phone = phone;
+  if (sift_payment_method !== void 0) {
+    if (skip_payment_method_normalization) {
+      siftMetadata.$payment_method = toSiftKeyedObject(sift_payment_method);
+    } else {
+      const result = normalizeSiftPaymentMethod(
+        sift_payment_method
+      );
+      if (result !== null) {
+        siftMetadata.$payment_method = toSiftKeyedObject(result.method);
+        if (result.metadataExtras) {
+          Object.assign(siftMetadata, result.metadataExtras);
+        }
+      }
+    }
+  }
+  if (payment_methods !== void 0) {
+    if (skip_payment_method_normalization) {
+      siftMetadata.$payment_methods = toSiftKeyedObject(payment_methods);
+    } else {
+      const { payment_methods: normalized, metadata: pmMetadata } = normalizeSiftPaymentMethods(
+        payment_methods
+      );
+      if (normalized !== void 0) {
+        siftMetadata.$payment_methods = toSiftKeyedObject(normalized);
+      }
+      if (pmMetadata) {
+        Object.assign(siftMetadata, pmMetadata);
+      }
+    }
+  }
+  if (billing_address !== void 0) {
+    siftMetadata.$billing_address = toSiftKeyedObject(billing_address);
+  }
+  if (shipping_address !== void 0) {
+    siftMetadata.$shipping_address = toSiftKeyedObject(shipping_address);
+  }
+  if (app !== void 0) siftMetadata.$app = toSiftKeyedObject(app);
+  if (browser !== void 0) {
+    siftMetadata.$browser = toSiftKeyedObject(browser);
+  }
+  if (event_type === "$create_order" || event_type === "$update_account") {
+    if (verification_phone_number !== void 0) {
+      siftMetadata.$verification_phone_number = verification_phone_number;
+    }
+  }
+  if (event_type === "$create_order") {
+    if (order_id !== void 0) siftMetadata.$order_id = order_id;
+    if (amount !== void 0) siftMetadata.$amount = amount;
+    if (currency_code !== void 0) siftMetadata.$currency_code = currency_code;
+    if (exchange_rate !== void 0) {
+      siftMetadata.$exchange_rate = toSiftKeyedObject(exchange_rate);
+    }
+    if (expedited_shipping !== void 0) siftMetadata.$expedited_shipping = expedited_shipping;
+    if (shipping_method !== void 0) siftMetadata.$shipping_method = shipping_method;
+    if (shipping_carrier !== void 0) siftMetadata.$shipping_carrier = shipping_carrier;
+    if (shipping_tracking_numbers !== void 0) {
+      siftMetadata.$shipping_tracking_numbers = shipping_tracking_numbers;
+    }
+    if (brand_name !== void 0) siftMetadata.$brand_name = brand_name;
+    if (site_country !== void 0) siftMetadata.$site_country = site_country;
+    if (site_domain !== void 0) siftMetadata.$site_domain = site_domain;
+    if (ip !== void 0) siftMetadata.$ip = ip;
+  }
+  return siftMetadata;
+}
+function normalizeBaseSiftFields(body) {
+  const siftMetadata = buildBaseSiftMetadata(body);
+  const stripped = stripSdkOnlyFields(body, [...BASE_SIFT_FIELD_KEYS]);
+  if (Object.keys(siftMetadata).length > 0) {
+    stripped.metadata = siftMetadata;
+  }
+  return stripped;
+}
+function applyRuleSignals(body, request, keys, stripKeys) {
+  const ruleSignals = collectRuleSignals(request, keys);
+  const stripped = stripSdkOnlyFields(body, [...stripKeys]);
+  if (Object.keys(ruleSignals).length > 0) {
+    stripped.metadata = mergeMetadata(
+      stripped.metadata,
+      ruleSignals
+    );
+  }
+  return stripped;
+}
 function normalizeUpdatePassword(request) {
   const { password_reason, password_status, metadata, ...rest } = request;
-  const body = createStrippedBody(rest, metadata, []);
-  const siftMetadata = {};
-  if (password_reason) siftMetadata.$reason = password_reason;
-  if (password_status) siftMetadata.$status = password_status;
-  return applySiftMetadata(body, metadata, siftMetadata);
+  let body = createStrippedBody(rest, metadata, [
+    "password_reason",
+    "password_status"
+  ]);
+  const siftMetadata = {
+    $reason: password_reason ?? PasswordUpdateReason.UserUpdate,
+    $status: password_status ?? PasswordUpdateStatus.Success
+  };
+  body = applySiftMetadata(body, metadata, siftMetadata);
+  return normalizeBaseSiftFields(body);
 }
 function normalizeWager(request) {
   const { wager_type, wager_status, wager_event_type, wager_event_name, wager_event_id, metadata, ...rest } = request;
-  const body = createStrippedBody(rest, metadata, [
+  let body = createStrippedBody(rest, metadata, [
     "wager_type",
     "wager_status",
     "wager_event_type",
@@ -166,17 +614,19 @@ function normalizeWager(request) {
     $wager_type: wager_type,
     $wager_status: wager_status
   };
-  if (wager_event_type) siftMetadata.wager_event_type = wager_event_type;
-  if (wager_event_name) siftMetadata.wager_event_name = wager_event_name;
-  if (wager_event_id) siftMetadata.wager_event_id = wager_event_id;
-  return applySiftMetadata(body, metadata, siftMetadata);
+  if (wager_event_type) siftMetadata.$wager_event_type = wager_event_type;
+  if (wager_event_name) siftMetadata.$wager_event_name = wager_event_name;
+  if (wager_event_id) siftMetadata.$wager_event_id = wager_event_id;
+  body = applySiftMetadata(body, metadata, siftMetadata);
+  return normalizeBaseSiftFields(body);
 }
 function normalizeLogin(request) {
   const { login_status, login_failure_reason, metadata, ...rest } = request;
   const effectiveStatus = login_status ?? LoginStatus.Success;
-  const body = createStrippedBody(rest, metadata, [
+  let body = createStrippedBody(rest, metadata, [
     "login_status",
-    "login_failure_reason"
+    "login_failure_reason",
+    ...LOGIN_RULE_SIGNAL_KEYS
   ]);
   const siftMetadata = {
     $login_status: effectiveStatus
@@ -184,14 +634,22 @@ function normalizeLogin(request) {
   if (effectiveStatus === LoginStatus.Failure && login_failure_reason) {
     siftMetadata.$failure_reason = login_failure_reason;
   }
-  return applySiftMetadata(body, metadata, siftMetadata);
+  body = applySiftMetadata(body, metadata, siftMetadata);
+  body = applyRuleSignals(
+    body,
+    request,
+    LOGIN_RULE_SIGNAL_KEYS,
+    []
+  );
+  return normalizeBaseSiftFields(body);
 }
 function normalizeTransaction(request) {
   const { transaction_status, decline_category, transfer_recipient_user_id, metadata, ...rest } = request;
-  const body = createStrippedBody(rest, metadata, [
+  let body = createStrippedBody(rest, metadata, [
     "transaction_status",
     "decline_category",
-    "transfer_recipient_user_id"
+    "transfer_recipient_user_id",
+    ...TRANSACTION_RULE_SIGNAL_KEYS
   ]);
   const siftMetadata = {};
   if (transaction_status) siftMetadata.$transaction_status = transaction_status;
@@ -199,7 +657,43 @@ function normalizeTransaction(request) {
   if (transfer_recipient_user_id) {
     siftMetadata.$transfer_recipient_user_id = transfer_recipient_user_id;
   }
-  return applySiftMetadata(body, metadata, siftMetadata, true);
+  body = applySiftMetadata(body, metadata, siftMetadata, true);
+  body = applyRuleSignals(
+    body,
+    request,
+    TRANSACTION_RULE_SIGNAL_KEYS,
+    []
+  );
+  return normalizeBaseSiftFields(body);
+}
+function normalizeUpdateAccount(request) {
+  const { metadata, ...rest } = request;
+  let body = createStrippedBody(rest, metadata, [
+    ...UPDATE_ACCOUNT_RULE_SIGNAL_KEYS
+  ]);
+  body = applyRuleSignals(
+    body,
+    request,
+    UPDATE_ACCOUNT_RULE_SIGNAL_KEYS,
+    []
+  );
+  return normalizeBaseSiftFields(body);
+}
+function normalizeCreateOrder(request) {
+  const { amount, currency_code, metadata, ...rest } = request;
+  let body = createStrippedBody(rest, metadata, [
+    "amount",
+    "currency_code"
+  ]);
+  const siftMetadata = {
+    $amount: amount,
+    $currency_code: currency_code
+  };
+  body = applySiftMetadata(body, metadata, siftMetadata);
+  return normalizeBaseSiftFields(body);
+}
+function normalizeDefault(request) {
+  return normalizeBaseSiftFields({ ...request });
 }
 function normalizeScoreRequestForApi(request) {
   switch (request.event_type) {
@@ -211,8 +705,12 @@ function normalizeScoreRequestForApi(request) {
       return normalizeLogin(request);
     case "$transaction":
       return normalizeTransaction(request);
+    case "$update_account":
+      return normalizeUpdateAccount(request);
+    case "$create_order":
+      return normalizeCreateOrder(request);
     default:
-      return { ...request };
+      return normalizeDefault(request);
   }
 }
 
@@ -224,6 +722,7 @@ function buildScoreRequestPreview(request) {
 // src/types/events.ts
 var SCORED_FRAUD_EVENT_TYPES = [
   "$create_account",
+  "$create_order",
   "$login",
   "$logout",
   "$update_account",
@@ -240,7 +739,6 @@ var PLANNED_FRAUD_EVENT_TYPES = [
   "$verification",
   "$link_session_to_user",
   "$security_notification",
-  "$create_order",
   "$update_order",
   "$order_status",
   "$add_promotion"
@@ -253,10 +751,33 @@ function isSupportedFraudEventType(eventType) {
 }
 
 // src/types/metadata.ts
-function hasReservedMetadataKey(metadata) {
-  for (const key of Object.keys(metadata)) {
-    if (key.startsWith("$")) {
-      return key;
+var TYPED_SIFT_METADATA_KEYS = {
+  session_id: "$session_id",
+  user_email: "$user_email",
+  name: "$name",
+  phone: "$phone",
+  sift_payment_method: "$payment_method",
+  billing_address: "$billing_address",
+  payment_methods: "$payment_methods",
+  app: "$app",
+  verification_phone_number: "$verification_phone_number",
+  order_id: "$order_id",
+  exchange_rate: "$exchange_rate",
+  shipping_address: "$shipping_address",
+  expedited_shipping: "$expedited_shipping",
+  shipping_method: "$shipping_method",
+  shipping_carrier: "$shipping_carrier",
+  shipping_tracking_numbers: "$shipping_tracking_numbers",
+  browser: "$browser",
+  brand_name: "$brand_name",
+  site_country: "$site_country",
+  site_domain: "$site_domain",
+  ip: "$ip"
+};
+function findMetadataConflictWithTypedFields(metadata, request) {
+  for (const [field, metaKey] of Object.entries(TYPED_SIFT_METADATA_KEYS)) {
+    if (request[field] !== void 0 && metadata[metaKey] !== void 0) {
+      return metaKey;
     }
   }
   return void 0;
@@ -282,22 +803,63 @@ function assertPositiveAmount(amount, field, errors, prefix) {
     errors.push(`${prefix}${field} must be greater than 0`);
   }
 }
-function validateMetadata(metadata, errors, prefix) {
+function validateMetadata(metadata, request, errors, prefix) {
   if (!metadata) return;
-  const reservedKey = hasReservedMetadataKey(metadata);
-  if (reservedKey) {
+  const conflictKey = findMetadataConflictWithTypedFields(
+    metadata,
+    request
+  );
+  if (conflictKey) {
     errors.push(
-      `${prefix}metadata keys must not start with '$' (found '${reservedKey}'). Use typed request fields instead.`
+      `${prefix}metadata.${conflictKey} conflicts with a typed request field that maps to the same key; omit metadata.${conflictKey} or remove the typed field`
     );
   }
 }
 
 // src/validation/rules.ts
+var E164_PHONE_PATTERN = /^\+[1-9]\d{7,14}$/;
+function validatePaymentMethods(request, errors, prefix) {
+  const { payment_methods, skip_payment_method_normalization: skipNormalization } = request;
+  if (payment_methods === void 0) return;
+  if (payment_methods.length === 0) {
+    errors.push(`${prefix}payment_methods must include at least one item when provided`);
+    return;
+  }
+  payment_methods.forEach((method, index) => {
+    const raw = method;
+    if (skipNormalization) {
+      for (const key of Object.keys(raw)) {
+        const plainKey = key.startsWith("$") ? key.slice(1) : key;
+        if (!SIFT_PAYMENT_METHOD_WHITELIST.has(plainKey)) {
+          errors.push(
+            `${prefix}payment_methods[${index}].${plainKey} is not a valid Sift payment method field`
+          );
+        }
+      }
+      const rawType2 = raw.payment_type !== void 0 ? String(raw.payment_type) : void 0;
+      if (rawType2 !== void 0 && normalizeSiftPaymentType(rawType2) === void 0) {
+        errors.push(
+          `${prefix}payment_methods[${index}].payment_type is not a valid Sift payment type`
+        );
+      }
+      return;
+    }
+    const rawType = raw.payment_type !== void 0 ? String(raw.payment_type) : raw.$payment_type !== void 0 ? String(raw.$payment_type) : void 0;
+    if (rawType !== void 0) {
+      const result = normalizeSiftPaymentMethod(raw);
+      if (result === null) {
+        errors.push(
+          `${prefix}payment_methods[${index}].payment_type is not a valid Sift payment type`
+        );
+      }
+    }
+  });
+}
 function validateBase(request, errors, prefix) {
   assertNonEmpty(request.customer_id, "customer_id", errors, prefix);
   assertNonEmpty(request.sift_user_id, "sift_user_id", errors, prefix);
   assertNonEmpty(request.event_type, "event_type", errors, prefix);
-  validateMetadata(request.metadata, errors, prefix);
+  validateMetadata(request.metadata, request, errors, prefix);
 }
 function validateLogin(request, errors, prefix) {
   assertEnum(request.login_status, SiftLoginStatusValues, "login_status", errors, prefix);
@@ -323,9 +885,6 @@ function validateUpdatePassword(request, errors, prefix) {
     errors,
     prefix
   );
-  if (!request.password_reason) {
-    errors.push(`${prefix}password_reason is required`);
-  }
   assertEnum(
     request.password_status,
     SiftPasswordUpdateStatusValues,
@@ -333,9 +892,6 @@ function validateUpdatePassword(request, errors, prefix) {
     errors,
     prefix
   );
-  if (!request.password_status) {
-    errors.push(`${prefix}password_status is required`);
-  }
 }
 function validateTransaction(request, errors, prefix) {
   assertPositiveAmount(request.amount, "amount", errors, prefix);
@@ -369,6 +925,28 @@ function validateWager(request, errors, prefix) {
   assertPositiveAmount(request.amount, "amount", errors, prefix);
   assertNonEmpty(request.currency, "currency", errors, prefix);
 }
+function validateCreateAccount(request, errors, prefix) {
+  validatePaymentMethods(request, errors, prefix);
+}
+function validateUpdateAccount(request, errors, prefix) {
+  validatePaymentMethods(request, errors, prefix);
+  if (request.verification_phone_number !== void 0) {
+    if (!E164_PHONE_PATTERN.test(request.verification_phone_number.trim())) {
+      errors.push(`${prefix}verification_phone_number must be E.164 (e.g. +14155550123)`);
+    }
+  }
+}
+function validateCreateOrder(request, errors, prefix) {
+  assertPositiveAmount(request.amount, "amount", errors, prefix);
+  assertNonEmpty(request.currency_code, "currency_code", errors, prefix);
+  validatePaymentMethods(request, errors, prefix);
+  if (request.shipping_tracking_numbers !== void 0) {
+    const hasEmpty = request.shipping_tracking_numbers.some((n) => n.trim() === "");
+    if (hasEmpty) {
+      errors.push(`${prefix}shipping_tracking_numbers cannot contain empty values`);
+    }
+  }
+}
 function validateChargeback(request, errors, prefix) {
   const hasTransactionId = !!request.transaction_id?.trim();
   const hasOrderId = !!request.order_id?.trim();
@@ -403,9 +981,20 @@ function validateByEventType(request, errors, prefix) {
     case "$wager":
       validateWager(request, errors, prefix);
       break;
+    case "$create_order":
+      validateCreateOrder(request, errors, prefix);
+      break;
     case "$chargeback":
       validateChargeback(request, errors, prefix);
       break;
+    case "$create_account":
+      validateCreateAccount(request, errors, prefix);
+      break;
+    case "$logout":
+      break;
+    case "$update_account":
+      validateUpdateAccount(request, errors, prefix);
+      break;
   }
 }
 function validateScoreRequest(request, index) {
@@ -472,10 +1061,12 @@ exports.CHARGEBACK_FRAUD_EVENT_TYPE = CHARGEBACK_FRAUD_EVENT_TYPE;
 exports.ChargebackReason = ChargebackReason;
 exports.ChargebackState = ChargebackState;
 exports.FraudClient = FraudClient;
+exports.LOGIN_RULE_SIGNAL_KEYS = LOGIN_RULE_SIGNAL_KEYS;
 exports.LoginStatus = LoginStatus;
 exports.PLANNED_FRAUD_EVENT_TYPES = PLANNED_FRAUD_EVENT_TYPES;
 exports.PasswordUpdateReason = PasswordUpdateReason;
 exports.PasswordUpdateStatus = PasswordUpdateStatus;
+exports.PaymentType = PaymentType;
 exports.SCORED_FRAUD_EVENT_TYPES = SCORED_FRAUD_EVENT_TYPES;
 exports.SUPPORTED_FRAUD_EVENT_TYPES = SUPPORTED_FRAUD_EVENT_TYPES;
 exports.SiftChargebackReasonValues = SiftChargebackReasonValues;
@@ -484,17 +1075,27 @@ exports.SiftLoginFailureReasonValues = SiftLoginFailureReasonValues;
 exports.SiftLoginStatusValues = SiftLoginStatusValues;
 exports.SiftPasswordUpdateReasonValues = SiftPasswordUpdateReasonValues;
 exports.SiftPasswordUpdateStatusValues = SiftPasswordUpdateStatusValues;
+exports.SiftPaymentTypeValues = SiftPaymentTypeValues;
 exports.SiftTransactionStatusValues = SiftTransactionStatusValues;
 exports.SiftTransactionTypeValues = SiftTransactionTypeValues;
 exports.SiftWagerStatusValues = SiftWagerStatusValues;
+exports.SiftWalletTypeValues = SiftWalletTypeValues;
+exports.TRANSACTION_RULE_SIGNAL_KEYS = TRANSACTION_RULE_SIGNAL_KEYS;
+exports.TYPED_SIFT_METADATA_KEYS = TYPED_SIFT_METADATA_KEYS;
 exports.TransactionStatus = TransactionStatus;
 exports.TransactionType = TransactionType;
+exports.UPDATE_ACCOUNT_RULE_SIGNAL_KEYS = UPDATE_ACCOUNT_RULE_SIGNAL_KEYS;
 exports.WagerStatus = WagerStatus;
+exports.WalletType = WalletType;
 exports.buildScoreRequestPreview = buildScoreRequestPreview;
-exports.hasReservedMetadataKey = hasReservedMetadataKey;
+exports.findMetadataConflictWithTypedFields = findMetadataConflictWithTypedFields;
 exports.isPlannedFraudEventType = isPlannedFraudEventType;
 exports.isSupportedFraudEventType = isSupportedFraudEventType;
 exports.normalizeScoreRequestForApi = normalizeScoreRequestForApi;
+exports.normalizeSiftPaymentMethod = normalizeSiftPaymentMethod;
+exports.normalizeSiftPaymentMethods = normalizeSiftPaymentMethods;
+exports.normalizeSiftPaymentType = normalizeSiftPaymentType;
+exports.toSiftAccountNumberLast5 = toSiftAccountNumberLast5;
 exports.validateScoreRequest = validateScoreRequest;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map