@wardby/cli 0.3.0 → 0.4.1

package/dist/providers/issue-tracker/adf.js

@@ -0,0 +1,181 @@
+// `_x_` is italic only when the underscores aren't inside a word, so
+// snake_case identifiers (WARDBY_JIRA_API_TOKEN, my_var_name) stay literal.
+// A bare https:// URL becomes a link too; it ends before whitespace or a
+// bracket and drops trailing sentence punctuation (`see https://x/y.`).
+const INLINE = /\*\*([^*]+)\*\*|`([^`]+)`|(?<![A-Za-z0-9_])_([^_\s][^_]*?)_(?![A-Za-z0-9_])|\[([^\]]+)\]\(([^)\s]+)\)|(https:\/\/[^\s<>()[\]"']*[^\s<>()[\]"'.,;:!?])/g;
+const ISSUE_KEY = /^[A-Z][A-Z0-9_]+-[1-9][0-9]*$/;
+const escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function inline(text, smart) {
+    const out = [];
+    const site = smart?.siteUrl.replace(/\/+$/, "");
+    const card = (key) => ({ type: "inlineCard", attrs: { url: `${site}/browse/${key}` } });
+    const keys = (smart?.projectKeys ?? []).filter((k) => /^[A-Z][A-Z0-9_]+$/.test(k));
+    const keyRe = keys.length
+        ? new RegExp(`(?<![A-Za-z0-9_/.-])(?:${keys.map(escapeRe).join("|")})-[1-9][0-9]*(?![A-Za-z0-9_-])`, "g")
+        : null;
+    const plain = (t) => {
+        if (!t)
+            return;
+        if (!keyRe)
+            return void out.push({ type: "text", text: t });
+        let at = 0;
+        for (const k of t.matchAll(keyRe)) {
+            if (k.index > at)
+                out.push({ type: "text", text: t.slice(at, k.index) });
+            out.push(card(k[0]));
+            at = k.index + k[0].length;
+        }
+        if (at < t.length)
+            out.push({ type: "text", text: t.slice(at) });
+    };
+    const push = (t, marks) => {
+        if (!t)
+            return;
+        if (marks)
+            out.push({ type: "text", text: t, marks });
+        else
+            plain(t);
+    };
+    const siteIssueKey = (url) => {
+        if (!site || !url.startsWith(`${site}/browse/`))
+            return null;
+        const key = url.slice(site.length + "/browse/".length);
+        return ISSUE_KEY.test(key) ? key : null;
+    };
+    let last = 0;
+    for (const m of text.matchAll(INLINE)) {
+        push(text.slice(last, m.index));
+        if (m[1] !== undefined)
+            push(m[1], [{ type: "strong" }]);
+        else if (m[2] !== undefined)
+            push(m[2], [{ type: "code" }]);
+        else if (m[3] !== undefined)
+            push(m[3], [{ type: "em" }]);
+        else if (m[5]?.startsWith("https://"))
+            push(m[4], [{ type: "link", attrs: { href: m[5] } }]);
+        else if (m[6] !== undefined) {
+            const key = siteIssueKey(m[6]);
+            if (key)
+                out.push(card(key));
+            else
+                push(m[6], [{ type: "link", attrs: { href: m[6] } }]);
+        }
+        else
+            push(m[0]);
+        last = m.index + m[0].length;
+    }
+    push(text.slice(last));
+    return out;
+}
+export function markdownToAdf(markdown, smart) {
+    const paragraph = (text) => ({ type: "paragraph", content: inline(text, smart) });
+    const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+    const content = [];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.trim() === "") {
+            i++;
+            continue;
+        }
+        const fence = /^```(\w*)\s*$/.exec(line);
+        if (fence) {
+            const body = [];
+            i++;
+            while (i < lines.length && !/^```\s*$/.test(lines[i]))
+                body.push(lines[i++]);
+            i++;
+            content.push({
+                type: "codeBlock",
+                ...(fence[1] ? { attrs: { language: fence[1] } } : {}),
+                content: body.length ? [{ type: "text", text: body.join("\n") }] : [],
+            });
+            continue;
+        }
+        const heading = /^(#{1,3})\s+(.*)$/.exec(line);
+        if (heading) {
+            content.push({ type: "heading", attrs: { level: heading[1].length }, content: inline(heading[2], smart) });
+            i++;
+            continue;
+        }
+        const listOf = (re, type) => {
+            const items = [];
+            while (i < lines.length && re.test(lines[i])) {
+                items.push({ type: "listItem", content: [paragraph(lines[i].replace(re, ""))] });
+                i++;
+            }
+            content.push({ type, content: items });
+        };
+        if (/^\s*[-*]\s+/.test(line)) {
+            listOf(/^\s*[-*]\s+/, "bulletList");
+            continue;
+        }
+        if (/^\s*\d+\.\s+/.test(line)) {
+            listOf(/^\s*\d+\.\s+/, "orderedList");
+            continue;
+        }
+        if (/^>\s?/.test(line)) {
+            const quoted = [];
+            while (i < lines.length && /^>\s?/.test(lines[i]))
+                quoted.push(lines[i++].replace(/^>\s?/, ""));
+            content.push({ type: "blockquote", content: [paragraph(quoted.join(" "))] });
+            continue;
+        }
+        const para = [];
+        while (i < lines.length && lines[i].trim() !== "" && !/^(```|#{1,3}\s|\s*[-*]\s|\s*\d+\.\s|>)/.test(lines[i])) {
+            para.push(lines[i++]);
+        }
+        content.push(paragraph(para.join(" ")));
+    }
+    return { type: "doc", version: 1, content };
+}
+const BLOCKS = new Set(["paragraph", "heading", "codeBlock", "blockquote", "listItem", "rule", "panel", "tableRow"]);
+/**
+ * Webhook payloads carry rich text in the REST v2 shape: a wiki-markup
+ * string, where a mention is `[~accountid:<accountId>]`.
+ */
+const WIKI_MENTION = /\[~accountid:([^\]\s]+)\]/gi;
+export function adfToText(node, maxChars = 20_000) {
+    if (typeof node === "string")
+        return cap(node.replace(WIKI_MENTION, "@user"), maxChars);
+    const parts = [];
+    const walk = (n) => {
+        if (!n || typeof n !== "object")
+            return;
+        const a = n;
+        if (a.type === "text" && typeof a.text === "string")
+            parts.push(a.text);
+        else if (a.type === "mention")
+            parts.push(typeof a.attrs?.text === "string" ? a.attrs.text : "@user");
+        else if (a.type === "hardBreak")
+            parts.push("\n");
+        for (const c of a.content ?? [])
+            walk(c);
+        if (BLOCKS.has(a.type))
+            parts.push("\n");
+    };
+    walk(node);
+    return cap(parts
+        .join("")
+        .replace(/\n{2,}/g, "\n")
+        .trim(), maxChars);
+}
+function cap(text, max) {
+    return text.length > max ? `${text.slice(0, max)}…` : text;
+}
+export function adfMentionIds(node) {
+    if (typeof node === "string")
+        return [...node.matchAll(WIKI_MENTION)].map((m) => m[1]);
+    const ids = [];
+    const walk = (n) => {
+        if (!n || typeof n !== "object")
+            return;
+        const a = n;
+        if (a.type === "mention" && typeof a.attrs?.id === "string")
+            ids.push(a.attrs.id);
+        for (const c of a.content ?? [])
+            walk(c);
+    };
+    walk(node);
+    return ids;
+}

