@rtbnext/core 2.0.0-alpha.1

package/dist/model/Stats.js

@@ -0,0 +1,435 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { log } from '../core/Logger.js';
+import { Storage } from '../core/Storage.js';
+import { Utils } from '../core/Utils.js';
+import { Percentiles, StatsGroup, WealthSpread } from '../lib/const.js';
+import { Parser } from '../parser/Parser.js';
+export class Stats {
+  static storage = Storage.getInstance();
+  static instance;
+  constructor() {
+    this.initDB();
+  }
+  initDB() {
+    log.debug('Initializing stats storage paths');
+    StatsGroup.forEach(group => Stats.storage.ensurePath(this.resolvePath(group), true));
+  }
+  // --- helper ---
+  resolvePath(path) {
+    return join('stats', path);
+  }
+  prepStats(data) {
+    return { ...Utils.metaData(), ...data };
+  }
+  getStats(path, format) {
+    return (
+      Stats.storage[format === 'csv' ? 'readCSV' : 'readJSON'](this.resolvePath(path)) ?? (format === 'csv' ? [] : {})
+    );
+  }
+  saveStats(path, format, data) {
+    return (
+      log.catch(
+        () => Stats.storage[format === 'csv' ? 'writeCSV' : 'writeJSON'](this.resolvePath(path), data),
+        `Failed to save stats to ${path}`
+      ) ?? false
+    );
+  }
+  // --- getter ---
+  getGlobalStats() {
+    return this.getStats('global.json', 'json');
+  }
+  getProfileStats() {
+    return this.getStats('profile.json', 'json');
+  }
+  getWealthStats() {
+    return this.getStats('wealth.json', 'json');
+  }
+  getScatter() {
+    return this.getStats('scatter.json', 'json');
+  }
+  getTop10() {
+    return this.getStats('top10.json', 'json');
+  }
+  getDBStats() {
+    return this.getStats('db.json', 'json');
+  }
+  getHistory() {
+    return this.getStats('history.csv', 'csv');
+  }
+  // --- grouped stats getter ---
+  getGroupedStatsIndex(group) {
+    return this.getStats(`${group}/index.json`, 'json');
+  }
+  getGroupedStatsHistory(group, key) {
+    return this.getStats(`${group}/${key}.csv`, 'csv');
+  }
+  getGroupedStats(group) {
+    const index = this.getGroupedStatsIndex(group);
+    const history = Object.fromEntries(Object.keys(index.items).map(k => [k, this.getGroupedStatsHistory(group, k)]));
+    return { index, history };
+  }
+  // --- setter ---
+  setGlobalStats(data) {
+    return this.saveStats(
+      'global.json',
+      'json',
+      this.prepStats(
+        Parser.container({
+          date: { value: data.date, type: 'date', args: ['ymd'] },
+          count: { value: data.count, type: 'number' },
+          total: { value: data.total, type: 'money' },
+          woman: { value: data.woman, type: 'number' },
+          quota: { value: data.quota, type: 'pct' },
+          today: {
+            value: Parser.container({
+              value: { value: data.today?.value, type: 'money' },
+              percent: { value: data.today?.percent, type: 'pct' }
+            }),
+            type: 'container'
+          },
+          ytd: {
+            value: Parser.container({
+              value: { value: data.ytd?.value, type: 'money' },
+              percent: { value: data.ytd?.percent, type: 'pct' }
+            }),
+            type: 'container'
+          },
+          stats: {
+            value: Parser.container({
+              profiles: { value: data.stats?.profiles, type: 'number' },
+              days: { value: data.stats?.days, type: 'number' }
+            }),
+            type: 'container'
+          }
+        })
+      )
+    );
+  }
+  setProfileStats(data) {
+    return this.saveStats(
+      'profile.json',
+      'json',
+      this.prepStats({
+        ...Parser.container({
+          gender: { value: data.gender, type: 'obj', args: ['number'] },
+          maritalStatus: { value: data.maritalStatus, type: 'obj', args: ['number'] },
+          children: {
+            value: Parser.container({
+              full: { value: data.children?.full, type: 'obj', args: ['number'] },
+              short: { value: data.children?.short, type: 'obj', args: ['number'] }
+            }),
+            type: 'container'
+          },
+          selfMade: { value: data.selfMade, type: 'obj', args: ['number'] },
+          philanthropyScore: { value: data.philanthropyScore, type: 'obj', args: ['number'] }
+        }),
+        agePyramid: Object.fromEntries(
+          Object.entries(data.agePyramid).map(([gender, item]) => [
+            gender,
+            Parser.container({
+              count: { value: item.count, type: 'number' },
+              decades: { value: item.decades, type: 'obj', args: ['number'] },
+              max: { value: item.max, type: 'number' },
+              min: { value: item.min, type: 'number' },
+              mean: { value: item.mean, type: 'number' }
+            })
+          ])
+        )
+      })
+    );
+  }
+  setWealthStats(data) {
+    return this.saveStats(
+      'wealth.json',
+      'json',
+      this.prepStats(
+        Parser.container({
+          percentiles: { value: data.percentiles, type: 'obj', args: ['money'] },
+          quartiles: { value: data.quartiles, type: 'list', args: ['money'] },
+          total: { value: data.total, type: 'money' },
+          max: { value: data.max, type: 'money' },
+          min: { value: data.min, type: 'money' },
+          mean: { value: data.mean, type: 'money' },
+          median: { value: data.median, type: 'money' },
+          stdDev: { value: data.stdDev, type: 'money' },
+          decades: { value: data.decades, type: 'obj', args: ['money'] },
+          gender: { value: data.gender, type: 'obj', args: ['money'] },
+          spread: { value: data.spread, type: 'obj', args: ['number'] }
+        })
+      )
+    );
+  }
+  setScatter(items) {
+    return this.saveStats('scatter.json', 'json', this.prepStats({ count: Parser.number(items.length), items }));
+  }
+  setTop10(data) {
+    return this.saveStats('top10.json', 'json', this.prepStats({ data }));
+  }
+  updateTop10(key, list) {
+    return this.setTop10({ ...this.getTop10().entries, [key]: list });
+  }
+  setDBStats(data) {
+    return this.saveStats(
+      'db.json',
+      'json',
+      this.prepStats(
+        Parser.container({ files: { value: data.files, type: 'number' }, size: { value: data.size, type: 'number' } })
+      )
+    );
+  }
+  // --- grouped stats setter ---
+  setGroupedStats(group, raw) {
+    return (
+      log.catch(() => {
+        const items = Object.fromEntries(
+          Object.entries(raw).map(([key, item]) => {
+            item = {
+              first: item.first,
+              ...Parser.container({
+                date: { value: item.date, type: 'date', args: ['ymd'] },
+                count: { value: item.count, type: 'number' },
+                total: { value: item.total, type: 'money' },
+                woman: { value: item.woman, type: 'number' },
+                quota: { value: item.quota, type: 'pct' },
+                today: {
+                  value: Parser.container({
+                    value: { value: item.today?.value, type: 'money' },
+                    percent: { value: item.today?.percent, type: 'pct' }
+                  }),
+                  type: 'container'
+                },
+                ytd: {
+                  value: Parser.container({
+                    value: { value: item.ytd?.value, type: 'money' },
+                    percent: { value: item.ytd?.percent, type: 'pct' }
+                  }),
+                  type: 'container'
+                }
+              })
+            };
+            Stats.storage.datedCSV(
+              this.resolvePath(`${group}/${key}.csv`),
+              [
+                item.date,
+                item.count,
+                item.total,
+                item.woman,
+                item.quota,
+                item.today?.value ?? 0,
+                item.today?.percent ?? 0
+              ],
+              true
+            );
+            return [key, item];
+          })
+        );
+        this.saveStats(`${group}/index.json`, 'json', this.prepStats({ items }));
+      }, `Failed to set grouped stats for group ${group}`) ?? false
+    );
+  }
+  // --- update history (add new line) ---
+  updateHistory(data) {
+    return (
+      log.catch(
+        () =>
+          Stats.storage.datedCSV(
+            this.resolvePath('history.csv'),
+            [
+              Parser.date(data.date, 'ymd'),
+              Parser.number(data.count),
+              Parser.money(data.total),
+              Parser.number(data.woman),
+              Parser.pct(data.quota),
+              Parser.money(data.today?.value),
+              Parser.pct(data.today?.percent)
+            ],
+            true
+          ),
+        'Failed to update history'
+      ) ?? false
+    );
+  }
+  // --- generate wealth stats ---
+  generateWealthStats(scatter) {
+    return (
+      log.catch(() => {
+        log.debug('Generating wealth stats ...');
+        if (!scatter || !scatter.length) throw new Error('No scatter data provided');
+        scatter.sort((a, b) => a.networth - b.networth);
+        const count = scatter.length;
+        const total = scatter.reduce((acc, i) => acc + i.networth, 0);
+        const medianIndex = Math.floor(count / 2);
+        const median =
+          count % 2 === 0
+            ? (scatter[medianIndex - 1].networth + scatter[medianIndex].networth) / 2
+            : scatter[medianIndex].networth;
+        const mean = total / count;
+        const variance =
+          scatter.reduce((acc, i) => {
+            const diff = i.networth - mean;
+            return acc + diff * diff;
+          }, 0) / count;
+        const stdDev = Math.sqrt(variance);
+        const percentiles = {};
+        Percentiles.forEach(p => {
+          const idx = Math.ceil((parseInt(p) / 100) * count) - 1;
+          percentiles[p] = scatter[idx].networth;
+        });
+        const quartiles = [
+          scatter[Math.floor(count * 0.25)].networth,
+          scatter[Math.floor(count * 0.5)].networth,
+          scatter[Math.floor(count * 0.75)].networth
+        ];
+        const decades = {};
+        const gender = {};
+        const spread = {};
+        scatter.forEach(item => {
+          const { gender: g, age, networth } = item;
+          const decade = Math.max(30, Math.min(90, Math.floor(age / 10) * 10));
+          decades[decade] = (decades[decade] ?? 0) + networth;
+          gender[g] = (gender[g] ?? 0) + networth;
+          WealthSpread.forEach(n => {
+            if (networth >= Number(n) * 1000) spread[n] = (spread[n] ?? 0) + 1;
+          });
+        });
+        return this.setWealthStats({
+          total,
+          median,
+          mean,
+          stdDev,
+          percentiles,
+          quartiles,
+          decades,
+          gender,
+          spread,
+          max: scatter.at(-1).networth,
+          min: scatter[0].networth
+        });
+      }, 'Failed to generate wealth stats') ?? false
+    );
+  }
+  // --- generate top 10 entry ---
+  generateTop10Entry(snapshot) {
+    return (
+      log.catch(() => {
+        const [year, month] = snapshot.date.split('-', 2).map(Number);
+        const key = `${year}-${String(month).padStart(2, '0')}`;
+        const prev = `${month === 1 ? year - 1 : year}-${String(month === 1 ? 12 : month - 1).padStart(2, '0')}`;
+        log.debug(`Generating top 10 entry for ${key} ...`);
+        const { entries = {} } = this.getTop10();
+        const last = entries[prev];
+        const top10 = [];
+        for (const { uri, rank, networth } of snapshot.items.slice(0, 10)) {
+          const prevItem = last?.find(i => i.uri === uri);
+          top10.push({
+            uri,
+            rank,
+            networth,
+            flag: !last
+              ? 'unknown'
+              : prevItem
+                ? rank < prevItem.rank
+                  ? 'up'
+                  : rank > prevItem.rank
+                    ? 'down'
+                    : 'unchanged'
+                : Object.entries(entries).some(([k, l]) => k !== key && l.some(i => i.uri === uri))
+                  ? 'returned'
+                  : 'new'
+          });
+        }
+        return this.updateTop10(key, top10);
+      }, 'Failed to generate top 10 entry') ?? false
+    );
+  }
+  // --- generate DB stats ---
+  generateDBStats() {
+    return (
+      log.catch(() => {
+        log.debug('Generating DB stats ...');
+        const stats = { files: 0, size: 0 };
+        const scan = path => {
+          readdirSync(path, { recursive: true }).forEach(p => {
+            if (p === '.' || p === '..' || typeof p !== 'string') return;
+            const fullPath = join(path, p);
+            const stat = Stats.storage.stat(fullPath);
+            if (stat) stat.isDirectory() ? scan(fullPath) : (stats.files++, (stats.size += stat.size));
+          });
+        };
+        scan(Stats.storage.root);
+        return this.setDBStats(stats);
+      }, 'Failed to generate DB stats') ?? false
+    );
+  }
+  // --- instantiate ---
+  static getInstance() {
+    return (Stats.instance ??= new Stats());
+  }
+  // --- aggregate stats data ---
+  static aggregate(data, date, stats) {
+    return log.catch(() => {
+      const { uri, info, realtime, realtime: { rank, networth } = {} } = data;
+      const age = Parser.age(info.birthDate),
+        decade = Parser.ageDecade(info.birthDate);
+      const item = { uri, name: info.name.shortName };
+      const set = (path, n) => Utils.update('set', stats, path, n);
+      const inc = (path, n) => Utils.update('inc', stats, path, n);
+      const max = (path, n) => Utils.update('max', stats, path, n);
+      const min = (path, n) => Utils.update('min', stats, path, n);
+      const srt = n =>
+        n >= 10
+          ? 'over-10'
+          : n >= 5
+            ? '5-to-10'
+            : n === 4
+              ? 'four'
+              : n === 3
+                ? 'three'
+                : n === 2
+                  ? 'two'
+                  : n === 1
+                    ? 'one'
+                    : 'none';
+      if (info.gender) inc(`profile.gender.${info.gender}`);
+      if (info.maritalStatus) inc(`profile.maritalStatus.${info.maritalStatus}`);
+      if (info.selfMade?.rank) inc(`profile.selfMade.${info.selfMade.rank}`);
+      if (info.philanthropyScore) inc(`profile.philanthropyScore.${info.philanthropyScore}`);
+      if (info.gender && age && decade) {
+        inc(`profile.agePyramid.${info.gender}.count`);
+        inc(`profile.agePyramid.${info.gender}.decades.${decade}`);
+        inc(`profile.agePyramid.${info.gender}.total`, age);
+        max(`profile.agePyramid.${info.gender}.max`, age);
+        min(`profile.agePyramid.${info.gender}.min`, age);
+        set(
+          `profile.agePyramid.${info.gender}.mean`,
+          stats.profile.agePyramid[info.gender].total / stats.profile.agePyramid[info.gender].count
+        );
+      }
+      if (info.children) {
+        inc(`profile.children.full.${info.children}`);
+        inc(`profile.children.short.${srt(info.children)}`);
+      } else {
+        inc('profile.children.short.none');
+      }
+      if (!networth || !rank || realtime?.date !== date) return stats;
+      if (info.gender && age && networth) (stats.scatter ??= []).push({ ...item, gender: info.gender, age, networth });
+      let k;
+      StatsGroup.forEach(key => {
+        if (key in info && info[key] && (k = info[key])) {
+          set(`groups.${key}.${k}.date`, date);
+          inc(`groups.${key}.${k}.count`);
+          inc(`groups.${key}.${k}.total`, networth);
+          inc(`groups.${key}.${k}.woman`, +(info.gender === 'f'));
+          set(`groups.${key}.${k}.quota`, (stats.groups[key][k].woman / stats.groups[key][k].count) * 100);
+          inc(`groups.${key}.${k}.today.value`, realtime.today?.value ?? 0);
+          inc(`groups.${key}.${k}.today.percent`, realtime.today?.percent ?? 0);
+          inc(`groups.${key}.${k}.ytd.value`, realtime.ytd?.value ?? 0);
+          inc(`groups.${key}.${k}.ytd.percent`, realtime.ytd?.percent ?? 0);
+          if (rank < (stats?.groups?.[key]?.[k]?.first?.rank ?? Infinity))
+            set(`groups.${key}.${k}.first`, { ...item, rank, networth });
+        }
+      });
+    }, 'Failed to aggregate stats data');
+  }
+}

