redmine-context 1.0.0

package/dist/surfaces/tui/hooks/use-exit-guard.d.ts

@@ -0,0 +1,18 @@
+/** Tempo (ms) que o aviso de saída fica armado antes de expirar sozinho. */
+export declare const EXIT_GUARD_WINDOW_MS = 2000;
+/** Valor retornado pelo hook. */
+export interface UseExitGuardResult {
+    /** `true` enquanto o aviso "pressione Ctrl+C de novo para sair" deve aparecer. */
+    armed: boolean;
+}
+/**
+ * Liga o handler global de Ctrl+C do app.
+ *
+ * @param onExit Chamado na segunda pressão dentro da janela de tempo.
+ * @param onCancel Chamado na primeira pressão (cancela uma operação em
+ *   andamento, se houver). Opcional.
+ * @param windowMs Janela de tempo em que a segunda pressão conta como
+ *   confirmação de saída. Parametrizável para testes; usa
+ *   {@link EXIT_GUARD_WINDOW_MS} por padrão em produção.
+ */
+export declare function useExitGuard(onExit: () => void, onCancel?: () => void, windowMs?: number): UseExitGuardResult;

package/dist/surfaces/tui/hooks/use-exit-guard.js

@@ -0,0 +1,66 @@
+/**
+ * Padrão "duplo Ctrl+C" da TUI (M2-04): a primeira pressão cancela uma
+ * operação em andamento (gancho `onCancel` — ainda sem consumidor no M2-04,
+ * mas já pronto para telas assíncronas futuras: login em validação no
+ * M2-05.2, job rodando no M2-11) e arma um aviso visual temporizado; uma
+ * segunda pressão dentro da janela de tempo encerra o app via `onExit`. Fora
+ * da janela, a pressão seguinte volta a contar como a "primeira".
+ *
+ * Isolado do roteador (`../app.tsx`) para poder ser testado sem depender do
+ * resto da árvore de telas — `app.tsx` só liga `onExit` a `useApp().exit()`.
+ *
+ * Requer que o app rode com `exitOnCtrlC: false` no `render()` do Ink
+ * (`../index.ts`) — do contrário, o próprio Ink intercepta Ctrl+C antes de
+ * `useInput()` rodar e sai do processo na primeira pressão, sem chance deste
+ * hook aplicar o padrão de duas pressões.
+ */
+import { useInput } from 'ink';
+import { useEffect, useRef, useState } from 'react';
+/** Tempo (ms) que o aviso de saída fica armado antes de expirar sozinho. */
+export const EXIT_GUARD_WINDOW_MS = 2000;
+/**
+ * Liga o handler global de Ctrl+C do app.
+ *
+ * @param onExit Chamado na segunda pressão dentro da janela de tempo.
+ * @param onCancel Chamado na primeira pressão (cancela uma operação em
+ *   andamento, se houver). Opcional.
+ * @param windowMs Janela de tempo em que a segunda pressão conta como
+ *   confirmação de saída. Parametrizável para testes; usa
+ *   {@link EXIT_GUARD_WINDOW_MS} por padrão em produção.
+ */
+export function useExitGuard(onExit, onCancel, windowMs = EXIT_GUARD_WINDOW_MS) {
+    const [armed, setArmed] = useState(false);
+    // Reason: `armedRef` é a fonte de verdade lida de forma síncrona dentro do
+    // handler de input — evita depender da closure presa ao `armed` da última
+    // renderização (o handler de `useInput` é recriado a cada render, mas o
+    // `ref` sempre reflete o estado mais recente, mesmo entre pressões rápidas).
+    const armedRef = useRef(false);
+    const timeoutRef = useRef(undefined);
+    useEffect(() => {
+        return () => {
+            if (timeoutRef.current !== undefined) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, []);
+    useInput((input, key) => {
+        if (!(key.ctrl && input === 'c')) {
+            return;
+        }
+        if (armedRef.current) {
+            onExit();
+            return;
+        }
+        onCancel?.();
+        armedRef.current = true;
+        setArmed(true);
+        if (timeoutRef.current !== undefined) {
+            clearTimeout(timeoutRef.current);
+        }
+        timeoutRef.current = setTimeout(() => {
+            armedRef.current = false;
+            setArmed(false);
+        }, windowMs);
+    });
+    return { armed };
+}

package/dist/surfaces/tui/hooks/use-export-bundle.d.ts

@@ -0,0 +1,62 @@
+import { type Issue } from '../../../index.js';
+/** Formato escolhido na tela: os dois formatos do core, ou ambos de uma vez. */
+export type ExportFormat = 'md' | 'json' | 'both';
+/** Um arquivo gravado com sucesso. */
+export interface ExportedFile {
+    /** Formato do arquivo (sempre um dos dois formatos reais do core, nunca `'both'`). */
+    format: 'md' | 'json';
+    /** Caminho absoluto do arquivo gravado. */
+    path: string;
+}
+/** Estado da exportação, consumido por `../screens/export.tsx`. */
+export type ExportBundleState = {
+    status: 'idle';
+} | {
+    status: 'exporting';
+} | {
+    status: 'success';
+    files: ExportedFile[];
+} | {
+    status: 'error';
+    message: string;
+};
+/** Dependências injetáveis do hook — hoje só o ambiente (para `REDMINE_URL`). */
+export interface UseExportBundleOptions {
+    /** Ambiente consultado para `REDMINE_URL` (compõe o bundle); default `process.env`. */
+    env?: NodeJS.ProcessEnv;
+}
+/** Valor retornado pelo hook. */
+export interface UseExportBundleResult {
+    /** Estado atual da exportação (ver {@link ExportBundleState}). */
+    state: ExportBundleState;
+    /** Dispara a exportação: empacota e grava `<id>.<ext>` no destino informado. */
+    runExport: (format: ExportFormat, destination: string) => Promise<void>;
+    /** Volta ao estado `idle` — usado para tentar de novo após um erro. */
+    reset: () => void;
+}
+/**
+ * Expande um `~` inicial para o diretório home do usuário (mesma convenção
+ * de shells POSIX) — `~` sozinho ou `~/resto/do/caminho`. Qualquer outro
+ * caminho (absoluto, relativo, ou um `~` no meio da string) é devolvido sem
+ * alteração.
+ *
+ * @param path - Caminho digitado pelo usuário no destino.
+ * @param getHomedir - Resolve o diretório home; default `node:os`'s `homedir`.
+ * @returns Caminho com `~` expandido, se aplicável.
+ * @example
+ * expandHome('~/exports') // => '/home/ana/exports'
+ * expandHome('/tmp/out')  // => '/tmp/out' (inalterado)
+ */
+export declare function expandHome(path: string, getHomedir?: () => string): string;
+/**
+ * Empacota `issue` (`buildMarkdownBundle`/`buildJsonBundle`) e grava o(s)
+ * arquivo(s) resultante(s) no destino informado.
+ *
+ * @param issue - Issue já normalizada, em memória (ver o JSDoc do módulo).
+ * @param options - Dependências injetáveis. Ver {@link UseExportBundleOptions}.
+ * @returns O {@link UseExportBundleResult} atual.
+ * @example
+ * const { state, runExport } = useExportBundle(issue);
+ * await runExport('both', '~/exports');
+ */
+export declare function useExportBundle(issue: Issue | undefined, options?: UseExportBundleOptions): UseExportBundleResult;

package/dist/surfaces/tui/hooks/use-export-bundle.js

@@ -0,0 +1,100 @@
+/**
+ * Lógica de dados da tela de exportação do bundle (#33): empacota a issue já
+ * carregada (`../screens/loaded-issue-context.js`, ver o JSDoc daquele módulo
+ * para a escolha de REUSAR a issue em memória em vez de refazer a busca) nos
+ * formatos Markdown/JSON/ambos e grava `<id>.md`/`<id>.json` no destino
+ * informado pelo usuário.
+ *
+ * Fronteira do core (ADR-005): `buildMarkdownBundle`/`buildJsonBundle` +
+ * `TOOL_VERSION` vêm de `../../../index.js` — nenhum módulo interno do core é
+ * importado direto por aqui.
+ *
+ * `node:fs/promises` (`writeFile`) é importado DIRETO no topo do módulo (sem
+ * injeção via opções) — mesmo padrão de `../../cli/commands.ts`, o único
+ * outro lugar do repo que grava bundles em disco. Os testes mockam o módulo
+ * inteiro com `vi.mock('node:fs/promises', ...)` (ver
+ * `tests/surfaces/tui/hooks/use-export-bundle.test.tsx`), não memfs.
+ *
+ * ## Escolha deliberada: sem `mkdir` automático
+ *
+ * Diferente do `--out` da CLI (que cria o diretório com `mkdir(..., {
+ * recursive: true })` porque o usuário passou uma flag explícita para um
+ * pipeline não-interativo), esta tela é interativa e a AC da #33 pede um
+ * estado de erro dedicado para "diretório inexistente" — se o diretório
+ * fosse criado silenciosamente, esse caminho de erro nunca aconteceria e o
+ * usuário nunca veria (nem teria chance de corrigir) um destino digitado
+ * errado. `writeFile` falha com `ENOENT` nesse caso; o erro é mostrado com a
+ * ação corretiva de criar o diretório ou escolher outro destino.
+ */
+import { writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { useCallback, useState } from 'react';
+import { buildJsonBundle, buildMarkdownBundle, TOOL_VERSION } from '../../../index.js';
+/**
+ * Expande um `~` inicial para o diretório home do usuário (mesma convenção
+ * de shells POSIX) — `~` sozinho ou `~/resto/do/caminho`. Qualquer outro
+ * caminho (absoluto, relativo, ou um `~` no meio da string) é devolvido sem
+ * alteração.
+ *
+ * @param path - Caminho digitado pelo usuário no destino.
+ * @param getHomedir - Resolve o diretório home; default `node:os`'s `homedir`.
+ * @returns Caminho com `~` expandido, se aplicável.
+ * @example
+ * expandHome('~/exports') // => '/home/ana/exports'
+ * expandHome('/tmp/out')  // => '/tmp/out' (inalterado)
+ */
+export function expandHome(path, getHomedir = homedir) {
+    if (path === '~')
+        return getHomedir();
+    if (path.startsWith('~/'))
+        return join(getHomedir(), path.slice(2));
+    return path;
+}
+/** Os dois formatos reais do core que `format` produz (`'both'` vira os dois). */
+function realFormats(format) {
+    return format === 'both' ? ['md', 'json'] : [format];
+}
+/**
+ * Empacota `issue` (`buildMarkdownBundle`/`buildJsonBundle`) e grava o(s)
+ * arquivo(s) resultante(s) no destino informado.
+ *
+ * @param issue - Issue já normalizada, em memória (ver o JSDoc do módulo).
+ * @param options - Dependências injetáveis. Ver {@link UseExportBundleOptions}.
+ * @returns O {@link UseExportBundleResult} atual.
+ * @example
+ * const { state, runExport } = useExportBundle(issue);
+ * await runExport('both', '~/exports');
+ */
+export function useExportBundle(issue, options = {}) {
+    const env = options.env ?? process.env;
+    const [state, setState] = useState({ status: 'idle' });
+    const reset = useCallback(() => {
+        setState({ status: 'idle' });
+    }, []);
+    const runExport = useCallback(async (format, destination) => {
+        if (issue === undefined) {
+            setState({ status: 'error', message: 'Nenhuma issue carregada para exportar.' });
+            return;
+        }
+        setState({ status: 'exporting' });
+        const trimmed = destination.trim();
+        const dir = resolve(expandHome(trimmed.length > 0 ? trimmed : '.'));
+        const meta = { baseUrl: env.REDMINE_URL ?? '', toolVersion: TOOL_VERSION };
+        try {
+            const files = [];
+            for (const fmt of realFormats(format)) {
+                const content = fmt === 'json' ? buildJsonBundle(issue, meta).canonical : buildMarkdownBundle(issue, meta);
+                const path = join(dir, `${issue.id}.${fmt}`);
+                await writeFile(path, content, 'utf8');
+                files.push({ format: fmt, path });
+            }
+            setState({ status: 'success', files });
+        }
+        catch (cause) {
+            const message = cause instanceof Error ? cause.message : String(cause);
+            setState({ status: 'error', message });
+        }
+    }, [issue, env]);
+    return { state, runExport, reset };
+}

package/dist/surfaces/tui/hooks/use-issue-detail.d.ts

@@ -0,0 +1,61 @@
+import { createHttpClient, getIssue, normalizeIssue, resolveApiKey, type Issue } from '../../../index.js';
+/**
+ * Estado da busca de detalhe de issue, consumido por
+ * `../screens/issue-detail.tsx`. `no-selection` cobre o caso defensivo de a
+ * tela ser alcançada sem uma issue selecionada (ver
+ * `../screens/home-selection.tsx`) — não deveria acontecer no fluxo normal
+ * (a home sempre define `selectedIssueId` antes de empilhar esta tela), mas
+ * evita uma busca com `issueId` inválido caso aconteça.
+ */
+export type IssueDetailState = {
+    status: 'no-selection';
+} | {
+    status: 'loading';
+} | {
+    status: 'loaded';
+    issue: Issue;
+} | {
+    status: 'error-network';
+    message: string;
+} | {
+    status: 'error-forbidden';
+    message: string;
+} | {
+    status: 'error-not-found';
+    message: string;
+} | {
+    status: 'auth-aborted';
+    message: string;
+};
+/** Dependências injetáveis do hook — todas opcionais, com defaults de produção via o core. */
+export interface UseIssueDetailOptions {
+    /** Ambiente consultado para `REDMINE_URL`; default `process.env`. */
+    env?: NodeJS.ProcessEnv;
+    /** Resolve a api_key pela cascata M2; default `resolveApiKey` do core. */
+    resolveApiKey?: typeof resolveApiKey;
+    /** Constrói o client HTTP autenticado; default `createHttpClient` do core. */
+    createHttpClient?: typeof createHttpClient;
+    /** Busca o payload bruto de `/issues/{id}.json`; default `getIssue` do core. */
+    getIssue?: typeof getIssue;
+    /** Normaliza o payload bruto no modelo `Issue`; default `normalizeIssue` do core. */
+    normalizeIssue?: typeof normalizeIssue;
+}
+/** Valor retornado pelo hook. */
+export interface UseIssueDetailResult {
+    /** Estado atual da busca (ver {@link IssueDetailState}). */
+    state: IssueDetailState;
+    /** Reexecuta a busca do zero — usado pelo retry (tecla `r`) dos estados de erro. */
+    retry: () => void;
+}
+/**
+ * Busca o detalhe completo de uma issue (`getIssue` + `normalizeIssue`) via
+ * o core.
+ *
+ * @param issueId - Id da issue a buscar, ou `undefined` (estado defensivo
+ *   `no-selection`, ver {@link IssueDetailState}).
+ * @param options - Dependências injetáveis. Ver {@link UseIssueDetailOptions}.
+ * @returns O {@link UseIssueDetailResult} atual.
+ * @example
+ * const { state, retry } = useIssueDetail(selectedIssueId); // deps de produção
+ */
+export declare function useIssueDetail(issueId: number | undefined, options?: UseIssueDetailOptions): UseIssueDetailResult;

package/dist/surfaces/tui/hooks/use-issue-detail.js

@@ -0,0 +1,132 @@
+/**
+ * Lógica de dados da tela de detalhe de issue (#31): busca o detalhe
+ * completo via o core — resolve a credencial pela cascata (`resolveApiKey`),
+ * monta um client HTTP autenticado (`createHttpClient`), busca o payload
+ * bruto (`getIssue`) e normaliza para o modelo estável (`normalizeIssue`).
+ *
+ * Escolha deliberada: `getIssue` + `normalizeIssue` DIRETO, não
+ * `fetchIssueBundle` — o bundle serializa para Markdown/JSON (formato de
+ * saída da CLI/MCP); a tela de detalhe da TUI precisa do modelo `Issue` em
+ * memória para renderizar metadados + paginar/rolar descrição e journals
+ * (`../components/scroll-view.tsx`), não de um texto já serializado.
+ *
+ * Extraída para um hook pelo mesmo motivo de `./use-my-issues.ts`: a busca é
+ * assíncrona e precisa ser testável com dependências injetadas — nenhum
+ * teste deste arquivo toca keychain ou rede reais.
+ *
+ * Fronteira do core (ADR-005): a única coisa importada daqui é
+ * `../../../index.js` — a tela (`../screens/issue-detail.tsx`) só formata os
+ * estados visuais, nunca chama o core diretamente.
+ *
+ * A instância vem de `REDMINE_URL` (mesma convenção do doctor/home — ver
+ * `./use-my-issues.ts`), lida do `env` injetado (default `process.env`).
+ *
+ * Mandatório (M2-13, #36): a busca é envolvida por `useAuthGuard` — um 401
+ * dispara o re-login e retoma a busca sozinha (o estado permanece `loading`
+ * até lá); se o re-login for abandonado (Esc), o hook expõe o estado
+ * `auth-aborted` (neutro, não um erro), com `retry` disponível.
+ */
+import { useCallback, useEffect, useState } from 'react';
+import { createHttpClient, getIssue, normalizeIssue, resolveApiKey, RedmineForbiddenError, RedmineNotFoundError, } from '../../../index.js';
+import { useEnvFallbackAllowed } from '../instance.js';
+import { ReAuthAbortedError, useAuthGuard } from './use-auth-guard.js';
+/** Lê `REDMINE_URL` do ambiente, tratando string vazia como ausente (mesma convenção do doctor/home). */
+function instanceFromEnv(env) {
+    const value = env.REDMINE_URL;
+    return value !== undefined && value.length > 0 ? value : undefined;
+}
+/**
+ * Busca o detalhe completo de uma issue (`getIssue` + `normalizeIssue`) via
+ * o core.
+ *
+ * @param issueId - Id da issue a buscar, ou `undefined` (estado defensivo
+ *   `no-selection`, ver {@link IssueDetailState}).
+ * @param options - Dependências injetáveis. Ver {@link UseIssueDetailOptions}.
+ * @returns O {@link UseIssueDetailResult} atual.
+ * @example
+ * const { state, retry } = useIssueDetail(selectedIssueId); // deps de produção
+ */
+export function useIssueDetail(issueId, options = {}) {
+    const env = options.env ?? process.env;
+    const resolve = options.resolveApiKey ?? resolveApiKey;
+    const buildClient = options.createHttpClient ?? createHttpClient;
+    const fetchIssue = options.getIssue ?? getIssue;
+    const normalize = options.normalizeIssue ?? normalizeIssue;
+    // Mandatório (M2-13, #36): ver o JSDoc do módulo.
+    const { guard } = useAuthGuard();
+    // SEGURANÇA (#187): origem config (URL persistida) → sem env-key instance-agnóstica.
+    const allowEnvFallback = useEnvFallbackAllowed();
+    const [state, setState] = useState(issueId === undefined ? { status: 'no-selection' } : { status: 'loading' });
+    const [reloadToken, setReloadToken] = useState(0);
+    const retry = useCallback(() => {
+        setReloadToken((current) => current + 1);
+    }, []);
+    useEffect(() => {
+        let cancelled = false;
+        if (issueId === undefined) {
+            setState({ status: 'no-selection' });
+            return;
+        }
+        setState({ status: 'loading' });
+        const instanceUrl = instanceFromEnv(env);
+        if (instanceUrl === undefined) {
+            setState({
+                status: 'error-network',
+                message: 'Instância não configurada (defina REDMINE_URL).',
+            });
+            return;
+        }
+        const cascadeOptions = { env, allowEnvFallback };
+        void (async () => {
+            try {
+                const apiKey = await resolve(instanceUrl, cascadeOptions);
+                if (apiKey === undefined) {
+                    if (!cancelled) {
+                        setState({
+                            status: 'error-network',
+                            message: `Nenhuma credencial encontrada para ${instanceUrl}.`,
+                        });
+                    }
+                    return;
+                }
+                const http = buildClient({ baseUrl: instanceUrl, apiKey });
+                const payload = await guard(() => fetchIssue(http, issueId));
+                if (cancelled)
+                    return;
+                setState({ status: 'loaded', issue: normalize(payload) });
+            }
+            catch (cause) {
+                if (cancelled)
+                    return;
+                if (cause instanceof RedmineNotFoundError) {
+                    setState({ status: 'error-not-found', message: `Issue #${issueId} não encontrada (404).` });
+                    return;
+                }
+                if (cause instanceof RedmineForbiddenError) {
+                    setState({
+                        status: 'error-forbidden',
+                        message: 'Sem permissão para ver esta issue nesta instância (403).',
+                    });
+                    return;
+                }
+                if (cause instanceof ReAuthAbortedError) {
+                    setState({
+                        status: 'auth-aborted',
+                        message: 'login cancelado — pressione r para tentar de novo',
+                    });
+                    return;
+                }
+                const message = cause instanceof Error ? cause.message : String(cause);
+                setState({ status: 'error-network', message });
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+        // Reason: `env`/`resolve`/`buildClient`/`fetchIssue`/`normalize`/`guard`
+        // são estáveis entre renders com as deps de produção — o efeito só
+        // precisa refazer a busca quando `issueId` muda (nova issue selecionada)
+        // ou `reloadToken` muda (retry).
+    }, [issueId, env, allowEnvFallback, resolve, buildClient, fetchIssue, normalize, guard, reloadToken]);
+    return { state, retry };
+}

package/dist/surfaces/tui/hooks/use-issue-search.d.ts

@@ -0,0 +1,71 @@
+import { fetchIssueSearch, resolveApiKey } from '../../../index.js';
+/** Debounce (ms) default aplicado a `query` antes de disparar a busca. */
+export declare const DEFAULT_DEBOUNCE_MS = 300;
+/** Filtro rápido de status (tecla `f` cicla entre os três, ver `../screens/home.tsx`). */
+export type SearchStatusFilter = 'open' | 'closed' | 'all';
+/**
+ * Estado da busca, consumido por `../screens/home.tsx`. Mesmo vocabulário de
+ * `MyIssuesState` (`use-my-issues.ts`) + um `idle` inicial próprio: a busca
+ * só começa a existir quando há algo para buscar (query não vazia OU filtro
+ * de status diferente de `'all'`) — sem isso, `idle` evita uma chamada de
+ * rede desnecessária assim que o campo de busca abre vazio.
+ */
+export type IssueSearchState = {
+    status: 'idle';
+} | {
+    status: 'loading';
+} | {
+    status: 'loaded';
+    content: string;
+    count: number;
+    degraded: boolean;
+    warnings: string[];
+} | {
+    status: 'error-network';
+    message: string;
+} | {
+    status: 'error-forbidden';
+    message: string;
+} | {
+    status: 'auth-aborted';
+    message: string;
+};
+/** Dependências injetáveis do hook — todas opcionais, com defaults de produção via o core. */
+export interface UseIssueSearchOptions {
+    /** Ambiente consultado para `REDMINE_URL`; default `process.env`. */
+    env?: NodeJS.ProcessEnv;
+    /** Resolve a api_key pela cascata M2; default `resolveApiKey` do core. */
+    resolveApiKey?: typeof resolveApiKey;
+    /** Orquestra a busca (filtros + full-text best-effort); default `fetchIssueSearch` do core. */
+    fetchIssueSearch?: typeof fetchIssueSearch;
+    /** Debounce (ms) aplicado a `query`. Default: {@link DEFAULT_DEBOUNCE_MS}. */
+    debounceMs?: number;
+}
+/** Valor retornado pelo hook. */
+export interface UseIssueSearchResult {
+    /** Estado atual da busca (ver {@link IssueSearchState}). */
+    state: IssueSearchState;
+    /**
+     * Restaura o estado para `idle` IMEDIATAMENTE, cancelando qualquer debounce
+     * pendente — usado pelo Esc da home (M2-07, #30) para "limpar a busca"
+     * sem esperar o debounce nem disparar uma nova chamada a `fetchIssueSearch`.
+     * A tela também deve resetar `query`/`statusFilter` para os valores neutros
+     * (`''`/`'all'`) ao chamar isto, para que o próximo efeito não reagende a
+     * mesma busca.
+     */
+    clear: () => void;
+}
+/**
+ * Busca issues (filtros + full-text best-effort) via o core, com debounce de
+ * digitação e o filtro rápido de status.
+ *
+ * @param query - Termo full-text bruto (não debounced) — tipicamente o
+ *   `value` do `TextInput` da busca da home.
+ * @param statusFilter - Filtro rápido de status (ver {@link SearchStatusFilter}).
+ * @param options - Dependências injetáveis. Ver {@link UseIssueSearchOptions}.
+ * @returns O {@link UseIssueSearchResult} atual.
+ *
+ * @example
+ * const { state, clear } = useIssueSearch(query, statusFilter); // deps de produção
+ */
+export declare function useIssueSearch(query: string, statusFilter: SearchStatusFilter, options?: UseIssueSearchOptions): UseIssueSearchResult;