/**
 * Helpers de agregação puros — composáveis, retornam objetos JS
 * diretamente serializáveis para JSON.
 */
/**
 * Agrupa registros por uma chave e retorna contagens: `{ chave: count }`.
 *
 * Chaves `null`/`undefined` são convertidas para a string literal 'null'
 * para garantir serialização JSON consistente.
 */
declare function countBy<T>(records: Iterable<T>, key: (record: T) => unknown): Record<string, number>;
/**
 * Agrupa por duas chaves aninhadas: `{ chaveA: { chaveB: count } }`.
 */
declare function countByNested<T>(records: Iterable<T>, keyA: (record: T) => unknown, keyB: (record: T) => unknown): Record<string, Record<string, number>>;
/**
 * Retorna os N pares `{ key, count }` com maior contagem de um mapa produzido
 * por `countBy`, ordenados decrescente.
 */
declare function topN(counts: Record<string, number>, n: number): Array<{
    count: number;
    key: string;
}>;

declare const index$6_countBy: typeof countBy;
declare const index$6_countByNested: typeof countByNested;
declare const index$6_topN: typeof topN;
declare namespace index$6 {
  export { index$6_countBy as countBy, index$6_countByNested as countByNested, index$6_topN as topN };
}

interface AtividadeConvenio {
    atividade: string;
    atividadeRotulo: string;
    convenio: string;
    convenioRotulo: string;
}

interface InstalacaoContagem {
    /** Código da instalação (ex: "QTINST15"). */
    codigo: string;
    /** Quantidade de unidades dessa instalação no estabelecimento. */
    quantidade: number;
    /** Rótulo pt-BR; null quando o código não está mapeado. */
    rotulo: null | string;
}

interface LeitosTotais {
    /** Leitos por especialidade (com quantidade > 0). */
    porEspecialidade: readonly {
        codigo: string;
        quantidade: number;
        rotulo: null | string;
    }[];
    /** Soma total de leitos (inclui `LEITHOSP` + todos os `QTLEIT*`). */
    total: number;
}

type Modalidade = 'ambos' | 'proprio' | 'terceirizado';
interface ServicoApoio {
    /** Código base (ex: "SERAP03"). */
    codigo: string;
    /** Modalidade da oferta. */
    modalidade: Modalidade;
    /** Rótulo pt-BR do serviço. */
    rotulo: string;
}

/**
 * Tipos para registros CNES.
 *
 * ST (estabelecimentos) e PF (profissionais) têm schemas distintos.
 * Demais colunas permanecem acessíveis via index signature.
 */
/**
 * Registro de estabelecimento (CNES-ST).
 */
interface CnesEstabelecimentoRecord {
    [key: string]: unknown;
    /** CNES de 7 dígitos. */
    CNES: string;
    /** CNPJ. */
    CNPJ_MAN: string | null;
    /** Código IBGE do município (6 dígitos). */
    CODUFMUN: string;
    /** Esfera administrativa (1=Federal, 2=Estadual, 3=Municipal, 4=Privada). */
    ESFERA_A: string | null;
    /** Nome fantasia do estabelecimento. */
    FANTASIA: string | null;
    /** Latitude (string — algumas versões). */
    LATITUDE: string | null;
    /** Longitude. */
    LONGITUDE: string | null;
    /** Razão social. */
    RAZAO: string | null;
    /** Tipo de estabelecimento (tabela TP_UNID). */
    TP_UNID: string | null;
}
/**
 * Registro de profissional (CNES-PF) — um registro por vínculo.
 */
interface CnesProfissionalRecord {
    [key: string]: unknown;
    /** CBO-Saúde 2002 (ocupação). */
    CBO: string;
    /** CNES do estabelecimento. */
    CNES: string;
    /** CNPJ da entidade contratante. */
    CNPJ_CPF: string | null;
    /** Código do município. */
    CODUFMUN: string;
    /** CPF do profissional (mascarado em algumas vintages). */
    CPF_PROF: string | null;
}

/**
 * Projeta um registro CNES-ST cru (150+ campos de códigos DATASUS) num
 * objeto legível em pt-BR, pronto pra consumo por apps web ou CLI.
 *
 * Campos categóricos vêm como `{ codigo, rotulo }` — o código original é
 * preservado pra permitir filtros e joins sem perda; o rótulo é o texto
 * humano correspondente (ou `null` quando o código não está mapeado).
 *
 * Agregações (leitos, instalações, serviços de apoio, matriz
 * atividade×convênio) são filtradas para omitir entradas zeradas, o que
 * mantém o JSON enxuto.
 */

