@rtbnext/core 2.0.0-alpha.1

package/dist/parser/PersonListParser.js

@@ -0,0 +1,111 @@
+import { Utils } from '../core/Utils.js';
+import { ListParser } from './ListParser.js';
+import { Parser } from './Parser.js';
+import { ProfileParser } from './ProfileParser.js';
+export class PersonListParser extends ListParser {
+  uri() {
+    return this.cache('uri', () => Utils.sanitize(this.raw.uri));
+  }
+  id() {
+    return this.cache('id', () => Utils.hash(this.raw.naturalId));
+  }
+  // --- basic fields ---
+  date() {
+    return this.cache('date', () => Parser.date(this.raw.date ?? this.raw.timestamp, 'ymd'));
+  }
+  year() {
+    return this.cache('year', () => Number(this.date().slice(0, 4)));
+  }
+  rank() {
+    return this.cache(
+      'rank',
+      () => Parser.strict(this.raw.rank, 'number') ?? Parser.strict(this.raw.position, 'number')
+    );
+  }
+  networth() {
+    return this.cache('networth', () => Parser.strict(this.raw.finalWorth, 'money'));
+  }
+  dropOff() {
+    return this.cache('dropOff', () => (this.raw.finalWorth ? this.raw.finalWorth < 1e3 : undefined));
+  }
+  name() {
+    return this.cache('name', () =>
+      ProfileParser.name(this.raw.person?.name ?? this.raw.personName, this.raw.lastName)
+    );
+  }
+  // --- profile data ---
+  info() {
+    return this.cache('info', () => ({
+      flags: { dropOff: this.dropOff() },
+      ...this.name(),
+      ...Parser.container({
+        gender: { value: this.raw.gender, type: 'gender' },
+        birthDate: { value: this.raw.birthDate, type: 'date' },
+        citizenship: { value: this.raw.countryOfCitizenship, type: 'country' },
+        industry: { value: this.raw.industries?.[0], type: 'industry' },
+        source: { value: this.raw.source, type: 'list' }
+      }),
+      residence: this.residence(),
+      selfMade: this.selfMade(),
+      philanthropyScore: this.philanthropyScore(),
+      organization: this.organization()
+    }));
+  }
+  residence() {
+    return Parser.location({ country: this.raw.country, state: this.raw.state, city: this.raw.city });
+  }
+  selfMade() {
+    return this.cache('selfMade', () => {
+      if (this.raw.selfMadeRank)
+        return Parser.container({
+          is: { value: this.raw.selfMadeRank > 7, type: 'boolean' },
+          rank: { value: this.raw.selfMadeRank, type: 'number' }
+        });
+    });
+  }
+  philanthropyScore() {
+    return this.cache('philanthropyScore', () => Parser.strict(this.raw.philanthropyScore, 'number'));
+  }
+  organization() {
+    return this.cache('organization', () => {
+      if (this.raw.organization)
+        return Parser.container({
+          name: { value: this.raw.organization, type: 'string' },
+          title: { value: this.raw.title, type: 'string' }
+        });
+    });
+  }
+  bio() {
+    return this.cache('bio', () =>
+      Parser.container({
+        cv: { value: this.raw.bios, type: 'list', args: ['safeStr'] },
+        facts: { value: this.raw.abouts, type: 'list', args: ['safeStr'] },
+        quotes: { value: [], type: 'list', args: ['safeStr'] }
+      })
+    );
+  }
+  age() {
+    return this.cache('age', () => Parser.strict(this.raw.birthDate, 'age'));
+  }
+  // --- prepare raw list data ---
+  static prepareList(res, filter) {
+    if (!res?.success || !res.data) throw new Error('Response does not contain valid list data');
+    const rawList = res.data.personList.personsLists;
+    const entries = rawList
+      .filter(filter ?? Boolean)
+      .filter(Boolean)
+      .sort((a, b) => (a.rank ?? a.position ?? Infinity) - (b.rank ?? b.position ?? Infinity));
+    if (!entries.length) throw new Error('Response does not contain any valid list entries');
+    return { rawData: res.data, rawList, entries };
+  }
+  // --- prepare stats ---
+  static stats(data) {
+    return Parser.container({
+      date: { value: data.date, type: 'string' },
+      count: { value: data.count, type: 'number' },
+      total: { value: data.total, type: 'money' },
+      woman: { value: data.woman, type: 'number' },
+      quota: { value: ((data.woman ?? 0) / (data.count ?? 1)) * 100, type: 'pct' }
+    });
+  }
+}

