@rtbnext/core 2.0.0-alpha.1

package/dist/job/Wiki.js

@@ -0,0 +1,40 @@
+import { Job } from '../abstract/Job.js';
+import { Profile } from '../model/Profile.js';
+import { Wiki } from '../utils/Wiki.js';
+export class WikiJob extends Job {
+  constructor(options) {
+    super(options, 'Wiki');
+  }
+  // --- job runner ---
+  async update(profile) {
+    this.log(`Updating wiki for profile: ${profile.getUri()}`);
+    const wiki = await Wiki.fromProfileData(profile.getData());
+    if (!wiki) throw new Error(`No wiki data found for profile: ${profile.getUri()}`);
+    profile.updateData({ wiki });
+    profile.save();
+  }
+  async assign(profile, title) {
+    this.log(`Assigning wiki page "${title}" to profile: ${profile.getUri()}`);
+    const wiki = await Wiki.queryWikiPage(title);
+    if (!wiki) throw new Error(`Wiki page not found: ${title}`);
+    profile.updateData({ wiki });
+    profile.save();
+  }
+  async run() {
+    await this.protect(async () => {
+      const profile = Profile.find(this.options.profile);
+      if (!profile) throw new Error(`Profile not found: ${this.options.profile}`);
+      if (this.options.assign) await this.assign(profile, this.options.assign);
+      else await this.update(profile);
+    });
+  }
+  // --- command definition ---
+  static command = {
+    id: 'wiki',
+    desc: 'Update and assign wiki data to a profile',
+    options: [
+      { name: '-p, --profile <URI>', desc: 'The profile URI to process', required: true },
+      { name: '--assign <TITLE>', desc: 'Assign wiki data from the specified wiki title to the profile' }
+    ]
+  };
+}

package/dist/job/index.d.ts

@@ -0,0 +1,26 @@
+import { AliasJob } from './Alias.js';
+import { AnnualJob } from './Annual.js';
+import { ListJob } from './List.js';
+import { MergeJob } from './Merge.js';
+import { MoveJob } from './Move.js';
+import { PerformanceJob } from './Performance.js';
+import { ProfileJob } from './Profile.js';
+import { QueueJob } from './Queue.js';
+import { RTBJob } from './RTB.js';
+import { StatsJob } from './Stats.js';
+import { Top10Job } from './Top10.js';
+import { WikiJob } from './Wiki.js';
+export declare const JOBS: readonly [
+  typeof AliasJob,
+  typeof AnnualJob,
+  typeof ListJob,
+  typeof MergeJob,
+  typeof MoveJob,
+  typeof PerformanceJob,
+  typeof ProfileJob,
+  typeof QueueJob,
+  typeof RTBJob,
+  typeof StatsJob,
+  typeof Top10Job,
+  typeof WikiJob
+];

package/dist/job/index.js

@@ -0,0 +1,26 @@
+import { AliasJob } from './Alias.js';
+import { AnnualJob } from './Annual.js';
+import { ListJob } from './List.js';
+import { MergeJob } from './Merge.js';
+import { MoveJob } from './Move.js';
+import { PerformanceJob } from './Performance.js';
+import { ProfileJob } from './Profile.js';
+import { QueueJob } from './Queue.js';
+import { RTBJob } from './RTB.js';
+import { StatsJob } from './Stats.js';
+import { Top10Job } from './Top10.js';
+import { WikiJob } from './Wiki.js';
+export const JOBS = [
+  AliasJob,
+  AnnualJob,
+  ListJob,
+  MergeJob,
+  MoveJob,
+  PerformanceJob,
+  ProfileJob,
+  QueueJob,
+  RTBJob,
+  StatsJob,
+  Top10Job,
+  WikiJob
+];

package/dist/lib/const.d.ts