package/dist/providers/issue-tracker/index.d.ts

@@ -0,0 +1,5 @@
+import type { IssueTrackerRegistry } from "./types.js";
+export * from "./types.js";
+export { JiraIssueTracker, agentFooter } from "./jira.js";
+/** One tracker per configured provider; empty when Jira isn't configured (the jira_* tools are then never offered). */
+export declare function buildIssueTrackers(env?: NodeJS.ProcessEnv): IssueTrackerRegistry;

package/dist/providers/issue-tracker/index.js

@@ -0,0 +1,12 @@
+import { loadJiraConfig } from "../../config/providers.js";
+import { JiraClient } from "./jira-client.js";
+import { JiraIssueTracker } from "./jira.js";
+export * from "./types.js";
+export { JiraIssueTracker, agentFooter } from "./jira.js";
+/** One tracker per configured provider; empty when Jira isn't configured (the jira_* tools are then never offered). */
+export function buildIssueTrackers(env = process.env) {
+    const jira = loadJiraConfig(env);
+    return jira
+        ? { jira: new JiraIssueTracker(new JiraClient(jira), jira.siteUrl, { epicLinkField: jira.epicLinkField }) }
+        : {};
+}

package/dist/providers/issue-tracker/jira-client.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Minimal Jira Cloud REST client. Holds the credential; callers pass paths.
+ * One retry on 429 honouring Retry-After (capped), per Atlassian's
+ * rate-limiting guidance. Response bodies are never logged.
+ */
+import type { JiraConfig } from "../../config/providers.js";
+export interface RequestOptions {
+    /** Accept an empty 2xx body as `undefined` (void writes). */
+    allowEmpty?: boolean;
+    /** Per-attempt timeout; default 30 s. */
+    timeoutMs?: number;
+    /** Retry once on 429 honouring Retry-After; default true. */
+    retryOn429?: boolean;
+}
+export declare class JiraClient {
+    private readonly cfg;
+    private readonly authorization;
+    private readonly fetchImpl;
+    private readonly sleep;
+    /**
+     * Always sent explicitly: undici's default `Accept-Language: *` makes Jira answer in the site's default
+     * language rather than the account's own, which breaks matching of status and link type names.
+     */
+    private language;
+    constructor(cfg: Pick<JiraConfig, "apiBaseUrl" | "auth">, opts?: {
+        fetch?: typeof fetch;
+        sleep?: (ms: number) => Promise<void>;
+    });
+    setLanguage(tag: string): void;
+    request<T>(method: "GET" | "POST" | "PUT", path: string, body?: unknown, opts?: RequestOptions): Promise<T>;
+    /**
+     * GET returning at most `maxBytes` of the raw body (attachment content). Sends `Range` (unless
+     * `range: false`) and caps client-side too, in case the server ignores it. Redirects are never followed with the credential:
+     * a 3xx is followed only to an https Atlassian host and without Authorization.
+     */
+    requestBytes(path: string, opts: {
+        maxBytes: number;
+        timeoutMs?: number;
+        range?: boolean;
+    }): Promise<Uint8Array>;
+}