package/dist/parser/ProfileParser.d.ts

@@ -0,0 +1,44 @@
+import type {
+  TEducation,
+  TImage,
+  TLocation,
+  TOrganization,
+  TRelation,
+  TSelfMade
+} from '@rtbnext/schema/src/base/generic';
+import type { TProfileBio, TProfileFlags, TProfileInfo, TProfileName } from '@rtbnext/schema/src/model/profile';
+import { Cache } from '../abstract/Cache.js';
+import type { IProfileParser } from '../interfaces/parser';
+import type { TProfileResponse } from '../types/response';
+export declare class ProfileParser extends Cache implements IProfileParser {
+  private readonly raw;
+  private readonly lists;
+  constructor(res: TProfileResponse);
+  rawData(): TProfileResponse['person'];
+  sortedLists(): TProfileResponse['person']['personLists'];
+  uri(): string;
+  id(): string;
+  aliases(): string[];
+  name(): { name: TProfileName; family: boolean };
+  flags(): TProfileFlags;
+  info(): TProfileInfo;
+  citizenship(): string | undefined;
+  residence(): TLocation | undefined;
+  birthPlace(): TLocation | undefined;
+  education(): TEducation[];
+  selfMade(): TSelfMade;
+  philanthropyScore(): number | undefined;
+  organization(): TOrganization | undefined;
+  bio(): TProfileBio;
+  cv(): string[];
+  facts(): string[];
+  quotes(): string[];
+  related(): TRelation[];
+  media(): TImage[];
+  static name(
+    value: unknown,
+    lastName?: unknown,
+    firstName?: unknown,
+    asianFormat?: boolean
+  ): { name: TProfileName; family: boolean };
+}

package/dist/parser/ProfileParser.js