@@ -0,0 +1,31 @@
+import type {
+  TAssetType,
+  TChangeFlag,
+  TChildrenGroup,
+  TFilterGroup,
+  TFilterSpecial,
+  TGender,
+  TIndustry,
+  TMaritalStatus,
+  TPercentiles,
+  TRelationType,
+  TSelfMadeRank,
+  TStatsGroup,
+  TWealthSpread
+} from '@rtbnext/schema/src/base/const';
+import type { TIndustryResolver, TMaritalStatusResolver } from '../types/generic';
+export declare const Industry: TIndustry[];
+export declare const Gender: TGender[];
+export declare const MaritalStatus: TMaritalStatus[];
+export declare const SelfMadeRank: TSelfMadeRank[];
+export declare const RelationType: TRelationType[];
+export declare const AssetType: TAssetType[];
+export declare const ChangeFlag: TChangeFlag[];
+export declare const StatsGroup: TStatsGroup[];
+export declare const ChildrenGroup: TChildrenGroup[];
+export declare const Percentiles: TPercentiles[];
+export declare const WealthSpread: TWealthSpread[];
+export declare const FilterGroup: TFilterGroup[];
+export declare const FilterSpecial: TFilterSpecial[];
+export declare const MaritalStatusResolver: TMaritalStatusResolver;
+export declare const IndustryResolver: TIndustryResolver;

package/dist/lib/const.js

@@ -0,0 +1,74 @@
+// --- basics ---
+export const Industry = [
+  'automotive',
+  'diversified',
+  'energy',
+  'engineering',
+  'finance',
+  'foodstuff',
+  'gambling',
+  'healthcare',
+  'logistics',
+  'manufacturing',
+  'media',
+  'mining',
+  'property',
+  'retail',
+  'service',
+  'sports',
+  'technology',
+  'telecom'
+];
+export const Gender = ['m', 'f', 'd'];
+export const MaritalStatus = [
+  'single',
+  'relationship',
+  'married',
+  'remarried',
+  'engaged',
+  'separated',
+  'divorced',
+  'widowed'
+];
+export const SelfMadeRank = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10'];
+export const RelationType = ['person', 'organization', 'place', 'unknown'];
+export const AssetType = ['public', 'private', 'misc'];
+export const ChangeFlag = ['up', 'down', 'unchanged', 'new', 'returned', 'dropoff', 'unknown'];
+// --- stats ---
+export const StatsGroup = ['industry', 'citizenship'];
+export const ChildrenGroup = ['none', 'one', 'two', 'three', 'four', '5-to-10', 'over-10'];
+export const Percentiles = ['10th', '25th', '50th', '75th', '90th', '95th', '99th'];
+export const WealthSpread = ['1', '2', '5', '10', '20', '50', '100', '200', '500', '1000'];
+// --- filter ---
+export const FilterGroup = ['industry', 'citizenship', 'country', 'state', 'gender', 'age', 'maritalStatus', 'special'];
+export const FilterSpecial = ['deceased', 'dropOff', 'family', 'selfMade'];
+// --- resolver ---
+export const MaritalStatusResolver = {
+  'single': 'single',
+  'in-relationship': 'relationship',
+  'married': 'married',
+  'remarried': 'remarried',
+  'engaged': 'engaged',
+  'separated': 'separated',
+  'divorced': 'divorced',
+  'widowed': 'widowed'
+};
+export const IndustryResolver = {
+  'technology': 'technology',
+  'fashion-retail': 'retail',
+  'finance-investments': 'finance',
+  'diversified': 'diversified',
+  'telecom': 'telecom',
+  'energy': 'energy',
+  'metals-mining': 'mining',
+  'gambling-casinos': 'gambling',
+  'healthcare': 'healthcare',
+  'manufacturing': 'manufacturing',
+  'logistics': 'logistics',
+  'automotive': 'automotive',
+  'media-entertainment': 'media',
+  'construction-engineering': 'engineering',
+  'sports': 'sports',
+  'real-estate': 'property',
+  'service': 'service'
+};

package/dist/lib/list.d.ts