/** Par código/rótulo usado nos campos categóricos. */
interface CodigoRotulo {
    codigo: null | string;
    rotulo: null | string;
}
interface LabeledEstabelecimento {
    /** Flags booleanas ativas (ex: "Atende pré-natal", "Possui centro cirúrgico"). */
    atendimentos: readonly string[];
    atividadeEnsino: CodigoRotulo;
    clientela: CodigoRotulo;
    /** CNES do estabelecimento (7 dígitos). Obrigatório; a função falha se ausente. */
    cnes: string;
    cnpj: null | string;
    /** Competência no formato ISO (`"YYYY-MM"`); `null` se ausente ou inválida. */
    competencia: null | string;
    esferaAdministrativa: CodigoRotulo;
    geo: {
        latitude: null | string;
        longitude: null | string;
    };
    gestao: CodigoRotulo;
    instalacoes: readonly InstalacaoContagem[];
    leitos: LeitosTotais;
    matrizAtividadeConvenio: readonly AtividadeConvenio[];
    municipio: {
        codigo: null | string;
        nome: null | string;
        uf: null | string;
    };
    naturezaJuridica: CodigoRotulo;
    nivelAtencaoAmbulatorial: CodigoRotulo;
    nivelAtencaoHospitalar: CodigoRotulo;
    nivelDependencia: CodigoRotulo;
    nomeFantasia: null | string;
    pessoa: CodigoRotulo;
    razaoSocial: null | string;
    servicosApoio: readonly ServicoApoio[];
    tipo: CodigoRotulo;
    tipoPrestador: CodigoRotulo;
    turno: CodigoRotulo;
    vinculoSUS: CodigoRotulo;
}
/**
 * Converte um registro CNES-ST cru num objeto labeled. O input genérico
 * (`CnesEstabelecimentoRecord`) é aceito pra permitir fixtures tipadas;
 * na prática a função lê só os campos documentados abaixo.
 *
 * Validação: o registro precisa ter pelo menos `CNES` preenchido. Passar
 * um registro de outro subdataset (ex: CNES-PF) produziria um objeto
 * todo com nulls — a exceção aqui falha rápido pra evitar dados
 * silenciosamente vazios.
 */
declare function labelEstabelecimento(record: CnesEstabelecimentoRecord): LabeledEstabelecimento;

/**
 * Cliente FTP para DATASUS com cache local.
 *
 * DATASUS distribui microdados em `ftp://ftp.datasus.gov.br` via FTP
 * passivo sem autenticação. Este módulo é somente para Node — o browser
 * não tem suporte nativo a FTP. Consumidores browser devem obter os bytes
 * por outro meio (HTTP mirror, upload do usuário) e passar direto para o
 * decoder em `@precisa-saude/datasus-dbc`.
 */
interface ProgressEvent {
    /** true se os bytes vieram do cache local (sem tráfego de rede). */
    fromCache: boolean;
    /** Caminho remoto sendo transferido. */
    path: string;
    /** Tamanho total em bytes; `null` se o servidor não reportou. */
    total: null | number;
    /** Bytes transferidos até o momento. */
    transferred: number;
}
interface DownloadOptions {
    /** Diretório de cache local. Default: `~/.cache/datasus-brasil`. */
    cache?: string;
    /** Força re-download mesmo se já existir no cache. Default: false. */
    forceRefresh?: boolean;
    /** Host FTP. Default: `ftp.datasus.gov.br`. */
    host?: string;
    /** Caminho absoluto no servidor FTP (ex: `/dissemin/publicos/CNES/...`). */
    path: string;
    /** Modo seguro (FTPS). DATASUS usa FTP plano — default false. */
    secure?: boolean;
    /**
     * Callback chamado com eventos de progresso. Invocado pelo menos uma vez:
     * - cache hit: um único evento com `fromCache: true` e `transferred == total`.
     * - download: evento inicial (transferred 0), N intermediários (intervalo
     *   ~500ms) e um final com `transferred == total`.
     */
    onProgress?: (event: ProgressEvent) => void;
}
/**
 * Baixa um arquivo do FTP (com cache). Retorna os bytes em memória.
 *
 * Se o arquivo já estiver em cache, retorna imediatamente sem conectar
 * ao servidor. O diretório de cache preserva a estrutura do servidor
 * para facilitar inspeção manual.
 */
declare function download(options: DownloadOptions): Promise<Uint8Array>;

type index$5_DownloadOptions = DownloadOptions;
type index$5_ProgressEvent = ProgressEvent;
declare const index$5_download: typeof download;
declare namespace index$5 {
  export { type index$5_DownloadOptions as DownloadOptions, type index$5_ProgressEvent as ProgressEvent, index$5_download as download };
}