@@ -0,0 +1,193 @@
+import { Cache } from '../abstract/Cache.js';
+import { Utils } from '../core/Utils.js';
+import { RelationType } from '../lib/const.js';
+import { REGEX_FAMILY, REGEX_SPACE_DELIMITER } from '../lib/regex.js';
+import { Parser } from './Parser.js';
+export class ProfileParser extends Cache {
+  raw;
+  lists;
+  constructor(res) {
+    super();
+    this.raw = res.person;
+    this.lists = res.person.personLists.sort((a, b) => Number(b.date ?? 0) - Number(a.date ?? 0));
+  }
+  // --- raw data ---
+  rawData() {
+    return this.raw;
+  }
+  sortedLists() {
+    return this.lists;
+  }
+  // --- URIs & IDs ---
+  uri() {
+    return this.cache('uri', () => Utils.sanitize(this.raw.uri));
+  }
+  id() {
+    return this.cache('id', () => Utils.hash(this.raw.naturalId));
+  }
+  aliases() {
+    return this.cache('aliases', () => {
+      const uri = this.uri();
+      return this.raw.uris
+        .filter(Boolean)
+        .map(i => Utils.sanitize(i))
+        .filter(i => i !== uri)
+        .sort();
+    });
+  }
+  // --- profile info ---
+  name() {
+    return this.cache('name', () =>
+      ProfileParser.name(this.raw.name, this.raw.lastName, this.raw.firstName, Parser.boolean(this.raw.asianFormat))
+    );
+  }
+  flags() {
+    return this.cache('flags', () =>
+      Parser.container({
+        deceased: { value: this.raw.deceased, type: 'boolean' },
+        family: { value: this.name().family, type: 'boolean' },
+        dropOff: { value: this.raw.dropOff, type: 'boolean' },
+        embargo: { value: this.raw.embargo, type: 'boolean' }
+      })
+    );
+  }
+  info() {
+    return this.cache('info', () => ({
+      ...Parser.container({
+        gender: { value: this.raw.gender, type: 'gender' },
+        birthDate: { value: this.raw.birthDate, type: 'date' },
+        maritalStatus: { value: this.raw.maritalStatus, type: 'maritalStatus' },
+        children: { value: this.raw.numberOfChildren, type: 'number' },
+        industry: { value: this.raw.industries?.[0], type: 'industry' },
+        source: { value: this.raw.source, type: 'list' }
+      }),
+      flags: this.flags(),
+      name: this.name().name,
+      citizenship: this.citizenship(),
+      birthPlace: this.birthPlace(),
+      residence: this.residence(),
+      education: this.education(),
+      selfMade: this.selfMade(),
+      philanthropyScore: this.philanthropyScore(),
+      organization: this.organization()
+    }));
+  }
+  citizenship() {
+    return this.cache('citizenship', () =>
+      Parser.strict(this.raw.countryOfCitizenship ?? this.raw.countryOfResidence, 'country')
+    );
+  }
+  residence() {
+    return Parser.location({
+      country: this.raw.countryOfResidence,
+      state: this.raw.stateProvince,
+      city: this.raw.city
+    });
+  }
+  birthPlace() {
+    return Parser.location({ country: this.raw.birthCountry, state: this.raw.birthState, city: this.raw.birthCity });
+  }
+  education() {
+    return this.cache('education', () =>
+      (this.raw.educations ?? [])
+        .filter(Boolean)
+        .map(item =>
+          Parser.container({
+            school: { value: item.school, type: 'string' },
+            degree: { value: item.degree, type: 'string' }
+          })
+        )
+    );
+  }
+  selfMade() {
+    return this.cache('selfMade', () =>
+      Parser.container({
+        type: { value: this.raw.selfMadeType, type: 'string' },
+        is: { value: this.raw.selfMade, type: 'boolean' },
+        rank: { value: this.raw.selfMadeRank, type: 'number' }
+      })
+    );
+  }
+  philanthropyScore() {
+    return this.cache('philanthropyScore', () => Utils.aggregate(this.lists, 'philanthropyScore', 'first'));
+  }
+  organization() {
+    return this.cache('organization', () => {
+      if (this.raw.organization)
+        return Parser.container({
+          name: { value: this.raw.organization, type: 'string' },
+          title: { value: this.raw.title, type: 'string' }
+        });
+    });
+  }
+  // --- bio ---
+  bio() {
+    return this.cache('bio', () => ({ cv: this.cv(), facts: this.facts(), quotes: this.quotes() }));
+  }
+  cv() {
+    return this.cache('cv', () => Parser.list(Utils.aggregate(this.lists, 'bios', 'first'), 'safeStr'));
+  }
+  facts() {
+    return this.cache('facts', () => Parser.list(Utils.aggregate(this.lists, 'abouts', 'first'), 'safeStr'));
+  }
+  quotes() {
+    return this.cache('quotes', () => Parser.list([this.raw.quote ?? ''], 'safeStr'));
+  }
+  // --- related entries ---
+  related() {
+    return this.cache('related', () =>
+      (this.raw.relatedEntities ?? [])
+        .filter(Boolean)
+        .map(item => ({
+          uri: item.uri ? Utils.sanitize(item.uri) : undefined,
+          ...Parser.container({
+            type: { value: item.type, type: 'map', args: [RelationType] },
+            name: { value: item.name, type: 'string' },
+            relation: { value: item.relationshipType, type: 'string' }
+          })
+        }))
+    );
+  }
+  // --- media ---
+  media() {
+    return this.cache('media', () =>
+      (this.raw.listImages ?? [])
+        .filter(Boolean)
+        .map(item =>
+          Parser.container({
+            url: { value: item.uri, type: 'string' },
+            credits: { value: item.credit, type: 'safeStr' },
+            file: { value: item.image, type: 'string' },
+            caption: { value: item.caption, type: 'safeStr' },
+            desc: { value: item.description, type: 'safeStr' }
+          })
+        )
+    );
+  }
+  // --- static methods ---
+  static name(value, lastName = undefined, firstName = undefined, asianFormat = false) {
+    const name = Parser.string(value);
+    const clean = name.replace(REGEX_FAMILY, '').trim();
+    const family = REGEX_FAMILY.test(name);
+    const parts = clean.split(REGEX_SPACE_DELIMITER).filter(Boolean);
+    const fN = firstName
+      ? Parser.string(firstName)
+      : asianFormat
+        ? parts.slice(1).join(' ')
+        : parts.slice(0, -1).join(' ');
+    const lN = lastName
+      ? Parser.string(lastName).replace(REGEX_FAMILY, '')
+      : asianFormat
+        ? (parts[0] ?? '')
+        : (parts.pop() ?? '');
+    return {
+      family,
+      name: {
+        fullName: clean + (family ? ' & family' : ''),
+        shortName: `${fN.split(' ')[0]} ${lN}`.trim(),
+        lastName: lN,
+        firstName: fN
+      }
+    };
+  }
+}

