@certik/skynet 0.25.0 → 0.25.2

package/dist/dynamodb.js

@@ -0,0 +1,479 @@
+// src/object-hash.ts
+import xh from "@node-rs/xxhash";
+function getHash(obj) {
+  const xxh3 = xh.xxh3.Xxh3.withSeed();
+  hash(obj, xxh3);
+  return xxh3.digest().toString(16);
+}
+function hash(obj, xxh3) {
+  if (obj === null) {
+    xxh3.update("null");
+  } else if (obj === undefined) {
+    xxh3.update("undefined");
+  } else if (typeof obj === "string") {
+    xxh3.update(obj);
+  } else if (typeof obj === "number") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "boolean") {
+    xxh3.update(obj.toString());
+  } else if (typeof obj === "bigint") {
+    xxh3.update(obj.toString());
+  } else if (obj instanceof Date) {
+    xxh3.update(obj.toISOString());
+  } else if (Array.isArray(obj)) {
+    arrayHash(obj, xxh3);
+  } else if (obj instanceof Set) {
+    setHash(obj, xxh3);
+  } else if (obj instanceof Map) {
+    mapHash(obj, xxh3);
+  } else if (typeof obj === "object") {
+    objectHash(obj, xxh3);
+  } else {
+    throw new Error(`Unsupported type: ${obj}`);
+  }
+}
+function arrayHash(array, xxh3) {
+  xxh3.update("[");
+  for (const obj of array) {
+    hash(obj, xxh3);
+  }
+  xxh3.update("]");
+}
+function setHash(_set, _xxh3) {
+  throw new Error("Set hashing not implemented");
+}
+function mapHash(map, xxh3) {
+  const array = Array.from(map.entries()).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
+}
+function objectHash(obj, xxh3) {
+  const array = Object.entries(obj).sort(([aKey], [bKey]) => aKey.localeCompare(bKey));
+  for (const [key, value] of array) {
+    hash(key, xxh3);
+    hash(value, xxh3);
+  }
+}
+
+// src/availability.ts
+import pThrottle from "p-throttle";
+import pMemoize from "p-memoize";
+import QuickLRU from "quick-lru";
+async function wait(time) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, time);
+  });
+}
+async function exponentialRetry(func, {
+  maxRetry,
+  initialDuration,
+  growFactor,
+  test,
+  verbose
+}) {
+  let retries = maxRetry;
+  let duration = initialDuration || 5000;
+  const growFactorFinal = growFactor || 2;
+  let result = await func();
+  while (!test(result) && retries > 0) {
+    if (verbose) {
+      console.log("failed attempt result", result);
+      console.log(`sleep for ${duration}ms after failed attempt, remaining ${retries} attempts`);
+    }
+    retries = retries - 1;
+    await wait(duration);
+    result = await func();
+    duration = duration * growFactorFinal;
+  }
+  if (verbose) {
+    console.log(`function to retry ends with status ${test(result)}, number of retries done: ${maxRetry - retries}}`);
+  }
+  return result;
+}
+function withRetry(func, options) {
+  let retries = options?.maxRetry || 3;
+  let duration = options?.initialDuration || 500;
+  const growFactorFinal = options?.growFactor || 2;
+  return async (...args) => {
+    do {
+      try {
+        return await func(...args);
+      } catch (error) {
+        retries = retries - 1;
+        if (retries <= 0) {
+          throw error;
+        }
+        await wait(duration);
+        duration = duration * growFactorFinal;
+      }
+    } while (retries > 0);
+    throw new Error("unreachable");
+  };
+}
+function memoize(func, options) {
+  if (!options) {
+    options = {};
+  }
+  if (!options.cache) {
+    options.cache = new QuickLRU({ maxSize: options.lruMaxSize || 1e4 });
+  }
+  if (!options.cacheKey) {
+    options.cacheKey = (args) => getHash(args);
+  }
+  return pMemoize(func, options);
+}
+// src/util.ts
+function range(startAt, endAt, step) {
+  const arr = [];
+  for (let i = startAt;i <= endAt; i += step) {
+    arr.push([i, Math.min(endAt, i + step - 1)]);
+  }
+  return arr;
+}
+function arrayGroup(array, groupSize) {
+  const groups = [];
+  for (let i = 0;i < array.length; i += groupSize) {
+    groups.push(array.slice(i, i + groupSize));
+  }
+  return groups;
+}
+function fillRange(start, end) {
+  const result = [];
+  for (let i = start;i <= end; i++) {
+    result.push(i);
+  }
+  return result;
+}
+// src/dynamodb.ts
+import {
+  DynamoDBDocumentClient,
+  ScanCommand,
+  BatchWriteCommand,
+  GetCommand,
+  PutCommand,
+  QueryCommand,
+  UpdateCommand
+} from "@aws-sdk/lib-dynamodb";
+import { DynamoDBClient, DescribeTableCommand } from "@aws-sdk/client-dynamodb";
+var _dynamoDB;
+var _docClient;
+function getDynamoDB(forceNew = false) {
+  if (!_dynamoDB || forceNew) {
+    _dynamoDB = new DynamoDBClient;
+  }
+  return _dynamoDB;
+}
+function getDocClient(forceNew = false) {
+  const marshallOptions = {
+    convertEmptyValues: true,
+    removeUndefinedValues: true,
+    convertClassInstanceToMap: true
+  };
+  const unmarshallOptions = {
+    wrapNumbers: false
+  };
+  if (!_docClient || forceNew) {
+    _docClient = DynamoDBDocumentClient.from(getDynamoDB(), {
+      marshallOptions,
+      unmarshallOptions
+    });
+  }
+  return _docClient;
+}
+async function scanWholeTable(options) {
+  const dynamodb = getDocClient();
+  let items = [];
+  let count = 0;
+  let scannedCount = 0;
+  let data = await dynamodb.send(new ScanCommand(options));
+  while (data.LastEvaluatedKey) {
+    if (data.Items) {
+      items = items.concat(data.Items);
+    }
+    count += data.Count || 0;
+    scannedCount += data.ScannedCount || 0;
+    data = await dynamodb.send(new ScanCommand({ ...options, ExclusiveStartKey: data.LastEvaluatedKey }));
+  }
+  if (data.Items) {
+    items = items.concat(data.Items);
+  }
+  count += data.Count || 0;
+  scannedCount += data.ScannedCount || 0;
+  return {
+    Items: items,
+    Count: count,
+    ScannedCount: scannedCount
+  };
+}
+async function batchCreateRecords(tableName, records, maxWritingCapacity, verbose = false) {
+  if (verbose) {
+    console.log(`creating ${records.length} items in ${tableName}`);
+  }
+  const docClient = getDocClient();
+  let remainingItems = records;
+  let prevRemainingCount = remainingItems.length + 1;
+  let factor = 1;
+  let rejection = undefined;
+  while (remainingItems.length > 0 && factor <= 128 && !rejection) {
+    if (prevRemainingCount === remainingItems.length) {
+      await wait(5000 * factor);
+      factor = factor * 2;
+    }
+    if (factor >= 32) {
+      console.log(`WARNING: no progress for a long time for batchCreateRecords, please check`);
+    }
+    const slices = arrayGroup(remainingItems.slice(0, maxWritingCapacity), 25);
+    const results = await Promise.allSettled(slices.map((rs) => docClient.send(new BatchWriteCommand({
+      RequestItems: {
+        [tableName]: rs.map((record) => ({ PutRequest: { Item: record } }))
+      }
+    }))));
+    const isFulfilled = (p) => p.status === "fulfilled";
+    const isRejected = (p) => p.status === "rejected";
+    prevRemainingCount = remainingItems.length;
+    remainingItems = remainingItems.slice(maxWritingCapacity);
+    results.forEach((rs, idx) => {
+      if (isRejected(rs)) {
+        remainingItems = remainingItems.concat(slices[idx]);
+        rejection = rs;
+      } else if (isFulfilled(rs) && rs.value.UnprocessedItems && Object.keys(rs.value.UnprocessedItems).length > 0) {
+        const unprocessedItems = rs.value.UnprocessedItems[tableName].map((it) => it.PutRequest?.Item ?? []).flat();
+        remainingItems = remainingItems.concat(unprocessedItems);
+      }
+    });
+    if (verbose) {
+      console.log(`processed=${prevRemainingCount - remainingItems.length}, remaining=${remainingItems.length}`);
+    }
+  }
+  if (rejection) {
+    console.log("batchCreateRecords rejected", rejection);
+    throw new Error(`batchCreateRecords rejected, failed items=${remainingItems.length}`);
+  }
+  if (remainingItems.length > 0) {
+    console.log(`failed batchCreateRecords, failed items=${remainingItems.length}`);
+    throw new Error(`batchCreateRecords retry failed, failed items=${remainingItems.length}`);
+  }
+}
+async function createRecord(tableName, fields, verbose = false) {
+  if (verbose) {
+    console.log("creating", tableName, fields);
+  }
+  const docClient = getDocClient();
+  const params = {
+    TableName: tableName,
+    Item: fields
+  };
+  return docClient.send(new PutCommand(params));
+}
+async function readRecord(tableName, key, verbose = false) {
+  if (verbose) {
+    console.log("reading", tableName, key);
+  }
+  const docClient = getDocClient();
+  const record = await docClient.send(new GetCommand({
+    TableName: tableName,
+    Key: key
+  }));
+  return record.Item;
+}
+async function getRecordsByKey(tableName, keys, indexName) {
+  const docClient = getDocClient();
+  const keyNames = Object.keys(keys);
+  const conditionExpression = keyNames.map((key) => `#${key} = :${key}`).join(" and ");
+  const params = {
+    TableName: tableName,
+    KeyConditionExpression: conditionExpression,
+    ExpressionAttributeNames: generateExpressionNames(keyNames),
+    ExpressionAttributeValues: generateExpressionValues(keyNames, keys)
+  };
+  if (indexName) {
+    params.IndexName = indexName;
+  }
+  try {
+    let data = await docClient.send(new QueryCommand(params));
+    let items = data.Items ?? [];
+    while (data.LastEvaluatedKey) {
+      data = await docClient.send(new QueryCommand({
+        ...params,
+        ExclusiveStartKey: data.LastEvaluatedKey
+      }));
+      if (data.Items) {
+        items = items.concat(data.Items);
+      }
+    }
+    return items;
+  } catch (err) {
+    console.log(err);
+    if (err instanceof Error && "statusCode" in err && err.statusCode === 400) {
+      return null;
+    }
+    throw err;
+  }
+}
+async function getRecordByKey(tableName, keys, indexName) {
+  if (indexName) {
+    const records = await getRecordsByKey(tableName, keys, indexName);
+    if (records) {
+      return records[0];
+    } else {
+      return null;
+    }
+  } else {
+    return readRecord(tableName, keys);
+  }
+}
+function generateExpressionNames(keys) {
+  return keys.reduce((acc, key) => ({ ...acc, [`#${key}`]: key }), {});
+}
+function generateExpressionValues(keys, fields) {
+  return keys.reduce((acc, key) => ({ ...acc, [`:${key}`]: fields[key] }), {});
+}
+async function updateRecordByKey(tableName, idKey, fields, conditionExpressions = null, verbose = false) {
+  if (verbose) {
+    console.log("update", tableName, idKey, fields);
+  }
+  const docClient = getDocClient();
+  const idKeyNames = Object.keys(idKey);
+  const fieldsToDelete = Object.keys(fields).filter((f) => fields[f] === undefined);
+  const fieldsToUpdate = Object.keys(fields).filter((k) => !idKeyNames.includes(k) && !fieldsToDelete.includes(k));
+  let data;
+  if (fieldsToDelete.length > 0) {
+    if (verbose) {
+      console.log("delete fields", tableName, fieldsToDelete);
+    }
+    const deleteParams = {
+      TableName: tableName,
+      Key: idKey,
+      ExpressionAttributeNames: generateExpressionNames(fieldsToDelete),
+      UpdateExpression: `REMOVE ${fieldsToDelete.map((f) => `#${f}`).join(", ")}`,
+      ReturnValues: "ALL_NEW"
+    };
+    if (conditionExpressions) {
+      deleteParams.ConditionExpression = conditionExpressions;
+    }
+    data = await docClient.send(new UpdateCommand(deleteParams));
+  }
+  if (fieldsToUpdate.length > 0) {
+    if (verbose) {
+      console.log("update fields", tableName, fieldsToUpdate);
+    }
+    const updateExpressions = fieldsToUpdate.map((key) => `#${key} = :${key}`);
+    const params = {
+      TableName: tableName,
+      Key: idKey,
+      ExpressionAttributeNames: generateExpressionNames(fieldsToUpdate),
+      ExpressionAttributeValues: generateExpressionValues(fieldsToUpdate, fields),
+      UpdateExpression: `SET ${updateExpressions.join(", ")}`,
+      ReturnValues: "ALL_NEW"
+    };
+    if (conditionExpressions) {
+      params.ConditionExpression = conditionExpressions;
+    }
+    data = await docClient.send(new UpdateCommand(params));
+  }
+  return data?.Attributes;
+}
+async function batchDeleteRecords(tableName, keys) {
+  const docClient = getDocClient();
+  for (let start = 0;start < keys.length; start += 25) {
+    const slice = keys.slice(start, start + 25);
+    await docClient.send(new BatchWriteCommand({
+      RequestItems: {
+        [tableName]: slice.map((key) => {
+          return { DeleteRequest: { Key: key } };
+        })
+      }
+    }));
+  }
+}
+function getKeyName(keySchema, type) {
+  const key = keySchema.find((k) => k.KeyType === type);
+  return key?.AttributeName;
+}
+function getIndexKeyName(globalSecondaryIndexes, indexName, type) {
+  const idx = globalSecondaryIndexes.find((i) => i.IndexName === indexName);
+  return idx?.KeySchema && getKeyName(idx.KeySchema, type);
+}
+async function deleteRecordsByHashKey(tableName, indexName, hashKeyValue, verbose = false) {
+  const docClient = getDocClient();
+  const meta = await getDynamoDB().send(new DescribeTableCommand({ TableName: tableName }));
+  if (!meta.Table) {
+    throw new Error(`cannot find table ${tableName}`);
+  }
+  if (indexName && !meta.Table.GlobalSecondaryIndexes) {
+    throw new Error(`cannot find global secondary indexes for table ${tableName}`);
+  }
+  if (!meta.Table.KeySchema) {
+    throw new Error(`cannot find key schema for table ${tableName}`);
+  }
+  const hashKeyName = indexName ? getIndexKeyName(meta.Table.GlobalSecondaryIndexes, indexName, "HASH") : getKeyName(meta.Table.KeySchema, "HASH");
+  if (!hashKeyName) {
+    throw new Error(`cannot find hash key name for table ${tableName}`);
+  }
+  const mainHashKeyName = getKeyName(meta.Table.KeySchema, "HASH");
+  if (!mainHashKeyName) {
+    throw new Error(`cannot find main hash key name for table ${tableName}`);
+  }
+  const mainRangeKeyName = getKeyName(meta.Table.KeySchema, "RANGE");
+  if (!mainRangeKeyName) {
+    throw new Error(`cannot find main range key name for table ${tableName}`);
+  }
+  let totalDeleted = 0;
+  const params = {
+    TableName: tableName,
+    KeyConditionExpression: "#hashKeyName = :hashKeyValue",
+    ExpressionAttributeNames: { "#hashKeyName": hashKeyName },
+    ExpressionAttributeValues: { ":hashKeyValue": hashKeyValue }
+  };
+  if (indexName) {
+    params.IndexName = indexName;
+  }
+  let data = await docClient.send(new QueryCommand(params));
+  if (data.Items) {
+    await batchDeleteRecords(tableName, data.Items.map((item) => mainRangeKeyName ? {
+      [mainHashKeyName]: item[mainHashKeyName],
+      [mainRangeKeyName]: item[mainRangeKeyName]
+    } : {
+      [mainHashKeyName]: item[mainHashKeyName]
+    }));
+    totalDeleted += data.Items.length;
+  }
+  while (data.LastEvaluatedKey) {
+    data = await docClient.send(new QueryCommand({
+      ...params,
+      ExclusiveStartKey: data.LastEvaluatedKey
+    }));
+    if (data.Items) {
+      await batchDeleteRecords(tableName, data.Items.map((item) => mainRangeKeyName ? {
+        [mainHashKeyName]: item[mainHashKeyName],
+        [mainRangeKeyName]: item[mainRangeKeyName]
+      } : {
+        [mainHashKeyName]: item[mainHashKeyName]
+      }));
+      totalDeleted += data.Items.length;
+    }
+  }
+  if (verbose) {
+    console.log(`successfully delete ${totalDeleted} items`);
+  }
+  return totalDeleted;
+}
+export {
+  updateRecordByKey,
+  scanWholeTable,
+  getRecordsByKey,
+  getRecordByKey,
+  getDocClient,
+  deleteRecordsByHashKey,
+  createRecord,
+  batchDeleteRecords,
+  batchCreateRecords,
+  UpdateCommand,
+  ScanCommand,
+  QueryCommand,
+  PutCommand,
+  GetCommand,
+  BatchWriteCommand
+};