/**
 * Convenções de caminho no FTP DATASUS para CNES (Cadastro Nacional de
 * Estabelecimentos de Saúde).
 *
 * Estrutura (verificada no FTP oficial):
 *   ftp://ftp.datasus.gov.br/dissemin/publicos/CNES/200508_/Dados/{SUB}/{SUB}{UF}{YYMM}.dbc
 *
 * SUB: subdataset de 2 letras (ST=estabelecimentos, PF=profissionais,
 * EP=equipamentos, LT=leitos, DC=dados complementares, ...).
 *
 * Fase MVP: ST (estabelecimentos) e PF (profissionais) — os dois usados
 * para lookup patient-facing de "laboratórios e médicos próximos".
 */
/**
 * Subdatasets CNES suportados no MVP.
 * - ST: estabelecimentos (dados cadastrais de cada CNES)
 * - PF: profissionais (vínculos de profissionais aos estabelecimentos)
 */
type CnesSubdataset = 'ST' | 'PF';
interface CnesPathParams {
    /** Mês 1..12. */
    month: number;
    /** Subdataset: ST (estabelecimentos) ou PF (profissionais). */
    sub: CnesSubdataset;
    /** Sigla UF (2 letras, maiúsculo). */
    uf: string;
    /** Ano completo (>= 2005, histórico CNES começa em 2005/08). */
    year: number;
}
/**
 * Monta o caminho FTP canônico de um arquivo CNES para um subdataset
 * × UF × ano × mês.
 */
declare function cnesFtpPath({ month, sub, uf, year }: CnesPathParams): string;

/**
 * Loaders alto-nível para CNES (estabelecimentos e profissionais).
 */

interface LoadOptions$1 extends Omit<CnesPathParams, 'sub'> {
    /** Opções de cache/FTP. */
    ftp?: Omit<DownloadOptions, 'path'>;
}
/** Baixa e decodifica o CNES-ST (estabelecimentos) de uma UF × mês. */
declare function loadEstabelecimentos(options: LoadOptions$1): Promise<CnesEstabelecimentoRecord[]>;
/** Baixa e decodifica o CNES-PF (profissionais) de uma UF × mês. */
declare function loadProfissionais(options: LoadOptions$1): Promise<CnesProfissionalRecord[]>;
/**
 * Versão streaming do CNES-ST — recomendado para varreduras single-pass ou
 * processamento com `--limit` no CLI. Memória constante.
 */
declare function streamEstabelecimentos(options: LoadOptions$1): AsyncIterable<CnesEstabelecimentoRecord>;
/** Versão streaming do CNES-PF. */
declare function streamProfissionais(options: LoadOptions$1): AsyncIterable<CnesProfissionalRecord>;

/**
 * Tabela TP_UNID do CNES — tipo de estabelecimento.
 *
 * Fonte: dicionário CNES DATASUS. Cobertura dos tipos mais comuns;
 * códigos não mapeados retornam null.
 */
/**
 * Retorna o rótulo pt-BR do tipo de unidade CNES, ou `null` para códigos
 * não mapeados.
 */
declare function labelTipoUnidade(code: string | null | undefined): string | null;

type index$4_AtividadeConvenio = AtividadeConvenio;
type index$4_CnesEstabelecimentoRecord = CnesEstabelecimentoRecord;
type index$4_CnesPathParams = CnesPathParams;
type index$4_CnesProfissionalRecord = CnesProfissionalRecord;
type index$4_CnesSubdataset = CnesSubdataset;
type index$4_CodigoRotulo = CodigoRotulo;
type index$4_InstalacaoContagem = InstalacaoContagem;
type index$4_LabeledEstabelecimento = LabeledEstabelecimento;
type index$4_LeitosTotais = LeitosTotais;
type index$4_ServicoApoio = ServicoApoio;
declare const index$4_cnesFtpPath: typeof cnesFtpPath;
declare const index$4_labelEstabelecimento: typeof labelEstabelecimento;
declare const index$4_labelTipoUnidade: typeof labelTipoUnidade;
declare const index$4_loadEstabelecimentos: typeof loadEstabelecimentos;
declare const index$4_loadProfissionais: typeof loadProfissionais;
declare const index$4_streamEstabelecimentos: typeof streamEstabelecimentos;
declare const index$4_streamProfissionais: typeof streamProfissionais;
declare namespace index$4 {
  export { type index$4_AtividadeConvenio as AtividadeConvenio, type index$4_CnesEstabelecimentoRecord as CnesEstabelecimentoRecord, type index$4_CnesPathParams as CnesPathParams, type index$4_CnesProfissionalRecord as CnesProfissionalRecord, type index$4_CnesSubdataset as CnesSubdataset, type index$4_CodigoRotulo as CodigoRotulo, type index$4_InstalacaoContagem as InstalacaoContagem, type index$4_LabeledEstabelecimento as LabeledEstabelecimento, type index$4_LeitosTotais as LeitosTotais, type LoadOptions$1 as LoadOptions, type index$4_ServicoApoio as ServicoApoio, index$4_cnesFtpPath as cnesFtpPath, index$4_labelEstabelecimento as labelEstabelecimento, index$4_labelTipoUnidade as labelTipoUnidade, index$4_loadEstabelecimentos as loadEstabelecimentos, index$4_loadProfissionais as loadProfissionais, index$4_streamEstabelecimentos as streamEstabelecimentos, index$4_streamProfissionais as streamProfissionais };
}