package/dist/parser/RTBListParser.d.ts

@@ -0,0 +1,15 @@
+import type { TAsset, TRealtime } from '@rtbnext/schema/src/base/assets';
+import type { TChangeFlag } from '@rtbnext/schema/src/base/const';
+import type { TProfileData } from '@rtbnext/schema/src/model/profile';
+import type { TGenericStats } from '@rtbnext/schema/src/model/stats';
+import type { IRTBListParser } from '../interfaces/parser';
+import { PersonListParser } from './PersonListParser.js';
+import { TPreparedList } from '../types/list';
+import { TListResponse, TPersonListEntry, TResponse } from '../types/response';
+export declare class RTBListParser extends PersonListParser implements IRTBListParser {
+  assets(): TAsset[];
+  realtime(data?: Partial<TProfileData>, prev?: string, next?: string): TRealtime | undefined;
+  rankDiff(data?: Partial<TProfileData>): { flag: TChangeFlag; rankDiff?: number };
+  static prepareList(res: TResponse<TListResponse<TPersonListEntry>>): TPreparedList<TPersonListEntry>;
+  static stats(data: Partial<TGenericStats>): TGenericStats;
+}

package/dist/parser/RTBListParser.js

@@ -0,0 +1,91 @@
+import { Parser } from './Parser.js';
+import { PersonListParser } from './PersonListParser.js';
+export class RTBListParser extends PersonListParser {
+  assets() {
+    return this.cache('assets', () =>
+      (this.raw.financialAssets ?? []).map(a =>
+        Parser.container({
+          type: { value: 'public', type: 'string' },
+          label: { value: a.companyName, type: 'string' },
+          value: {
+            value:
+              a.numberOfShares && (a.currentPrice ?? a.sharePrice)
+                ? (a.numberOfShares * (a.currentPrice ?? a.sharePrice)) / 1e6
+                : undefined,
+            type: 'money'
+          },
+          info: {
+            value:
+              a.exchange && a.ticker
+                ? Parser.container({
+                    exchange: { value: a.exchange, type: 'string' },
+                    ticker: { value: a.ticker, type: 'string' },
+                    shares: { value: a.numberOfShares, type: 'number' },
+                    price: { value: a.currentPrice ?? a.sharePrice, type: 'number', args: [6] },
+                    currency: { value: a.currencyCode, type: 'string' },
+                    exRate: { value: a.exchangeRate, type: 'number', args: [6] }
+                  })
+                : undefined,
+            type: 'container'
+          }
+        })
+      )
+    );
+  }
+  realtime(data, prev, next) {
+    return this.cache('realtime', () => {
+      if (!this.raw.finalWorth) return;
+      const cur = this.raw.finalWorth;
+      const lastDay = data?.realtime?.networth;
+      const lastYear = data?.annual?.find(i => i.year === this.year() - 1)?.networth?.last;
+      let diff;
+      return {
+        date: this.date(),
+        rank: this.rank(),
+        networth: this.networth(),
+        prev,
+        next,
+        today: lastDay
+          ? { value: Parser.money((diff = cur - lastDay)), percent: Parser.pct((diff / lastDay) * 100) }
+          : undefined,
+        ytd: lastYear
+          ? { value: Parser.money((diff = cur - lastYear)), percent: Parser.pct((diff / lastYear) * 100) }
+          : undefined
+      };
+    });
+  }
+  rankDiff(data) {
+    if (this.rank() === undefined || (this.networth() ?? 0) < 1000) return { flag: 'dropoff' };
+    const item = data?.annual?.find(i => i.year === this.year() - 1);
+    if (!item) return { flag: data?.annual?.filter(i => i.rank?.last !== undefined).length ? 'returned' : 'new' };
+    if (item.rank?.last === undefined) return { flag: 'unknown' };
+    const rankDiff = item.rank.last - this.rank();
+    return { flag: rankDiff > 0 ? 'up' : rankDiff < 0 ? 'down' : 'unchanged', rankDiff };
+  }
+  // --- prepare raw list data ---
+  static prepareList(res) {
+    return super.prepareList(res, item => !!(item.rank || item.position) && !!item.finalWorth);
+  }
+  // --- prepare stats ---
+  static stats(data) {
+    return {
+      ...super.stats(data),
+      ...Parser.container({
+        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'
+        }
+      })
+    };
+  }
+}

package/dist/types/annual.d.ts