package/dist/parser/BillionairesListParser.d.ts

@@ -0,0 +1,3 @@
+import type { IBillionairesListParser } from '../interfaces/parser';
+import { PersonListParser } from './PersonListParser.js';
+export declare class BillionairesListParser extends PersonListParser implements IBillionairesListParser {}

package/dist/parser/BillionairesListParser.js

@@ -0,0 +1,2 @@
+import { PersonListParser } from './PersonListParser.js';
+export class BillionairesListParser extends PersonListParser {}

package/dist/parser/ListParser.d.ts

@@ -0,0 +1,7 @@
+import { Cache } from '../abstract/Cache.js';
+import type { IListParser } from '../interfaces/parser';
+export declare class ListParser<T extends object> extends Cache implements IListParser<T> {
+  protected readonly raw: T;
+  constructor(raw: T);
+  rawData(): T;
+}

package/dist/parser/ListParser.js

@@ -0,0 +1,11 @@
+import { Cache } from '../abstract/Cache.js';
+export class ListParser extends Cache {
+  raw;
+  constructor(raw) {
+    super();
+    this.raw = raw;
+  }
+  rawData() {
+    return this.raw;
+  }
+}

package/dist/parser/Parser.d.ts

@@ -0,0 +1,43 @@
+import type { TGender, TIndustry, TMaritalStatus } from '@rtbnext/schema/src/base/const';
+import type { TLocation } from '@rtbnext/schema/src/base/generic';
+import type { Primitive } from 'devtypes/types/primitive';
+import type { TParserContainer, TParserDateType, TParserMethod } from '../types/parser';
+export declare class Parser {
+  static primitive(value: unknown, safe?: boolean): Primitive;
+  static string(value: unknown): string;
+  static safeStr(value: unknown, allowedTags?: string[]): string;
+  static boolean(value: unknown): boolean;
+  static number(value: unknown, digits?: number): number;
+  static money(value: unknown): number;
+  static pct(value: unknown, digits?: number): number;
+  static date(value?: any, format?: TParserDateType): string | undefined;
+  static json(value: unknown): any;
+  static decodeURI(value: unknown): string;
+  static encodeURI(value: unknown): string;
+  static age(value: any): number | undefined;
+  static ageDecade(value: any, min?: number, max?: number): number | undefined;
+  static gender(value: unknown): TGender | undefined;
+  static maritalStatus(value: unknown): TMaritalStatus | undefined;
+  static industry(value: unknown): TIndustry;
+  static country(value: unknown): string | undefined;
+  static state(value: unknown): string | undefined;
+  static latLng(lat: unknown, lng: unknown): [number, number] | undefined;
+  static location(value: { country: unknown; state?: unknown; city?: unknown }): TLocation | undefined;
+  static strict<T = unknown>(value: unknown, method: TParserMethod, ...args: any[]): T | undefined;
+  static list<T extends string | (string | number | undefined)[]>(
+    value: T | T[],
+    type?: TParserMethod,
+    delimiter?: string,
+    strict?: boolean,
+    ...args: any[]
+  ): T[];
+  static obj<T = unknown>(value: T, type?: TParserMethod, strict?: boolean, ...args: any[]): T;
+  static map<T extends Primitive, L extends readonly T[] | Record<string | number, T>>(
+    value: any,
+    list: L,
+    fb?: T | undefined,
+    exactMatch?: boolean,
+    useKey?: boolean
+  ): T | undefined;
+  static container<T = unknown>(obj: { [K in keyof T]: TParserContainer }): T;
+}