@@ -0,0 +1,90 @@
+import { BillionairesListParser } from '../parser/BillionairesListParser.js';
+import { PersonListParser } from '../parser/PersonListParser.js';
+import { RTBListParser } from '../parser/RTBListParser.js';
+import type { TListIndexItemCtx, TListTypes, TPersonListItemCtx, TRTBListItemCtx } from '../types/list';
+export declare const LISTS: {
+  readonly rtb: {
+    readonly lists: readonly ['rtb'];
+    readonly parser: typeof RTBListParser;
+    readonly indexItem: () => {
+      uri: string;
+      name: string;
+      shortName: string;
+      desc: string;
+      text: string;
+      columns: string[];
+      filters: string[];
+    };
+    readonly listItem: (ctx: TRTBListItemCtx) => {
+      flag: import('@rtbnext/schema/src/base/const').TChangeFlag;
+      rankDiff: number | undefined;
+      today: import('@rtbnext/schema/src/base/assets').TChangeItem | undefined;
+      ytd: import('@rtbnext/schema/src/base/assets').TChangeItem | undefined;
+      uri: string;
+      rank: number;
+      networth: number;
+      name: string;
+      gender: import('@rtbnext/schema/src/base/const').TGender | undefined;
+      age: number | undefined;
+      citizenship: string | undefined;
+      industry: import('@rtbnext/schema/src/base/const').TIndustry;
+      source: string[];
+    };
+  };
+  readonly billionaires: {
+    readonly lists: readonly ['billionaires', 'forbes-400'];
+    readonly parser: typeof BillionairesListParser;
+    readonly indexItem: (
+      uri: string,
+      ctx: TListIndexItemCtx
+    ) => {
+      uri: string;
+      name: string;
+      shortName: string;
+      desc: string;
+      text: string;
+      columns: string[];
+      filters: string[];
+    };
+    readonly listItem: (ctx: TPersonListItemCtx) => {
+      selfMadeRank: import('@rtbnext/schema/src/base/const').TSelfMadeRank | undefined;
+      philanthropyScore: number | undefined;
+      uri: string;
+      rank: number;
+      networth: number;
+      name: string;
+      gender: import('@rtbnext/schema/src/base/const').TGender | undefined;
+      age: number | undefined;
+      citizenship: string | undefined;
+      industry: import('@rtbnext/schema/src/base/const').TIndustry;
+      source: string[];
+    };
+  };
+  readonly person: {
+    readonly parser: typeof PersonListParser;
+    readonly indexItem: (
+      uri: string,
+      ctx: TListIndexItemCtx
+    ) => {
+      uri: string;
+      name: string;
+      shortName: string;
+      desc: string;
+      text: string;
+      columns: string[];
+      filters: string[];
+    };
+    readonly listItem: (ctx: TPersonListItemCtx) => {
+      uri: string;
+      rank: number;
+      networth: number;
+      name: string;
+      gender: import('@rtbnext/schema/src/base/const').TGender | undefined;
+      age: number | undefined;
+      citizenship: string | undefined;
+      industry: import('@rtbnext/schema/src/base/const').TIndustry;
+      source: string[];
+    };
+  };
+};
+export declare const getListConfigByUri: (uri: string) => (typeof LISTS)[TListTypes];

package/dist/lib/list.js

@@ -0,0 +1,72 @@
+import { Utils } from '../core/Utils.js';
+import { BillionairesListParser } from '../parser/BillionairesListParser.js';
+import { PersonListParser } from '../parser/PersonListParser.js';
+import { RTBListParser } from '../parser/RTBListParser.js';
+const personListItem = ctx => ({
+  uri: ctx.parsed.uri(),
+  rank: ctx.parsed.rank(),
+  networth: ctx.parsed.networth(),
+  name: ctx.profileData.info.name.shortName,
+  gender: ctx.profileData.info?.gender,
+  age: ctx.parsed.age(),
+  citizenship: ctx.profileData.info?.citizenship,
+  industry: ctx.profileData.info?.industry,
+  source: ctx.profileData.info?.source
+});
+export const LISTS = {
+  rtb: {
+    lists: ['rtb'],
+    parser: RTBListParser,
+    indexItem: () => ({
+      uri: 'rtb',
+      name: 'The World’s Real-Time Billionaires',
+      shortName: 'Real-Time Billionaires',
+      desc: 'Today’s richest people in the world',
+      text: 'todays richest people world',
+      columns: ['rank', 'diff', 'profile', 'networth', 'today', 'ytd', 'age', 'citizenship', 'source'],
+      filters: ['gender', 'industry', 'citizenship', 'diff', 'age']
+    }),
+    listItem: ctx => ({
+      ...personListItem(ctx),
+      flag: ctx.flag,
+      rankDiff: ctx.rankDiff,
+      today: ctx.realtime?.today,
+      ytd: ctx.realtime?.ytd
+    })
+  },
+  billionaires: {
+    lists: ['billionaires', 'forbes-400'],
+    parser: BillionairesListParser,
+    indexItem: (uri, ctx) => ({
+      uri,
+      name: ctx.name,
+      shortName: ctx.name,
+      desc: ctx.desc,
+      text: Utils.buildSearchText(ctx.desc),
+      columns: ['rank', 'profile', 'networth', 'age', 'citizenship', 'selfMadeRank', 'philanthropyScore', 'source'],
+      filters: ['gender', 'industry', 'citizenship', 'age', 'selfMadeRank', 'philanthropyScore']
+    }),
+    listItem: ctx => ({
+      ...personListItem(ctx),
+      selfMadeRank: ctx.parsed.selfMade()?.rank,
+      philanthropyScore: ctx.parsed.philanthropyScore()
+    })
+  },
+  person: {
+    parser: PersonListParser,
+    indexItem: (uri, ctx) => ({
+      uri,
+      name: ctx.name,
+      shortName: ctx.name,
+      desc: ctx.desc,
+      text: Utils.buildSearchText(ctx.desc),
+      columns: ['rank', 'profile', 'networth', 'age', 'citizenship', 'source'],
+      filters: ['gender', 'industry', 'citizenship', 'age']
+    }),
+    listItem: personListItem
+  }
+};
+export const getListConfigByUri = uri => {
+  for (const config of Object.values(LISTS)) if ('lists' in config && config.lists.includes(uri)) return config;
+  return LISTS.person;
+};