package/dist/providers/issue-tracker/jira-client.js

@@ -0,0 +1,151 @@
+import { IssueTrackerError } from "./types.js";
+const MAX_RETRY_AFTER_MS = 10_000;
+const DEFAULT_TIMEOUT_MS = 30_000;
+export class JiraClient {
+    cfg;
+    authorization;
+    fetchImpl;
+    sleep;
+    /**
+     * Always sent explicitly: undici's default `Accept-Language: *` makes Jira answer in the site's default
+     * language rather than the account's own, which breaks matching of status and link type names.
+     */
+    language = "en-US";
+    constructor(cfg, opts = {}) {
+        this.cfg = cfg;
+        this.authorization = `Bearer ${cfg.auth.token}`;
+        this.fetchImpl = opts.fetch ?? fetch;
+        this.sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    }
+    setLanguage(tag) {
+        this.language = tag;
+    }
+    async request(method, path, body, opts = {}) {
+        for (let attempt = 0;; attempt++) {
+            let res;
+            try {
+                res = await this.fetchImpl(`${this.cfg.apiBaseUrl}${path}`, {
+                    method,
+                    headers: {
+                        authorization: this.authorization,
+                        accept: "application/json",
+                        "accept-language": this.language,
+                        ...(body !== undefined ? { "content-type": "application/json" } : {}),
+                    },
+                    ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+                    signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+                });
+            }
+            catch {
+                throw new IssueTrackerError("tracker_api_error", "Jira could not be reached.");
+            }
+            if (res.status === 429 && attempt === 0 && opts.retryOn429 !== false) {
+                const seconds = Number(res.headers.get("retry-after"));
+                await this.sleep(Math.min(Number.isFinite(seconds) && seconds > 0 ? seconds * 1000 : 2000, MAX_RETRY_AFTER_MS));
+                continue;
+            }
+            if (res.status === 204)
+                return undefined;
+            if (!res.ok)
+                throw statusError(res.status);
+            try {
+                // Void writes (issue links, property writes) may succeed with an empty body; JSON callers may not.
+                const text = await res.text();
+                if (text === "" && opts.allowEmpty)
+                    return undefined;
+                return JSON.parse(text);
+            }
+            catch {
+                throw new IssueTrackerError("tracker_invalid_response", "Jira returned a response that was not JSON.");
+            }
+        }
+    }
+    /**
+     * GET returning at most `maxBytes` of the raw body (attachment content). Sends `Range` (unless
+     * `range: false`) and caps client-side too, in case the server ignores it. Redirects are never followed with the credential:
+     * a 3xx is followed only to an https Atlassian host and without Authorization.
+     */
+    async requestBytes(path, opts) {
+        const headers = {
+            authorization: this.authorization,
+            accept: "*/*",
+            "accept-language": this.language,
+            ...(opts.range === false ? {} : { range: `bytes=0-${Math.max(opts.maxBytes, 1) - 1}` }),
+        };
+        let url = `${this.cfg.apiBaseUrl}${path}`;
+        let res;
+        let retried = false;
+        try {
+            for (let hops = 0; hops <= 3;) {
+                res = await this.fetchImpl(url, {
+                    method: "GET",
+                    headers,
+                    redirect: "manual",
+                    signal: AbortSignal.timeout(opts.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+                });
+                if (res.status === 429 && !retried) {
+                    retried = true;
+                    const seconds = Number(res.headers.get("retry-after"));
+                    await this.sleep(Math.min(Number.isFinite(seconds) && seconds > 0 ? seconds * 1000 : 2000, MAX_RETRY_AFTER_MS));
+                    continue;
+                }
+                if (res.status < 300 || res.status >= 400)
+                    break;
+                hops++;
+                let next;
+                try {
+                    next = new URL(res.headers.get("location") ?? "", url);
+                }
+                catch {
+                    throw new IssueTrackerError("tracker_invalid_response", "Jira returned an unusable download redirect.");
+                }
+                if (next.protocol !== "https:" || !isAtlassianHost(next.hostname))
+                    throw new IssueTrackerError("tracker_invalid_response", "Jira redirected the download somewhere unexpected.");
+                url = next.toString();
+                // A pre-signed media URL: the Jira credential never goes to it.
+                delete headers.authorization;
+            }
+        }
+        catch (err) {
+            if (err instanceof IssueTrackerError)
+                throw err;
+            throw new IssueTrackerError("tracker_api_error", "Jira could not be reached.");
+        }
+        if (!res || (res.status >= 300 && res.status < 400))
+            throw new IssueTrackerError("tracker_api_error", "Jira's download redirected too many times.");
+        if (!res.ok)
+            throw statusError(res.status);
+        const chunks = [];
+        let total = 0;
+        try {
+            const reader = res.body?.getReader();
+            while (reader && total < opts.maxBytes) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const piece = value.subarray(0, opts.maxBytes - total);
+                chunks.push(piece);
+                total += piece.length;
+            }
+            if (reader && total >= opts.maxBytes)
+                await reader.cancel().catch(() => undefined);
+        }
+        catch {
+            throw new IssueTrackerError("tracker_api_error", "Jira's download was interrupted.");
+        }
+        return Buffer.concat(chunks);
+    }
+}
+/** Hosts a download redirect may point at (Atlassian media). */
+const isAtlassianHost = (h) => /(^|\.)(atlassian\.com|atlassian\.net|atl-paas\.net)$/.test(h);
+function statusError(status) {
+    if (status === 404)
+        return new IssueTrackerError("tracker_not_found", "Not found in Jira (or not visible to wardby's Jira account).");
+    if (status === 401 || status === 403)
+        return new IssueTrackerError("tracker_permission_denied", "wardby's Jira account is not allowed to do that.");
+    if (status === 429)
+        return new IssueTrackerError("tracker_rate_limited", "Jira is rate-limiting wardby; try again shortly.");
+    if (status === 400)
+        return new IssueTrackerError("tracker_invalid_request", "Jira rejected the request as invalid.");
+    return new IssueTrackerError("tracker_api_error", `Jira returned HTTP ${status}.`);
+}