/**
 * Tipos para registros SIA-SUS.
 *
 * Schema PA (Produção Ambulatorial). Varia por vintage — este tipa a
 * vintage 2008+ (60 colunas em 2024). Demais colunas permanecem
 * acessíveis via index signature.
 *
 * Valores numéricos vêm já decodificados pelo reader DBC (quantidades
 * e valores já em decimal — `PA_VALAPR` está em reais, não centavos).
 * Campos categóricos vêm como strings zero-padded pra bater com as
 * tabelas SIGTAP/CBO/CID-10.
 */
/**
 * Registro de Produção Ambulatorial (SIA-PA) — um registro por
 * procedimento faturado no mês.
 */
interface SiaProducaoAmbulatorialRecord {
    [key: string]: unknown;
    /** CBO-Saúde 2002 — ocupação do profissional. */
    PA_CBOCOD: null | string;
    /** CID-10 principal (4 dígitos, `"0000"` quando não informado). */
    PA_CIDPRI: null | string;
    /** Competência no formato `"YYYYMM"` (ex: `"202401"`). */
    PA_CMP: string;
    /** CNES do estabelecimento executor (7 dígitos). */
    PA_CODUNI: string;
    /** Idade zero-padded para 3 dígitos (`"999"` = não informado). */
    PA_IDADE: null | string;
    /** Município de residência do paciente (IBGE 6 dígitos). */
    PA_MUNPCN: null | string;
    /** Código SIGTAP do procedimento (10 dígitos). */
    PA_PROC_ID: string;
    /** Quantidade aprovada. */
    PA_QTDAPR: null | number;
    /** Quantidade apresentada. */
    PA_QTDPRO: null | number;
    /** Raça/cor (tabela IBGE). */
    PA_RACACOR: null | string;
    /** Sexo (`M`/`F`/`0`=não informado). */
    PA_SEXO: null | string;
    /** UF do município do estabelecimento executor (IBGE 6 dígitos). */
    PA_UFMUN: string;
    /** Valor aprovado em reais (já em decimal, não centavos). */
    PA_VALAPR: null | number;
    /** Valor apresentado em reais. */
    PA_VALPRO: null | number;
}

/**
 * Projeta um registro SIA-PA cru em um objeto legível em pt-BR, pronto
 * pra consumo por apps web ou CLI.
 *
 * Campos categóricos vêm como `{ codigo, rotulo }` — o código original
 * é preservado pra permitir filtros e joins sem perda; o rótulo é o
 * texto humano (ou `null` quando o código não está mapeado).
 *
 * Enrichment LOINC é opt-in via `enrichWithLoinc` em `laboratorio.ts` —
 * não é aplicado aqui pra manter o labeler barato em cenários que só
 * querem rotular.
 */

/** Competência decomposta (ex: `{ iso: "2024-01", ano: 2024, mes: 1 }`). */
interface Competencia {
    ano: null | number;
    iso: null | string;
    mes: null | number;
}
interface LabeledProducaoAmbulatorial {
    cbo: CodigoRotulo;
    cidPrincipal: null | string;
    competencia: Competencia;
    /** Município do estabelecimento executor. */
    estabelecimento: {
        cnes: null | string;
        municipio: {
            codigo: null | string;
            nome: null | string;
            uf: null | string;
        };
    };
    idadeAnos: null | number;
    /** Município de residência do paciente. */
    municipioPaciente: {
        codigo: null | string;
        nome: null | string;
        uf: null | string;
    };
    procedimento: {
        codigo: null | string;
        rotulo: null | string;
    };
    quantidade: {
        aprovada: null | number;
        apresentada: null | number;
    };
    racaCor: CodigoRotulo;
    sexo: CodigoRotulo;
    valor: {
        aprovadoBRL: null | number;
        apresentadoBRL: null | number;
    };
}
/**
 * Projeta um registro SIA-PA num objeto pt-BR legível. Não enriquece
 * com LOINC — use `enrichWithLoinc` em cima do resultado se precisar.
 */
declare function labelProducaoAmbulatorial(r: SiaProducaoAmbulatorialRecord): LabeledProducaoAmbulatorial;