package/dist/parser/Parser.js

@@ -0,0 +1,146 @@
+import usStates from '@isodb/us-states';
+import countries from 'i18n-iso-countries';
+import { Gender, IndustryResolver, MaritalStatusResolver } from '../lib/const.js';
+import { REGEX_SPACES } from '../lib/regex.js';
+export class Parser {
+  static primitive(value, safe = true) {
+    return value === null || value === undefined
+      ? value
+      : typeof value === 'boolean'
+        ? value
+        : !isNaN(Number(value)) && value !== ''
+          ? Parser.number(value)
+          : safe
+            ? Parser.safeStr(value)
+            : Parser.string(value);
+  }
+  static string(value) {
+    return String(value).trim().replace(REGEX_SPACES, ' ');
+  }
+  static safeStr(value, allowedTags) {
+    return String(value)
+      .replace(
+        new RegExp(allowedTags?.length ? `<\\/?(?!(${allowedTags.join('|')})\\b)(\\w+)([^>]*)>` : '<[^>]*>', 'gi'),
+        ''
+      )
+      .replace(REGEX_SPACES, ' ')
+      .trim();
+  }
+  static boolean(value) {
+    return (
+      value !== null &&
+      value !== undefined &&
+      (typeof value === 'boolean' ? value : ['1', 'true', 'yes', 'y'].includes(Parser.string(value).toLowerCase()))
+    );
+  }
+  static number(value, digits = 0) {
+    return Number(Number(value).toFixed(digits));
+  }
+  static money(value) {
+    return Parser.number(value, 3);
+  }
+  static pct(value, digits = 3) {
+    return Parser.number(value, digits);
+  }
+  static date(value, format = 'ymd') {
+    try {
+      value = (value ? new Date(value) : new Date()).toISOString();
+    } catch {
+      return undefined;
+    }
+    return format === 'iso' ? value : value.split('T')[0].split('-').slice(0, format.length).join('-');
+  }
+  static json(value) {
+    if (typeof value === 'object') return value;
+    try {
+      return JSON.parse(String(value));
+    } catch (err) {
+      throw new SyntaxError(`Invalid JSON string: ${value}`);
+    }
+  }
+  // --- URI component ---
+  static decodeURI(value) {
+    return decodeURIComponent(Parser.string(value));
+  }
+  static encodeURI(value) {
+    return encodeURIComponent(Parser.string(value));
+  }
+  // --- profile ---
+  static age(value) {
+    const date = new Date(value);
+    return isNaN(date.getTime()) ? undefined : new Date(Date.now() - date.getTime()).getUTCFullYear() - 1970;
+  }
+  static ageDecade(value, min = 30, max = 90) {
+    const age = Parser.age(value);
+    return age === undefined ? undefined : Math.max(min, Math.min(max, Math.floor(age / 10) * 10));
+  }
+  static gender(value) {
+    return Parser.map(value, Gender);
+  }
+  static maritalStatus(value) {
+    return Parser.map(value, MaritalStatusResolver);
+  }
+  static industry(value) {
+    return Parser.map(value, IndustryResolver, 'diversified');
+  }
+  // --- location ---
+  static country(value) {
+    const code = countries.getAlpha2Code(Parser.string(value), 'en');
+    return code ? code.toUpperCase() : undefined;
+  }
+  static state(value) {
+    return usStates.byName(Parser.string(value))?.code;
+  }
+  static latLng(lat, lng) {
+    const latitude = Parser.number(lat, 6),
+      longitude = Parser.number(lng, 6);
+    return isNaN(latitude) || isNaN(longitude) ? undefined : [latitude, longitude];
+  }
+  static location(value) {
+    const country = Parser.country(value.country);
+    return country
+      ? { country, state: Parser.state(value.state), city: Parser.strict(value.city, 'string') }
+      : undefined;
+  }
+  // --- helper ---
+  static strict(value, method, ...args) {
+    return value === null || value === undefined ? undefined : Parser[method](value, ...args);
+  }
+  static list(value, type = 'primitive', delimiter = ',', strict = true, ...args) {
+    return (Array.isArray(value) ? value : value.split(delimiter))
+      .map(v => (strict ? Parser.strict(v, type, ...(args ?? [])) : Parser[type](v, ...(args ?? []))))
+      .filter(Boolean);
+  }
+  static obj(value, type = 'primitive', strict = true, ...args) {
+    if (typeof value !== 'object' || value === null) return {};
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [
+        k,
+        strict ? Parser.strict(v, type, ...(args ?? [])) : Parser[type](v, ...(args ?? []))
+      ])
+    );
+  }
+  static map(value, list, fb = undefined, exactMatch = false, useKey) {
+    if (useKey === undefined) useKey = !Array.isArray(list);
+    value = Parser.string(value).toLowerCase();
+    return (
+      Object.entries(list).find(([k, v]) => {
+        const test = Parser.string(useKey ? k : v).toLowerCase();
+        return exactMatch ? value === test : (value.includes(test) ?? test.includes(value));
+      })?.[1] ?? fb
+    );
+  }
+  // --- container ---
+  static container(obj) {
+    return Object.fromEntries(
+      Object.entries(obj).map(([key, { value, type, strict = true, args }]) => [
+        key,
+        type === 'container'
+          ? value
+          : strict
+            ? Parser.strict(value, type, ...(args ?? []))
+            : Parser[type](value, ...(args ?? []))
+      ])
+    );
+  }
+}

