@indigoai-us/hq-cli 5.126.0 → 5.128.0

package/dist/lib/lanes/outpost-dispatch.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Push an Outpost-targeted lane through `hq outposts exec` (spec §5.2).
+ *
+ * The transport is the existing OutpostsClient submit/wait pair — the same
+ * path as `hq outposts exec --async`. Create stages a payload, then runs
+ * `hq lanes pickup --payload-url` on the box. A submit or wait failure is
+ * `outpost_dispatch_failed`, never a queued lane nobody will pick up.
+ */
+import { OutpostsClient } from "@indigoai-us/hq-cloud/outposts";
+import type { LaneRecord } from "./types.js";
+export declare const PICKUP_EXEC_TIMEOUT_SECONDS = 120;
+export declare const PICKUP_WAIT_MS: number;
+export interface OutpostPickupPayload {
+    lane: LaneRecord;
+    brief: string;
+    timeout?: {
+        timeout_secs: number;
+        deadline_at: string;
+    };
+}
+export interface OutpostDispatchResult {
+    commandId: string;
+    status: string;
+    done?: boolean;
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+}
+export interface OutpostExecPort {
+    stageExecInput: (outpostId?: string) => Promise<{
+        putUrl: string;
+        getUrl: string;
+    }>;
+    submitExec: (command: string, outpostId?: string, timeoutSeconds?: number) => Promise<{
+        commandId: string;
+    }>;
+    waitForExecResult: (commandId: string, outpostId?: string, options?: {
+        signal?: AbortSignal;
+    }) => Promise<{
+        status: string;
+        done: boolean;
+        exitCode?: number | null;
+        stdout?: string;
+        stderr?: string;
+    }>;
+}
+export declare function parseOutpostPickupPayload(raw: unknown): OutpostPickupPayload;
+/** Same wrapping `hq outposts exec` applies: run from the box's HQ folder. */
+export declare function buildOutpostPickupCommand(payloadUrl: string): string;
+export declare function stageOutpostPayload(port: Pick<OutpostExecPort, "stageExecInput">, outpostId: string, bytes: Uint8Array, put?: typeof fetch): Promise<{
+    getUrl: string;
+}>;
+export declare function dispatchOutpostPickup(port: OutpostExecPort, input: {
+    outpostId: string;
+    command: string;
+    timeoutSeconds?: number;
+    waitMs?: number;
+}): Promise<OutpostDispatchResult>;
+export declare function dispatchErrorMessage(err: unknown): string;
+/** Factory matching `hq outposts exec`'s client wiring. */
+export declare function createOutpostsClient(opts: {
+    transport: ConstructorParameters<typeof OutpostsClient>[0]["transport"];
+    token: ConstructorParameters<typeof OutpostsClient>[0]["token"];
+}): OutpostsClient;
+//# sourceMappingURL=outpost-dispatch.d.ts.map

package/dist/lib/lanes/outpost-dispatch.js