/**
 * Tipos do módulo de terminologia LOINC ↔ TUSS ↔ SIGTAP.
 *
 * LOINC vem do `@precisa-saude/fhir` (código universal de observação
 * laboratorial). TUSS é o código comercial brasileiro (ANS, saúde
 * suplementar). SIGTAP é o código do SUS (procedimentos faturáveis
 * pelo Ministério da Saúde).
 */
/** Grau de confiança do refinamento LLM da equivalência LOINC → TUSS/SIGTAP. */
type TerminologyConfidence = 'high' | 'low' | 'medium';
/** Origem do mapeamento — hoje só temos a pipeline fuzzy + refinamento Gemini. */
type TerminologySource = 'llm-refined';
interface Biomarker {
    /** Código curto interno (ex: "HDL"). Vem do `@precisa-saude/fhir`. */
    code: string;
    /** Nome legível em pt-BR (ex: "Colesterol HDL"). */
    display: string;
}
interface LoincMapping {
    /** Biomarcador associado no catálogo da Precisa Saúde. */
    biomarker: Biomarker;
    /** Confiança do LLM; null quando não foi possível decidir. */
    confidence: null | TerminologyConfidence;
    /**
     * Código LOINC (ex: "2085-9" para Colesterol HDL). Null para
     * biomarcadores que não têm um LOINC canônico (ex: métricas
     * compostas de composição corporal como `VATVolume`).
     */
    loinc: null | string;
    /** Razão do "sem match" (quando `sigtap` e `tuss` são null). */
    noMatchReason: null | string;
    /** Justificativa textual do LLM para a seleção. */
    reasoning: null | string;
    /** Código SIGTAP selecionado (null quando o LLM não achou equivalente). */
    sigtap: null | string;
    /** Pipeline que gerou este mapeamento. */
    source: TerminologySource;
    /** Código TUSS selecionado (null quando o LLM não achou equivalente). */
    tuss: null | string;
}
interface SigtapProcedure {
    /** Código SIGTAP de 10 dígitos (ex: "0202010279"). */
    code: string;
    /** Nome oficial do procedimento na tabela SIGTAP. */
    name: string;
}
interface SigtapEquivalent {
    /** Código SIGTAP equivalente. */
    code: string;
    /**
     * Grau de equivalência ANS:
     * - "1": equivalência total (mesmo conteúdo)
     * - "2": equivalência parcial (conteúdo mais amplo/restrito)
     * - "3": mapeamento conceitual (aproximação)
     */
    equivalencia: string;
    /** Nome do procedimento SIGTAP. */
    name: string;
}
interface TussProcedure {
    /** Código TUSS de 8 dígitos (ex: "40301583"). */
    code: string;
    /** Nome oficial do procedimento na tabela TUSS. */
    name: string;
    /** Procedimentos SIGTAP equivalentes segundo o mapeamento oficial ANS. */
    sigtapEquivalents: readonly SigtapEquivalent[];
}

/**
 * Helpers opt-in para filtrar exames laboratoriais e enriquecer
 * registros SIA-PA com mapeamento LOINC.
 *
 * Mantidos fora de `load.ts`/`label.ts` para preservar o contrato
 * "load retorna raw, label retorna projeção pt-BR" — consumidores que
 * não precisam de LOINC não pagam custo de enrichment.
 */

/**
 * `true` sse o código SIGTAP pertence ao grupo 02.02 (Diagnóstico em
 * Laboratório Clínico). Aceita códigos com ou sem zeros à esquerda.
 */
declare function isSigtapLaboratorio(procId: null | string | undefined): boolean;
/**
 * Enriquece um registro SIA-PA com o mapeamento LOINC correspondente
 * ao `PA_PROC_ID`, quando houver. `loinc = null` significa "SIGTAP sem
 * equivalente LOINC conhecido no catálogo" — não é um erro.
 */
declare function enrichWithLoinc<R extends {
    PA_PROC_ID?: unknown;
}>(record: R): R & {
    loinc: LoincMapping | null;
};
/**
 * Filtra um stream/iterable para reter apenas registros de laboratório
 * (SIGTAP `02.02.*`). Mantém memória constante — não bufferiza.
 */
declare function filterLaboratorio(source: AsyncIterable<SiaProducaoAmbulatorialRecord>): AsyncIterable<SiaProducaoAmbulatorialRecord>;