package/dist/lib/regex.d.ts

@@ -0,0 +1,7 @@
+export declare const REGEX_DIACRITICS: RegExp;
+export declare const REGEX_FAMILY: RegExp;
+export declare const REGEX_NOALNUM: RegExp;
+export declare const REGEX_NONUM: RegExp;
+export declare const REGEX_SPACE_DELIMITER: RegExp;
+export declare const REGEX_SPACES: RegExp;
+export declare const REGEX_URI_CLEANUP: RegExp;

package/dist/lib/regex.js

@@ -0,0 +1,7 @@
+export const REGEX_DIACRITICS = /[\u0300-\u036f]/g;
+export const REGEX_FAMILY = /&\s*family/i;
+export const REGEX_NOALNUM = /[^a-z0-9]+/g;
+export const REGEX_NONUM = /[^\d]+/g;
+export const REGEX_SPACE_DELIMITER = /\s+/;
+export const REGEX_SPACES = /\s+/g;
+export const REGEX_URI_CLEANUP = /-(family|\d+)$/i;

package/dist/model/Filter.d.ts

@@ -0,0 +1,28 @@
+import type { TFilterGroup, TFilterSpecial } from '@rtbnext/schema/src/base/const';
+import type { TFilter, TFilterList } from '@rtbnext/schema/src/model/filter';
+import type { TProfileData } from '@rtbnext/schema/src/model/profile';
+import type { IFilter } from '../interfaces/filter';
+export declare class Filter implements IFilter {
+  private static readonly storage;
+  private static instance;
+  private data;
+  private constructor();
+  private initDB;
+  private prepFilter;
+  private setFilterData;
+  private splitPath;
+  private joinPath;
+  resolvePath(path: string): string | false;
+  private loadFilter;
+  private saveFilter;
+  private saveGroup;
+  private saveSpecial;
+  getFilter(group: TFilterGroup, key: string): TFilter | undefined;
+  getFilterByPath(path: string): TFilter | undefined;
+  getGroup(group: TFilterGroup): Record<string, TFilter> | undefined;
+  getSpecial(special: TFilterSpecial): TFilter | undefined;
+  has(path: string, uriLike: string): boolean;
+  save(col: Partial<TFilterList>): void;
+  static getInstance(): IFilter;
+  static aggregate(data: TProfileData, filter: Partial<TFilterList>): void;
+}

package/dist/model/Filter.js