@@ -0,0 +1,90 @@
+/**
+ * Push an Outpost-targeted lane through `hq outposts exec` (spec §5.2).
+ *
+ * The transport is the existing OutpostsClient submit/wait pair — the same
+ * path as `hq outposts exec --async`. Create stages a payload, then runs
+ * `hq lanes pickup --payload-url` on the box. A submit or wait failure is
+ * `outpost_dispatch_failed`, never a queued lane nobody will pick up.
+ */
+import { OutpostsClient, joinCommandParts, withRemoteHqDir } from "@indigoai-us/hq-cloud/outposts";
+import { LanesError } from "./errors.js";
+export const PICKUP_EXEC_TIMEOUT_SECONDS = 120;
+export const PICKUP_WAIT_MS = PICKUP_EXEC_TIMEOUT_SECONDS * 1000;
+export function parseOutpostPickupPayload(raw) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+        throw new LanesError("outpost_payload_invalid", "Outpost pickup payload must be a JSON object", {});
+    }
+    const body = raw;
+    if (body.lane === null || typeof body.lane !== "object" || Array.isArray(body.lane)) {
+        throw new LanesError("outpost_payload_invalid", "Outpost pickup payload.lane must be an object", {});
+    }
+    if (typeof body.brief !== "string") {
+        throw new LanesError("outpost_payload_invalid", "Outpost pickup payload.brief must be a string", {});
+    }
+    let timeout;
+    if (body.timeout !== undefined && body.timeout !== null) {
+        if (typeof body.timeout !== "object" || Array.isArray(body.timeout)) {
+            throw new LanesError("outpost_payload_invalid", "Outpost pickup payload.timeout must be an object", {});
+        }
+        const t = body.timeout;
+        if (typeof t.timeout_secs !== "number" || typeof t.deadline_at !== "string") {
+            throw new LanesError("outpost_payload_invalid", "Outpost pickup payload.timeout needs timeout_secs and deadline_at", {});
+        }
+        timeout = { timeout_secs: t.timeout_secs, deadline_at: t.deadline_at };
+    }
+    return {
+        lane: body.lane,
+        brief: body.brief,
+        timeout,
+    };
+}
+/** Same wrapping `hq outposts exec` applies: run from the box's HQ folder. */
+export function buildOutpostPickupCommand(payloadUrl) {
+    return withRemoteHqDir(joinCommandParts(["hq", "lanes", "pickup", "--payload-url", payloadUrl]));
+}
+export async function stageOutpostPayload(port, outpostId, bytes, put = fetch) {
+    const staged = await port.stageExecInput(outpostId);
+    const upload = await put(staged.putUrl, {
+        method: "PUT",
+        headers: { "Content-Length": String(bytes.byteLength) },
+        body: bytes,
+    });
+    if (!upload.ok) {
+        throw new LanesError("outpost_dispatch_failed", `Could not upload lane payload: HTTP ${upload.status}`, { status: upload.status, outpost_id: outpostId });
+    }
+    return { getUrl: staged.getUrl };
+}
+export async function dispatchOutpostPickup(port, input) {
+    const submitted = await port.submitExec(input.command, input.outpostId, input.timeoutSeconds ?? PICKUP_EXEC_TIMEOUT_SECONDS);
+    const ac = new AbortController();
+    const waitMs = input.waitMs ?? PICKUP_WAIT_MS;
+    const timer = setTimeout(() => ac.abort(), waitMs);
+    try {
+        const result = await port.waitForExecResult(submitted.commandId, input.outpostId, { signal: ac.signal });
+        return {
+            commandId: submitted.commandId,
+            status: result.status,
+            done: result.done,
+            exitCode: result.exitCode ?? null,
+            stdout: result.stdout ?? "",
+            stderr: result.stderr ?? "",
+        };
+    }
+    catch (err) {
+        if (ac.signal.aborted) {
+            throw new LanesError("outpost_dispatch_failed", `Timed out waiting for Outpost pickup (${waitMs}ms)`, { outpost_id: input.outpostId, command_id: submitted.commandId });
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function dispatchErrorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+/** Factory matching `hq outposts exec`'s client wiring. */
+export function createOutpostsClient(opts) {
+    return new OutpostsClient(opts);
+}
+//# sourceMappingURL=outpost-dispatch.js.map

package/dist/lib/lanes/questions.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Raise a lane question (spec §6.1). One function for the CLI `hq lanes ask`
+ * path and for envelope `decision: "ask"` ingestion. Two writers here would
+ * drift on hop, origin, raised_via, body store, and routing_history.
+ */
+import { type LaneEnvelope, type LaneRecord, type QuestionBodyStore, type QuestionKind, type QuestionRecord, type RaisedVia } from "./types.js";
+export interface QuestionBody {
+    question: string;
+    context: string;
+    options: string[];
+    recommended?: string;
+    notes?: string;
+}
+export declare function parseQuestionBodyStore(value: unknown): QuestionBodyStore;
+export declare function bodyStoreForLane(lane: Pick<LaneRecord, "company">): QuestionBodyStore;
+export declare function questionBodyRef(questionId: string): string;
+export declare function sha256Text(text: string): string;
+/** Tenant-store path for a question body (spec §6.2 / §10). Never the personal vault for company prose. */
+export declare function questionBodyAbsPath(hqRoot: string, question: Pick<QuestionRecord, "company" | "body" | "question_id">): string;
+export declare function writeQuestionBody(hqRoot: string, question: Pick<QuestionRecord, "company" | "body" | "question_id">, body: QuestionBody): {
+    store: QuestionBodyStore;
+    ref: string;
+    digest: string;
+};
+export interface RaiseLaneQuestionInput {
+    hqRoot: string;
+    lane: LaneRecord;
+    body: QuestionBody;
+    raisedVia: RaisedVia;
+    at: string;
+    questionId?: string;
+}
+/**
+ * Persist one question the way `hq lanes ask` does: createQuestion, write the
+ * tenant body, then CAS routing_history with reason `asked`.
+ */
+export declare function raiseLaneQuestion(input: RaiseLaneQuestionInput): QuestionRecord;
+/**
+ * Options that, trimmed, case-folded and stripped of trailing punctuation,
+ * are exactly {continue, stop} in either order. The brief authorises the work
+ * it lists, so this question asks the operator nothing the brief did not
+ * already settle; it is recorded as `question_kind: "continue"`.
+ */
+export declare function classifyQuestionKind(options: readonly string[]): QuestionKind | undefined;
+/** The store a lane's question bodies live in, derived from the lane and never the reverse. */
+export declare function questionBodyPathForLane(hqRoot: string, lane: Pick<LaneRecord, "company">, questionId: string): string;
+/**
+ * Free-text notes the operator attached with `questions answer --notes`.
+ * Read from the lane's own store (spec §6.5): the company store for a company
+ * lane, the personal store otherwise. Returns undefined when the answer has
+ * no notes_ref or the body carries no notes; a body the host cannot read is
+ * reported and skipped rather than failing the resume.
+ */
+export declare function readAnswerNotes(hqRoot: string, lane: Pick<LaneRecord, "company">, question: Pick<QuestionRecord, "question_id" | "answer">): string | undefined;
+export interface AnsweredQuestionEntry {
+    question_id: string;
+    choice: string | undefined;
+    answered_at: string | undefined;
+    answered_by: string | undefined;
+    notes?: string;
+}
+/**
+ * The `answered-questions.json` a resumed worker is handed (spec §6.5). Ids,
+ * choices and timestamps come from the routing record; the operator's notes
+ * come from the lane's own body store and are written only into the run
+ * directory on the executing host.
+ */
+export declare function answeredQuestionEntries(hqRoot: string, lane: Pick<LaneRecord, "lane_id" | "company">, questions: QuestionRecord[]): AnsweredQuestionEntry[];
+export declare function envelopeQuestionId(laneId: string, envelopeRef: string, index: number): string;
+/**
+ * Spec §6.1: each envelope questions[] entry becomes one queue record, via
+ * raiseLaneQuestion (the same function the CLI ask path uses).
+ */
+export declare function raiseEnvelopeQuestions(hqRoot: string, lane: LaneRecord, envelope: LaneEnvelope, envelopeRef: string, at: string): QuestionRecord[];
+//# sourceMappingURL=questions.d.ts.map

package/dist/lib/lanes/questions.js

@@ -0,0 +1,243 @@
+/**
+ * Raise a lane question (spec §6.1). One function for the CLI `hq lanes ask`
+ * path and for envelope `decision: "ask"` ingestion. Two writers here would
+ * drift on hop, origin, raised_via, body store, and routing_history.
+ */
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { LanesError } from "./errors.js";
+import { appendCappedHistory, createQuestion, retryUpdateQuestion, } from "./store.js";
+import { QUESTION_BODY_STORES, } from "./types.js";
+export function parseQuestionBodyStore(value) {
+    if (typeof value === "string" &&
+        QUESTION_BODY_STORES.includes(value)) {
+        return value;
+    }
+    throw new LanesError("unknown_body_store", `Unknown question body store ${JSON.stringify(value)}. Accepted: ${QUESTION_BODY_STORES.join(", ")}`, { accepted: [...QUESTION_BODY_STORES], value });
+}
+export function bodyStoreForLane(lane) {
+    return lane.company ? "company" : "personal";
+}
+export function questionBodyRef(questionId) {
+    return path.posix.join("lanes", "questions", `${questionId}.json`);
+}
+export function sha256Text(text) {
+    return `sha256:${createHash("sha256").update(text).digest("hex")}`;
+}
+/** Tenant-store path for a question body (spec §6.2 / §10). Never the personal vault for company prose. */
+export function questionBodyAbsPath(hqRoot, question) {
+    const store = parseQuestionBodyStore(question.body.store);
+    if (store === "company") {
+        if (!question.company?.slug) {
+            throw new LanesError("question_body_store_unresolved", "Company question body is missing a company slug", { question_id: question.question_id });
+        }
+        return path.join(hqRoot, "companies", question.company.slug, "lanes", "questions", `${question.question_id}.json`);
+    }
+    return path.join(hqRoot, "personal", "lanes", "questions", `${question.question_id}.json`);
+}
+export function writeQuestionBody(hqRoot, question, body) {
+    const store = parseQuestionBodyStore(question.body.store);
+    const filePath = questionBodyAbsPath(hqRoot, question);
+    const serialized = `${JSON.stringify(body, null, 2)}\n`;
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, serialized, "utf8");
+    return {
+        store,
+        ref: questionBodyRef(question.question_id),
+        digest: sha256Text(serialized),
+    };
+}
+/**
+ * Persist one question the way `hq lanes ask` does: createQuestion, write the
+ * tenant body, then CAS routing_history with reason `asked`.
+ */
+export function raiseLaneQuestion(input) {
+    const store = bodyStoreForLane(input.lane);
+    let questionId = input.questionId;
+    if (!questionId) {
+        const created = createQuestion(input.hqRoot, {
+            lane_id: input.lane.lane_id,
+            company: input.lane.company,
+            project_id: input.lane.project_id,
+            story_id: input.lane.story_id,
+            thread_id: input.lane.thread_id,
+            raised_via: input.raisedVia,
+            asked_at: input.at,
+            origin: { kind: "lane", id: input.lane.lane_id },
+            hop: 1,
+            status: "pending",
+            body: { store, ref: "", digest: "" },
+            routing_history: [],
+        });
+        questionId = created.question_id;
+    }
+    else {
+        try {
+            createQuestion(input.hqRoot, {
+                question_id: questionId,
+                lane_id: input.lane.lane_id,
+                company: input.lane.company,
+                project_id: input.lane.project_id,
+                story_id: input.lane.story_id,
+                thread_id: input.lane.thread_id,
+                raised_via: input.raisedVia,
+                asked_at: input.at,
+                origin: { kind: "lane", id: input.lane.lane_id },
+                hop: 1,
+                status: "pending",
+                body: { store, ref: "", digest: "" },
+                routing_history: [],
+            });
+        }
+        catch (err) {
+            if (!(err instanceof LanesError) || err.error !== "question_exists") {
+                throw err;
+            }
+        }
+    }
+    const stored = writeQuestionBody(input.hqRoot, {
+        company: input.lane.company,
+        question_id: questionId,
+        body: { store, ref: "", digest: "" },
+    }, input.body);
+    const questionKind = classifyQuestionKind(input.body.options);
+    return retryUpdateQuestion(input.hqRoot, questionId, (current) => {
+        const asked = current.routing_history.some((entry) => entry.reason === "asked");
+        return {
+            ...current,
+            ...(questionKind !== undefined ? { question_kind: questionKind } : {}),
+            body: stored,
+            raised_via: input.raisedVia,
+            routing_history: asked
+                ? current.routing_history
+                : appendCappedHistory(current.routing_history, {
+                    hop: 1,
+                    audience: input.lane.senior,
+                    at: input.at,
+                    reason: "asked",
+                }),
+        };
+    });
+}
+/**
+ * Options that, trimmed, case-folded and stripped of trailing punctuation,
+ * are exactly {continue, stop} in either order. The brief authorises the work
+ * it lists, so this question asks the operator nothing the brief did not
+ * already settle; it is recorded as `question_kind: "continue"`.
+ */
+export function classifyQuestionKind(options) {
+    if (options.length !== 2)
+        return undefined;
+    const folded = options.map((option) => option
+        .trim()
+        .toLowerCase()
+        .replace(/[.!?…]+$/u, "")
+        .trim());
+    const isContinueStop = folded.includes("continue") && folded.includes("stop") && folded[0] !== folded[1];
+    return isContinueStop ? "continue" : undefined;
+}
+/** The store a lane's question bodies live in, derived from the lane and never the reverse. */
+export function questionBodyPathForLane(hqRoot, lane, questionId) {
+    return questionBodyAbsPath(hqRoot, {
+        company: lane.company,
+        question_id: questionId,
+        body: { store: bodyStoreForLane(lane), ref: "", digest: "" },
+    });
+}
+/**
+ * Free-text notes the operator attached with `questions answer --notes`.
+ * Read from the lane's own store (spec §6.5): the company store for a company
+ * lane, the personal store otherwise. Returns undefined when the answer has
+ * no notes_ref or the body carries no notes; a body the host cannot read is
+ * reported and skipped rather than failing the resume.
+ */
+export function readAnswerNotes(hqRoot, lane, question) {
+    if (!question.answer?.notes_ref)
+        return undefined;
+    const filePath = questionBodyPathForLane(hqRoot, lane, question.question_id);
+    let text;
+    try {
+        text = fs.readFileSync(filePath, "utf8");
+    }
+    catch (err) {
+        const code = err.code;
+        process.stderr.write(`hq lanes: answer notes for ${question.question_id} unreadable at ${filePath} (${code ?? (err instanceof Error ? err.message : String(err))})\n`);
+        return undefined;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        process.stderr.write(`hq lanes: answer notes for ${question.question_id} at ${filePath} is not JSON: ${err instanceof Error ? err.message : String(err)}\n`);
+        return undefined;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return undefined;
+    const notes = parsed.notes;
+    return typeof notes === "string" && notes.length > 0 ? notes : undefined;
+}
+/**
+ * The `answered-questions.json` a resumed worker is handed (spec §6.5). Ids,
+ * choices and timestamps come from the routing record; the operator's notes
+ * come from the lane's own body store and are written only into the run
+ * directory on the executing host.
+ */
+export function answeredQuestionEntries(hqRoot, lane, questions) {
+    return questions
+        .filter((q) => q.origin.id === lane.lane_id && q.status === "answered" && q.answer)
+        .map((q) => {
+        const entry = {
+            question_id: q.question_id,
+            choice: q.answer?.choice,
+            answered_at: q.answer?.answered_at,
+            answered_by: q.answer?.answered_by,
+        };
+        const notes = readAnswerNotes(hqRoot, lane, q);
+        if (notes !== undefined)
+            entry.notes = notes;
+        return entry;
+    });
+}
+export function envelopeQuestionId(laneId, envelopeRef, index) {
+    const stem = path.basename(envelopeRef, ".json").replace(/[^A-Za-z0-9_-]/g, "");
+    const digest = createHash("sha256")
+        .update(`${laneId}\0${envelopeRef}\0${index}`)
+        .digest("hex")
+        .slice(0, 10);
+    return `qenv_${stem}_${index}_${digest}`;
+}
+function envelopeQuestionBody(item) {
+    const body = {
+        question: item.question,
+        context: item.context,
+        options: item.options,
+    };
+    if (item.recommended !== undefined)
+        body.recommended = item.recommended;
+    return body;
+}
+/**
+ * Spec §6.1: each envelope questions[] entry becomes one queue record, via
+ * raiseLaneQuestion (the same function the CLI ask path uses).
+ */
+export function raiseEnvelopeQuestions(hqRoot, lane, envelope, envelopeRef, at) {
+    const items = envelope.questions ?? [];
+    const raised = [];
+    for (let i = 0; i < items.length; i += 1) {
+        const item = items[i];
+        if (!item)
+            continue;
+        raised.push(raiseLaneQuestion({
+            hqRoot,
+            lane,
+            body: envelopeQuestionBody(item),
+            raisedVia: "envelope",
+            at,
+            questionId: envelopeQuestionId(lane.lane_id, envelopeRef, i),
+        }));
+    }
+    return raised;
+}
+//# sourceMappingURL=questions.js.map

package/dist/lib/lanes/quota.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Machine-written provider quota, keyed by account and model.
+ *
+ * `enabled` and `disabled_reason` live in personal/lanes/config.json and are
+ * the operator's hand-written switch. `quota_reset_at` and `needs_credits`
+ * are written here, in personal/lanes/quota.json, from the provider's own
+ * 429. They are separate fields because a quota hold expires on its own:
+ * copying it into `disabled_reason` or flipping `enabled` would erase the
+ * operator's reason, and would leave the account switched off after the
+ * provider reset. The balancer reads this file and does not rewrite the
+ * operator fields.
+ *
+ * A weekly-limit 429 names a reset and applies to every model on that
+ * account (measured: account b, every model, until the reset). A credits
+ * 429 names one model and no reset (measured: account d refuses
+ * claude-fable-5-1 and still runs claude-opus-5). The record is therefore
+ * per (account, model), plus an account-wide reset when the text is a
+ * usage limit rather than a switch-model refusal.
+ */
+import type { LaneProvider } from "./types.js";
+export declare const QUOTA_STATE_REL: string;
+export declare const QUOTA_SCHEMA_VERSION = "hq-lanes-quota.v1";
+export interface ModelQuota {
+    quota_reset_at?: string;
+    needs_credits?: boolean;
+    /** Operator-facing marker, e.g. "needs credits for claude-fable-5-1". */
+    marker?: string;
+}
+export interface AccountQuota {
+    /** Set when the 429 is an account-wide usage limit with a reset time. */
+    all_models_quota_reset_at?: string;
+    models: Record<string, ModelQuota>;
+}
+export interface QuotaState {
+    schema_version: typeof QUOTA_SCHEMA_VERSION;
+    providers: Partial<Record<LaneProvider, Record<string, AccountQuota>>>;
+}
+export interface QuotaSignal {
+    reason: "account_quota_exhausted" | "account_model_unavailable";
+    quota_reset_at?: string;
+    model?: string;
+    needs_credits?: boolean;
+    marker?: string;
+    /** True when the text is a usage limit with a reset, not a per-model credits refusal. */
+    account_wide?: boolean;
+}
+export declare function quotaStatePath(hqRoot: string): string;
+export declare function loadQuotaState(hqRoot: string): QuotaState;
+/**
+ * Parse "resets Sep 24, 2am (UTC)" into an ISO timestamp. The year is the
+ * current UTC year, rolled forward when that instant is already past.
+ * Returns null when the text names no reset.
+ */
+export declare function parseProviderResetTime(text: string, now: Date): string | null;
+/**
+ * Read only `api_error_status`, `is_error`, and `result` off the last
+ * `type: "result"` object. Nothing else from the payload is returned, and
+ * this function does not log.
+ */
+export declare function quotaFieldsFromOutput(text: string): {
+    api_error_status: unknown;
+    is_error: unknown;
+    result: unknown;
+} | null;
+export declare function quotaSignalFromFields(fields: {
+    api_error_status: unknown;
+    is_error: unknown;
+    result: unknown;
+}, model: string | undefined, now: Date): QuotaSignal | null;
+export declare function readQuotaSignal(runDir: string, model: string | undefined, now: Date, workerOutOffset?: number): QuotaSignal | null;
+export declare function recordAccountQuota(hqRoot: string, provider: LaneProvider, accountId: string, signal: QuotaSignal): QuotaState;
+export interface QuotaBlock {
+    blocked: boolean;
+    reason?: "account_quota_exhausted" | "account_model_unavailable";
+    quota_reset_at?: string;
+    marker?: string;
+    model?: string;
+}
+/**
+ * Skip an account only for the models it cannot run. An account-wide reset
+ * blocks every model. A needs-credits marker blocks only that model, with
+ * no expiry. A past reset does not block.
+ */
+export declare function quotaBlockFor(state: QuotaState, provider: LaneProvider, accountId: string, model: string | undefined, now: Date): QuotaBlock;
+export interface AccountQuotaView {
+    quota_reset_at: string | null;
+    model_quota: Array<{
+        model: string;
+        quota_reset_at?: string;
+        needs_credits?: boolean;
+        marker?: string;
+    }>;
+}
+export declare function accountQuotaView(state: QuotaState, provider: LaneProvider, accountId: string): AccountQuotaView;
+//# sourceMappingURL=quota.d.ts.map