@@ -0,0 +1,7 @@
+export type TAnnualRawData = {
+  networth: number[];
+  prevNetworth?: number;
+  rank: number[];
+  hadBefore: boolean;
+  prevRank?: number;
+};

package/dist/types/config.d.ts

@@ -0,0 +1,35 @@
+export type TLoggingLevel = 'error' | 'warn' | 'info' | 'debug';
+
+export type TLoggingConfig = { level: TLoggingLevel; console?: boolean; file?: boolean };
+
+export type TJobConfig = { silent: boolean; safeMode: boolean };
+
+export type TCronConfig = { timezone: string };
+
+export type TStorageConfig = { baseDir: string; compression: boolean };
+
+export type TFetchConfig = {
+  endpoints: { profile: string; list: string; wikipedia: string; commons: string; wikidata: string; wayback: string };
+  headers: Record<string, string>;
+  apiAgent: string;
+  agentPool: string[];
+  rateLimit: {
+    batchSize: number;
+    timeout: number;
+    retries: number;
+    idle: number;
+    requestDelay: { max: number; min: number };
+  };
+  requests: { list: { chunkSize: number; maxRequests: number } };
+};
+
+export type TQueueConfig = { tsThreshold: number; maxSize: number; defaultPrio: number };
+
+export type TConfigObject = {
+  logging: TLoggingConfig;
+  job: TJobConfig;
+  cron: TCronConfig;
+  storage: TStorageConfig;
+  fetch: TFetchConfig;
+  queue: TQueueConfig;
+};

package/dist/types/fetch.d.ts

@@ -0,0 +1,3 @@
+export type TFetchMethod = 'get' | 'post';
+
+export type THeader = Record<string, string>;

package/dist/types/generic.d.ts

@@ -0,0 +1,10 @@
+import type { TIndustry, TMaritalStatus } from '@rtbnext/schema/src/base/const';
+
+export type TAggregator = 'all' | 'first' | 'last' | 'sum' | 'min' | 'max' | 'mean' | ((values: readonly T[K][]) => R);
+
+export type TObjOperator = 'set' | 'inc' | 'max' | 'min' | 'append' | 'prepend' | ((curr: any, p: string) => any);
+
+export type TMeasuredResult<R> = { result: R; ms: number };
+
+export type TMaritalStatusResolver = Record<string, TMaritalStatus>;
+export type TIndustryResolver = Record<string, TIndustry>;

package/dist/types/job.d.ts

@@ -0,0 +1,71 @@
+import type { Expand } from 'devtypes/types/util';
+
+import type { IJob } from '../interfaces/job';
+import type { TQueueType } from './queue';
+
+export type TJobClsOptions<T extends object = {}> = Expand<{ silent?: boolean; safeMode?: boolean } & T>;
+
+export type TAliasJobOptions = TJobClsOptions<{
+  removeGlobal?: string[];
+  profile?: string;
+  add?: string[];
+  remove?: string[];
+}>;
+
+export type TAnnualJobOptions = TJobClsOptions<{ year: number; profiles?: string[] }>;
+
+export type TListJobOptions = TJobClsOptions<{
+  override?: boolean;
+  profileUpdate?: boolean;
+  list?: string;
+  year?: string;
+  name?: string;
+  desc?: string;
+}>;
+
+export type TMergeJobOptions = TJobClsOptions<{
+  list?: string[];
+  source?: string;
+  target?: string;
+  dryRun?: boolean;
+  force?: boolean;
+  makeAlias?: boolean;
+}>;
+
+export type TMoveJobOptions = TJobClsOptions<{ source: string; target: string; makeAlias?: boolean }>;
+
+export type TProfileJobOptions = TJobClsOptions<{
+  profiles?: string[];
+  replace?: boolean;
+  skipRanking?: boolean;
+  skipWiki?: boolean;
+}>;
+
+export type TQueueJobOptions = TJobClsOptions<{
+  type: TQueueType;
+  add?: string[];
+  remove?: string[];
+  prio?: number;
+  args?: any;
+  clear?: boolean;
+}>;
+
+export type TTop10JobOptions = TJobClsOptions<{ date?: readonly [year: number, month: number] }>;
+
+export type TWikiJobOptions = TJobClsOptions<{ profile: string; assign?: string }>;
+
+export type TJobOption = { name: string; desc: string; parser?: (value: string) => any; required?: boolean };
+
+export type TJobOptions = ReadonlyArray<TJobOption>;
+
+export type TCommandJob = { readonly id: string; desc: string; options?: TJobOptions };
+
+export type TCronJob<T extends object = {}> = ReadonlyArray<{ cronexpr: string; options?: (date: Date) => T }>;
+
+export interface TJobCls<T extends TJobClsOptions = TJobClsOptions> {
+  readonly command: TCommandJob;
+  readonly cron?: TCronJob<T>;
+  new (options: T): IJob;
+}
+
+export type TJobRegistry = ReadonlyArray<TJobCls<any>>;

