jsegd-bpm 0.1.0

package/dist/jsegd-bpm.d.ts

@@ -0,0 +1,1045 @@
+import { ICache } from 'jsegd';
+import { Alpine } from 'alpinejs';
+
+/**
+ * Resposta de sucesso retornada pelo endpoint `/dataset/api/v2/dataset-handle/search` (HTTP 200).
+ */
+interface DatasetResponse {
+    /** Nomes dos campos retornados pelo dataset. */
+    columns: string[];
+    /** Linhas de dados retornadas pelo dataset. */
+    values: DatasetRow[];
+}
+/** Uma linha do dataset — chaves são os nomes dos campos retornados. */
+type DatasetRow = Record<string, unknown>;
+/**
+ * Resposta de erro retornada pela API Fluig (HTTP 400, 401, 500).
+ */
+interface DatasetError {
+    /** Código de erro. */
+    code: string;
+    /** Mensagem resumida do erro. */
+    message: string;
+    /** Mensagem detalhada do erro. */
+    detailedMessage: string;
+    /** URL de ajuda, quando disponível. */
+    helpUrl?: string;
+    /** Detalhes adicionais do erro, quando presentes. */
+    details?: unknown[];
+}
+
+declare enum ConstraintsType {
+    MUST = "MUST",
+    MUST_NOT = "MUST_NOT",
+    SHOULD = "SHOULD"
+}
+interface SearchParams {
+    /** Código do dataset — obrigatório. */
+    datasetId: string;
+    /** Campos a retornar; omitir para retornar todos os campos. */
+    field?: string[];
+    /** Registros a ignorar — usado para paginação (padrão: 0). */
+    offset?: number;
+    /** Máximo de registros a retornar (padrão: 300; 0 = todos). */
+    limit?: number;
+    /** Nome do campo para ordenação, opcionalmente sufixado com _ASC ou _DESC. */
+    orderby?: string;
+    constraintsField?: string[];
+    constraintsInitialValue?: string[];
+    constraintsFinalValue?: string[];
+    constraintsType?: ConstraintsType[];
+    /** Quando verdadeiro, o curinga % é aceito no valor inicial/final correspondente. */
+    constraintsLikeSearch?: boolean[];
+}
+
+/**
+ * Promise cancelável retornada por {@link WorkerManager.query}.
+ */
+type CancelablePromise<T> = {
+    /** Promise que resolve com o resultado da consulta. */
+    promise: Promise<T>;
+    /** Função para cancelar a requisição e liberar o worker. */
+    cancel: () => void;
+};
+
+type CacheOptions = {
+    storeName: string;
+    cacheExpirationMs: number;
+};
+interface WorkerManagerOptions {
+    poolSize?: number;
+    /** Injeta uma instância existente de ICache (compartilhada entre componentes). */
+    cache?: ICache;
+    /** Cria um LocalCache interno com as opções fornecidas. */
+    cacheOptions?: CacheOptions;
+}
+/**
+ * Gerencia um pool de Web Workers para executar consultas à API de Datasets do Fluig fora da thread principal.
+ * Suporta deduplicacão de requisições, cache em IndexedDB e cancelamento HTTP real via AbortController.
+ *
+ * @example
+ * ```typescript
+ * import { WorkerManager, ConstraintsType } from 'jsegd-bpm'
+ *
+ * const manager = new WorkerManager({
+ *     poolSize: 4,
+ *     cacheOptions: { storeName: 'datasetCache', cacheExpirationMs: 24 * 60 * 60 * 1000 }
+ * })
+ *
+ * const { promise, cancel } = manager.query('https://tenant.fluig.com', {
+ *     datasetId: 'dsColaboradores',
+ *     field: ['nome', 'email'],
+ *     constraintsField: ['ativo'],
+ *     constraintsInitialValue: ['true'],
+ *     constraintsType: [ConstraintsType.MUST],
+ * })
+ *
+ * // Cancelar se necessário:
+ * // cancel()
+ *
+ * const result = await promise
+ * console.log(result.columns)  // ['nome', 'email']
+ * console.log(result.values)   // [{ nome: 'João', email: 'joao@co.com' }, ...]
+ * ```
+ */
+declare class WorkerManager {
+    private pool;
+    private workerMeta;
+    private taskQueue;
+    private inFlight;
+    private cache;
+    private nextRequestId;
+    constructor(options?: WorkerManagerOptions);
+    /**
+     * Consulta a API de Datasets do Fluig. Retorna uma CancelablePromise.
+     * Chame `cancel()` para abortar a requisição HTTP e liberar o worker imediatamente.
+     */
+    query(baseUrl: string, params: SearchParams): CancelablePromise<DatasetResponse>;
+    /**
+     * Encerra todos os workers do pool. Chame quando o gerenciador não for mais necessário
+     * para evitar vazamentos de memória e workers zumbis.
+     */
+    terminate(): void;
+    private deduplicateOrEnqueue;
+    private enqueueRequest;
+    private scheduleNext;
+    private abortRequest;
+    private handleResponse;
+    private buildUrl;
+}
+
+type UploadStatus = 'success' | 'error' | 'reset';
+interface UploadEventDetail {
+    status: UploadStatus;
+}
+declare global {
+    interface WindowEventMap {
+        'jsegd:upload:success': CustomEvent<UploadEventDetail>;
+        'jsegd:upload:error': CustomEvent<UploadEventDetail>;
+        'jsegd:upload:reset': CustomEvent<UploadEventDetail>;
+        'jsegd:attachment:download': CustomEvent<{
+            documentId: number;
+        }>;
+    }
+}
+
+/** Origem do upload de um anexo */
+type AttachmentSource = 'button' | 'toolbar' | 'drag-drop';
+/**
+ * Metadados associados a um único documento anexado ao processo.
+ * Persiste informações que o ECM não armazena nativamente.
+ */
+interface AttachmentRecord {
+    /** ID do documento no ECM */
+    documentId: number;
+    /** Mecanismo pelo qual o arquivo foi adicionado */
+    source: AttachmentSource;
+    /**
+     * Descrição base do `AttachButton` que originou o upload.
+     * Presente apenas quando `source === 'button'`.
+     */
+    buttonDescription?: string;
+    /** Filtro de tipos de arquivo ativo no momento do upload (`null` = qualquer tipo) */
+    accept: string | null;
+    /** Número de sequência da movimentação do processo em que foi anexado */
+    workflowSequence: number;
+    /** Data e hora do upload em ISO 8601 */
+    uploadedAt: string;
+    /**
+     * Metadados arbitrários adicionados pelo consumidor da biblioteca.
+     * Nunca interpretado internamente — apenas serializado/desserializado.
+     */
+    custom?: Record<string, unknown>;
+}
+
+/**
+ * @protected
+ */
+declare class Attach {
+    private static instance;
+    /** Origem do último upload iniciado (atualizado por `add()` e `uploadBlob()`) */
+    static currentUploadSource: AttachmentSource;
+    /** Filtro de tipos do último upload iniciado */
+    static currentUploadAccept: string | null;
+    private constructor();
+    static getInstance(): Attach;
+    private interceptUploadEvents;
+    /**
+     * Abre o seletor de arquivos para adicionar um novo anexo ao processo.
+     * Aplica versionamento automático ao nome quando já existe um anexo com a mesma descrição.
+     *
+     * @param attachmentDescription Descrição (label) do anexo — usada como nome do arquivo no ECM
+     * @param accept Tipos de arquivo aceitos pelo seletor (ex: ".pdf,.docx"). `null` aceita qualquer tipo.
+     */
+    add(attachmentDescription: string, accept: string | null | undefined): void;
+    /**
+     * Abre o visualizador de documentos para o anexo informado.
+     * Quando há mais de um anexo com a mesma descrição, exibe um modal de seleção.
+     * Bloqueia ação em processos não iniciados e valida permissões de leitura.
+     *
+     * @param attachmentDescription Descrição do anexo a ser visualizado
+     */
+    view(attachmentDescription: string): void;
+    /**
+     * Remove um anexo do processo após confirmação via modal.
+     * Quando há mais de um anexo com a mesma descrição, exibe um modal de seleção.
+     * Valida permissões de exclusão antes de prosseguir.
+     *
+     * @param attachmentDescription Descrição do anexo a ser removido
+     */
+    remove(attachmentDescription: string): void;
+    /**
+     * Inicia o download de um anexo pelo seu identificador de documento.
+     * Bloqueia a ação em processos não iniciados.
+     *
+     * @param documentId Identificador do documento a ser baixado
+     */
+    static download(documentId: number): void;
+    /**
+     * Abre o painel de edição de conteúdo para o anexo informado.
+     * Filtra apenas anexos publicados que o usuário tem permissão de editar.
+     * Quando há mais de um anexo editável, exibe modal de seleção.
+     * Bloqueia a ação em processos não iniciados.
+     *
+     * @param attachmentDescription Descrição do anexo a ser editado
+     */
+    edit(attachmentDescription: string): void;
+    /**
+     * Retorna todos os anexos do processo atual.
+     * @returns Lista de todos os objetos `Attachment` presentes no processo
+     */
+    static getAllAttachments(): Attachment[];
+    /**
+     * Inicia o download de um Blob diretamente no navegador do usuário,
+     * sem interação com o ECM ou com o processo em execução.
+     *
+     * @param blob Conteúdo a ser baixado
+     * @param filename Nome do arquivo que será sugerido ao navegador
+     * @param type Tipo MIME do arquivo. Quando omitido, usa `blob.type`.
+     */
+    static downloadBlob(blob: Blob, filename: string, type?: string): void;
+    /**
+     * Faz upload programático de um Blob como anexo do processo,
+     * sem abrir o seletor de arquivos nativo. Sanitiza o nome antes do envio.
+     *
+     * @param blob Arquivo no formato `Blob` — deve ser não-vazio
+     * @param description Nome/descrição do arquivo que será exibido no ECM
+     * @param type Tipo MIME do arquivo. Quando omitido, usa `blob.type`.
+     * @throws {Error} Via toast quando o Blob é inválido, o MIME está ausente ou o contexto não está disponível
+     */
+    static uploadBlob(blob: Blob, description: string, type?: string): void;
+}
+
+/**
+ * Implementa um botão para gerenciar anexos
+ * @hideconstructor
+ * @example
+ * ```html
+ * <attachment-button description="CONTRATO"></attachment-button>
+ * ```
+ */
+declare class AttachButton extends HTMLElement {
+    /**
+     * Descrição do tipo de anexo gerenciado pelo botão.
+     * Quando vazio, um modal é exibido para o usuário informar a descrição no momento do upload.
+     * @defaultValue `''`
+     */
+    description: string;
+    /**
+     * Filtro de tipos de arquivo aceitos pelo seletor nativo (ex: `".pdf,.docx"`).
+     * `null` aceita qualquer tipo de arquivo.
+     */
+    accept: string | null;
+    noaddbutton: string | null;
+    noviewbutton: string | null;
+    noeditbutton: string | null;
+    nodeletebutton: string | null;
+    private handleSuccess;
+    private handleError;
+    private handleDefault;
+    constructor();
+    static get observedAttributes(): string[];
+    attributeChangedCallback(name: string, _oldValue: string, newValue: string): void;
+    disconnectedCallback(): void;
+    /**
+     * @internal
+     */
+    connectedCallback(): void;
+    private displayButtons;
+    private addButton;
+    private viewButton;
+    private editButton;
+    private removeButton;
+    private showModal;
+}
+
+/**
+ * Modo de operação da tabela de anexos.
+ * - `buttons-only` — somente download por linha; uploads exclusivamente via `AttachButton` externos
+ * - `self-managed` — gerencia seu próprio ciclo de upload; exibe ações completas por linha;
+ *   aceita `AttachButton` externos cujos atributos são herdados pela linha do anexo
+ */
+type AttachmentsTableMode = 'buttons-only' | 'self-managed';
+/** Opções de configuração de `AttachmentsTable` */
+interface AttachmentsTableOptions {
+    /** Modo de operação. Obrigatório — sem valor padrão. */
+    mode: AttachmentsTableMode;
+    /**
+     * Tipos de arquivo aceitos nos uploads avulsos do modo `self-managed`.
+     * Ex: `".pdf,.docx"`. `null` aceita qualquer tipo.
+     */
+    accept?: string | null;
+}
+/**
+ * Registro de um `AttachButton` na `AttachmentsTable`.
+ * Armazenado para associar anexos existentes ao botão que os originou.
+ */
+interface AttachButtonRegistration {
+    /** Descrição base usada pelo botão (sem sufixo `_V\d+`). */
+    description: string;
+    /** Filtro de tipos de arquivo definido no botão. */
+    accept: string | null;
+}
+/**
+ * Cria e gerencia uma tabela de anexos customizada no frame pai,
+ * mantendo a tabela nativa do Fluig oculta.
+ * @hideconstructor
+ */
+declare class AttachmentsTable {
+    private static instance;
+    private static options;
+    private static attachInstance;
+    private static buttonRegistry;
+    private constructor();
+    /**
+     * Retorna a instância singleton da tabela de anexos.
+     * Deve ser chamado uma única vez durante a inicialização do form.
+     *
+     * @param options Configuração obrigatória de modo e accept
+     */
+    static getInstance(options: AttachmentsTableOptions): AttachmentsTable;
+    /**
+     * Registra um `AttachButton` para que seus metadados sejam associados
+     * às linhas de anexo originadas por aquele botão.
+     * Só tem efeito no modo `self-managed`.
+     * @internal Chamado por `AttachButton` durante sua inicialização.
+     */
+    static registerButton(registration: AttachButtonRegistration): void;
+    private static resolveButtonRegistration;
+    private static start;
+    private static render;
+    private static hydrateFromMetadata;
+    private static persistMetadata;
+    private static openNameInputModal;
+    private static getRows;
+    private static setOrder;
+    private static sortBy;
+    private static getCellValue;
+}
+
+/** Entrada de um arquivo para upload em lote via drag-and-drop */
+type DragDropEntry = {
+    file: File;
+    name: string;
+};
+
+type FieldError = {
+    field?: HTMLElement | null;
+    errorMessage: string;
+};
+declare class BeforeSendValidate {
+    private static clearAllErrors;
+    static throwValidationError(fields: FieldError[]): never;
+}
+
+/**
+ * Override de `sendRequestEvent()` do widget de processo.
+ * Executa os hooks `beforeValidate` e `afterValidate` em sequência antes de enviar a solicitação.
+ * Reabilita os botões de ação em caso de erro ou quando a validação falha.
+ */
+declare function sendRequestEvent(this: ECM_WKFView): Promise<void>;
+
+/**
+ * Contrato dos hooks customizáveis do widget de processo.
+ * Estas funções são registradas pelo `WorkflowViewPatcher` e executadas em `send-request.ts`.
+ */
+interface IWorkflowViewHooks {
+    /**
+     * Executado ANTES da validação principal do widget.
+     * Se lançar exceção (sync ou async), o envio é cancelado e os botões são reabilitados.
+     */
+    beforeValidate?: () => void | Promise<void>;
+    /**
+     * Executado APÓS `beforeSendValidate` retornar `true`, mas ANTES do envio efetivo.
+     * Se lançar exceção (sync ou async), o envio é cancelado e os botões são reabilitados.
+     */
+    afterValidate?: () => void | Promise<void>;
+    /**
+     * Executado quando a movimentação do processo é concluída com sucesso.
+     */
+    onMoveSuccess?: () => void | Promise<void>;
+    /**
+     * Executado quando ocorre erro na movimentação do processo.
+     */
+    onMoveError?: () => void | Promise<void>;
+    /**
+     * Executado para manipular os links exibidos na página de conclusão da movimentação.
+     *
+     * @param message - Objeto de mensagem de conclusão do processo.
+     */
+    onCompletionLinkAdd?: (message: ProcessCompletionMessage) => void | Promise<void>;
+}
+/**
+ * Shape do objeto de mensagem de conclusão do processo.
+ * Passado como parâmetro para o hook `onCompletionLinkAdd`.
+ */
+interface ProcessCompletionMessage {
+    links: ProcessCompletionLink[];
+    [key: string]: unknown;
+}
+/**
+ * Shape de um link na página de conclusão da movimentação.
+ */
+interface ProcessCompletionLink {
+    description: string;
+    href?: string;
+    bind?: string;
+}
+
+type HooksMap = {
+    beforeValidate: Array<() => void | Promise<void>>;
+    afterValidate: Array<() => void | Promise<void>>;
+    onMoveSuccess: Array<() => void | Promise<void>>;
+    onMoveError: Array<() => void | Promise<void>>;
+    onCompletionLinkAdd: Array<(message: ProcessCompletionMessage) => void | Promise<void>>;
+};
+
+/**
+ * Mapa de substituições que serão aplicadas ao widget nativo de processo.
+ */
+declare const overrides: {
+    sendRequestEvent: typeof sendRequestEvent;
+};
+/**
+ * Tipo do mapa de substituições.
+ */
+type OverrideMap = typeof overrides;
+/**
+ * Classe utilitária para substituir métodos no widget nativo de processo.
+ *
+ * Preserva os métodos originais para permitir reversão via `restore()`.
+ *
+ * @example
+ * ```typescript
+ * // Aguardar inicialização do widget de processo
+ * await WorkflowViewPatcher.init()
+ *
+ * // Aplicar todos os patches registrados
+ * WorkflowViewPatcher.patchAll()
+ *
+ * // Registrar hooks
+ * WorkflowViewPatcher.addBeforeValidate(async () => {
+ *   console.log('Antes da validação')
+ * })
+ *
+ * WorkflowViewPatcher.addAfterValidate(async () => {
+ *   console.log('Após a validação')
+ * })
+ * ```
+ */
+declare class WorkflowViewPatcher {
+    private static isInitialized;
+    private static isInitializing;
+    private static originalMethods;
+    /**
+     * Inicializa o patcher aguardando o carregamento do widget de processo no frame pai.
+     *
+     * Chamadas repetidas retornam imediatamente se já inicializado.
+     *
+     * @param timeout - Tempo máximo de espera em ms (padrão: 5000ms)
+     * @returns Promise<void>
+     *
+     * @throws {Error} Se outra chamada a `init()` já estiver em progresso
+     * @throws {Error} Se o widget `ECM_WKFView` não estiver disponível após o timeout
+     *
+     * @example
+     * ```typescript
+     * await WorkflowViewPatcher.init()
+     * WorkflowViewPatcher.patchAll()
+     * ```
+     */
+    static init(timeout?: number): Promise<void>;
+    /**
+     * Aplica o patch de um override específico no widget de processo.
+     *
+     * Salva o método original antes de sobrescrever, permitindo reversão via `restore()`.
+     *
+     * @param attr - Nome do método a ser substituído
+     * @throws {Error} Se `init()` não tiver sido chamado antes
+     * @throws {Error} Se o override não estiver registrado no mapa de substituições
+     */
+    static patch(attr: keyof OverrideMap): void;
+    /**
+     * Aplica patches para múltiplos métodos do widget de processo.
+     *
+     * @param attrs - Array com nomes dos métodos a serem substituídos
+     * @throws {Error} Se `init()` não tiver sido chamado antes
+     */
+    static patchMany(attrs: (keyof OverrideMap)[]): void;
+    /**
+     * Aplica todos os patches registrados no mapa de substituições.
+     * @throws {Error} Se `init()` não tiver sido chamado antes
+     */
+    static patchAll(): void;
+    /**
+     * Restaura todos os métodos do widget para as implementações originais.
+     *
+     * Deve ser chamado ao desmontar o componente em SPAs, para evitar que os patches
+     * persistam além do ciclo de vida do formulário. Também zera os flags de estado
+     * interno, permitindo reinicialização via `init()`.
+     *
+     * @example
+     * ```typescript
+     * // Ao desmontar o formulário
+     * WorkflowViewPatcher.restore()
+     * ```
+     */
+    static restore(): void;
+    /**
+     * Acessa a lista interna de hooks para um tipo específico.
+     * Usado por `sendRequestEvent` para executar os hooks em sequência.
+     *
+     * @internal
+     */
+    static getHooks<K extends keyof HooksMap>(key: K): HooksMap[K];
+    /**
+     * Registra uma função executada ANTES da validação principal do widget.
+     *
+     * Múltiplas chamadas acumulam handlers — nenhuma sobrescreve a anterior.
+     * Se o handler lançar exceção (sync ou async), o envio é cancelado e os botões são reabilitados.
+     *
+     * @param fn - Função a ser executada (pode ser async).
+     *
+     * @example
+     * ```typescript
+     * WorkflowViewPatcher.addBeforeValidate(async () => {
+     *   const value = getValue('campo_obrigatorio')
+     *   if (!value) {
+     *     throw new Error('Campo obrigatório não preenchido')
+     *   }
+     * })
+     * ```
+     */
+    static addBeforeValidate(fn: () => void | Promise<void>): void;
+    /**
+     * Registra uma função executada APÓS `beforeSendValidate` retornar `true`,
+     * mas ANTES do envio efetivo da solicitação.
+     *
+     * Múltiplas chamadas acumulam handlers — nenhuma sobrescreve a anterior.
+     * Se o handler lançar exceção (sync ou async), o envio é cancelado e os botões são reabilitados.
+     *
+     * @param fn - Função a ser executada (pode ser async).
+     *
+     * @example
+     * ```typescript
+     * WorkflowViewPatcher.addAfterValidate(async () => {
+     *   console.log('Validação concluída, preparando envio...')
+     *   await salvarDadosLocais()
+     * })
+     * ```
+     */
+    static addAfterValidate(fn: () => void | Promise<void>): void;
+    /**
+     * Registra uma função executada quando a movimentação do processo é concluída com sucesso.
+     *
+     * Múltiplas chamadas acumulam handlers — nenhuma sobrescreve a anterior.
+     *
+     * @param fn - Função callback executada em caso de sucesso (pode ser async).
+     *
+     * @example
+     * ```typescript
+     * WorkflowViewPatcher.addOnMoveSuccess(() => {
+     *   console.log('Processo movimentado com sucesso')
+     * })
+     * ```
+     */
+    static addOnMoveSuccess(fn: () => void | Promise<void>): void;
+    /**
+     * Registra uma função executada quando ocorre erro na movimentação do processo.
+     *
+     * Múltiplas chamadas acumulam handlers — nenhuma sobrescreve a anterior.
+     *
+     * @param fn - Função callback executada em caso de erro (pode ser async).
+     *
+     * @example
+     * ```typescript
+     * WorkflowViewPatcher.addOnMoveError(() => {
+     *   console.error('Erro ao movimentar processo')
+     * })
+     * ```
+     */
+    static addOnMoveError(fn: () => void | Promise<void>): void;
+    /**
+     * Registra uma função para manipular os links da página de conclusão da movimentação.
+     *
+     * Múltiplas chamadas acumulam handlers — nenhuma sobrescreve a anterior.
+     *
+     * @param fn - Função que recebe o objeto de conclusão e pode adicionar ou modificar links (pode ser async).
+     *
+     * @example
+     * ```typescript
+     * WorkflowViewPatcher.addOnCompletionLinkAdd((message: ProcessCompletionMessage) => {
+     *   message.links.push({ description: 'Voltar ao início', href: '/inicio' })
+     * })
+     * ```
+     */
+    static addOnCompletionLinkAdd(fn: (message: ProcessCompletionMessage) => void | Promise<void>): void;
+}
+
+/**
+ * Contrato agnóstico ao EGD para acesso a dados do formulário e tabelas filhas.
+ * Implementado por `BpmFormRepository` (produção) e `MockFormRepository` (testes).
+ *
+ * **Convenção de nomenclatura:** campos do formulário devem seguir `{domínio}_{atributo_snake_case}`.
+ * `load` e `save` gerenciam a conversão entre nome DOM e atributo do modelo automaticamente.
+ */
+interface IFormRepository {
+    /**
+     * Lê campos do formulário cujo `name` começa com `{section}_`.
+     *
+     * O prefixo `{section}_` é removido e o restante convertido de `snake_case` para `camelCase`
+     * antes de retornar — o modelo recebe atributos limpos, sem o prefixo de domínio.
+     *
+     * @param section Prefixo de domínio dos campos no formulário (ex: `'contrato'`, `'imovel'`)
+     * @returns Objeto parcial com os valores lidos, chaves em camelCase
+     *
+     * @example
+     * ```typescript
+     * // DOM: input[name="contrato_indice"], input[name="contrato_primeiro_pagamento"]
+     * const data = repository.load<Contrato>('contrato')
+     * // data.indice, data.primeiroPagamento
+     * ```
+     */
+    load<T>(section: string): Partial<T>;
+    /**
+     * Lê todas as linhas visíveis de uma tabela filha do formulário.
+     * Cada linha corresponde a um `<tr>` visível da tabela com o `tablename` informado.
+     *
+     * @param tableName Valor do atributo `tablename` na `<table>` do formulário BPM
+     * @returns Array de objetos com os valores dos campos de cada linha
+     */
+    loadTable<T>(tableName: string): T[];
+    /**
+     * Escreve valores no DOM do formulário para os campos do domínio informado.
+     *
+     * Converte cada chave camelCase do modelo para `{section}_{snake_case}` antes de
+     * escrever — espelha exatamente o que `load` desfaz.
+     *
+     * @param section Prefixo de domínio dos campos (ex: `'contrato'`, `'imovel'`)
+     * @param data Objeto com os valores a persistir (chaves em camelCase)
+     *
+     * @example
+     * ```typescript
+     * // Escreve input[name="contrato_indice"] e input[name="contrato_primeiro_pagamento"]
+     * repository.save<Contrato>('contrato', { indice: 'IGPM', primeiroPagamento: '2026-02-01' })
+     * ```
+     */
+    save<T>(section: string, data: Partial<T>): void;
+    /**
+     * Substitui as linhas de uma tabela filha, removendo as existentes e
+     * recriando via `wdkAddChild`. Encapsula toda a interação com o DOM.
+     *
+     * @param tableName Valor do atributo `tablename` na `<table>` do formulário BPM
+     * @param rows Array de objetos a persistir como linhas da tabela
+     */
+    saveTable<T>(tableName: string, rows: T[]): void;
+}
+
+/**
+ * Adapter de produção que isola o acesso ao DOM do formulário BPM e às
+ * funções globais `wdkAddChild`/`fnWdkRemoveChild` (definidas em `wdkdetail.js`).
+ *
+ * Segue o mesmo padrão de fronteira estabelecido por `process-context/` —
+ * este é o único arquivo autorizado a referenciar as globais do formulário BPM.
+ */
+declare class BpmFormRepository implements IFormRepository {
+    load<T>(section: string): Partial<T>;
+    loadTable<T>(tableName: string): T[];
+    save<T>(section: string, data: Partial<T>): void;
+    saveTable<T>(tableName: string, rows: T[]): void;
+}
+
+/**
+ * Implementação em memória de `IFormRepository` para uso em testes unitários.
+ * Não depende de DOM, jQuery ou da plataforma — permite testar Presenters em isolamento.
+ *
+ * Aplica a mesma lógica de prefixo e conversão de `BpmFormRepository`: armazena
+ * internamente com o nome DOM completo (`{section}_{snake_case}`) e converte para
+ * camelCase ao retornar — garantindo que os testes reflitam o comportamento real.
+ *
+ * @example
+ * const repo = new MockFormRepository()
+ * repo.save('vigencia', { prazo: '12', tipoDePrazo: 'Meses' })
+ * const data = repo.load<Vigencia>('vigencia')
+ * // data.prazo === '12'
+ * // data.tipoDePrazo === 'Meses'
+ *
+ * @example
+ * const repo = new MockFormRepository()
+ * repo.save('imovel', { cep: '01310100', logradouro: 'Av. Paulista' })
+ * repo.save('contrato', { indice: 'IGPM', primeiroPagamento: '2026-02-01' })
+ * // imovel_cep e contrato_indice são domínios distintos — sem colisão
+ */
+declare class MockFormRepository implements IFormRepository {
+    /** Armazena valores com chave no formato DOM completo: `{section}_{snake_case}`. */
+    private readonly store;
+    private readonly tables;
+    load<T>(section: string): Partial<T>;
+    loadTable<T>(tableName: string): T[];
+    save<T>(section: string, data: Partial<T>): void;
+    saveTable<T>(tableName: string, rows: T[]): void;
+    /**
+     * Limpa todo o estado interno — campos e tabelas.
+     * Ideal para uso em `beforeEach` nos testes.
+     */
+    reset(): void;
+}
+
+/**
+ * Lê campos do formulário por mapeamento explícito `{ propriedadeModelo: nomeDOM }`.
+ *
+ * Utilitário para **processos legados** cujos campos não seguem a convenção
+ * `{domínio}_{atributo}` — use quando o nome DOM não pode ser alterado sem
+ * migração de dados no banco EGD.
+ *
+ * Novos processos devem usar `IFormRepository.load(section)` diretamente.
+ *
+ * @param fieldMap Mapeamento de propriedade do modelo → nome do campo no DOM
+ * @returns Objeto parcial com os valores lidos, chaveado pelos atributos do modelo
+ *
+ * @example
+ * ```typescript
+ * // Processo legado: campos com sufixo em vez de prefixo
+ * import { loadFields } from 'jsegd-bpm'
+ *
+ * interface Solicitante {
+ *     nome: string
+ *     email: string
+ * }
+ *
+ * const dados = loadFields<Solicitante>({
+ *     nome: 'nome_solicitante',
+ *     email: 'email_solicitante',
+ * })
+ * // dados.nome === valor de input[name="nome_solicitante"]
+ * ```
+ */
+declare function loadFields<T>(fieldMap: {
+    [K in keyof T]?: string;
+}): Partial<T>;
+
+/** Categoria de uma atividade — determina o comportamento na barra de progresso */
+type ActivityKind = 
+/** Ação de usuário — estágio atual destacado na barra */
+'human'
+/** Aguardando retorno externo (webhook) — exibe spinner no estágio atual */
+ | 'system'
+/** Suporte transversal — sobrepõe banner de alerta; não avança a barra */
+ | 'support'
+/** Roteamento interno do motor BPM — invisível na barra */
+ | 'routing';
+/** Definição de um módulo (aba/seção) do formulário BPM */
+interface WorkflowModuleDefinition {
+    /** Identificador único do módulo — usado como chave nas políticas de atividade */
+    moduleId: string;
+    /** Rótulo exibido na navegação */
+    label: string;
+    /** Nome do ícone exibido junto ao rótulo */
+    icon: string;
+    /** Posição na ordem de exibição — menor valor aparece primeiro */
+    order: number;
+    /** Exibe o módulo na barra de navegação lateral/superior */
+    showInNavigation: boolean;
+    /** Renderiza o conteúdo do módulo no DOM quando visível */
+    renderContent: boolean;
+    /** Caminho do arquivo HTML incluído como conteúdo do módulo */
+    contentIncludePath: string;
+}
+/**
+ * Políticas de visibilidade e editabilidade dos módulos para uma atividade.
+ * `TModuleId` é inferido automaticamente por `defineWorkflowConfig`.
+ */
+interface ActivityModulePolicy<TModuleId extends string = string> {
+    /** Módulos visíveis nesta atividade */
+    visible: readonly TModuleId[];
+    /** Módulos editáveis nesta atividade (subconjunto de `visible`) */
+    editable: readonly TModuleId[];
+    /** Módulo ativo (tab selecionada) ao abrir o formulário nesta atividade */
+    active?: TModuleId;
+}
+/** Definição de uma atividade do workflow com suas políticas de módulo */
+interface WorkflowActivityDefinition<TModuleId extends string = string> {
+    /** Número de sequência da atividade no motor BPM EGD */
+    sequence: number;
+    /** Descrição legível da atividade para fins de diagnóstico */
+    description: string;
+    /** Categoria da atividade — controla comportamento na barra de progresso */
+    kind: ActivityKind;
+    /**
+     * Estágio de negócio representado por esta atividade na barra de progresso.
+     * Obrigatório para `'human'` e `'system'`. Omitido para `'routing'`.
+     * Para `'support'`: identifica o estágio que está sendo interrompido.
+     */
+    stage?: string;
+    /** Políticas de visibilidade e editabilidade dos módulos */
+    modules?: ActivityModulePolicy<TModuleId>;
+}
+/**
+ * Configuração tipada de um workflow BPM — retornada por `defineWorkflowConfig`.
+ * `TModuleId` é inferido automaticamente do array de módulos.
+ */
+interface WorkflowConfig<TModules extends readonly WorkflowModuleDefinition[], TModuleId extends string = TModules[number]['moduleId']> {
+    readonly modules: TModules;
+    readonly activities: readonly WorkflowActivityDefinition<TModuleId>[];
+}
+
+/**
+ * Define a configuração de workflow de um projeto BPM a partir de uma
+ * declaração única de módulos e atividades. O tipo `ModuleId` é inferido
+ * automaticamente do array de módulos — nenhum type alias manual é necessário.
+ *
+ * @param config Objeto com `modules` (definições de módulo) e `activities` (políticas por atividade)
+ * @returns Configuração tipada pronta para uso em `resolveWorkflowScreen` e `extractCompletedStages`
+ *
+ * @example
+ * const workflowConfig = defineWorkflowConfig({
+ *     modules: [
+ *         { moduleId: 'solicitante', label: 'Dados Iniciais', icon: 'file', order: 1,
+ *           showInNavigation: true, renderContent: true, contentIncludePath: 'solicitante.html' },
+ *         { moduleId: 'juridico', label: 'Jurídico', icon: 'gavel', order: 2,
+ *           showInNavigation: true, renderContent: true, contentIncludePath: 'juridico.html' },
+ *     ],
+ *     activities: [
+ *         { sequence: 9, description: 'Solicitação inicial', kind: 'human', stage: 'solicitacao',
+ *           modules: { visible: ['solicitante'], editable: ['solicitante'], active: 'solicitante' } },
+ *         { sequence: 88, description: 'Roteamento', kind: 'routing' },
+ *     ]
+ * } as const)
+ * // Tipo de ModuleId inferido automaticamente: 'solicitante' | 'juridico'
+ */
+declare function defineWorkflowConfig<const M extends readonly (WorkflowModuleDefinition & {
+    moduleId: string;
+})[]>(config: {
+    modules: M;
+    activities: readonly WorkflowActivityDefinition<M[number]['moduleId']>[];
+}): WorkflowConfig<M, M[number]['moduleId']>;
+
+/**
+ * Entrada do histórico do processo BPM retornada por
+ * `parent.ECM.workflowView.processDefinition.urlHistory`.
+ * As chaves do objeto pai são arbitrárias — usar apenas `movementDate` e
+ * `movementHour` para determinar a ordem cronológica real.
+ */
+interface BpmHistoryEntry {
+    /** `null` = ação de usuário; `'SYSTEM'` = tarefa de sistema; `'OBSERVATION'`/`'ATTACHMENT'` = ignorar */
+    historyType: 'SYSTEM' | 'OBSERVATION' | 'ATTACHMENT' | null;
+    /** Equivalente a `WorkflowActivityDefinition.sequence` */
+    stateSequence: number;
+    /** `0` = atividade de usuário/sistema | `1` = gateway/decisão automática */
+    stateType: number;
+    /** Timestamp numérico para ordenação — `null` em sub-registros sem posição cronológica */
+    movementDate: number | null;
+    /** Hora no formato `"HH:mm:ss"` — desempate na ordenação quando `movementDate` é igual */
+    movementHour: string | null;
+    /** Rótulo da atividade no motor BPM */
+    labelActivity: string | null;
+}
+/** Mapa bruto retornado por `urlHistory` — chaves são arbitrárias, ignorar na ordenação */
+type BpmHistoryMap = Record<string, BpmHistoryEntry>;
+/** Histórico processado — alimenta `ScreenContext` para construir a barra de progresso */
+interface ProcessHistory {
+    /** Estágios concluídos em ordem cronológica real; deduplica estágios repetidos */
+    completedStages: string[];
+    /** Estágio atual com seu status; `null` se a atividade atual não tiver stage mapeado */
+    currentStage: {
+        stage: string;
+        status: 'current' | 'waiting';
+    } | null;
+}
+/**
+ * Extrai os estágios concluídos do histórico BPM na ordem cronológica real.
+ * Ignora gateways (`stateType === 1`), entradas `SYSTEM`, `OBSERVATION` e `ATTACHMENT`,
+ * e sub-registros sem `movementDate`. Deduplica estágios — a primeira ocorrência
+ * cronológica define a posição na barra de progresso.
+ *
+ * @param history Mapa bruto retornado por `urlHistory` do processo BPM
+ * @param activities Array de definições de atividade do `WorkflowConfig`
+ * @returns Array de stage IDs na ordem em que ocorreram no processo
+ */
+declare function extractCompletedStages(history: BpmHistoryMap, activities: readonly WorkflowActivityDefinition[]): string[];
+/**
+ * Determina o estágio atual e seu status (`'current'` ou `'waiting'`).
+ * Retorna `null` se a sequência atual não tiver um `stage` mapeado na configuração.
+ *
+ * @param currentSequence Número de sequência da atividade atual do processo
+ * @param currentHistoryType `historyType` da entrada atual — `null` para ação humana, `'SYSTEM'` para espera
+ * @param activities Array de definições de atividade do `WorkflowConfig`
+ * @returns Objeto com `stage` e `status`, ou `null`
+ */
+declare function extractCurrentStage(currentSequence: number, currentHistoryType: 'SYSTEM' | null, activities: readonly WorkflowActivityDefinition[]): {
+    stage: string;
+    status: 'current' | 'waiting';
+} | null;
+
+/** Módulo com políticas de visibilidade e editabilidade resolvidas para a atividade atual */
+interface ResolvedModule {
+    moduleId: string;
+    label: string;
+    icon: string;
+    order: number;
+    showInNavigation: boolean;
+    renderContent: boolean;
+    contentIncludePath: string;
+    isVisible: boolean;
+    isEditable: boolean;
+    isActive: boolean;
+}
+/**
+ * Contexto de tela para uma atividade de workflow.
+ * Consultado por Presenters para decidir visibilidade/editabilidade
+ * sem conhecer números de sequência.
+ *
+ * @hideconstructor
+ */
+declare class ScreenContext {
+    private readonly activity;
+    private readonly resolvedModules;
+    private readonly history;
+    constructor(activity: WorkflowActivityDefinition, resolvedModules: readonly ResolvedModule[], history: ProcessHistory);
+    /**
+     * Retorna `true` se o módulo é visível na atividade atual.
+     *
+     * @param moduleId Identificador do módulo
+     */
+    isVisible(moduleId: string): boolean;
+    /**
+     * Retorna `true` se o módulo é editável na atividade atual.
+     *
+     * @param moduleId Identificador do módulo
+     */
+    isEditable(moduleId: string): boolean;
+    /**
+     * Retorna `true` se o módulo é o ativo (tab selecionada) na atividade atual.
+     *
+     * @param moduleId Identificador do módulo
+     */
+    isActive(moduleId: string): boolean;
+    /**
+     * Retorna o número de sequência da atividade atual no motor BPM EGD.
+     *
+     * Equivalente a `WorkflowActivityDefinition.sequence`. Exposto para presenters
+     * que precisam do valor em regras de domínio baseadas em sequências específicas
+     * (ex: listas de sequences especiais para exibir/ocultar campos).
+     */
+    getSequence(): number;
+    /**
+     * Retorna `true` se a atividade atual está aguardando um sistema externo
+     * (`kind === 'system'` ou `currentStage.status === 'waiting'`).
+     */
+    isAwaitingSystem(): boolean;
+    /**
+     * Retorna `true` se a atividade atual é uma atividade de suporte transversal.
+     */
+    isInSupport(): boolean;
+    /**
+     * Retorna os estágios para renderizar na barra de progresso.
+     * Inclui os estágios concluídos do histórico (`'done'`) e o estágio atual
+     * (`'current'` ou `'waiting'`), sem duplicar.
+     */
+    getProgressBarStages(): Array<{
+        stage: string;
+        status: 'done' | 'current' | 'waiting';
+    }>;
+    /**
+     * Retorna todos os módulos resolvidos, incluindo os não-visíveis.
+     */
+    getModules(): readonly ResolvedModule[];
+    /**
+     * Retorna apenas os módulos visíveis, ordenados por `order` ascendente.
+     */
+    getVisibleModules(): readonly ResolvedModule[];
+    /**
+     * Retorna os módulos que aparecem na navegação (`showInNavigation && isVisible`),
+     * ordenados por `order` ascendente.
+     */
+    getNavigationModules(): readonly ResolvedModule[];
+}
+
+/**
+ * Resolve a tela para a sequência informada, cruzando a configuração do workflow
+ * com o histórico do processo para produzir um `ScreenContext`.
+ *
+ * @param config Configuração gerada por `defineWorkflowConfig`
+ * @param sequence Número de sequência da atividade atual no processo BPM
+ * @param history Histórico processado via `extractCompletedStages` e `extractCurrentStage`
+ * @returns `ScreenContext` pronto para consulta pelos Presenters
+ *
+ * @throws {Error} Se a sequência não estiver mapeada na configuração
+ *
+ * @example
+ * const screen = resolveWorkflowScreen(workflowConfig, 53, processHistory)
+ * screen.isVisible('juridico')   // true
+ * screen.isEditable('juridico')  // true
+ * screen.isInSupport()           // false
+ */
+declare function resolveWorkflowScreen(config: WorkflowConfig<readonly WorkflowModuleDefinition[]>, sequence: number, history: ProcessHistory): ScreenContext;
+
+/** Mapa de stores: chave = nome do store, valor = objeto do store */
+type StoreMap = Record<string, object>;
+/**
+ * Tipo utilitário que gera um proxy com getters tipados para cada store registrado.
+ * Permite `stores.contador` ao invés de `Alpine.store('contador') as ContadorStore`.
+ */
+type StoreProxy<T extends StoreMap> = {
+    readonly [K in keyof T]: T[K];
+};
+/**
+ * Registra múltiplos Alpine stores e retorna um proxy tipado para acesso direto.
+ * Deve ser chamado no ponto de inicialização da aplicação, antes de `Alpine.start()`.
+ *
+ * @param alpine Instância Alpine — aceita `Pick<Alpine, 'store'>` para facilitar mock em testes
+ * @param storeMap Objeto com pares `{ nomeDoStore: objetoInicial }`
+ * @returns Proxy tipado para leitura dos stores sem casting manual
+ *
+ * @example
+ * const stores = registerStores(Alpine, {
+ *     usuario: { nome: '', perfil: '' as PerfilId },
+ *     ui:      { carregando: false, erro: null as string | null }
+ * })
+ * // stores.usuario.nome está tipado como string
+ * // Internamente: Alpine.store('usuario', { nome: '', perfil: '' })
+ */
+declare function registerStores<T extends StoreMap>(alpine: Pick<Alpine, 'store'>, storeMap: T): StoreProxy<T>;
+
+export { Attach, AttachButton, AttachmentsTable, BeforeSendValidate, BpmFormRepository, ConstraintsType, MockFormRepository, ScreenContext, WorkerManager, WorkflowViewPatcher, defineWorkflowConfig, extractCompletedStages, extractCurrentStage, loadFields, registerStores, resolveWorkflowScreen, sendRequestEvent };
+export type { ActivityKind, ActivityModulePolicy, AttachButtonRegistration, AttachmentRecord, AttachmentSource, AttachmentsTableMode, AttachmentsTableOptions, BpmHistoryEntry, BpmHistoryMap, CacheOptions, CancelablePromise, DatasetError, DatasetResponse, DatasetRow, DragDropEntry, FieldError, IFormRepository, IWorkflowViewHooks, ProcessCompletionLink, ProcessCompletionMessage, ProcessHistory, ResolvedModule, SearchParams, StoreMap, StoreProxy, WorkerManagerOptions, WorkflowActivityDefinition, WorkflowConfig, WorkflowModuleDefinition };