package/dist/env.d.ts

@@ -0,0 +1,6 @@
+declare function ensureAndGet(envName: string, defaultValue?: string): string | undefined;
+declare function getEnvironment(): string | undefined;
+declare function getEnvOrThrow(envName: string): string;
+declare function isProduction(): boolean;
+declare function isDev(): boolean;
+export { ensureAndGet, getEnvOrThrow, getEnvironment, isProduction, isDev };

package/dist/env.js

@@ -0,0 +1,26 @@
+// src/env.ts
+function ensureAndGet(envName, defaultValue) {
+  return process.env[envName] || defaultValue;
+}
+function getEnvironment() {
+  return ensureAndGet("SKYNET_ENVIRONMENT", "dev");
+}
+function getEnvOrThrow(envName) {
+  if (!process.env[envName]) {
+    throw new Error(`Must set environment variable ${envName}`);
+  }
+  return process.env[envName];
+}
+function isProduction() {
+  return getEnvironment() === "prd";
+}
+function isDev() {
+  return getEnvironment() === "dev";
+}
+export {
+  isProduction,
+  isDev,
+  getEnvironment,
+  getEnvOrThrow,
+  ensureAndGet
+};

package/dist/goalert.d.ts

@@ -0,0 +1,19 @@
+export type GoAlertAction = "close";
+export interface GoAlertGenericIncomingRequest {
+    /** Short description of the alert sent as SMS and voice. */
+    summary: string;
+    /** Additional information about the alert, supports markdown. */
+    details?: string;
+    /** If set to `close`, it will close any matching alerts. */
+    action?: GoAlertAction;
+    /** All calls for the same service with the same `dedup` string will update the same alert (if open) or create a new one. Defaults to using summary & details together. */
+    dedup?: string;
+}
+export interface GoAlertSendOptions {
+    url?: string;
+}
+export interface GoAlertSendResult {
+    ok: boolean;
+    status: number;
+}
+export declare function sendGoAlertAlert(body: GoAlertGenericIncomingRequest, options?: GoAlertSendOptions): Promise<GoAlertSendResult>;