package/dist/providers/issue-tracker/jira-events.d.ts

@@ -0,0 +1,3 @@
+import { type IssueEvent } from "./types.js";
+export declare function verifyJiraSignature(rawBody: string, header: string | undefined, secret: string): boolean;
+export declare function normalizeJiraEvent(payload: unknown, botAccountId: string): IssueEvent | null;

package/dist/providers/issue-tracker/jira-events.js

@@ -0,0 +1,98 @@
+/**
+ * Jira Cloud webhook → host-neutral IssueEvent. Pure: no I/O. The signature
+ * is WebSub-style (X-Hub-Signature: <method>=<hex HMAC of the raw body>);
+ * only sha256 is accepted. Actors that aren't licensed humans (JSM
+ * customers, apps) and the bot itself never produce an event.
+ */
+import { createHmac, timingSafeEqual } from "node:crypto";
+import { adfMentionIds, adfToText } from "./adf.js";
+import { ISSUE_KEY, projectOf } from "./types.js";
+const MAX_TEXT = 20_000;
+export function verifyJiraSignature(rawBody, header, secret) {
+    if (!header || !/^sha256=[0-9a-f]{64}$/i.test(header))
+        return false;
+    const expected = createHmac("sha256", secret).update(rawBody, "utf8").digest();
+    const presented = Buffer.from(header.slice("sha256=".length), "hex");
+    return presented.length === expected.length && timingSafeEqual(presented, expected);
+}
+const obj = (v) => (v && typeof v === "object" && !Array.isArray(v) ? v : null);
+const str = (v) => (typeof v === "string" ? v : "");
+function humanActor(user, bot) {
+    const u = obj(user);
+    if (!u || typeof u.accountId !== "string" || u.accountType !== "atlassian" || u.accountId === bot)
+        return null;
+    return { accountId: u.accountId, displayName: str(u.displayName) };
+}
+const words = (s) => str(s).split(/\s+/).filter(Boolean);
+function getChangelogField(item, field) {
+    return item[field];
+}
+export function normalizeJiraEvent(payload, botAccountId) {
+    const p = obj(payload);
+    if (!p)
+        return null;
+    const event = str(p.webhookEvent);
+    const issue = obj(p.issue);
+    const issueKey = str(issue?.key);
+    if (!ISSUE_KEY.test(issueKey))
+        return null;
+    const fields = obj(issue?.fields);
+    const subject = fields
+        ? { summary: str(fields.summary).slice(0, 256), description: adfToText(fields.description, MAX_TEXT) }
+        : undefined;
+    const base = {
+        provider: "jira",
+        projectKey: projectOf(issueKey),
+        issueKey,
+        addedLabels: [],
+        ...(subject ? { subject } : {}),
+    };
+    if (event === "jira:issue_created") {
+        const actor = humanActor(p.user, botAccountId);
+        return actor ? { ...base, kinds: ["created"], actor } : null;
+    }
+    if (event === "jira:issue_updated") {
+        const actor = humanActor(p.user, botAccountId);
+        if (!actor)
+            return null;
+        const items = Array.isArray(obj(p.changelog)?.items) ? obj(p.changelog).items.map(obj) : [];
+        const kinds = [];
+        const out = { ...base, kinds, actor };
+        for (const item of items) {
+            if (!item)
+                continue;
+            if (item.field === "status" && str(getChangelogField(item, "toString"))) {
+                kinds.push("transitioned");
+                out.toStatus = str(getChangelogField(item, "toString"));
+            }
+            else if (item.field === "labels") {
+                const before = new Set(words(getChangelogField(item, "fromString")));
+                const added = words(getChangelogField(item, "toString")).filter((l) => !before.has(l));
+                if (added.length) {
+                    kinds.push("labeled");
+                    out.addedLabels = added;
+                }
+            }
+            else if (item.field === "assignee" && typeof item.to === "string" && item.to) {
+                kinds.push("assigned");
+                out.assigneeAccountId = item.to;
+            }
+        }
+        return kinds.length ? out : null;
+    }
+    if (event === "comment_created" || event === "comment_updated") {
+        const comment = obj(p.comment);
+        // An edit is attributed to the editor, never the original author:
+        // otherwise anyone who can edit others' comments could reuse a trusted
+        // user's mention to pass the allowlist.
+        const actor = event === "comment_updated"
+            ? humanActor(comment?.updateAuthor, botAccountId)
+            : humanActor(comment?.author ?? p.user, botAccountId);
+        if (!actor || !comment || typeof comment.id !== "string")
+            return null;
+        if (!adfMentionIds(comment.body).includes(botAccountId))
+            return null;
+        return { ...base, kinds: ["mention"], actor, comment: { id: comment.id, body: adfToText(comment.body, MAX_TEXT) } };
+    }
+    return null;
+}