/**
 * Convenções de caminho no FTP DATASUS para SIA-SUS (Sistema de
 * Informações Ambulatoriais).
 *
 * Estrutura (verificada no FTP oficial — diferente de CNES, **sem**
 * subpasta por subdataset):
 *   ftp://ftp.datasus.gov.br/dissemin/publicos/SIASUS/200801_/Dados/{SUB}{UF}{YYMM}.dbc
 *
 * SUB: subdataset de 2 ou 3 letras (PA=Produção Ambulatorial, BI=Boletim
 * Individualizado, AM/AN/AQ/AR/AB/ABO/ACF/ATD=APACs diversos, PS=RAAS
 * Psicossocial, AD=RAAS Atenção Domiciliar, IMP=medicamentos...).
 *
 * Fase MVP desta package: só PA (Produção Ambulatorial) — é o arquivo
 * que contém TODOS os procedimentos ambulatoriais faturados ao SUS,
 * incluindo exames laboratoriais (SIGTAP grupo 02.02).
 */
/** Subdatasets SIA suportados no MVP. */
type SiaSubdataset = 'PA';
interface SiaPathParams {
    /** Mês 1..12. */
    month: number;
    /** Subdataset SIA. Só PA suportado no MVP. */
    sub: SiaSubdataset;
    /** Sigla UF (2 letras, maiúsculo). */
    uf: string;
    /** Ano completo (>= 2008, histórico SIA no formato atual começa em 2008/01). */
    year: number;
}
/**
 * Monta o caminho FTP canônico de um arquivo SIA para um subdataset
 * × UF × ano × mês.
 *
 * SIA usa estrutura plana (sem subpasta `{SUB}/`), diferente de CNES.
 */
declare function siaFtpPath({ month, sub, uf, year }: SiaPathParams): string;

/**
 * Loaders alto-nível para SIA-SUS (Produção Ambulatorial).
 *
 * Observação de volume: PA é **ordens de magnitude maior** que CNES-ST
 * — uma UF grande × mês recente pode ter milhões de registros. A
 * variante `stream*` é o default recomendado; `load*` existe por
 * simetria com CNES mas só é viável para UFs pequenas (AC/RR/AP/TO) ou
 * com `--limit`.
 *
 * Schema vintage suportado: SIA-PA 2008+ (60 colunas na vintage 2024).
 */

interface LoadOptions extends Omit<SiaPathParams, 'sub'> {
    /** Opções de cache/FTP. */
    ftp?: Omit<DownloadOptions, 'path'>;
}
/**
 * Baixa e decodifica o SIA-PA de uma UF × mês, buferizando todos os
 * registros. **Use `streamProducaoAmbulatorial` em produção** — esta
 * função é viável apenas para UFs pequenas ou cenários de teste.
 */
declare function loadProducaoAmbulatorial(options: LoadOptions): Promise<SiaProducaoAmbulatorialRecord[]>;
/**
 * Versão streaming do SIA-PA — recomendado como default. Memória
 * constante mesmo em UFs grandes × múltiplos meses.
 */
declare function streamProducaoAmbulatorial(options: LoadOptions): AsyncIterable<SiaProducaoAmbulatorialRecord>;

/**
 * Converte `PA_IDADE` (3 dígitos zero-padded, `"999"` = não informado)
 * em número ou `null`.
 *
 * Observação: `PA_IDADE` grava anos completos. Algumas vintages usam
 * `PA_FLIDADE` para indicar unidade (meses/dias) — intencionalmente
 * ignorado aqui: o caso dominante é anos, e adicionamos a unidade mais
 * tarde se aparecer demanda real.
 */
declare function parseIdade(code: null | string | undefined): null | number;

/**
 * Tabela raça/cor do SIA-SUS (campo `PA_RACACOR`).
 *
 * Convenção IBGE + "99 sem informação" usada em sistemas DATASUS.
 */
declare function labelRacaCor(code: null | string | undefined): null | string;

/**
 * Tabela de sexo usada no SIA-SUS (campo `PA_SEXO`).
 *
 * DATASUS grava `M`/`F` para valores informados e `0` (ou string vazia)
 * para não informado. Algumas vintages antigas também usam `I`.
 */
declare function labelSexo(code: null | string | undefined): null | string;