package/dist/parser/PersonListParser.d.ts

@@ -0,0 +1,29 @@
+import type { TLocation, TOrganization, TSelfMade } from '@rtbnext/schema/src/base/generic';
+import type { TProfileBio, TProfileInfo, TProfileName } from '@rtbnext/schema/src/model/profile';
+import type { TGenericStats } from '@rtbnext/schema/src/model/stats';
+import type { IPersonListParser } from '../interfaces/parser';
+import { ListParser } from './ListParser.js';
+import type { TPreparedList } from '../types/list';
+import type { TListResponse, TPersonListEntry, TResponse } from '../types/response';
+export declare class PersonListParser extends ListParser<TPersonListEntry> implements IPersonListParser {
+  uri(): string;
+  id(): string;
+  date(): string;
+  year(): number;
+  rank(): number | undefined;
+  networth(): number | undefined;
+  dropOff(): boolean | undefined;
+  name(): { name: TProfileName; family: boolean };
+  info(): TProfileInfo;
+  residence(): TLocation | undefined;
+  selfMade(): TSelfMade | undefined;
+  philanthropyScore(): number | undefined;
+  organization(): TOrganization | undefined;
+  bio(): TProfileBio;
+  age(): number | undefined;
+  static prepareList(
+    res: TResponse<TListResponse<TPersonListEntry>>,
+    filter?: (item: TPersonListEntry) => boolean
+  ): TPreparedList<TPersonListEntry>;
+  static stats(data: Partial<TGenericStats>): TGenericStats;
+}