@pungoyal/kite-cli 0.1.0

package/dist/core/session.js

@@ -0,0 +1,102 @@
+import { chmod, readFile, unlink, writeFile } from 'node:fs/promises';
+import { z } from 'zod';
+import { configDir, ensurePrivateDir, sessionFile } from './paths.js';
+/**
+ * Non-secret session metadata.
+ *
+ * The access token itself lives in the OS keyring; only its expiry and the
+ * identity it belongs to are stored here. That split lets `kite whoami` show
+ * who you are and when your session dies without unlocking the keyring, and
+ * lets `kite logout` drop the token without touching the API secret.
+ */
+export const SessionMetaSchema = z.object({
+    userId: z.string(),
+    userName: z.string().optional(),
+    broker: z.string().optional(),
+    env: z.string(),
+    apiKey: z.string(),
+    /** ISO 8601. Kite invalidates all tokens at 06:00 IST daily. */
+    expiresAt: z.string(),
+    loginTime: z.string().optional(),
+    exchanges: z.array(z.string()).default([]),
+    products: z.array(z.string()).default([]),
+});
+export async function loadSessionMeta() {
+    let raw;
+    try {
+        raw = await readFile(sessionFile(), 'utf8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+    try {
+        const result = SessionMetaSchema.safeParse(JSON.parse(raw));
+        return result.success ? result.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveSessionMeta(meta) {
+    await ensurePrivateDir(configDir());
+    const path = sessionFile();
+    await writeFile(path, `${JSON.stringify(meta, null, 2)}\n`, {
+        mode: 0o600,
+        encoding: 'utf8',
+    });
+    if (process.platform !== 'win32') {
+        await chmod(path, 0o600);
+    }
+}
+export async function clearSessionMeta() {
+    try {
+        await unlink(sessionFile());
+    }
+    catch (err) {
+        if (err.code !== 'ENOENT')
+            throw err;
+    }
+}
+/**
+ * Kite access tokens expire at 06:00 IST the following day — a regulatory
+ * requirement, not a configurable session length.
+ *
+ * This is a floor, not a guarantee: a master logout from Kite web invalidates
+ * the token immediately, and there is no way to detect that except by getting a
+ * 403. Callers must treat TokenException as authoritative regardless of what
+ * this says.
+ */
+export function nextTokenExpiry(now = new Date()) {
+    // Work out "now" in IST, decide whether 6 AM IST has already passed today,
+    // then build the corresponding UTC instant.
+    const istOffsetMs = 5.5 * 3600 * 1000;
+    const istNow = new Date(now.getTime() + istOffsetMs);
+    const year = istNow.getUTCFullYear();
+    const month = istNow.getUTCMonth();
+    const day = istNow.getUTCDate();
+    const hour = istNow.getUTCHours();
+    // 06:00 IST today, expressed as a UTC instant.
+    let expiryUtcMs = Date.UTC(year, month, day, 6, 0, 0) - istOffsetMs;
+    if (hour >= 6) {
+        // Already past 6 AM IST, so the token dies at 6 AM IST tomorrow.
+        expiryUtcMs += 24 * 3600 * 1000;
+    }
+    return new Date(expiryUtcMs);
+}
+export function isExpired(meta, now = new Date()) {
+    const expiry = Date.parse(meta.expiresAt);
+    if (Number.isNaN(expiry))
+        return true;
+    return now.getTime() >= expiry;
+}
+/** Human-readable time remaining, e.g. "4h 12m". */
+export function timeUntilExpiry(meta, now = new Date()) {
+    const remaining = Date.parse(meta.expiresAt) - now.getTime();
+    if (Number.isNaN(remaining) || remaining <= 0)
+        return 'expired';
+    const hours = Math.floor(remaining / 3_600_000);
+    const minutes = Math.floor((remaining % 3_600_000) / 60_000);
+    return hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
+}

package/dist/core/ticker.d.ts

@@ -0,0 +1,131 @@
+import { EventEmitter } from 'node:events';
+import type { Endpoints } from './config.js';
+/**
+ * Kite streaming quotes over WebSocket.
+ *
+ * Frame layout (all integers BIG-endian):
+ *
+ *   [0..2)   int16  number of packets in this message
+ *   [2..4)   int16  byte length of packet 1
+ *   [4..N)          packet 1
+ *   ...             (repeating int16 length prefix, then payload)
+ *
+ * A 1-byte message is a heartbeat.
+ *
+ * The single most important rule here: **dispatch on packet byte length, not on
+ * the mode you subscribed with.** Indices and tradeable instruments share the
+ * same subscription modes but have completely different layouts — and their
+ * OHLC fields are even in a different order. Five valid sizes exist:
+ *
+ *   8    LTP mode, any instrument
+ *   28   index, quote mode
+ *   32   index, full mode
+ *   44   tradeable, quote mode
+ *   184  tradeable, full mode
+ */
+export type TickerMode = 'ltp' | 'quote' | 'full';
+export interface Depth {
+    price: number;
+    quantity: number;
+    orders: number;
+}
+export interface Tick {
+    instrumentToken: number;
+    tradable: boolean;
+    mode: TickerMode;
+    lastPrice: number;
+    lastQuantity?: number;
+    averagePrice?: number;
+    volume?: number;
+    buyQuantity?: number;
+    sellQuantity?: number;
+    ohlc?: {
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+    };
+    /** Percentage change against the previous close, computed client-side. */
+    change?: number;
+    lastTradeTime?: Date;
+    exchangeTimestamp?: Date;
+    oi?: number;
+    oiDayHigh?: number;
+    oiDayLow?: number;
+    depth?: {
+        buy: Depth[];
+        sell: Depth[];
+    };
+}
+export declare function divisorFor(instrumentToken: number): number;
+export declare function isTradable(instrumentToken: number): boolean;
+/** Parse one packet. Returns null for a size we do not recognise. */
+export declare function parsePacket(buf: Buffer): Tick | null;
+/**
+ * Split a binary message into ticks.
+ *
+ * Every read is bounds-checked. A truncated or malformed frame must not throw
+ * inside the tick loop — a single bad frame should drop that message, not kill
+ * a running dashboard.
+ */
+export declare function parseBinaryMessage(data: Buffer): Tick[];
+export interface TickerOptions {
+    apiKey: string;
+    accessToken: string;
+    endpoints: Endpoints;
+    /** Required by the sandbox WebSocket, which the official SDKs omit. */
+    userId?: string | undefined;
+    maxRetries?: number;
+    maxReconnectDelayMs?: number;
+    /** Force a reconnect if no data (including heartbeats) arrives for this long. */
+    readTimeoutMs?: number;
+}
+export interface TickerEvents {
+    connect: [];
+    ticks: [Tick[]];
+    orderUpdate: [unknown];
+    message: [unknown];
+    error: [Error];
+    close: [{
+        code: number;
+        reason: string;
+    }];
+    reconnect: [{
+        attempt: number;
+        delayMs: number;
+    }];
+    noreconnect: [];
+}
+/** Kite caps a single connection at 3000 instruments, and 3 connections per key. */
+export declare const MAX_INSTRUMENTS_PER_CONNECTION = 3000;
+export declare const MAX_CONNECTIONS_PER_KEY = 3;
+export declare class Ticker extends EventEmitter<TickerEvents> {
+    private ws;
+    private readonly opts;
+    /** Desired subscription state, replayed on every reconnect. */
+    private readonly subscriptions;
+    private readonly modes;
+    private attempt;
+    private closedByUser;
+    private watchdog;
+    private reconnectTimer;
+    constructor(options: TickerOptions);
+    private url;
+    connect(): void;
+    private handleTextMessage;
+    /**
+     * Watchdog: a TCP connection can die without a close event, leaving the
+     * dashboard silently frozen. Kite sends heartbeats continuously, so silence
+     * beyond the timeout means the connection is dead.
+     */
+    private armWatchdog;
+    private clearWatchdog;
+    private scheduleReconnect;
+    private send;
+    private replaySubscriptions;
+    subscribe(tokens: number[], mode?: TickerMode): void;
+    unsubscribe(tokens: number[]): void;
+    setMode(mode: TickerMode, tokens: number[]): void;
+    get connected(): boolean;
+    close(): void;
+}

package/dist/core/ticker.js

@@ -0,0 +1,367 @@
+import { EventEmitter } from 'node:events';
+import WebSocket from 'ws';
+import { redactUrl } from './redact.js';
+/**
+ * Exchange segment is the low byte of the instrument token, and it determines
+ * the price divisor.
+ *
+ * Kite's docs mention only the currency case ("divide by 10000000"), and omit
+ * BSE currency entirely — that one divides by 10000. Getting this wrong yields
+ * prices that are wrong by three orders of magnitude, silently.
+ */
+const Segment = {
+    NseCM: 1,
+    NseFO: 2,
+    NseCD: 3,
+    BseCM: 4,
+    BseFO: 5,
+    BseCD: 6,
+    McxFO: 7,
+    McxSX: 8,
+    Indices: 9,
+};
+export function divisorFor(instrumentToken) {
+    const segment = instrumentToken & 0xff;
+    if (segment === Segment.NseCD)
+        return 10_000_000;
+    if (segment === Segment.BseCD)
+        return 10_000;
+    return 100;
+}
+export function isTradable(instrumentToken) {
+    return (instrumentToken & 0xff) !== Segment.Indices;
+}
+function toDate(epochSeconds) {
+    // Kite sends 0 when a timestamp is not applicable.
+    return epochSeconds > 0 ? new Date(epochSeconds * 1000) : undefined;
+}
+function percentChange(lastPrice, close) {
+    if (close === 0)
+        return undefined;
+    return ((lastPrice - close) * 100) / close;
+}
+/** Parse one packet. Returns null for a size we do not recognise. */
+export function parsePacket(buf) {
+    const token = buf.readUInt32BE(0);
+    const divisor = divisorFor(token);
+    const tradable = isTradable(token);
+    // --- LTP mode: 8 bytes, any instrument ---------------------------------
+    if (buf.length === 8) {
+        return {
+            instrumentToken: token,
+            tradable,
+            mode: 'ltp',
+            lastPrice: buf.readUInt32BE(4) / divisor,
+        };
+    }
+    // --- Index packets: 28 (quote) / 32 (full) ------------------------------
+    // NOTE the field order is high/low/open/close here, NOT open/high/low/close
+    // as in tradeable packets. Transposing these is an easy and silent bug.
+    if (buf.length === 28 || buf.length === 32) {
+        const lastPrice = buf.readUInt32BE(4) / divisor;
+        const close = buf.readUInt32BE(20) / divisor;
+        const tick = {
+            instrumentToken: token,
+            tradable: false,
+            mode: buf.length === 28 ? 'quote' : 'full',
+            lastPrice,
+            ohlc: {
+                high: buf.readUInt32BE(8) / divisor,
+                low: buf.readUInt32BE(12) / divisor,
+                open: buf.readUInt32BE(16) / divisor,
+                close,
+            },
+            change: percentChange(lastPrice, close),
+        };
+        if (buf.length === 32) {
+            tick.exchangeTimestamp = toDate(buf.readUInt32BE(28));
+        }
+        return tick;
+    }
+    // --- Tradeable packets: 44 (quote) / 184 (full) -------------------------
+    if (buf.length === 44 || buf.length === 184) {
+        const lastPrice = buf.readUInt32BE(4) / divisor;
+        const close = buf.readUInt32BE(40) / divisor;
+        const tick = {
+            instrumentToken: token,
+            tradable: true,
+            mode: buf.length === 44 ? 'quote' : 'full',
+            lastPrice,
+            lastQuantity: buf.readUInt32BE(8),
+            averagePrice: buf.readUInt32BE(12) / divisor,
+            volume: buf.readUInt32BE(16),
+            buyQuantity: buf.readUInt32BE(20),
+            sellQuantity: buf.readUInt32BE(24),
+            ohlc: {
+                open: buf.readUInt32BE(28) / divisor,
+                high: buf.readUInt32BE(32) / divisor,
+                low: buf.readUInt32BE(36) / divisor,
+                close,
+            },
+            change: percentChange(lastPrice, close),
+        };
+        if (buf.length === 184) {
+            tick.lastTradeTime = toDate(buf.readUInt32BE(44));
+            tick.oi = buf.readUInt32BE(48);
+            tick.oiDayHigh = buf.readUInt32BE(52);
+            tick.oiDayLow = buf.readUInt32BE(56);
+            tick.exchangeTimestamp = toDate(buf.readUInt32BE(60));
+            // Market depth: 10 entries of 12 bytes each, from offset 64.
+            // Each entry: int32 quantity, int32 price, int16 orders, 2 bytes padding.
+            const buy = [];
+            const sell = [];
+            for (let i = 0; i < 10; i += 1) {
+                const offset = 64 + i * 12;
+                const entry = {
+                    quantity: buf.readUInt32BE(offset),
+                    price: buf.readUInt32BE(offset + 4) / divisor,
+                    orders: buf.readUInt16BE(offset + 8),
+                    // bytes offset+10..offset+12 are padding
+                };
+                if (i < 5)
+                    buy.push(entry);
+                else
+                    sell.push(entry);
+            }
+            tick.depth = { buy, sell };
+        }
+        return tick;
+    }
+    return null;
+}
+/**
+ * Split a binary message into ticks.
+ *
+ * Every read is bounds-checked. A truncated or malformed frame must not throw
+ * inside the tick loop — a single bad frame should drop that message, not kill
+ * a running dashboard.
+ */
+export function parseBinaryMessage(data) {
+    // 1-byte messages are heartbeats.
+    if (data.length < 2)
+        return [];
+    const ticks = [];
+    const packetCount = data.readInt16BE(0);
+    let offset = 2;
+    for (let i = 0; i < packetCount; i += 1) {
+        if (offset + 2 > data.length)
+            break;
+        const length = data.readInt16BE(offset);
+        offset += 2;
+        if (length <= 0 || offset + length > data.length)
+            break;
+        const packet = data.subarray(offset, offset + length);
+        offset += length;
+        try {
+            const tick = parsePacket(packet);
+            if (tick)
+                ticks.push(tick);
+        }
+        catch {
+            // Unrecognised layout; skip this packet and keep the stream alive.
+        }
+    }
+    return ticks;
+}
+/** Kite caps a single connection at 3000 instruments, and 3 connections per key. */
+export const MAX_INSTRUMENTS_PER_CONNECTION = 3000;
+export const MAX_CONNECTIONS_PER_KEY = 3;
+export class Ticker extends EventEmitter {
+    ws;
+    opts;
+    /** Desired subscription state, replayed on every reconnect. */
+    subscriptions = new Set();
+    modes = new Map();
+    attempt = 0;
+    closedByUser = false;
+    watchdog;
+    reconnectTimer;
+    constructor(options) {
+        super();
+        this.opts = {
+            apiKey: options.apiKey,
+            accessToken: options.accessToken,
+            endpoints: options.endpoints,
+            userId: options.userId,
+            maxRetries: options.maxRetries ?? 50,
+            maxReconnectDelayMs: options.maxReconnectDelayMs ?? 60_000,
+            readTimeoutMs: options.readTimeoutMs ?? 10_000,
+        };
+    }
+    url() {
+        const url = new URL(this.opts.endpoints.ws);
+        url.searchParams.set('api_key', this.opts.apiKey);
+        url.searchParams.set('access_token', this.opts.accessToken);
+        // The sandbox ticker will not authenticate without this; production ignores it.
+        if (this.opts.userId)
+            url.searchParams.set('user_id', this.opts.userId);
+        return url.toString();
+    }
+    connect() {
+        if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
+            return;
+        }
+        this.closedByUser = false;
+        const target = this.url();
+        const socket = new WebSocket(target, { handshakeTimeout: 10_000 });
+        socket.binaryType = 'nodebuffer';
+        this.ws = socket;
+        socket.on('open', () => {
+            this.attempt = 0;
+            this.armWatchdog();
+            this.emit('connect');
+            // The server keeps no subscription state across connections, so the full
+            // desired state must be replayed every time.
+            this.replaySubscriptions();
+        });
+        socket.on('message', (data, isBinary) => {
+            this.armWatchdog();
+            if (isBinary) {
+                const buf = toBuffer(data);
+                // A 1-byte payload is a heartbeat: liveness only, no ticks.
+                if (buf.length === 1)
+                    return;
+                const ticks = parseBinaryMessage(buf);
+                if (ticks.length > 0)
+                    this.emit('ticks', ticks);
+                return;
+            }
+            this.handleTextMessage(toBuffer(data).toString('utf8'));
+        });
+        // Kite sends a heartbeat frame; treat any ping as liveness too.
+        socket.on('ping', () => this.armWatchdog());
+        socket.on('pong', () => this.armWatchdog());
+        socket.on('error', (err) => {
+            // The ws error message can embed the full URL, which carries the access
+            // token as a query parameter. Never emit it unredacted.
+            this.emit('error', new Error(`${redactUrl(this.opts.endpoints.ws)}: ${redactMessage(err.message, target)}`));
+        });
+        socket.on('close', (code, reason) => {
+            // Guard against a stale socket's close event racing a newer connection.
+            if (this.ws !== socket)
+                return;
+            this.clearWatchdog();
+            this.emit('close', { code, reason: reason.toString('utf8') });
+            if (!this.closedByUser)
+                this.scheduleReconnect();
+        });
+    }
+    handleTextMessage(raw) {
+        let payload;
+        try {
+            payload = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        switch (payload.type) {
+            case 'order':
+                // Same payload shape as an HTTP postback. For a single-user CLI this is
+                // the recommended way to receive order updates — no public URL needed.
+                this.emit('orderUpdate', payload.data);
+                break;
+            case 'error':
+                this.emit('error', new Error(String(payload.data ?? 'Ticker error')));
+                break;
+            default:
+                this.emit('message', payload.data);
+                break;
+        }
+    }
+    /**
+     * Watchdog: a TCP connection can die without a close event, leaving the
+     * dashboard silently frozen. Kite sends heartbeats continuously, so silence
+     * beyond the timeout means the connection is dead.
+     */
+    armWatchdog() {
+        this.clearWatchdog();
+        this.watchdog = setTimeout(() => {
+            this.ws?.terminate();
+        }, this.opts.readTimeoutMs);
+        this.watchdog.unref?.();
+    }
+    clearWatchdog() {
+        if (this.watchdog) {
+            clearTimeout(this.watchdog);
+            this.watchdog = undefined;
+        }
+    }
+    scheduleReconnect() {
+        if (this.attempt >= this.opts.maxRetries) {
+            this.emit('noreconnect');
+            return;
+        }
+        this.attempt += 1;
+        // Exponential backoff with jitter. Jitter matters: without it, several
+        // ticker processes restarted together would reconnect in lockstep.
+        const base = Math.min(2 ** this.attempt * 1000, this.opts.maxReconnectDelayMs);
+        const delayMs = Math.round(base / 2 + Math.random() * (base / 2));
+        this.emit('reconnect', { attempt: this.attempt, delayMs });
+        this.reconnectTimer = setTimeout(() => this.connect(), delayMs);
+        this.reconnectTimer.unref?.();
+    }
+    send(payload) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(payload));
+        }
+    }
+    replaySubscriptions() {
+        if (this.subscriptions.size === 0)
+            return;
+        this.send({ a: 'subscribe', v: [...this.subscriptions] });
+        // Group tokens by mode so we send one message per mode rather than per token.
+        const byMode = new Map();
+        for (const [token, mode] of this.modes) {
+            if (!this.subscriptions.has(token))
+                continue;
+            const list = byMode.get(mode) ?? [];
+            list.push(token);
+            byMode.set(mode, list);
+        }
+        for (const [mode, tokens] of byMode) {
+            this.send({ a: 'mode', v: [mode, tokens] });
+        }
+    }
+    subscribe(tokens, mode = 'quote') {
+        for (const token of tokens) {
+            this.subscriptions.add(token);
+            this.modes.set(token, mode);
+        }
+        this.send({ a: 'subscribe', v: tokens });
+        this.send({ a: 'mode', v: [mode, tokens] });
+    }
+    unsubscribe(tokens) {
+        for (const token of tokens) {
+            this.subscriptions.delete(token);
+            this.modes.delete(token);
+        }
+        this.send({ a: 'unsubscribe', v: tokens });
+    }
+    setMode(mode, tokens) {
+        for (const token of tokens)
+            this.modes.set(token, mode);
+        this.send({ a: 'mode', v: [mode, tokens] });
+    }
+    get connected() {
+        return this.ws?.readyState === WebSocket.OPEN;
+    }
+    close() {
+        this.closedByUser = true;
+        this.clearWatchdog();
+        if (this.reconnectTimer)
+            clearTimeout(this.reconnectTimer);
+        this.ws?.close();
+        this.ws = undefined;
+    }
+}
+function toBuffer(data) {
+    if (Buffer.isBuffer(data))
+        return data;
+    if (Array.isArray(data))
+        return Buffer.concat(data);
+    return Buffer.from(data);
+}
+/** Strip the connection URL (and therefore the access token) out of an error. */
+function redactMessage(message, url) {
+    return message.split(url).join(redactUrl(url));
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Programmatic entry point.
+ *
+ * The CLI is the product, but the client underneath it is useful on its own —
+ * these exports let you script against Kite with the same rate limiting,
+ * validation, redaction and error taxonomy the CLI uses.
+ */
+export { type GttParams, KiteApi, type ModifyOrderParams, type PlaceOrderParams, } from './core/api.js';
+export { buildLoginUrl, computeChecksum, computePostbackChecksum, verifyPostbackChecksum, } from './core/auth.js';
+export { type ClientOptions, KiteClient, setDispatcher, } from './core/client.js';
+export { type Endpoints, type Environment, endpointsFor, SANDBOX_CREDENTIALS, } from './core/config.js';
+export { AuthRequiredError, ExitCode, KiteApiError, KiteCliError, type KiteErrorType, NetworkError, UsageError, } from './core/errors.js';
+export { InstrumentStore, parseInstrumentKey, parseInstrumentsCsv, } from './core/instruments.js';
+export { ORDER_LIMITS, type RateCategory, RateLimiter, } from './core/ratelimit.js';
+export { maskSecret, redact, redactString, redactUrl, registerSecret, } from './core/redact.js';
+export * from './core/schemas.js';
+export { divisorFor, isTradable, parseBinaryMessage, parsePacket, type Tick, Ticker, type TickerMode, type TickerOptions, } from './core/ticker.js';

package/dist/index.js

@@ -0,0 +1,17 @@
+/**
+ * Programmatic entry point.
+ *
+ * The CLI is the product, but the client underneath it is useful on its own —
+ * these exports let you script against Kite with the same rate limiting,
+ * validation, redaction and error taxonomy the CLI uses.
+ */
+export { KiteApi, } from './core/api.js';
+export { buildLoginUrl, computeChecksum, computePostbackChecksum, verifyPostbackChecksum, } from './core/auth.js';
+export { KiteClient, setDispatcher, } from './core/client.js';
+export { endpointsFor, SANDBOX_CREDENTIALS, } from './core/config.js';
+export { AuthRequiredError, ExitCode, KiteApiError, KiteCliError, NetworkError, UsageError, } from './core/errors.js';
+export { InstrumentStore, parseInstrumentKey, parseInstrumentsCsv, } from './core/instruments.js';
+export { ORDER_LIMITS, RateLimiter, } from './core/ratelimit.js';
+export { maskSecret, redact, redactString, redactUrl, registerSecret, } from './core/redact.js';
+export * from './core/schemas.js';
+export { divisorFor, isTradable, parseBinaryMessage, parsePacket, Ticker, } from './core/ticker.js';

package/dist/output/format.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Number, currency and date formatting.
+ *
+ * Everything is rendered in the Indian locale and IST, because that is the only
+ * frame of reference Kite operates in. Rupee amounts use the Indian digit
+ * grouping (lakh/crore), which `en-IN` gives us for free.
+ */
+/** A rupee amount, e.g. "12,34,567.89". No symbol — callers add it. */
+export declare function money(value: number | undefined | null): string;
+/** A rupee amount with the symbol, e.g. "₹12,34,567.89". */
+export declare function rupees(value: number | undefined | null): string;
+/** A signed rupee amount, e.g. "+₹1,200.00" / "-₹340.50". */
+export declare function signedRupees(value: number | undefined | null): string;
+/** Large rupee amounts abbreviated as L / Cr, the conventional Indian units. */
+export declare function compactRupees(value: number | undefined | null): string;
+export declare function percent(value: number | undefined | null, digits?: number): string;
+export declare function quantity(value: number | undefined | null): string;
+/** Compact volume, e.g. "1.2M". */
+export declare function compactNumber(value: number | undefined | null): string;
+export declare function dateTime(value: Date | string | undefined | null): string;
+export declare function timeOnly(value: Date | string | undefined | null): string;
+export declare function dateOnly(value: Date | string | undefined | null): string;
+/**
+ * Parse a user-supplied date for historical queries.
+ *
+ * Accepts YYYY-MM-DD, "YYYY-MM-DD HH:MM:SS", and relative offsets like "7d",
+ * "3m", "1y" meaning "N units ago".
+ */
+export declare function parseUserDate(value: string, now?: Date): Date | null;
+/** Truncate to a display width, appending an ellipsis. */
+export declare function truncate(value: string, max: number): string;