package/dist/providers/issue-tracker/jira.d.ts

@@ -0,0 +1,116 @@
+import type { JiraClient, RequestOptions } from "./jira-client.js";
+import { type CreateIssueInput, type CreateMetaField, type CreateMetaIssueType, type IssueSearchResult, type IssueSnapshot, type IssueTracker, type IssueTrackerIdentity, type IssueView, type TrackerCallOptions } from "./types.js";
+export declare const agentFooter: (agentId: string) => string;
+/** Whether rendered comment text ends with this agent's footer (as adfToText renders it: no markdown underscores). */
+export declare const hasAgentFooter: (text: string, agentId: string) => boolean;
+/** Whether rendered comment text ends with wardby's run-status footer (`_wardby run <id>_` as adfToText renders it). */
+export declare const isStatusComment: (text: string) => boolean;
+/**
+ * One call's budget (TrackerCallOptions): each request gets what is left of `timeoutMs`, and awaits that
+ * are not requests (the cached identity) are abandoned at the deadline. Without `timeoutMs`, a no-op.
+ */
+declare function callBudget(opts?: TrackerCallOptions): {
+    request(extra?: RequestOptions): RequestOptions;
+    within<T>(p: Promise<T>): Promise<T>;
+};
+type CallBudget = ReturnType<typeof callBudget>;
+export declare class JiraIssueTracker implements IssueTracker {
+    private readonly client;
+    private readonly siteUrl;
+    private readonly opts;
+    readonly provider: "jira";
+    private me;
+    constructor(client: JiraClient, siteUrl: string, opts?: {
+        epicLinkField?: string;
+    });
+    identity(): Promise<IssueTrackerIdentity>;
+    /** Refuses to act when the token belongs to a person; a failed identity() propagates and is not cached. */
+    private ready;
+    botAccountId(): Promise<string>;
+    /** Markdown to ADF, with this site's issue links (and the given projects' bare keys) as smart links. */
+    private toAdf;
+    issueUrl(key: string): string;
+    getIssue(key: string, opts: {
+        maxComments: number;
+        agentMarker: string;
+    } & TrackerCallOptions): Promise<IssueView>;
+    issueProject(key: string): Promise<string>;
+    snapshotIssue(key: string, opts?: {
+        timeoutMs?: number;
+        retryOn429?: boolean;
+    }): Promise<IssueSnapshot>;
+    search(jql: string, opts: {
+        maxResults: number;
+        timeoutMs?: number;
+        retryOn429?: boolean;
+    }): Promise<IssueSearchResult>;
+    matchesJql(key: string, jql: string, opts?: {
+        timeoutMs?: number;
+        retryOn429?: boolean;
+    }): Promise<boolean>;
+    comment(key: string, input: {
+        markdown: string;
+        visibilityRole?: string;
+        issueKeyProjects?: readonly string[];
+    }, opts?: TrackerCallOptions): Promise<{
+        id: string;
+        url: string;
+    }>;
+    editComment(key: string, commentId: string, input: {
+        markdown: string;
+        issueKeyProjects?: readonly string[];
+    }): Promise<void>;
+    readComment(key: string, commentId: string): Promise<{
+        authorId: string | null;
+        body: string;
+    } | null>;
+    transitions(key: string): Promise<Array<{
+        id: string;
+        name: string;
+        toStatus: string;
+        toCategory: string;
+    }>>;
+    transitionTo(key: string, toStatus: string): Promise<{
+        transitionId: string;
+        toStatus: string;
+    }>;
+    editableFields(key: string): Promise<string[]>;
+    editFields(key: string, fields: Record<string, unknown>): Promise<void>;
+    linkTypes(opts?: TrackerCallOptions): Promise<Array<{
+        name: string;
+        inward: string;
+        outward: string;
+    }>>;
+    linkIssues(input: {
+        type: string;
+        inwardKey: string;
+        outwardKey: string;
+    }, opts?: TrackerCallOptions): Promise<void>;
+    addRemoteLink(key: string, input: {
+        globalId: string;
+        url: string;
+        title: string;
+        status?: {
+            resolved: boolean;
+        };
+    }): Promise<void>;
+    getProperty(key: string, property: string): Promise<unknown>;
+    setProperty(key: string, property: string, value: unknown): Promise<void>;
+    /** Pages a createmeta endpoint (startAt/maxResults/total), capped. */
+    private pagedMeta;
+    createMeta(projectKey: string, budget?: CallBudget): Promise<{
+        issueTypes: CreateMetaIssueType[];
+    }>;
+    fieldMeta(projectKey: string, issueTypeId: string, budget?: CallBudget): Promise<CreateMetaField[]>;
+    createIssue(input: CreateIssueInput, opts?: TrackerCallOptions): Promise<{
+        key: string;
+        url: string;
+    }>;
+    readAttachmentText(id: string, maxBytes: number): Promise<{
+        filename: string;
+        mimeType: string;
+        text: string;
+        truncated: boolean;
+    }>;
+}
+export {};