type index$3_Competencia = Competencia;
type index$3_LabeledProducaoAmbulatorial = LabeledProducaoAmbulatorial;
type index$3_LoadOptions = LoadOptions;
type index$3_SiaPathParams = SiaPathParams;
type index$3_SiaProducaoAmbulatorialRecord = SiaProducaoAmbulatorialRecord;
type index$3_SiaSubdataset = SiaSubdataset;
declare const index$3_enrichWithLoinc: typeof enrichWithLoinc;
declare const index$3_filterLaboratorio: typeof filterLaboratorio;
declare const index$3_isSigtapLaboratorio: typeof isSigtapLaboratorio;
declare const index$3_labelProducaoAmbulatorial: typeof labelProducaoAmbulatorial;
declare const index$3_labelRacaCor: typeof labelRacaCor;
declare const index$3_labelSexo: typeof labelSexo;
declare const index$3_loadProducaoAmbulatorial: typeof loadProducaoAmbulatorial;
declare const index$3_parseIdade: typeof parseIdade;
declare const index$3_siaFtpPath: typeof siaFtpPath;
declare const index$3_streamProducaoAmbulatorial: typeof streamProducaoAmbulatorial;
declare namespace index$3 {
  export { type index$3_Competencia as Competencia, type index$3_LabeledProducaoAmbulatorial as LabeledProducaoAmbulatorial, type index$3_LoadOptions as LoadOptions, type index$3_SiaPathParams as SiaPathParams, type index$3_SiaProducaoAmbulatorialRecord as SiaProducaoAmbulatorialRecord, type index$3_SiaSubdataset as SiaSubdataset, index$3_enrichWithLoinc as enrichWithLoinc, index$3_filterLaboratorio as filterLaboratorio, index$3_isSigtapLaboratorio as isSigtapLaboratorio, index$3_labelProducaoAmbulatorial as labelProducaoAmbulatorial, index$3_labelRacaCor as labelRacaCor, index$3_labelSexo as labelSexo, index$3_loadProducaoAmbulatorial as loadProducaoAmbulatorial, index$3_parseIdade as parseIdade, index$3_siaFtpPath as siaFtpPath, index$3_streamProducaoAmbulatorial as streamProducaoAmbulatorial };
}

declare namespace index$2 {
  export { index$4 as cnes, index$3 as sia };
}

/**
 * Lookup de municípios brasileiros por código IBGE.
 *
 * Dados: IBGE, API de localidades (CC-BY).
 * Fonte: https://servicodados.ibge.gov.br/api/v1/localidades/municipios
 *
 * A tabela contém 5571 municípios. DATASUS usa código IBGE de 6 dígitos
 * (sem o dígito verificador); IBGE e CNES usam 7 dígitos. Esta API aceita
 * ambos e faz a normalização internamente.
 */
/** Informação de um município (subset usado em labeling). */
interface Municipio {
    /** Código IBGE de 7 dígitos (com dígito verificador). */
    id: number;
    /** Nome oficial do município. */
    nome: string;
    /** Sigla da UF (ex: 'SP', 'AC'). */
    uf: string;
}
/**
 * Busca um município por código IBGE. Aceita 6 ou 7 dígitos
 * (DATASUS usa 6, IBGE/CNES usam 7).
 *
 * @param code - código como string ou number
 * @returns município ou `null` se não encontrado
 */
declare function findMunicipio(code: string | number): Municipio | null;
/** Lista todos os municípios (imutável). */
declare function allMunicipios(): readonly Municipio[];

type index$1_Municipio = Municipio;
declare const index$1_allMunicipios: typeof allMunicipios;
declare const index$1_findMunicipio: typeof findMunicipio;
declare namespace index$1 {
  export { type index$1_Municipio as Municipio, index$1_allMunicipios as allMunicipios, index$1_findMunicipio as findMunicipio };
}

/**
 * Mapeamento LOINC → TUSS → SIGTAP para biomarcadores laboratoriais.
 *
 * Fonte dos dados: pipeline de fuzzy matching (TUSS↔SIGTAP oficial da ANS
 * + catálogo SIGTAP completo + 164 biomarcadores LOINC do
 * `@precisa-saude/fhir`) refinada por Gemini 3.1 Pro via OpenRouter pra
 * resolver colisões (ex: Apo A × Apo B com mesmo score fuzzy).
 *
 * Use este módulo quando o app tiver um biomarcador FHIR em mãos e
 * precisar do código SIGTAP equivalente pra cruzar com SIA-SUS.
 */

/**
 * Retorna o mapeamento LOINC → TUSS/SIGTAP refinado pelo LLM.
 *
 * Aceita o código LOINC canônico (ex: `"2085-9"`) ou o código curto do
 * biomarcador (`"HDL"`). Retorna `null` se não houver entrada no
 * catálogo. Um mapeamento presente com `sigtap === null` indica que o
 * LLM analisou mas decidiu "sem equivalente SIGTAP confiável" —
 * diferente de não conhecer o biomarcador (consulte `noMatchReason`).
 */
declare function loincToSigtap(code: string): LoincMapping | null;
/**
 * Retorna o mapeamento LOINC correspondente a um código SIGTAP, quando
 * houver. Útil para enriquecer registros SIA-SUS (onde o eixo de join
 * é SIGTAP) com o biomarcador e o LOINC equivalente.
 *
 * Aceita o código SIGTAP com ou sem zeros à esquerda (a tabela usa
 * sempre 10 dígitos como chave canônica). Retorna `null` se o SIGTAP
 * não estiver mapeado a nenhum LOINC no catálogo.
 */
