arkiv-cli 0.0.0-stage → 0.1.0

package/dist/arkiv.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Chain access for the CLI: network resolution, a quiet client factory and
+ * helpers that turn block numbers into wall-clock answers.
+ */
+import { type WalletArkivClient } from "@arkiv-network/sdk";
+import { type Chain } from "viem";
+import { type PrivateKeyAccount } from "viem/accounts";
+import type { Entity } from "./render.js";
+export interface NetworkInfo {
+    name: string;
+    chain: Chain;
+    explorer?: string;
+}
+export declare const NETWORKS: Record<string, {
+    explorer?: string;
+}>;
+export declare function networkNames(): string[];
+export interface ClientOptions {
+    network: string;
+    accessKey?: string;
+    rpcUrl?: string;
+}
+/** Build a chain definition, optionally overriding the RPC endpoint. */
+export declare function resolveChain(options: ClientOptions): Chain;
+export declare function explorerUrl(network: string, key?: string): string | null;
+export declare function takeNotice(): string;
+/**
+ * The SDK's own client types are narrower than the client it actually returns:
+ * `where()` is typed as taking an Expression even though a rendered predicate
+ * string works at runtime, and the generic projection types reject dynamic
+ * SELECT lists. Rather than spraying casts through every command, the CLI
+ * declares the surface it uses once, here, and casts at the factory boundary.
+ */
+export interface QueryResultLike {
+    entities: Entity[];
+    blockNumber?: bigint;
+    skipped?: number;
+    count?: bigint;
+}
+export interface QueryBuilderLike {
+    where(expression: string | unknown): QueryBuilderLike;
+    orderBy(term: unknown): QueryBuilderLike;
+    limit(n: number): QueryBuilderLike;
+    offset(n: number): QueryBuilderLike;
+    withCount(): QueryBuilderLike;
+    fetch(): Promise<QueryResultLike>;
+}
+export interface ArkivPublic {
+    select(selection?: Record<string, boolean>): QueryBuilderLike;
+    getEntity(key: `0x${string}`): Promise<unknown>;
+    getBlockTiming(): Promise<unknown>;
+    getBalance(args: {
+        address: `0x${string}`;
+    }): Promise<bigint>;
+    getChainId(): Promise<number>;
+    getBlock(args?: {
+        blockNumber?: bigint;
+    }): Promise<{
+        timestamp?: bigint | number;
+    }>;
+    getGasPrice(): Promise<bigint>;
+}
+export declare function makeClient(options: ClientOptions): ArkivPublic;
+export declare function makeWallet(options: ClientOptions, privateKey: `0x${string}`): {
+    client: WalletArkivClient;
+    account: PrivateKeyAccount;
+    chain: Chain;
+};
+export interface Timing {
+    currentBlock: number;
+    currentBlockTime: number;
+    blockDuration: number;
+}
+export declare function getTiming(client: ArkivPublic): Promise<Timing>;
+export declare function blockToUnix(timing: Timing, block: number): number;
+export declare function unixToBlock(timing: Timing, unixSeconds: number): number;
+export declare function explainError(error: unknown): string;

package/dist/arkiv.js