package/dist/types/list.d.ts

@@ -0,0 +1,49 @@
+import type { TRealtime } from '@rtbnext/schema/src/base/assets';
+import type { TChangeFlag } from '@rtbnext/schema/src/base/const';
+import type {
+  TBillionairesListItem,
+  TListIndexItem,
+  TPersonListItem,
+  TRTBListItem
+} from '@rtbnext/schema/src/model/list';
+import type { TProfileData } from '@rtbnext/schema/src/model/profile';
+import type { Expand } from 'devtypes/types/util';
+
+import type { IBillionairesListParser, IListParser, IPersonListParser, IRTBListParser } from '../interfaces/parser';
+import type { TListResponse } from './response';
+
+export type TListTypes = 'rtb' | 'billionaires' | 'person';
+
+export type TListParserCls<T extends IListParser> = new (...args: any[]) => T;
+
+export type TListIndexItemCtx = { name: string; desc: string };
+
+export type TPersonListItemCtx = { parsed: IPersonListParser; profileData: Partial<TProfileData> };
+
+export type TRTBListItemCtx = Expand<
+  TPersonListItemCtx & { parsed: IRTBListParser; flag: TChangeFlag; rankDiff?: number; realtime?: TRealtime }
+>;
+
+export type TRTBListConfig = {
+  lists: readonly ['rtb'];
+  parser: TListParserCls<IRTBListParser>;
+  indexItem(): TListIndexItem;
+  listItem(ctx: TRTBListItemCtx): TRTBListItem;
+};
+
+export type TBillionairesListConfig = {
+  lists: readonly ['billionaires', 'forbes-400'];
+  parser: TListParserCls<IBillionairesListParser>;
+  indexItem(uri: string, ctx: TListIndexItemCtx): TListIndexItem;
+  listItem(ctx: TPersonListItemCtx): TBillionairesListItem;
+};
+
+export type TPersonListConfig = {
+  parser: TListParserCls<IPersonListParser>;
+  indexItem(uri: string, ctx: TListIndexItemCtx): TListIndexItem;
+  listItem(ctx: TPersonListItemCtx): TPersonListItem;
+};
+
+export type TListConfig = { rtb: TRTBListConfig; billionaires: TBillionairesListConfig; person: TPersonListConfig };
+
+export type TPreparedList<T extends object> = { rawData: TListResponse<T>; rawList: T[]; entries: T[] };

package/dist/types/parser.d.ts

@@ -0,0 +1,7 @@
+import type { Parser } from '../parser/Parser.js';
+
+export type TParserDateType = 'iso' | 'ymd' | 'ym' | 'y';
+
+export type TParserMethod = Exclude<keyof typeof Parser, 'prototype'>;
+
+export type TParserContainer = { value: unknown; type: TParserMethod; strict?: boolean; args?: unknown[] };

package/dist/types/profile.d.ts

@@ -0,0 +1,9 @@
+import type { IProfile } from '../interfaces/profile';
+
+export type TProfileOperation = 'create' | 'update' | 'move';
+
+export type TProfileUpdateMode = 'setData' | 'updateData' | 'createOnly';
+
+export type TProfileLookupResult = { profile: IProfile | false; isExisting: boolean; isSimilar: boolean };
+
+export type TProfileProcessResult = { profile: IProfile | false; action: TProfileOperation; success: boolean };

package/dist/types/queue.d.ts

@@ -0,0 +1,15 @@
+export type TQueueType = 'profile' | 'list';
+
+export type TQueueOptions = { uriLike: string; args?: Record<string, unknown>; prio?: number };
+
+export type TQueueItem = {
+  readonly key: string;
+  readonly uri: string;
+  ts: string;
+  args?: Record<string, unknown>;
+  prio?: number;
+};
+
+export type TQueue = Map<string, TQueueItem>;
+
+export type TQueueStorage = TQueueItem[];