declare function sigtapToLoinc(sigtap: string): LoincMapping | null;
/** Lista todos os biomarcadores do catálogo (imutável). */
declare function listBiomarkers(): readonly LoincMapping[];

/**
 * Lookup de procedimentos SIGTAP (Sistema de Gerenciamento da Tabela de
 * Procedimentos, Medicamentos e OPM do SUS).
 *
 * Fonte: tabela SIGTAP completa baixada do FTP DATASUS, competência mais
 * recente disponível quando o pacote foi gerado.
 */

/**
 * Busca um procedimento SIGTAP pelo código de 10 dígitos.
 *
 * Aceita o código com ou sem zeros à esquerda implícitos; a tabela usa
 * sempre 10 dígitos como chave canônica.
 */
declare function lookupSigtap(code: string): SigtapProcedure | null;

/**
 * Lookup de procedimentos TUSS (Terminologia Unificada da Saúde
 * Suplementar — ANS) com os procedimentos SIGTAP equivalentes.
 *
 * Fonte: mapeamento oficial ANS × SUS, competência 2017-04. Trabalho
 * conjunto ANS + COPISS + Ministério da Saúde baseado em ISO/TR
 * 12300:2014. É o último mapeamento publicado oficialmente.
 */

/**
 * Busca um procedimento TUSS pelo código de 8 dígitos e retorna o
 * procedimento com todos os SIGTAP equivalentes publicados pela ANS.
 */
declare function lookupTuss(code: string): TussProcedure | null;

/**
 * Terminologia LOINC ↔ TUSS ↔ SIGTAP.
 *
 * Ponte entre:
 * - biomarcadores/LOINC usados pelo `@precisa-saude/fhir`
 * - códigos TUSS (ANS, saúde suplementar)
 * - códigos SIGTAP (SUS, procedimentos faturáveis)
 *
 * Fluxo típico: app recebe um código LOINC do FHIR, chama
 * `loincToSigtap` pra pegar o procedimento SUS correspondente, depois
 * `lookupSigtap`/`lookupTuss` pra detalhes adicionais.
 */

type index_Biomarker = Biomarker;
type index_LoincMapping = LoincMapping;
type index_SigtapEquivalent = SigtapEquivalent;
type index_SigtapProcedure = SigtapProcedure;
type index_TerminologyConfidence = TerminologyConfidence;
type index_TerminologySource = TerminologySource;
type index_TussProcedure = TussProcedure;
declare const index_listBiomarkers: typeof listBiomarkers;
declare const index_loincToSigtap: typeof loincToSigtap;
declare const index_lookupSigtap: typeof lookupSigtap;
declare const index_lookupTuss: typeof lookupTuss;
declare const index_sigtapToLoinc: typeof sigtapToLoinc;
declare namespace index {
  export { type index_Biomarker as Biomarker, type index_LoincMapping as LoincMapping, type index_SigtapEquivalent as SigtapEquivalent, type index_SigtapProcedure as SigtapProcedure, type index_TerminologyConfidence as TerminologyConfidence, type index_TerminologySource as TerminologySource, type index_TussProcedure as TussProcedure, index_listBiomarkers as listBiomarkers, index_loincToSigtap as loincToSigtap, index_lookupSigtap as lookupSigtap, index_lookupTuss as lookupTuss, index_sigtapToLoinc as sigtapToLoinc };
}

/**
 * @precisa-saude/datasus — façade alto-nível para microdados DATASUS.
 *
 * Compõe FTP + decoder DBC + schemas tipados + labeling + agregações
 * em uma API consumível por web apps e CLIs. Saída JSON-first.
 */

declare const VERSION = "0.1.0";

export { type AtividadeConvenio, type Biomarker, type CnesEstabelecimentoRecord, type CnesProfissionalRecord, type CodigoRotulo, type Competencia, type DownloadOptions, type InstalacaoContagem, type LabeledEstabelecimento, type LabeledProducaoAmbulatorial, type LeitosTotais, type LoincMapping, type Municipio, type ProgressEvent, type ServicoApoio, type SiaPathParams, type SiaProducaoAmbulatorialRecord, type SiaSubdataset, type SigtapEquivalent, type SigtapProcedure, type TussProcedure, VERSION, index$6 as aggregations, allMunicipios, index$4 as cnes, countBy, countByNested, index$2 as datasets, download, enrichWithLoinc, filterLaboratorio, findMunicipio, index$5 as ftp, isSigtapLaboratorio, labelEstabelecimento, labelProducaoAmbulatorial, labelTipoUnidade, index$1 as labeling, listBiomarkers, loincToSigtap, lookupSigtap, lookupTuss, index$3 as sia, sigtapToLoinc, index as terminology, topN };