@@ -0,0 +1,122 @@
+import { join } from 'node:path';
+import { log } from '../core/Logger.js';
+import { Storage } from '../core/Storage.js';
+import { Utils } from '../core/Utils.js';
+import { FilterGroup, FilterSpecial } from '../lib/const.js';
+import { Parser } from '../parser/Parser.js';
+export class Filter {
+  static storage = Storage.getInstance();
+  static instance;
+  data = {};
+  constructor() {
+    this.initDB();
+  }
+  initDB() {
+    log.debug('Initializing filter storage paths');
+    FilterGroup.forEach(group => Filter.storage.ensurePath(join('filter', group), true));
+  }
+  // --- helper ---
+  prepFilter(list) {
+    return [...new Map(list.map(i => [i.uri, i])).values()].sort((a, b) => a.uri.localeCompare(b.uri));
+  }
+  setFilterData(group, key, filter) {
+    (this.data[group] ??= {})[key] = filter;
+  }
+  // --- path helper ---
+  splitPath(path) {
+    const [group, key] = path.replace('.json', '').split('/').slice(-2);
+    return FilterGroup.includes(group) && key ? [group, key] : undefined;
+  }
+  joinPath(group, key) {
+    return group && key ? join('filter', group, `${key}.json`) : false;
+  }
+  resolvePath(path) {
+    return this.joinPath(...(this.splitPath(path) ?? []));
+  }
+  // --- load & save filter ---
+  loadFilter(group, key) {
+    log.debug(`Loading filter from ${group}/${key}`);
+    return log.catch(() => {
+      const resolved = this.joinPath(group, key);
+      if (!resolved) throw new Error(`Invalid filter path: ${group}/${key}`);
+      const filter = Filter.storage.readJSON(resolved);
+      if (!filter) throw new Error(`Filter file not found: ${resolved}`);
+      this.setFilterData(group, key, filter);
+      return filter;
+    }, `Failed to load filter at ${group}/${key}`);
+  }
+  saveFilter(group, key, list) {
+    log.debug(`Saving filter to ${group}/${key}`);
+    log.catch(() => {
+      const resolved = this.joinPath(group, key);
+      if (!resolved) throw new Error(`Invalid filter path: ${group}/${key}`);
+      const items = this.prepFilter(list);
+      const filter = { ...Utils.metaData(), items, count: items.length };
+      this.setFilterData(group, key, filter);
+      if (!Filter.storage.writeJSON(resolved, filter)) throw new Error(`Failed to write filter file: ${resolved}`);
+    }, `Failed to save filter at ${group}/${key}`);
+  }
+  saveGroup(group, data) {
+    Object.entries(data).forEach(([key, list]) => this.saveFilter(group, key, list));
+  }
+  saveSpecial(special, data) {
+    this.saveFilter('special', special, data);
+  }
+  // --- getter ---
+  getFilter(group, key) {
+    return this.data[group]?.[key] ?? this.loadFilter(group, key);
+  }
+  getFilterByPath(path) {
+    const [group, key] = this.splitPath(path) ?? [];
+    return group && key ? this.getFilter(group, key) : undefined;
+  }
+  getGroup(group) {
+    Filter.storage.scanDir(join('filter', group)).forEach(file => {
+      const key = file.replace('.json', '').split('/').pop();
+      if (key && !this.data[group]?.[key]) this.loadFilter(group, key);
+    });
+    return this.data[group];
+  }
+  getSpecial(special) {
+    Filter.storage.scanDir('filter/special').forEach(file => {
+      const key = file.replace('.json', '').split('/').pop();
+      if (key && !this.data.special?.[special]) this.loadFilter('special', special);
+    });
+    return this.data.special?.[special];
+  }
+  // --- has filter ---
+  has(path, uriLike) {
+    const [group, key] = this.splitPath(path) ?? [];
+    const uri = Utils.sanitize(uriLike);
+    return !!group && !!key && !!this.getFilter(group, key)?.items?.some(i => i.uri === uri);
+  }
+  // --- save (partial) filter collection ---
+  save(col) {
+    FilterGroup.forEach(g => g !== 'special' && col[g] && this.saveGroup(g, col[g]));
+    FilterSpecial.forEach(s => col.special?.[s] && this.saveSpecial(s, col.special[s]));
+  }
+  // --- instantiate ---
+  static getInstance() {
+    return (Filter.instance ??= new Filter());
+  }
+  // --- aggregate filter data ---
+  static aggregate(data, filter) {
+    const { uri, info, realtime } = data;
+    const item = { uri, name: info.name.shortName, value: undefined };
+    const decade = Parser.ageDecade(info.birthDate)?.toString();
+    const add = (g, k, v = null) => {
+      g && k && ((filter[g] ??= {})[k] ??= []) && filter[g][k].push({ ...item, value: v === null ? k : v });
+    };
+    add('industry', info.industry);
+    add('citizenship', info.citizenship);
+    add('country', info.residence?.country);
+    add('state', info.residence?.state);
+    add('gender', info.gender);
+    add('age', decade, info.birthDate);
+    add('maritalStatus', info.maritalStatus);
+    info.flags.deceased && add('special', 'deceased', undefined);
+    info.flags.dropOff && add('special', 'dropOff', realtime?.date);
+    info.flags.family && add('special', 'family', undefined);
+    info.selfMade?.is && add('special', 'selfMade', info.selfMade.rank);
+  }
+}