package/dist/goalert.js

@@ -0,0 +1,43 @@
+// src/goalert.ts
+function getGoAlertUrl(url) {
+  return url || process.env["SKYNET_GOALERT_URL"];
+}
+async function sendGoAlertAlert(body, options = {}) {
+  if (!body?.summary) {
+    throw new Error("missing GoAlert summary");
+  }
+  const url = getGoAlertUrl(options.url);
+  if (!url) {
+    throw new Error("missing SKYNET_GOALERT_URL");
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  let parsed = undefined;
+  const contentType = response.headers.get("content-type") || "";
+  try {
+    if (contentType.includes("application/json")) {
+      parsed = await response.json();
+    } else {
+      const text = await response.text();
+      parsed = text.length ? text : undefined;
+    }
+  } catch {
+    parsed = undefined;
+  }
+  if (!response.ok) {
+    const extra = typeof parsed === "string" && parsed ? `: ${parsed}` : "";
+    throw new Error(`GoAlert API error ${response.status}${extra}`);
+  }
+  return {
+    ok: response.ok,
+    status: response.status
+  };
+}
+export {
+  sendGoAlertAlert
+};

package/dist/graphql.d.ts

@@ -0,0 +1,6 @@
+type GraphqlVariables = {
+    [key: string]: unknown;
+};
+type GraphQLVersion = "v1" | "v2";
+export declare function gql<T>(query: string, variables?: GraphqlVariables, version?: GraphQLVersion): Promise<T>;
+export {};

package/dist/graphql.js

@@ -0,0 +1,35 @@
+// src/graphql.ts
+async function gql(query, variables = {}, version = "v1") {
+  if (!["v1", "v2"].includes(version)) {
+    throw new Error(`Invalid GraphQL version: ${version}`);
+  }
+  let endpoint = process.env["SKYNET_GRAPHQL_ENDPOINT"];
+  let apiKey = process.env["SKYNET_GRAPHQL_API_KEY"];
+  if (version === "v2") {
+    endpoint = process.env["SKYNET_GRAPHQL_ENDPOINT_V2"];
+    apiKey = process.env["SKYNET_GRAPHQL_API_KEY_V2"];
+  }
+  if (!endpoint || !apiKey) {
+    throw new Error(`Missing GraphQL ${version} endpoint or API key`);
+  }
+  const res = await fetch(endpoint, {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({ query: query.trim(), variables })
+  });
+  if (res.ok) {
+    const { data, errors } = await res.json();
+    if (errors && errors.length > 0) {
+      throw new Error(JSON.stringify(errors, null, 2));
+    }
+    return data;
+  } else {
+    throw new Error(await res.text());
+  }
+}
+export {
+  gql
+};

package/dist/indexer.d.ts

@@ -0,0 +1,69 @@
+import type { SelectorFlags, Selector } from "./selector";
+type IndexerStateValue = string | number;
+type StatelessIndexerFlags<TSelector extends Selector> = SelectorFlags<TSelector & {
+    verbose: {
+        type: "boolean";
+        default: false;
+    };
+}>;
+type StatelessBuildFunction<TSelector extends Selector> = ({ verbose, ...selectorFlags }: StatelessIndexerFlags<TSelector>) => Promise<void> | void;
+type ModeIndexerFlags<TSelector extends Selector> = SelectorFlags<TSelector & {
+    verbose: {
+        type: "boolean";
+        default: false;
+    };
+    mode: {
+        type: "string";
+        default: "delta";
+    };
+    from: {
+        aliases: ["since"];
+        type: "string";
+    };
+    to: {
+        aliases: ["until"];
+        type: "string";
+    };
+    status: {
+        type: "boolean";
+        default: false;
+    };
+}>;
+type ModeBuildFunction<T extends IndexerStateValue, TSelector extends Selector> = ({ from, to, verbose, ...selectorFlags }: {
+    from: T;
+    to: T;
+    verbose: boolean;
+} & ModeIndexerFlags<TSelector>) => Promise<void | T[]> | void | T[];
+type ValidateFunction<TSelector extends Selector> = ({ from, to, verbose, ...selectorFlags }: ModeIndexerFlags<TSelector>) => Promise<void> | void;
+type State<T extends IndexerStateValue, TSelector extends Selector> = {
+    type: string;
+    updateInterval?: () => number;
+    getMinId: (selectorFlags: ModeIndexerFlags<TSelector>) => Promise<T>;
+    getMaxId: (selectorFlags: ModeIndexerFlags<TSelector>) => Promise<T>;
+};
+declare function increaseId<T extends IndexerStateValue = IndexerStateValue>(type: string, currentId: T, n: number): T;
+declare function createModeIndexerApp<T extends IndexerStateValue, TSelector extends Selector>({ binaryName, name, selector, build, buildBatchSize, buildConcurrency, validate, validateBatchSize, validateConcurrency, maxRetry, state, }: {
+    binaryName: string;
+    name: string;
+    selector: TSelector;
+    build: ModeBuildFunction<T, TSelector>;
+    maxRetry?: number;
+    buildBatchSize?: number;
+    buildConcurrency?: number;
+    validate?: ValidateFunction<TSelector>;
+    validateBatchSize?: number;
+    validateConcurrency?: number;
+    state: State<T, TSelector>;
+}): {
+    run: () => Promise<void>;
+};
+declare function createIndexerApp<TSelector extends Selector>({ binaryName, selector, build, maxRetry, }: {
+    binaryName: string;
+    selector?: TSelector;
+    build: StatelessBuildFunction<TSelector>;
+    maxRetry?: number;
+}): {
+    run: () => Promise<void>;
+};
+export { increaseId, createModeIndexerApp, createIndexerApp };
+export type { IndexerStateValue, State, StatelessBuildFunction, ModeBuildFunction, ValidateFunction };