@@ -0,0 +1,158 @@
+/**
+ * Chain access for the CLI: network resolution, a quiet client factory and
+ * helpers that turn block numbers into wall-clock answers.
+ */
+import { createPublicClient, createWalletClient, } from "@arkiv-network/sdk";
+import * as chains from "@arkiv-network/sdk/chains";
+import { http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { assertSafeRpcUrl } from "./env.js";
+import { safeText } from "./values.js";
+export const NETWORKS = {
+    rabdi: { explorer: "https://rabdi.explorer.arkiv.network" },
+    localhost: {},
+};
+export function networkNames() {
+    return Object.keys(NETWORKS);
+}
+/** Build a chain definition, optionally overriding the RPC endpoint. */
+export function resolveChain(options) {
+    const base = chains[options.network];
+    if (!base) {
+        throw new Error(`unknown network "${options.network}" (available: ${networkNames().join(", ")})`);
+    }
+    const chain = base({ accessKey: options.accessKey ?? "" });
+    if (!options.rpcUrl)
+        return chain;
+    const safe = assertSafeRpcUrl(options.rpcUrl);
+    if (!safe.ok)
+        throw new Error(safe.reason);
+    return {
+        ...chain,
+        rpcUrls: { default: { http: [safe.url] } },
+    };
+}
+/**
+ * The SDK prints a rate-limit notice when no access key is configured. That is
+ * useful advice, but it must not pollute stdout in --json mode, so the notice
+ * is captured here and re-emitted on stderr by the caller once.
+ */
+let capturedNotice = "";
+export function explorerUrl(network, key) {
+    const base = NETWORKS[network]?.explorer;
+    if (!base)
+        return null;
+    return key ? `${base}/entity/${key}` : base;
+}
+export function takeNotice() {
+    const notice = capturedNotice;
+    capturedNotice = "";
+    return notice;
+}
+function quietWarn() {
+    const originals = {
+        log: console.log,
+        warn: console.warn,
+        info: console.info,
+        debug: console.debug,
+    };
+    const capture = (...args) => {
+        const text = args.map(String).join(" ");
+        if (text.includes("heavily rate limited")) {
+            capturedNotice = text.trim();
+            return;
+        }
+        originals.log(...args);
+    };
+    console.log = capture;
+    console.info = capture;
+    console.debug = capture;
+    console.warn = capture;
+    return () => {
+        console.log = originals.log;
+        console.warn = originals.warn;
+        console.info = originals.info;
+        console.debug = originals.debug;
+    };
+}
+export function makeClient(options) {
+    const restore = quietWarn();
+    const chain = resolveChain(options);
+    try {
+        return createPublicClient({ chain, transport: http() });
+    }
+    finally {
+        restore();
+    }
+}
+export function makeWallet(options, privateKey) {
+    const restore = quietWarn();
+    const chain = resolveChain(options);
+    const account = privateKeyToAccount(privateKey);
+    try {
+        const client = createWalletClient({ chain, transport: http(), account });
+        return { client, account, chain };
+    }
+    finally {
+        restore();
+    }
+}
+export async function getTiming(client) {
+    try {
+        const raw = (await client.getBlockTiming());
+        return {
+            currentBlock: Number(raw.currentBlock),
+            currentBlockTime: Number(raw.currentBlockTime),
+            blockDuration: Number(raw.blockDuration) || 2,
+        };
+    }
+    catch {
+        const block = (await client.getBlock());
+        return {
+            currentBlock: Number(block.number ?? 0),
+            currentBlockTime: Number(block.timestamp ?? 0),
+            blockDuration: 2,
+        };
+    }
+}
+export function blockToUnix(timing, block) {
+    if (!Number.isFinite(block) || block <= 0)
+        return 0;
+    return timing.currentBlockTime + (block - timing.currentBlock) * timing.blockDuration;
+}
+export function unixToBlock(timing, unixSeconds) {
+    return (timing.currentBlock +
+        Math.ceil((unixSeconds - timing.currentBlockTime) / timing.blockDuration));
+}
+/* ------------------------------------------------------------------ errors */
+const HINTS = [
+    [
+        /heavily rate limited|rate limit|429|too many requests/i,
+        "The public endpoint is rate limited. Get a free key at https://hub.arkiv.network/access-keys and set ARKIV_ACCESS_KEY.",
+    ],
+    [
+        /missing access key|invalid access key|unauthori[sz]ed|401|403/i,
+        "The access key was rejected. Check ARKIV_ACCESS_KEY, or create a new key at https://hub.arkiv.network/access-keys.",
+    ],
+    [/insufficient funds|insufficient balance|exceeds balance/i, "The signer has no tGLM. Use the Rabdi faucet: https://hub.arkiv.network/faucet."],
+    [
+        /not queryable/i,
+        "That field can be selected but not filtered on. Drop it from the where clause; see `arkiv limits`.",
+    ],
+    [
+        /Query rejected/i,
+        "The query expression was rejected. Check syntax against https://docs.arkiv.network and try `arkiv query \"arkiv.schema = str('name')\"`.",
+    ],
+    [/no entity|not found|NoEntityFound/i, "No entity with that key on this network. Keys are network specific."],
+    [/expired/i, "The entity has expired. Its record no longer exists on chain."],
+    [
+        /ENOTFOUND|ECONNREFUSED|fetch failed|network error/i,
+        "The RPC endpoint is unreachable. Check connectivity and --rpc/--network.",
+    ],
+    [/entity too large|MAX_ENTITY_BYTES/i, "The entity exceeds the size limit. See `arkiv limits`."],
+];
+export function explainError(error) {
+    const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error ?? "unknown error");
+    const hint = HINTS.find(([re]) => re.test(message))?.[1];
+    return hint ? `${safeText(message)}\n  hint: ${hint}` : safeText(message);
+}