package/dist/model/List.d.ts

@@ -0,0 +1,12 @@
+import type { TListIndexItem, TListSnapshot, TListSnapshotData } from '@rtbnext/schema/src/model/list';
+import { Snapshot } from '../abstract/Snapshot.js';
+import type { IList } from '../interfaces/list';
+export declare class List extends Snapshot<TListSnapshot> implements IList {
+  private static readonly index;
+  private readonly uri;
+  private constructor();
+  getUri(): string;
+  saveSnapshot(snapshot: TListSnapshotData, force?: boolean): boolean;
+  static get(uriLike: string): IList | false;
+  static create(uriLike: string, data: TListIndexItem, snapshot?: TListSnapshotData): List | false;
+}

package/dist/model/List.js

@@ -0,0 +1,43 @@
+import { Snapshot } from '../abstract/Snapshot.js';
+import { log } from '../core/Logger.js';
+import { Utils } from '../core/Utils.js';
+import { ListIndex } from './ListIndex.js';
+export class List extends Snapshot {
+  static index = ListIndex.getInstance();
+  uri;
+  constructor(item) {
+    if (!item || !item.uri) throw new Error('No valid list index item given');
+    super('list');
+    this.uri = item.uri;
+  }
+  // --- getter ---
+  getUri() {
+    return this.uri;
+  }
+  // --- (override) save list snapshot ---
+  saveSnapshot(snapshot, force = false) {
+    return super.saveSnapshot({ ...Utils.metaData(), ...snapshot }, force);
+  }
+  // --- instantiate ---
+  static get(uriLike) {
+    try {
+      return new List(List.index.get(uriLike));
+    } catch {
+      return false;
+    }
+  }
+  // --- create list ---
+  static create(uriLike, data, snapshot) {
+    log.debug(`Creating List ${uriLike}`);
+    return (
+      log.catch(() => {
+        const item = List.index.add(uriLike, data);
+        if (!item) throw new Error(`List index item for ${uriLike} could not be created`);
+        const list = new List(item);
+        if (!list) throw new Error(`List ${item.uri} could not be created`);
+        if (snapshot) list.saveSnapshot(snapshot);
+        return list;
+      }, `Failed to create List ${uriLike}`) ?? false
+    );
+  }
+}

package/dist/model/ListIndex.d.ts

@@ -0,0 +1,8 @@
+import type { TListIndex, TListIndexItem } from '@rtbnext/schema/src/model/list';
+import { Index } from '../abstract/Index.js';
+import type { IListIndex } from '../interfaces/index';
+export declare class ListIndex extends Index<TListIndexItem, TListIndex> implements IListIndex {
+  protected static instance: ListIndex;
+  private constructor();
+  static getInstance(): IListIndex;
+}

package/dist/model/ListIndex.js

@@ -0,0 +1,10 @@
+import { Index } from '../abstract/Index.js';
+export class ListIndex extends Index {
+  static instance;
+  constructor() {
+    super('list', 'list/index.json');
+  }
+  static getInstance() {
+    return (ListIndex.instance ??= new ListIndex());
+  }
+}

package/dist/model/Mover.d.ts

@@ -0,0 +1,15 @@
+import type { TRealtime } from '@rtbnext/schema/src/base/assets';
+import type { TMover, TMoverData } from '@rtbnext/schema/src/model/mover';
+import { Snapshot } from '../abstract/Snapshot.js';
+import type { IMover } from '../interfaces/mover';
+export declare class Mover extends Snapshot<TMover> implements IMover {
+  private static instance;
+  private constructor();
+  private prepItems;
+  private parseEntry;
+  private parseBucket;
+  saveSnapshot(snapshot: TMoverData, force?: boolean): boolean;
+  static getInstance(): IMover;
+  static factory(date?: any): TMoverData;
+  static aggregate(data: TRealtime | undefined, uri: string, name: string, mover: TMoverData, total?: number): void;
+}