package/dist/cli.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * The command surface.
+ *
+ * Every flag is declared, so a typo becomes a usage error instead of a silently
+ * different query. Nothing here prints a credential: values come through
+ * readSecret(), which registers them with the redactor in ui.ts.
+ */
+export declare function main(argv?: string[]): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,343 @@
+#!/usr/bin/env node
+/**
+ * The command surface.
+ *
+ * Every flag is declared, so a typo becomes a usage error instead of a silently
+ * different query. Nothing here prints a credential: values come through
+ * readSecret(), which registers them with the redactor in ui.ts.
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+/*
+ * Node 26 emits an ExperimentalWarning the first time anything touches
+ * localStorage, and the SDK does that while building a client. That warning is
+ * not about this program and it corrupts piped output and --json, so it is
+ * dropped here rather than left for every caller to filter.
+ */
+const emitWarning = process.emitWarning.bind(process);
+process.emitWarning = ((warning, ...rest) => {
+    const text = typeof warning === "string" ? warning : warning?.message ?? "";
+    if (/localstorage/i.test(text))
+        return;
+    return emitWarning(warning, ...rest);
+});
+import { parseArgs, UsageError } from "./args.js";
+import { buildContext } from "./context.js";
+import { setColour, bold, dim, green, out, red, sanitize } from "./ui.js";
+import { networkNames, explainError, takeNotice } from "./arkiv.js";
+import { runDoctor, printDoctor } from "./commands/doctor.js";
+import { runQuery } from "./commands/query.js";
+import { runEntity } from "./commands/entity.js";
+import { runSchemaList, runSchemaDetail, sampleSchemas, renderAtlas } from "./commands/schema.js";
+import { runCost, describeLimits, parseLifetime } from "./commands/cost.js";
+import { runCreate } from "./commands/create.js";
+import { runInit } from "./commands/init.js";
+import { runWatch } from "./commands/watch.js";
+const VERSION = readVersion();
+function readVersion() {
+    try {
+        const raw = readFileSync(new URL("../package.json", import.meta.url), "utf8");
+        return JSON.parse(raw).version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+const HELP = `arkiv - a terminal toolkit for the Arkiv network
+
+  arkiv init [dir]              scaffold a runnable project
+  arkiv doctor                  check node, keys, balance, network and .env safety
+  arkiv query <expression>      run a query
+  arkiv entity <key>            read one entity in full
+  arkiv schema [name]           discover schemas, lint their names, or open one
+  arkiv create                  write one entity
+  arkiv watch <expression>      poll a query and print changes
+  arkiv cost                    size a write before you send it
+  arkiv limits                  protocol limits in one table
+  arkiv help                    this page
+
+Global flags
+  --network <name>   ${networkNames().join(" | ")} (default rabdi)
+  --rpc <url>        override the RPC endpoint
+  --env <path>       use a different .env file
+  --json             machine-readable output where supported
+  --no-colour        plain text
+  --verbose          extra detail
+  -h, --help         help for a command
+  -v, --version      version
+
+Credentials
+  ARKIV_ACCESS_KEY and ARKIV_PRIVATE_KEY are read from .env or the environment.
+  The CLI never generates a wallet and never prints a key.
+
+Examples
+  arkiv doctor
+  arkiv query "arkiv.schema = str('notes/v1')" --limit 5
+  arkiv schema --atlas atlas.html
+  arkiv create --schema notes/v1 --set title=str:Hello --set body=bytes:@./README.md
+  arkiv watch "arkiv.schema = str('notes/v1')" --interval 5
+`;
+const GLOBAL_SPEC = {
+    help: "bool",
+    version: "bool",
+    network: "string",
+    rpc: "string",
+    env: "string",
+    json: "bool",
+    colour: "bool",
+    "no-colour": "bool",
+    verbose: "bool",
+    quiet: "bool",
+};
+function exitCode() {
+    return typeof process.exitCode === "number" ? process.exitCode : 0;
+}
+function strFlag(flags, name) {
+    const value = flags[name];
+    return typeof value === "string" ? value : undefined;
+}
+function numFlag(flags, name, fallback) {
+    const value = flags[name];
+    return typeof value === "number" ? value : fallback;
+}
+function boolFlag(flags, name) {
+    return flags[name] === true;
+}
+function listFlag(flags, name) {
+    const value = flags[name];
+    if (value === undefined)
+        return [];
+    return Array.isArray(value) ? value.map(String) : [String(value)];
+}
+function globals(flags) {
+    const noColour = boolFlag(flags, "no-colour");
+    return {
+        json: boolFlag(flags, "json"),
+        colour: !noColour,
+        network: strFlag(flags, "network"),
+        rpc: strFlag(flags, "rpc"),
+        env: strFlag(flags, "env"),
+        verbose: boolFlag(flags, "verbose"),
+    };
+}
+export async function main(argv = process.argv.slice(2)) {
+    if (argv.length === 0 || argv[0] === "help" || argv[0] === "--help" || argv[0] === "-h") {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    if (argv[0] === "--version" || argv[0] === "-v" || argv[0] === "version") {
+        process.stdout.write(`arkiv ${VERSION}\n`);
+        return 0;
+    }
+    const command = argv[0];
+    const rest = argv.slice(1);
+    try {
+        switch (command) {
+            case "init": {
+                const parsed = parseArgs(rest, { ...GLOBAL_SPEC, force: "bool", install: "bool" }, { f: "force" });
+                setColour(globals(parsed.flags).colour);
+                if (boolFlag(parsed.flags, "help")) {
+                    process.stdout.write("arkiv init [dir]\n\n  scaffold a project that connects, writes and reads\n\n  --force    write into an existing directory (never overwrites files)\n  --install  run npm install afterwards\n");
+                    return 0;
+                }
+                await runInit({
+                    directory: parsed.positionals[0] ?? ".",
+                    force: boolFlag(parsed.flags, "force"),
+                    install: boolFlag(parsed.flags, "install"),
+                });
+                return exitCode();
+            }
+            case "doctor": {
+                const parsed = parseArgs(rest, GLOBAL_SPEC, {});
+                const g = globals(parsed.flags);
+                setColour(g.colour);
+                if (boolFlag(parsed.flags, "help")) {
+                    process.stdout.write("arkiv doctor\n\n  checks node, .env permissions, key formats, balance, clock and RPC\n");
+                    return 0;
+                }
+                const result = await runDoctor(buildContext(g));
+                printDoctor(result.checks, g.json === true);
+                return result.ok ? 0 : 1;
+            }
+            case "query": {
+                const parsed = parseArgs(rest, {
+                    ...GLOBAL_SPEC,
+                    schema: "string",
+                    limit: "number",
+                    offset: "number",
+                    sort: "string",
+                    type: "string",
+                    desc: "bool",
+                    asc: "bool",
+                    count: "bool",
+                    key: "bool",
+                    select: "string",
+                }, { n: "limit", s: "schema", j: "json", q: "quiet" });
+                const g = globals(parsed.flags);
+                setColour(g.colour);
+                if (boolFlag(parsed.flags, "help")) {
+                    process.stdout.write("arkiv query <expression>\n\n  --schema <name>   add arkiv.schema = str(name)\n  --limit <n>       rows per page (max 100, default 10)\n  --offset <n>      skip rows\n  --sort <field>    order by a queryable attribute\n  --type <t>        value type for the sort field\n  --desc            descending\n  --count           count matches instead of listing\n  --key             print keys only\n  --select a,b      project specific attributes\n");
+                    return 0;
+                }
+                const select = strFlag(parsed.flags, "select");
+                await runQuery(buildContext(g), {
+                    expression: parsed.positionals[0],
+                    schema: strFlag(parsed.flags, "schema"),
+                    limit: numFlag(parsed.flags, "limit", 10),
+                    offset: numFlag(parsed.flags, "offset", 0),
+                    countOnly: boolFlag(parsed.flags, "count"),
+                    showKey: boolFlag(parsed.flags, "key"),
+                    sort: strFlag(parsed.flags, "sort"),
+                    sortType: strFlag(parsed.flags, "type"),
+                    descending: boolFlag(parsed.flags, "desc"),
+                    select: select ? select.split(",").map((s) => s.trim()) : undefined,
+                });
+                return exitCode();
+            }
+            case "entity": {
+                const parsed = parseArgs(rest, GLOBAL_SPEC, { j: "json" });
+                const g = globals(parsed.flags);
+                setColour(g.colour);
+                if (boolFlag(parsed.flags, "help") || parsed.positionals.length === 0) {
+                    process.stdout.write("arkiv entity <key>\n\n  read one entity, including its attributes and expiry\n");
+                    return boolFlag(parsed.flags, "help") ? 0 : 2;
+                }
+                await runEntity(buildContext(g), parsed.positionals[0]);
+                return exitCode();
+            }
+            case "schema": {
+                const parsed = parseArgs(rest, { ...GLOBAL_SPEC, sample: "number", atlas: "string", min: "number" }, { n: "sample", j: "json" });
+                const g = globals(parsed.flags);
+                setColour(g.colour);
+                if (boolFlag(parsed.flags, "help")) {
+                    process.stdout.write("arkiv schema [name]\n\n  list   every schema found in a live sample, with lint findings\n  name   one schema: fields, types, expiry, findings\n\n  --sample <n>   entities to sample (default 300, max 1000)\n  --atlas <file> write a shareable HTML atlas\n  --min <n>      hide schemas with fewer than n entities\n");
+                    return 0;
+                }
+                const ctx = buildContext(g);
+                const atlas = strFlag(parsed.flags, "atlas");
+                const sample = numFlag(parsed.flags, "sample", atlas ? 1000 : 300);
+                const name = parsed.positionals[0];
+                if (name) {
+                    await runSchemaDetail(ctx, name);
+                    return exitCode();
+                }
+                if (atlas) {
+                    const { schemas, scanned, block } = await sampleSchemas(ctx, { sample });
+                    writeFileSync(atlas, renderAtlas(schemas, { scanned, block, network: ctx.network }));
+                    out(green(`wrote ${atlas}`));
+                    out(dim(`${schemas.size} schemas from ${scanned} sampled entities at block ${block.toLocaleString("en-US")}`));
+                    return 0;
+                }
+                await runSchemaList(ctx, { sample });
+                return exitCode();
+            }
+            case "create": {
+                const parsed = parseArgs(rest, {
+                    ...GLOBAL_SPEC,
+                    schema: "string",
+                    set: "string",
+                    index: "string",
+                    expires: "string",
+                    "dry-run": "bool",
+                    yes: "bool",
+                }, { s: "schema", j: "json" });
+                const g = globals(parsed.flags);
+                setColour(g.colour);
+                if (boolFlag(parsed.flags, "help")) {
+                    process.stdout.write("arkiv create --schema <name> --set name=type:value [...]\n\n  types   str bytes u64 i32 u256 bool addr key dec\n  bytes   @./file, ./file or 0x hex\n  --index <name>  mark an attribute indexed (repeatable)\n  --expires <30d> lifetime, default 30d\n  --dry-run       print the plan, sign nothing\n");
+                    return 0;
+                }
+                const schema = strFlag(parsed.flags, "schema");
+                if (!schema)
+                    throw new UsageError("create needs --schema <name>");
+                const sets = listFlag(parsed.flags, "set");
+                if (sets.length === 0)
+                    throw new UsageError("create needs at least one --set name=type:value");
+                await runCreate(buildContext(g), {
+                    schema,
+                    sets,
+                    indexed: listFlag(parsed.flags, "index"),
+                    expires: strFlag(parsed.flags, "expires"),
+                    dryRun: boolFlag(parsed.flags, "dry-run"),
+                });
+                return exitCode();
+            }
+            case "cost": {
+                const parsed = parseArgs(rest, { ...GLOBAL_SPEC, bytes: "number", file: "string", attributes: "number", expires: "string", avg: "number" }, { j: "json" });
+                const g = globals(parsed.flags);
+                setColour(g.colour);
+                if (boolFlag(parsed.flags, "help")) {
+                    process.stdout.write("arkiv cost [--file path] [--bytes n] [--attributes n] [--expires 30d]\n\n  sizes a write against the protocol limits and reads the live gas price\n");
+                    return 0;
+                }
+                let lifetimeDays = 30;
+                try {
+                    lifetimeDays = parseLifetime(strFlag(parsed.flags, "expires"), 30);
+                }
+                catch (error) {
+                    throw new UsageError(error.message);
+                }
+                await runCost(buildContext(g), {
+                    attributes: numFlag(parsed.flags, "attributes", 3),
+                    bytes: numFlag(parsed.flags, "bytes", 0),
+                    file: strFlag(parsed.flags, "file"),
+                    lifetimeDays,
+                    averageAttributeBytes: numFlag(parsed.flags, "avg", 32),
+                });
+                return exitCode();
+            }
+            case "limits": {
+                const parsed = parseArgs(rest, GLOBAL_SPEC, {});
+                setColour(globals(parsed.flags).colour);
+                out(bold("protocol limits"));
+                out(describeLimits());
+                return 0;
+            }
+            case "watch": {
+                const parsed = parseArgs(rest, { ...GLOBAL_SPEC, limit: "number", interval: "number", once: "bool" }, { n: "limit" });
+                const g = globals(parsed.flags);
+                setColour(g.colour);
+                if (boolFlag(parsed.flags, "help") || parsed.positionals.length === 0) {
+                    process.stdout.write("arkiv watch <expression>\n\n  --limit <n>     window size (default 200, max 1000)\n  --interval <s>  seconds between polls (default 5)\n  --once          print the current window and exit\n");
+                    return boolFlag(parsed.flags, "help") ? 0 : 2;
+                }
+                await runWatch(buildContext(g), {
+                    expression: parsed.positionals[0],
+                    limit: numFlag(parsed.flags, "limit", 200),
+                    intervalSeconds: numFlag(parsed.flags, "interval", 5),
+                    once: boolFlag(parsed.flags, "once"),
+                });
+                return exitCode();
+            }
+            default: {
+                process.stderr.write(`${red(`unknown command: ${command}`)}\n`);
+                process.stderr.write(HELP);
+                return 2;
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof UsageError) {
+            process.stderr.write(`${red("usage")}: ${error.message}\n`);
+            return 2;
+        }
+        process.stderr.write(`${red("error")}: ${explainError(error)}\n`);
+        return 1;
+    }
+    finally {
+        const notice = takeNotice();
+        if (notice)
+            process.stderr.write(`${dim(sanitize(notice))}\n`);
+    }
+}
+const isEntry = process.argv[1] !== undefined &&
+    (import.meta.url === `file://${process.argv[1]}` || import.meta.url.endsWith("/dist/cli.js"));
+if (isEntry) {
+    main()
+        .then((code) => {
+        process.exitCode = code;
+    })
+        .catch((error) => {
+        process.stderr.write(`${red("fatal")}: ${error.message}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/commands/cost.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `arkiv cost` - the pre-flight sizing check.
+ *
+ * Arkiv charges for storage at write time and the exact fee is whatever the
+ * create transaction consumes, so this command does not invent a price. What it
+ * does is the part people get wrong: work out how many bytes and blocks a write
+ * really needs, whether it fits the protocol limits, how many creates that takes,
+ * and what the chain is charging for gas right now.
+ */
+import type { Context } from "../context.js";
+export interface CostOptions {
+    attributes: number;
+    bytes: number;
+    file?: string;
+    lifetimeDays: number;
+    averageAttributeBytes: number;
+}
+export declare function parseLifetime(input: string | undefined, fallbackDays: number): number;
+export declare function runCost(ctx: Context, options: CostOptions): Promise<void>;
+export declare function formatBytes(bytes: number): string;
+export declare function describeLimits(): string;
+export declare function limitSummary(): string;