teraprox-core-sdk 0.3.10 → 0.3.14

package/dist/index.d.mts

@@ -1,10 +1,10 @@
-import { C as CoreService, T as ToastService, H as HttpController, I as IObservabilityPort, a as InteractionPayload, V as VitalsPayload, B as BreadcrumbPayload } from './federation-Bhx0XhSP.mjs';
-export { D as DevAutoLogin, F as FederatedBridge, M as MatchingObjectSubscription, R as ReducersBundle, b as ReducersBundleConfig, c as RemoteManifest, d as RemoteMenuItem, e as RemoteMenuSection, S as StandaloneProvider, f as ToastOptions, g as createReducersBundle } from './federation-Bhx0XhSP.mjs';
+import { C as CoreService, T as ToastService, H as HttpController, I as IObservabilityPort, a as InteractionPayload, V as VitalsPayload, B as BreadcrumbPayload } from './federation-Cp_lk0Xd.mjs';
+export { D as DefaultReducerKeys, b as DevAutoLogin, F as FederatedBridge, M as MatchingObjectSubscription, c as MenuTreeChild, d as MenuTreeNode, R as RateLimitEntry, e as ReducerDep, f as ReducersBundle, g as ReducersBundleConfig, h as RemoteFormRoute, i as RemoteManifest, j as RemoteMenuItem, k as RemoteMenuSection, l as RemoteReducerMap, S as StandaloneProvider, m as ToastOptions, n as createReducersBundle, o as createReducersFromManifest, p as groupMenuSections, q as isHostedByCore } from './federation-Cp_lk0Xd.mjs';
 import * as React from 'react';
 import { Dispatch } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as redux from 'redux';
 import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import 'react/jsx-runtime';
 
 interface Notification {
     id?: string | number;
@@ -54,24 +54,231 @@ interface SolicitacaoDeServico {
     equipamento?: string;
 }
 
+type StatusOrdemDeCorrecao = 'ABERTA' | 'EM_EXECUCAO' | 'CONCLUIDA' | 'CANCELADA' | 'PENDENTE_AUTORIZACAO';
+interface TarefaDeCorrecao {
+    id?: string | number;
+    localId?: string;
+    descricao: string;
+    responsavel?: string;
+    responsavelId?: string | number;
+    status?: string;
+    removed?: boolean;
+    tarefasUnidadeMaterial?: TarefaUnidadeMaterial[];
+}
+interface TarefaUnidadeMaterial {
+    id?: string | number;
+    unidadeMaterialId?: string | number | null;
+    unidadeMaterial?: any;
+    quantidade: number;
+    userId: string;
+    dataDoApontamento: string;
+    removed?: boolean;
+}
+interface OrdemDeCorrecao {
+    id: string | number;
+    status: StatusOrdemDeCorrecao;
+    ordemDeServicoId?: string | number;
+    registroDeCampoId?: string | number;
+    recursoNome?: string;
+    recursoId?: string | number;
+    observacao?: string;
+    dataDeAbertura?: string | null;
+    dataDeEncerramento?: string | null;
+    tarefas: TarefaDeCorrecao[];
+    solicitante?: {
+        id: string | number;
+        nome: string;
+    };
+    recurso?: {
+        id: string | number;
+        nome: string;
+    };
+    createdAt?: string;
+    updatedAt?: string;
+}
+interface OrdemDeCorrecaoFormState {
+    ordemDeServicoId: string;
+    registroDeCampoId: string;
+    recursoNome: string;
+    recursoId: string;
+    observacao: string;
+    tarefas: TarefaDeCorrecao[];
+    dataDeAbertura?: string | null;
+    dataDeEncerramento?: string | null;
+}
+
+interface RegraDeCorrecao {
+    id?: string | number;
+    acao?: any;
+    acaoId?: string | number;
+    parametro?: any;
+    parametroId?: string | number;
+    campoDeVerificacao?: any;
+    campoDeVerificacaoId?: string | number;
+    tipoDeCorrecao?: string;
+    calculosDeCorrecao?: CalculoDeCorrecao[];
+}
+interface CalculoDeCorrecao {
+    id?: string | number;
+    material?: any;
+    materialId?: string | number;
+    formula?: string;
+    unidade?: string;
+}
+interface RegraDeCorrecaoFormState {
+    acao: any;
+    acaoId: string;
+    parametro: any;
+    parametroId: string;
+    campoDeVerificacao: any;
+    campoDeVerificacaoId: string;
+    tipoDeCorrecao: string;
+    calculosDeCorrecao: CalculoDeCorrecao[];
+}
+
+/**
+ * Representação de um anexo persistido (retornado pela API).
+ */
+interface AnexoPersistido {
+    id: string | number;
+    nome: string;
+    tipo: string;
+    tamanho?: number;
+    /** Chave no object storage — necessária para `POST /anexo/signedUrl` (API não usa só anexoId). */
+    key?: string;
+    url?: string;
+    signedUrl?: string;
+    context?: string;
+    entityId?: string | number;
+    createdAt?: string;
+}
+/**
+ * Representação de um anexo local (selecionado mas ainda não enviado).
+ */
+interface AnexoLocal {
+    localId: string;
+    file: File;
+    nome: string;
+    tipo: string;
+    tamanho: number;
+    progress: number;
+    status: 'pending' | 'uploading' | 'done' | 'error';
+    errorMessage?: string;
+}
+/**
+ * Resultado da intent de upload (signed URL da nuvem).
+ */
+interface UploadIntent {
+    /** URL for signed upload — API may return as `uploadUrl` or `signedUrl`. */
+    signedUrl?: string;
+    uploadUrl?: string;
+    key?: string;
+    anexoId?: string | number;
+    fileName?: string;
+    contentType?: string;
+    dataId?: string;
+    dataContext?: string;
+    fields?: Record<string, string>;
+}
+/**
+ * Port Hexagonal para operações de anexo.
+ * Permite que qualquer módulo federado gerencie anexos de forma uniforme,
+ * sem conhecer detalhes de implementação (GCS, S3, local, etc.).
+ */
+interface IAnexoPort {
+    /** Solicita intent de upload ao backend (retorna signed URL). */
+    intent(params: {
+        nome: string;
+        tipo: string;
+        tamanho: number;
+        context: string;
+        entityId: string | number;
+    }): Promise<UploadIntent>;
+    /** Confirma que o upload para a signed URL foi concluído (alguns backends não usam anexoId — só key + dataId). */
+    confirm(params: {
+        anexoId?: string | number;
+        context: string;
+        entityId: string | number;
+        key: string;
+        fileName: string;
+        contentType: string;
+    }): Promise<AnexoPersistido>;
+    /** Upload direto via FormData (fallback quando signed URL não está disponível). */
+    uploadDirect(params: {
+        file: File;
+        context: string;
+        entityId: string | number;
+        path?: string;
+    }): Promise<AnexoPersistido>;
+    /** Lê todos os anexos de uma entidade num contexto. */
+    readByEntity(context: string, entityId: string | number): Promise<AnexoPersistido[]>;
+    /** Obtém URL assinada para download/visualização (corpo `{ key }` na API onRoad; `anexoId` é fallback). */
+    getSignedUrl(anexoId: string | number, key?: string): Promise<string>;
+    /** Remove um anexo pelo ID. */
+    remove(anexoId: string | number): Promise<void>;
+}
+
+/**
+ * Interceptors that can be injected into FetchHttpAdapter.
+ *
+ * The core provides implementations (token injection, auto-toast, MO dispatch, etc.).
+ * Standalone mode can use a subset or none at all.
+ */
+interface HttpInterceptors {
+    /**
+     * Called before every request.
+     * Use to inject dynamic headers (Authorization, tenant, etc.).
+     * Return the final headers to use.
+     */
+    onBeforeRequest?(headers: Record<string, string>): Record<string, string> | Promise<Record<string, string>>;
+    /**
+     * Called on successful HTTP response (2xx).
+     * Receives raw status, headers, and parsed JSON body.
+     * Return the value that callers will receive.
+     */
+    onResponse?(response: HttpResponseMeta, method: string): any;
+    /**
+     * Called on HTTP error (non-2xx).
+     * Can return a resolved value (swallow error), or throw/reject.
+     * `retry` re-executes the original request (useful for 401 token refresh).
+     */
+    onError?(error: HttpErrorMeta, retry: () => Promise<any>): any;
+}
+interface HttpResponseMeta {
+    status: number;
+    headers: Headers;
+    data: any;
+}
+interface HttpErrorMeta {
+    status: number;
+    headers: Headers;
+    data: any;
+    message: string;
+}
+
 declare const CoreServiceContext: React.Context<CoreService | null>;
 
 declare class FetchHttpAdapter implements HttpController {
     private endpoint;
     private extraHeaders?;
-    constructor(endpoint: string, extraHeaders?: Record<string, string> | undefined);
+    private interceptors?;
+    constructor(endpoint: string, extraHeaders?: Record<string, string> | undefined, interceptors?: HttpInterceptors | undefined);
+    private mergeHeaders;
+    /** Join non-empty path segments, avoiding double slashes. */
+    private joinPath;
     private request;
-    get(path?: string): Promise<any>;
-    post(path?: string, data?: any): Promise<any>;
-    put(path?: string, data?: any): Promise<any>;
-    patch(path?: string, data?: any): Promise<any>;
-    delete(path?: string, id?: string | number): Promise<any>;
-    deleteSimple(path?: string): Promise<any>;
-    save(path?: string, data?: any): Promise<any>;
-    read(path?: string, id?: string | number): Promise<any>;
-    readAll(path?: string): Promise<any>;
-    readAllwithPage(path?: string): Promise<any>;
-    bulkDelete(path?: string): Promise<any>;
+    private qs;
+    get(path?: string, query?: string): Promise<any>;
+    post(path?: string, data?: any, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    put(path?: string, data?: any, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    patch(path?: string, data?: any, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    delete(path?: string, id?: string | number, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    deleteSimple(path?: string, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    save(path?: string, data?: any, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    read(path?: string, id?: string | number, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    readAll(path?: string, extraHeaders?: Record<string, string>, query?: string): Promise<any>;
+    readAllwithPage(path?: string, page?: number, size?: number): Promise<any>;
+    bulkDelete(path?: string, ids?: (string | number)[], extraHeaders?: Record<string, string>, query?: string): Promise<any>;
 }
 declare class CoreServiceBuilder {
     private _toast;
@@ -222,6 +429,35 @@ declare function useNavigator(config: NavigatorConfig): NavigateFn;
  */
 declare function useObservability(): IObservabilityPort;
 
+interface UseAnexoManagerOptions$1 {
+    context: string;
+    entityId: string | number;
+    /** Port customizado (para injeção em testes ou implementações alternativas). */
+    port?: IAnexoPort;
+}
+interface UseAnexoManagerReturn {
+    persistidos: AnexoPersistido[];
+    locais: AnexoLocal[];
+    loading: boolean;
+    /** Carrega anexos existentes da entidade. */
+    loadAnexos: () => Promise<void>;
+    /** Adiciona arquivos locais (ainda não enviados). */
+    addFiles: (files: File[]) => void;
+    /** Remove um arquivo local da fila. */
+    removeLocal: (localId: string) => void;
+    /** Envia todos os arquivos pendentes. Se `overrideEntityId` for fornecido, usa-o em vez do entityId do hook. */
+    uploadAll: (overrideEntityId?: string | number) => Promise<AnexoPersistido[]>;
+    /** Remove um anexo persistido (do servidor). */
+    removePersistido: (anexoId: string | number) => Promise<void>;
+    /** Obtém signed URL para preview/download. */
+    getUrl: (anexoId: string | number) => Promise<string>;
+}
+/**
+ * Hook central para gerenciamento de anexos.
+ * Conecta a UI (AnexoManager do ui-kit) com a infraestrutura HTTP (core-sdk).
+ */
+declare function useAnexoManager({ context, entityId, port }: UseAnexoManagerOptions$1): UseAnexoManagerReturn;
+
 interface FetchDataReturn<T = any> {
     data: T | null;
     loading: boolean;
@@ -297,12 +533,1169 @@ interface ValidationReturn<T> {
  */
 declare function useValidation<T = any>(rules: ValidationRule<T>[]): ValidationReturn<T>;
 
-interface RecursoDisplayerProps {
-    selectedList?: any[];
-    onSaveRecurso: (recursos: any[], checked?: boolean) => void;
-    singleReturn?: boolean;
+/**
+ * useTimeFormat — helpers para conversao entre segundos e string `HH:mm:ss` /
+ * `HH:mm`. Extraido de `TimeFormField` (teraprox-SGM-OS) na Wave 5D.2 da
+ * sprint 2026-04-21-ui-kit-domain-split-wave0.
+ *
+ * Nao e um hook stateful — apenas um container reutilizavel de utilitarios
+ * para evitar duplicacao do `dayjs.extend(duration)` em cada caller. O nome
+ * `use*` sinaliza que o consumidor invoca dentro de um componente React.
+ */
+interface TimeFormatApi {
+    /** Converte segundos (number) em string `HH:mm:ss`. */
+    secondsToHms(seconds: number | null | undefined): string;
+    /** Converte string `HH:mm` (ou `HH:mm:ss`) em segundos totais. */
+    hmsToSeconds(value: string | null | undefined): number | null;
+}
+declare const secondsToHms: (seconds: number | null | undefined) => string;
+declare const hmsToSeconds: (value: string | null | undefined) => number | null;
+declare const useTimeFormat: () => TimeFormatApi;
+
+/**
+ * Modos de combinação de predicados em filtros multi-select.
+ *
+ * - `union` (∪)         — item passa se satisfazer QUALQUER predicado ativo (OR).
+ * - `intersection` (∩)  — item passa se satisfazer TODOS os predicados ativos (AND).
+ * - `xor` (△)           — diferença simétrica: item passa se satisfazer UM número
+ *                         ímpar de predicados (exactly-one quando há 2 predicados;
+ *                         generaliza para N: usado para "A ou B, mas não ambos").
+ */
+type FilterCombineMode = 'union' | 'intersection' | 'xor';
+declare const FILTER_COMBINE_MODES: readonly FilterCombineMode[];
+interface FilterCombineModeApi {
+    mode: FilterCombineMode;
+    setMode: (mode: FilterCombineMode) => void;
+    /** Avança para o próximo modo do ciclo: union → intersection → xor → union. */
+    cycleMode: () => void;
+    /**
+     * Combina predicados contra um item segundo o modo atual.
+     * Retorna `true` quando não há predicados (semântica "sem filtro").
+     */
+    matches: <T>(predicates: Array<(item: T) => boolean>, item: T) => boolean;
+}
+/**
+ * Hook que gerencia o modo de combinação para filtros multi-select.
+ *
+ * Contexto: em listas com múltiplas pills selecionáveis, o usuário pode querer:
+ *   - ver a UNIÃO dos filtros (qualquer match — padrão "mais permissivo"),
+ *   - a INTERSECÇÃO (drill-down, todos os filtros devem bater),
+ *   - ou a DIFERENÇA SIMÉTRICA (itens que batem em um número ímpar de filtros).
+ *
+ * Expõe um helper `matches` que o consumidor chama dentro do seu loop de filtragem:
+ *
+ * ```ts
+ * const combine = useFilterCombineMode('union')
+ * const filtered = items.filter(item => combine.matches(activePredicates, item))
+ * ```
+ */
+declare function useFilterCombineMode(initialMode?: FilterCombineMode): FilterCombineModeApi;
+
+/**
+ * Port for UnidadeMaterialForm (ui-kit).
+ *
+ * Implementado por ReduxUnidadeMaterialAdapter. A UI (UnidadeMaterialForm)
+ * nao deve chamar useCoreService / useSelector / useDispatch — consome
+ * exclusivamente este contrato via useUnidadeMaterialViewModel().
+ */
+interface UnidadeMaterialRef {
+    id: string | number;
+    nome: string;
+    [key: string]: any;
+}
+interface UnidadeMaterialValue {
+    material?: UnidadeMaterialRef | null;
+    quantidade?: number | string;
+    unidade?: UnidadeMaterialRef | null;
+}
+interface ValidationResult {
+    ok: boolean;
+    errors: Record<string, string>;
+}
+interface IUnidadeMaterialViewModel {
+    /** Estado atual da composição Unidade-Material (Redux) */
+    value: UnidadeMaterialValue;
+    /** Flag derivada: material+unidade+quantidade numerica > 0 */
+    isValid: boolean;
+    /** Flag transiente — true enquanto submit() esta pendente */
+    isSubmitting: boolean;
+    /** Atualiza material selecionado */
+    onMaterialSelected(material: UnidadeMaterialRef): void;
+    /** Atualiza quantidade */
+    onQuantidadeUpdate(qtd: string): void;
+    /** Atualiza unidade de medida */
+    onUnidadeSelected(unidade: UnidadeMaterialRef): void;
+    /** Carrega lista de materiais (via useCoreService('material')) */
+    loadMaterials(): Promise<any[]>;
+    /** Carrega lista de unidades (via useCoreService('unidade')) */
+    loadUnidades(): Promise<any[]>;
+    /** Limpa o estado da composicao */
+    clear(): void;
+    /** Popula a composicao para edicao */
+    populate(value: UnidadeMaterialValue): void;
+    /** Validacao sincrona — mesma regra do SGM-OS Services/default/validations.js */
+    validate(): ValidationResult;
+    /**
+     * Retorna o DTO consolidado pronto para o caller persistir.
+     * Nao dispatcha side effects adicionais — apenas valida e devolve.
+     * Lanca Error se validate() falhar.
+     */
+    submit(): Promise<UnidadeMaterialValue>;
+    /** Alias semantico de clear() para modal composto */
+    reset(): void;
+    /**
+     * Persiste edicao inline da quantidade utilizada de uma TarefaUnidadeMaterial.
+     *
+     * Em modo `edit` a UI consumidora pode interceptar via callback opcional
+     * (`TarefaItemProps.onAddUnidadeMaterial` etc); em `execute` o adapter
+     * persiste direto via `PUT /tarefaUnidadeMaterial/:id`.
+     *
+     * O adapter recebe `tarefaId` na construcao do hook
+     * (`useUnidadeMaterialViewModel(tarefaId)`) e o adiciona ao body.
+     *
+     * Em caso de erro, dispara `useToast().warning(...)` e relan ca o erro
+     * para que o caller possa reverter estado otimista se desejar.
+     */
+    updateQuantidade(tumId: string | number, quantidade: number): Promise<void>;
+}
+
+/**
+ * Adapter Redux que implementa IUnidadeMaterialViewModel.
+ *
+ * Consome useHttpController('material') e useHttpController('unidade')
+ * para expor loadMaterials/loadUnidades.
+ *
+ * Estado lido do slice 'unidadeMaterial' (ver unidadeMaterialSlice.ts),
+ * parametrizado por tarefaId para suportar multiplas composicoes simultaneas
+ * (ex: varias tarefas no mesmo form de Ordem de Servico).
+ *
+ * isSubmitting vive em useState local — estado transiente do modal,
+ * nao precisa ir para Redux.
+ */
+declare function useUnidadeMaterialViewModel(tarefaId?: string | number): IUnidadeMaterialViewModel;
+
+/**
+ * Slice para o estado do UnidadeMaterialForm.
+ *
+ * Estrutura parametrizada por tarefaId:
+ *   state.unidadeMaterial.byTarefa[tarefaId] = { material, quantidade, unidade }
+ *
+ * Chave '__default__' armazena o estado quando nenhum tarefaId eh fornecido.
+ */
+declare const DEFAULT_KEY$3 = "__default__";
+interface UnidadeMaterialSliceState {
+    byTarefa: Record<string, UnidadeMaterialValue>;
+}
+interface ByTarefaPayload$1<T> {
+    tarefaId?: string | number;
+    value: T;
+}
+declare const setMaterial: _reduxjs_toolkit.ActionCreatorWithPayload<ByTarefaPayload$1<UnidadeMaterialRef | null>, "unidadeMaterialVm/setMaterial">;
+declare const setQuantidade: _reduxjs_toolkit.ActionCreatorWithPayload<ByTarefaPayload$1<string | number>, "unidadeMaterialVm/setQuantidade">;
+declare const setUnidade: _reduxjs_toolkit.ActionCreatorWithPayload<ByTarefaPayload$1<UnidadeMaterialRef | null>, "unidadeMaterialVm/setUnidade">;
+declare const populateUnidadeMaterial: _reduxjs_toolkit.ActionCreatorWithPayload<ByTarefaPayload$1<UnidadeMaterialValue>, "unidadeMaterialVm/populate">;
+declare const clearUnidadeMaterial: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    tarefaId?: string | number;
+}, "unidadeMaterialVm/clearUnidadeMaterial">;
+declare const selectUnidadeMaterial: (state: any, tarefaId?: string | number) => UnidadeMaterialValue;
+declare const _default$7: redux.Reducer<UnidadeMaterialSliceState>;
+
+/**
+ * Port for InspecaoModal (ui-kit-sgm).
+ *
+ * Implementado por ReduxInspecaoModalAdapter. A UI (InspecaoModal) nao
+ * deve acessar Redux diretamente — consome o contrato via
+ * useInspecaoModalViewModel().
+ */
+interface LimiteDeControle {
+    nome?: string;
+    boundRule?: string;
+    valor?: number | string;
+    removed?: boolean;
+    [k: string]: unknown;
+}
+interface InspecaoValue {
+    tipo?: string;
+    nomeParametro?: string;
+    unidadeParametro?: string;
+    parametroId?: string;
+    limitesDeControle: LimiteDeControle[];
+    [k: string]: unknown;
+}
+interface InspecaoValidationResult {
+    ok: boolean;
+    errors: Record<string, string>;
+}
+interface IInspecaoModalViewModel {
+    /** Estado atual do form de inspecao (Redux) */
+    value: InspecaoValue;
+    /** Flag derivada — ver regra em validate() */
+    isValid: boolean;
+    /** Flag transiente — true enquanto submit() esta pendente */
+    isSubmitting: boolean;
+    /** Define o tipo de dado (Numerico | Verdadeiro ou Falso | ...) */
+    onTipoDeDado(tipo: string): void;
+    /** Atualiza o nome do parametro avulso */
+    onNomeParametro(nome: string): void;
+    /** Usuario selecionou um parametro pre-cadastrado (copia id/unidade/nome) */
+    onParametroSelected(parametro: any): void;
+    /** Atualiza a unidade de medida do parametro */
+    onUnidadeParametro(unidade: string): void;
+    /** Substitui toda a lista de limites de controle */
+    onLimitesChange(limites: LimiteDeControle[]): void;
+    /** Marca o limite no indice idx como removed=true (soft-delete) */
+    removeLimite(idx: number): void;
+    /**
+     * Coloca um limite em modo de edicao. Implementacao default faz
+     * noop no Redux — a UI pode manter o item em state local — mas
+     * a Port existe para que a UI nao precise conhecer esse detalhe.
+     */
+    editLimite(limite: LimiteDeControle): void;
+    /**
+     * Validacao sincrona:
+     *  - tipo obrigatorio
+     *  - tipo === 'Numerico' exige >= 1 limite de controle nao-removed
+     *  - tipo === 'Verdadeiro ou Falso' nao exige limites
+     */
+    validate(): InspecaoValidationResult;
+    /** Valida + retorna DTO. Nao persiste em API. */
+    submit(): Promise<InspecaoValue>;
+    /** Limpa para initialState */
+    reset(): void;
+    /** Popula para edicao */
+    populateFromExisting(inspecao: InspecaoValue): void;
+}
+
+/**
+ * Adapter Redux que implementa IInspecaoModalViewModel.
+ *
+ * Le de state.inspecaoModalVm (slice proprio — inspecaoModalSlice.ts).
+ * isSubmitting vive em useState local (estado transiente do modal).
+ */
+declare function useInspecaoModalViewModel(tarefaId?: string | number): IInspecaoModalViewModel;
+
+/**
+ * Slice autonomo para o modal de Inspecao (core-sdk).
+ *
+ * Parametrizado por tarefaId — mesmo padrao do unidadeMaterialSlice.
+ * Chave '__default__' armazena o estado quando nenhum tarefaId eh fornecido.
+ *
+ * Nao depende do slice legado state.inspecao do SGM-OS — o caller
+ * decide se quer espelhar (ou nao) de volta para o slice antigo.
+ */
+declare const DEFAULT_KEY$2 = "__default__";
+interface InspecaoModalSliceState {
+    byTarefa: Record<string, InspecaoValue>;
+}
+interface ByTarefaPayload<T> {
+    tarefaId?: string | number;
+    value: T;
+}
+declare const setInspecaoTipo: _reduxjs_toolkit.ActionCreatorWithPayload<ByTarefaPayload<string>, "inspecaoModalVm/setTipo">;
+declare const setInspecaoNomeParametro: _reduxjs_toolkit.ActionCreatorWithPayload<ByTarefaPayload<string>, "inspecaoModalVm/setNomeParametro">;
+declare const setInspecaoUnidadeParametro: _reduxjs_toolkit.ActionCreatorWithPayload<ByTarefaPayload<string>, "inspecaoModalVm/setUnidadeParametro">;
+declare const setInspecaoParametro: _reduxjs_toolkit.ActionCreatorWithPayload<ByTarefaPayload<any>, "inspecaoModalVm/setParametro">;
+declare const setInspecaoLimites: _reduxjs_toolkit.ActionCreatorWithPayload<ByTarefaPayload<LimiteDeControle[]>, "inspecaoModalVm/setLimites">;
+declare const removeInspecaoLimiteAt: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    tarefaId?: string | number;
+    idx: number;
+}, "inspecaoModalVm/removeLimiteAt">;
+declare const populateInspecaoModal: _reduxjs_toolkit.ActionCreatorWithPayload<ByTarefaPayload<InspecaoValue>, "inspecaoModalVm/populate">;
+declare const clearInspecaoModal: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    tarefaId?: string | number;
+}, "inspecaoModalVm/clearInspecaoModal">;
+declare const selectInspecaoModal: (state: any, tarefaId?: string | number) => InspecaoValue;
+declare const _default$6: redux.Reducer<InspecaoModalSliceState>;
+
+/**
+ * Port for RecursoDisplayer (ui-kit-sgm).
+ *
+ * Implementado por ReduxRecursoDisplayerAdapter. A UI (RecursoDisplayer)
+ * nao deve chamar useDispatch / useSelector / useHttpController /
+ * useCoreService — consome exclusivamente este contrato via
+ * useRecursoDisplayerViewModel().
+ *
+ * Wave 2A da sprint 2026-04-21-ui-kit-domain-split-wave0 — elimina a
+ * violacao P0 apontada em wiki/troubleshooting/2026-04-19-ui-kit-hexagonal-audit.md.
+ */
+interface BranchLevelRef {
+    level: number;
+    color?: string;
+    nome?: string;
+    [k: string]: any;
 }
-declare const RecursoDisplayer: ({ selectedList, onSaveRecurso, singleReturn, }: RecursoDisplayerProps) => react_jsx_runtime.JSX.Element;
+interface BranchNodeRef {
+    recurso: {
+        id: string | number;
+        nome: string;
+        branchId?: string | number;
+        branch?: {
+            id: string | number;
+            [k: string]: any;
+        };
+        [k: string]: any;
+    };
+    [k: string]: any;
+}
+interface Branch {
+    id: string | number;
+    branchId?: string | number;
+    nomeRecurso?: string;
+    branchLevel?: BranchLevelRef;
+    branchNodes?: BranchNodeRef[];
+    [k: string]: any;
+}
+interface IRecursoDisplayerViewModel {
+    /** Trilha atual (nivel raiz -> folha) do seletor arvore. */
+    branches: Branch[];
+    /** Flag transiente enquanto loadInitialBranches / advanceBranch estao pendentes. */
+    isLoading: boolean;
+    /**
+     * Carrega a raiz da arvore:
+     *   - arvoreEstrutural.get('branchByBranchLevel/1')  -> seta `branches[0]`
+     *   - branchLevel.readAll()                          -> dispatch(setLevels(...))
+     */
+    loadInitialBranches(): Promise<void>;
+    /**
+     * "branchSetter" do componente original (displays/RecursoDisplayer.tsx L69-94).
+     * Avanca a trilha — ao selecionar um branchNode no dropdown atual, carrega
+     * o proximo nivel via arvoreEstrutural.read('branch', nextBranchId).
+     */
+    advanceBranch(bn: BranchNodeRef): Promise<void>;
+    /**
+     * "backOnBranch" do componente original (L96-101). Recolhe a trilha para
+     * o nivel clicado, descartando niveis mais profundos.
+     */
+    backToBranch(branch: Branch): void;
+    /** Reinicia a trilha para vazio (util em cancel/cleanup). */
+    reset(): void;
+}
+
+/**
+ * Overrides opcionais de controllers — usado por callers que precisam de
+ * `gatewayBase` custom (ex. teraprox-SGM-OS/src/hooks/useArvoreControllers.js)
+ * para evitar que `useHttpController('')` caia em endpoint relativo.
+ *
+ * Regra de memoria (Federation endpoint bake-in): nunca passar
+ * `endPointManutencao` / `endPointUser` como baseEndPoint. O Adapter
+ * usa apenas o que for injetado OU o default de `useHttpController()`.
+ */
+interface RecursoDisplayerAdapterOverrides {
+    arvoreEstruturalController?: HttpController;
+    branchLevelController?: HttpController;
+}
+/**
+ * Adapter Redux que implementa IRecursoDisplayerViewModel.
+ *
+ * Porta para o Redux a logica antes inline em
+ * `teraprox-core/packages/ui-kit/src/displays/RecursoDisplayer.tsx`
+ * (useEffect de init + branchSetter + backOnBranch, L42-101).
+ *
+ * - `branches` vive em useState local (estado de navegacao do componente)
+ * - `levels` (branchLevel.readAll) continua em Redux via slice existente
+ *   (`branchLevelReducer.setLevels`) porque outros componentes do dominio
+ *   consomem essa lista.
+ */
+declare function useRecursoDisplayerViewModel(overrides?: RecursoDisplayerAdapterOverrides): IRecursoDisplayerViewModel;
+
+/**
+ * Port for FindRecursoByTagField (ui-kit-sgm).
+ *
+ * Implementado por ReduxFindRecursoByTagAdapter. A UI nao chama
+ * useHttpController — consome exclusivamente este contrato.
+ *
+ * Wave 2A da sprint 2026-04-21-ui-kit-domain-split-wave0.
+ */
+interface RecursoTagRef {
+    id: string | number;
+    descricao?: string;
+    [k: string]: any;
+}
+interface IFindRecursoByTagViewModel {
+    /** Flag transiente enquanto searchByTag / loadActiveTags estao pendentes. */
+    isSearching: boolean;
+    /**
+     * Carrega a lista de tags ativas (feed do AutoComplete).
+     * Equivalente a recurso.get('findActiveRecursosTags').
+     */
+    loadActiveTags(): Promise<RecursoTagRef[]>;
+    /**
+     * Busca um recurso pelo ID da tag selecionada no AutoComplete.
+     * Equivalente a recurso.read('findRecursoByTagId', tagId).
+     */
+    searchByTagId(tagId: string | number): Promise<any | null>;
+    /**
+     * Busca um recurso pela descricao lida via QR (sem espacos).
+     * Equivalente a recurso.read('recurso/findByTagDescription', description).
+     */
+    searchByTag(description: string): Promise<any | null>;
+}
+
+interface FindRecursoByTagAdapterOverrides {
+    /**
+     * Override explicito do controller — util para callers que precisam de
+     * gatewayBase customizado (workaround federation endpoint bake-in).
+     * Se ausente, resolve via useHttpController('recurso').
+     */
+    recursoController?: HttpController | Pick<HttpController, 'read' | 'get'>;
+}
+/**
+ * Adapter que implementa IFindRecursoByTagViewModel.
+ *
+ * Porta para fora da UI a logica antes inline em
+ * `teraprox-core/packages/ui-kit/src/forms/FindRecursoByTagField.tsx`
+ * (useHttpController('recurso') + findRecursoByTagId/Description handlers).
+ */
+declare function useFindRecursoByTagViewModel(overrides?: FindRecursoByTagAdapterOverrides): IFindRecursoByTagViewModel;
+
+/**
+ * Port for JustificativaModal (ui-kit).
+ *
+ * O componente ui-kit `JustificativaModal` eh puramente apresentacional
+ * (controlled via props/callbacks). Esta Port formaliza o ViewModel
+ * reutilizavel para que consumers nao precisem re-implementar a logica
+ * de adicionar/editar/remover/desfazer-remocao em cada tela.
+ *
+ * Implementado pelo `ReduxJustificativaModalAdapter` (default) — que vive
+ * 100% em useState local (nao ha slice global). Consumers que quiserem
+ * persistir em Redux podem implementar um Adapter proprio respeitando a
+ * mesma interface.
+ */
+interface JustificativaUserRef {
+    userId: string | number;
+    userName?: string;
+    firstName?: string;
+}
+interface Justificativa {
+    id: string | number;
+    descricao: string;
+    user?: JustificativaUserRef;
+    createdAt: string | number | Date;
+    removed?: boolean;
+    isNew?: boolean;
+    [k: string]: unknown;
+}
+interface JustificativaValidationResult {
+    ok: boolean;
+    errors: Record<string, string>;
+}
+interface IJustificativaModalViewModel {
+    /** Lista atual (inclui soft-deleted com `removed=true`) */
+    justificativas: Justificativa[];
+    /** Texto do input de nova justificativa / edicao em andamento */
+    draft: string;
+    /** Id sendo editado; null quando for criacao nova */
+    editingId: string | number | null;
+    /** True enquanto submit() estiver pendente */
+    isSubmitting: boolean;
+    /** Atualiza o draft */
+    setDraft(value: string): void;
+    /** Coloca uma justificativa em modo edicao (copia descricao pro draft) */
+    startEdit(id: string | number): void;
+    /** Cancela edicao e limpa draft */
+    cancelEdit(): void;
+    /**
+     * Adiciona (ou salva edicao) a justificativa usando o draft atual.
+     * Gera id local com `uuid` v4 quando em criacao.
+     * Retorna a lista atualizada apos persistir (quando onUpdate foi fornecido).
+     */
+    addOrEdit(): Promise<Justificativa[]>;
+    /** Soft-delete: marca `removed=true` */
+    remove(id: string | number): Promise<Justificativa[]>;
+    /** Desfaz soft-delete: volta `removed=false` */
+    undoRemove(id: string | number): Promise<Justificativa[]>;
+    /** Valida estado atual (draft nao-vazio quando editando) */
+    validate(): JustificativaValidationResult;
+    /** Reseta para a lista inicial (descarta edicoes locais) */
+    reset(): void;
+    /** Popula a lista para visualizacao/edicao */
+    populateFromExisting(justificativas: Justificativa[]): void;
+}
+
+interface JustificativaAdapterOptions {
+    /** Lista inicial (tipicamente vinda do backend via hook consumer) */
+    initialJustificativas?: Justificativa[];
+    /** Usuario corrente — usado para setar `user` ao criar novas */
+    currentUser: JustificativaUserRef;
+    /**
+     * Callback chamado apos qualquer mutacao. Recebe a lista completa
+     * (inclui soft-deleted). O consumer tipicamente faz dispatch Redux
+     * para persistir a alteracao.
+     *
+     * Retorno pode ser `void`, `Promise<void>`, ou `Promise<Justificativa[]>`
+     * (caso o consumer normalize a lista). Quando Promise<Justificativa[]>
+     * for retornada, usamos ela como novo estado.
+     */
+    onUpdate?: (justificativas: Justificativa[]) => void | Promise<void> | Promise<Justificativa[]>;
+}
+/**
+ * Adapter default — gerencia estado local (useState) e delega persistencia
+ * ao consumer via `onUpdate`. Nao fala com Redux diretamente porque
+ * nao existe slice global de justificativas; consumers tipicamente
+ * persistem como parte de uma tarefa/OS/OM.
+ *
+ * Caso um consumer queira slice proprio, basta implementar um Adapter
+ * alternativo respeitando `IJustificativaModalViewModel`.
+ */
+declare function useJustificativaModalViewModel(opts: JustificativaAdapterOptions): IJustificativaModalViewModel;
+
+/**
+ * Port for AnexoManager (ui-kit).
+ *
+ * A UI (`AnexoManager` em ui-kit) eh puramente apresentacional — consome
+ * `persistidos`, `locais`, e callbacks. Esta Port formaliza o ViewModel
+ * reutilizavel, elevando o hook parcial `useAnexoManager` (em core-sdk/hooks)
+ * ao padrao hexagonal completo com contrato explicito + adapter separado.
+ *
+ * O Adapter default (`ReduxAnexoManagerAdapter` — embora nao use Redux:
+ * o nome segue a convencao do core-sdk para indicar "Adapter HTTP/CoreService")
+ * usa `useCoreService().createController('anexo')` por baixo dos panos.
+ *
+ * Modulos que queiram customizar totalmente (testes, mocks, estrategias
+ * alternativas) podem injetar um `IAnexoPort` via `port` ou implementar
+ * um Adapter proprio respeitando `IAnexoManagerViewModel`.
+ */
+
+interface IAnexoManagerViewModel {
+    /** Anexos salvos no servidor */
+    persistidos: AnexoPersistido[];
+    /** Anexos selecionados localmente aguardando upload */
+    locais: AnexoLocal[];
+    /** True durante operacoes assincronas */
+    loading: boolean;
+    /** Busca anexos existentes da entidade (via Port.readByEntity) */
+    loadAnexos(): Promise<void>;
+    /** Adiciona arquivos na fila local (ainda nao faz upload) */
+    addFiles(files: File[]): void;
+    /** Remove um arquivo da fila local */
+    removeLocal(localId: string): void;
+    /**
+     * Executa upload de todos os pendentes.
+     * Se `overrideEntityId` for fornecido, usa-o no lugar do entityId do hook —
+     * util quando a entidade foi criada no mesmo fluxo (ex: save-then-upload).
+     * Retorna lista de anexos persistidos.
+     */
+    uploadAll(overrideEntityId?: string | number): Promise<AnexoPersistido[]>;
+    /** Remove um anexo persistido (chama Port.remove) */
+    removePersistido(anexoId: string | number): Promise<void>;
+    /** Obtem signed URL para preview/download */
+    getUrl(anexoId: string | number, key?: string): Promise<string>;
+}
+interface UseAnexoManagerOptions {
+    /** Contexto da entidade (ex: 'ordemDeServico', 'tarefa') */
+    context: string;
+    /** ID da entidade alvo */
+    entityId: string | number;
+    /**
+     * Port customizado (opcional). Por default o adapter constroi um Port
+     * a partir do `useCoreService().createController('anexo')`.
+     */
+    port?: IAnexoPort;
+}
+
+/**
+ * Adapter default do Port `IAnexoManagerViewModel`.
+ *
+ * Delega para `useAnexoManager` (hook parcial ja existente em core-sdk/hooks).
+ * A existencia deste Adapter formaliza a camada: a UI consome
+ * `useAnexoManagerViewModel({...})` e ganha contrato tipado + isolamento
+ * de implementacao.
+ *
+ * Retrocompatibilidade: `useAnexoManager` continua exportado no root do SDK
+ * com a mesma assinatura original.
+ */
+
+declare function useAnexoManagerViewModel(opts: UseAnexoManagerOptions): IAnexoManagerViewModel;
+
+/**
+ * Port for Recorrencia / FrequenciaFormV2 (cross-domain — SGM + SGP).
+ *
+ * Shape alinhado ao contrato do backend `api-manutencao/recorrencia`:
+ *
+ *   { id?, valor: number, escala: 'millisecond'|'second'|'minute'|'hour'|'day'|'week'|'month'|'year', dataInicio: ISO }
+ *
+ * SEM conversao a milissegundos no client — o backend persiste `valor`+`escala` cru.
+ * `dataFim`/`diaExecucao`/`horarioExecucao` nao existem neste contrato.
+ *
+ * Responsabilidades de orquestracao (isModel, XOR dataPlanejada vs recorrencia,
+ * coexistencia com agregador, historico) permanecem no caller — este Port foca
+ * apenas na entidade Recorrencia.
+ *
+ * Reescrito em Track C.1 UI (realinhamento atomico) da sprint
+ * 2026-04-20-code-split-fix-e-ports-faltantes.
+ */
+type RecorrenciaEscala = 'millisecond' | 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month' | 'year';
+interface RecorrenciaValue {
+    id?: number;
+    valor: number;
+    escala: RecorrenciaEscala;
+    /**
+     * ISO 8601. Opcional porque dominios como caderno/planoDeControle nao usam
+     * agendamento temporal, apenas intervalo de amostragem (valor+escala). SGM-OS
+     * (agendamento real de OS) continua passando dataInicio — o default do
+     * FrequenciaFormV2 preserva o campo, entao callers atuais nao precisam mudar.
+     */
+    dataInicio?: string;
+}
+interface RecorrenciaValidationResult {
+    ok: boolean;
+    errors: Record<string, string>;
+}
+interface IRecorrenciaViewModel {
+    /**
+     * Estado atual. `null` = "sem recorrencia" (estado valido em UI;
+     * a validacao so acusa invalido se o usuario comecou a preencher).
+     */
+    value: RecorrenciaValue | null;
+    /**
+     * Regra:
+     *   valid = false se value === null OU valor < 1 OU !escala.
+     *   dataInicio NAO entra na validacao (opcional — dominios sem agendamento
+     *   temporal nao fornecem). Callers que exigem dataInicio fazem validacao
+     *   adicional em cima deste Port.
+     *   value === null em contexto "sem recorrencia" e valido na UI mas
+     *   isValid reflete apenas validade estrutural da entidade Recorrencia.
+     */
+    isValid: boolean;
+    /** Transiente — true enquanto submit() esta pendente. */
+    isSubmitting: boolean;
+    onValorChange(valor: number): void;
+    onEscalaChange(escala: RecorrenciaEscala): void;
+    /** Aceita undefined para limpar (dominios sem agendamento temporal). */
+    onDataInicioChange(dataInicio: string | undefined): void;
+    /** Seta value = null (estado "sem recorrencia"). */
+    clear(): void;
+    /** Popula para edicao. Aceita null para limpar. */
+    populateFromExisting(value: RecorrenciaValue | null): void;
+    validate(): RecorrenciaValidationResult;
+    /** Valida + retorna DTO (ou null se sem recorrencia). Nao persiste em API. */
+    submit(): Promise<RecorrenciaValue | null>;
+    /** Alias semantico para clear(). */
+    reset(): void;
+}
+
+/**
+ * Adapter Redux que implementa IRecorrenciaViewModel.
+ *
+ * Estado lido do slice 'recorrenciaVm' (ver recorrenciaSlice.ts),
+ * parametrizado por entityId para suportar multiplas recorrencias
+ * simultaneas.
+ *
+ * isSubmitting vive em useState local — estado transiente.
+ */
+declare function useRecorrenciaViewModel(entityId?: string | number): IRecorrenciaViewModel;
+
+/**
+ * Slice autonomo para Recorrencia (core-sdk, cross-domain).
+ *
+ * Parametrizado por entityId — mesmo padrao dos demais slices
+ * (unidadeMaterialSlice, inspecaoModalSlice).
+ * Chave '__default__' armazena o estado quando nenhum entityId eh fornecido.
+ *
+ * Shape alinhado ao backend `api-manutencao/recorrencia`:
+ *   { id?, valor, escala, dataInicio }
+ *
+ * `value === null` = estado "sem recorrencia" (entidade ausente).
+ */
+declare const DEFAULT_KEY$1 = "__default__";
+interface RecorrenciaSliceState {
+    byEntity: Record<string, RecorrenciaValue | null>;
+}
+interface ByEntityPayload$1<T> {
+    entityId?: string | number;
+    value: T;
+}
+declare const setRecorrenciaValor: _reduxjs_toolkit.ActionCreatorWithPayload<ByEntityPayload$1<number>, "recorrenciaVm/setValor">;
+declare const setRecorrenciaEscala: _reduxjs_toolkit.ActionCreatorWithPayload<ByEntityPayload$1<RecorrenciaEscala>, "recorrenciaVm/setEscala">;
+declare const setRecorrenciaDataInicio: _reduxjs_toolkit.ActionCreatorWithPayload<ByEntityPayload$1<string | null | undefined>, "recorrenciaVm/setDataInicio">;
+declare const populateRecorrencia: _reduxjs_toolkit.ActionCreatorWithPayload<ByEntityPayload$1<RecorrenciaValue | null>, "recorrenciaVm/populate">;
+declare const clearRecorrencia: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    entityId?: string | number;
+}, "recorrenciaVm/clearRecorrencia">;
+declare const selectRecorrencia: (state: any, entityId?: string | number) => RecorrenciaValue | null;
+declare const _default$5: redux.Reducer<RecorrenciaSliceState>;
+
+/**
+ * Port for Contador / ContadorPicker (cross-domain — SGM + SGP).
+ *
+ * Implementado por ReduxContadorAdapter. A UI (ContadorPicker em
+ * ui-kit-core) nao deve chamar useSelector/useDispatch/useCoreService —
+ * consome exclusivamente este contrato via useContadorViewModel().
+ *
+ * Alinhado ao shape real usado em TarefaFormV2 + LimiteDeControlePicker
+ * legacy (SGM-OS): um "contador" eh uma leitura numerica com unidade,
+ * parametro e lista de limites de controle (min/max/target com regra
+ * de comparacao).
+ *
+ * Reaproveita o tipo `LimiteDeControle` ja exportado por
+ * IInspecaoModalViewModel para manter 1 unica fonte de verdade.
+ */
+
+type ContadorBoundRule = '>=' | '<=' | '>' | '<' | '==' | '!=';
+interface ContadorValue {
+    /** Leitura atual do contador (ex.: 23.5). Null quando ainda nao lido. */
+    valor: number | null;
+    /** Unidade de medida (ex.: "°C", "kg", "un"). */
+    unidade: string | null;
+    /** Nome do parametro medido (ex.: "Temperatura"). */
+    parametro: string | null;
+    /** Limites de controle aplicaveis (min/max/target + regra). */
+    limitesDeControle: LimiteDeControle[];
+}
+interface ContadorValidationResult {
+    ok: boolean;
+    errors: Record<string, string>;
+}
+interface IContadorViewModel {
+    /** Estado atual do contador (Redux). */
+    value: ContadorValue;
+    /** Flag derivada — ver regra em validate(). */
+    isValid: boolean;
+    /** Flag transiente — true enquanto submit() esta pendente. */
+    isSubmitting: boolean;
+    /** Atualiza a leitura numerica. */
+    onValorChange(v: number | null): void;
+    /** Atualiza a unidade de medida. */
+    onUnidadeChange(u: string): void;
+    /** Atualiza o nome do parametro. */
+    onParametroChange(p: string): void;
+    /** Anexa um novo limite de controle ao final da lista. */
+    onLimiteAdd(limite: LimiteDeControle): void;
+    /** Remove o limite no indice informado (hard-delete no array). */
+    onLimiteRemove(index: number): void;
+    /** Substitui o limite no indice informado. */
+    onLimiteUpdate(index: number, limite: LimiteDeControle): void;
+    /**
+     * Validacao sincrona:
+     *  - valor finito quando presente
+     *  - unidade nao-vazia quando ha valor
+     *  - cada limite precisa de nome, boundRule e valor numerico finito
+     */
+    validate(): ContadorValidationResult;
+    /** Valida + retorna DTO. Nao persiste em API. */
+    submit(): Promise<ContadorValue>;
+    /** Limpa para initialState. */
+    reset(): void;
+    /** Popula para edicao. */
+    populateFromExisting(value: ContadorValue): void;
+}
+
+/**
+ * Adapter Redux que implementa IContadorViewModel.
+ *
+ * Estado lido do slice 'contadorVm' (ver contadorSlice.ts),
+ * parametrizado por entityId para suportar multiplos contadores
+ * simultaneos (ex.: varias tarefas com leitura propria).
+ *
+ * isSubmitting vive em useState local — estado transiente.
+ */
+declare function useContadorViewModel(entityId?: string | number): IContadorViewModel;
+
+/**
+ * IMantenedorPickerViewModel — Port do widget de seleção de manutentor
+ * (Wave 5B hexagonal). Suporta estado client-side de busca + fluxo de
+ * confirmação de desalocação quando o mantenedor selecionado já está
+ * alocado em outra OS.
+ */
+interface MantenedorOption {
+    id: number | string;
+    nomeUsuario: string;
+    _busy?: boolean;
+    osId?: number | string | null;
+    [key: string]: unknown;
+}
+interface IMantenedorPickerViewModel {
+    readonly options: MantenedorOption[];
+    readonly filteredOptions: MantenedorOption[];
+    readonly searchTerm: string;
+    readonly isLoading: boolean;
+    readonly error?: string | null;
+    readonly pendingConfirm: MantenedorOption | null;
+    search(term: string): void;
+    refresh(): Promise<void>;
+    requestSelect(item: MantenedorOption, currentOsId?: number | string | null): 'confirm' | 'immediate';
+    confirmSelect(): MantenedorOption | null;
+    cancelConfirm(): void;
+    reset(): void;
+}
+
+/**
+ * Adapter Redux que implementa IMantenedorPickerViewModel.
+ *
+ * Estado lido do slice 'mantenedorPicker', parametrizado por entityId
+ * (normalmente osId). IO via useCoreService().createController('mantenedor').
+ */
+declare function useMantenedorPickerViewModel(entityId?: string | number | null): IMantenedorPickerViewModel;
+
+/**
+ * Slice do MantenedorPicker (Wave 5B). Parametrizado por entityId
+ * (tipicamente osId) — mesmo padrão dos demais slices hexagonais.
+ */
+interface MantenedorPickerSlot {
+    options: MantenedorOption[];
+    searchTerm: string;
+    isLoading: boolean;
+    error: string | null;
+    pendingConfirm: MantenedorOption | null;
+}
+interface MantenedorPickerSliceState {
+    byEntity: Record<string, MantenedorPickerSlot>;
+}
+declare const setMantenedorOptions: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    key: string;
+    options: MantenedorOption[];
+}, "mantenedorPicker/setOptions">;
+declare const setMantenedorSearchTerm: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    key: string;
+    term: string;
+}, "mantenedorPicker/setSearchTerm">;
+declare const setMantenedorLoading: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    key: string;
+    loading: boolean;
+}, "mantenedorPicker/setLoading">;
+declare const setMantenedorError: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    key: string;
+    error: string | null;
+}, "mantenedorPicker/setError">;
+declare const setMantenedorPendingConfirm: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    key: string;
+    item: MantenedorOption | null;
+}, "mantenedorPicker/setPendingConfirm">;
+declare const clearMantenedorSlot: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    key: string;
+}, "mantenedorPicker/clearSlot">;
+declare const _default$4: redux.Reducer<MantenedorPickerSliceState>;
+
+/**
+ * Slice autonomo para Contador (core-sdk, cross-domain).
+ *
+ * Parametrizado por entityId — mesmo padrao de recorrenciaSlice /
+ * unidadeMaterialSlice / inspecaoModalSlice.
+ * Chave '__default__' armazena o estado quando nenhum entityId eh fornecido.
+ *
+ * `entityId` eh generico: no SGM-OS eh o id da tarefa/OS; no SGP-caderno
+ * pode ser o id do campo de verificacao.
+ */
+declare const DEFAULT_KEY = "__default__";
+interface ContadorSliceState {
+    byEntity: Record<string, ContadorValue>;
+}
+interface ByEntityPayload<T> {
+    entityId?: string | number;
+    value: T;
+}
+interface ByEntityIndexedPayload<T> {
+    entityId?: string | number;
+    index: number;
+    value: T;
+}
+declare const setContadorValor: _reduxjs_toolkit.ActionCreatorWithPayload<ByEntityPayload<number | null>, "contadorVm/setValor">;
+declare const setContadorUnidade: _reduxjs_toolkit.ActionCreatorWithPayload<ByEntityPayload<string>, "contadorVm/setUnidade">;
+declare const setContadorParametro: _reduxjs_toolkit.ActionCreatorWithPayload<ByEntityPayload<string>, "contadorVm/setParametro">;
+declare const addContadorLimite: _reduxjs_toolkit.ActionCreatorWithPayload<ByEntityPayload<LimiteDeControle>, "contadorVm/addLimite">;
+declare const removeContadorLimiteAt: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    entityId?: string | number;
+    index: number;
+}, "contadorVm/removeLimiteAt">;
+declare const updateContadorLimiteAt: _reduxjs_toolkit.ActionCreatorWithPayload<ByEntityIndexedPayload<LimiteDeControle>, "contadorVm/updateLimiteAt">;
+declare const populateContador: _reduxjs_toolkit.ActionCreatorWithPayload<ByEntityPayload<ContadorValue>, "contadorVm/populate">;
+declare const clearContador: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    entityId?: string | number;
+}, "contadorVm/clearContador">;
+declare const selectContador: (state: any, entityId?: string | number) => ContadorValue;
+declare const _default$3: redux.Reducer<ContadorSliceState>;
+
+/**
+ * Port para o status de uma Tarefa (TarefaItem em modo execucao).
+ *
+ * Implementado por `ReduxTarefaStatusAdapter`. A UI apresentacional
+ * (`TarefaItem` em ui-kit-sgm) consome o contrato exclusivamente via
+ * `useTarefaStatusViewModel({ tarefaId, fatherId })`, sem importar
+ * Redux/useCoreService.
+ *
+ * Semantica:
+ *  - `current` reflete o status atual da tarefa (PENDENTE | EXECUTANDO | ENCERRADO)
+ *  - `toggle()` alterna entre PENDENTE e ENCERRADO. O Adapter aplica o flip
+ *    localmente (otimista), persiste via `PUT /ordemDeServico/tarefa/:id`
+ *    com payload `{ status, fatherId? }`. Em erro, reverte e dispara
+ *    `useToast().warning(...)`.
+ *  - `saving` indica operacao em curso.
+ */
+type TarefaStatus = 'PENDENTE' | 'EXECUTANDO' | 'ENCERRADO';
+interface ITarefaStatusViewModel {
+    /** Status atual da tarefa */
+    current: TarefaStatus;
+    /**
+     * Alterna PENDENTE ↔ ENCERRADO. Persiste via
+     * `PUT /ordemDeServico/tarefa/:id` `{ status, fatherId? }`.
+     * Em erro, reverte estado local e dispara toast warning.
+     */
+    toggle(): Promise<void>;
+    /** True enquanto a chamada de persistencia esta em curso */
+    saving: boolean;
+}
+interface UseTarefaStatusOptions {
+    /** Id da tarefa alvo */
+    tarefaId: string | number;
+    /**
+     * Id da estrutura pai (ex: ordemDeServicoId). Quando definido, o Adapter
+     * inclui no body do PUT (`{ status, fatherId }`). Mantem semantica do
+     * legacy `TarefaItem.js#handleToggleStatus`.
+     */
+    fatherId?: number | null;
+    /**
+     * Status inicial. Default `'PENDENTE'`. O caller normalmente passa o
+     * status atual da tarefa carregada (ex: `tarefa.status`).
+     */
+    initialStatus?: TarefaStatus;
+}
+
+/**
+ * Adapter default do Port `ITarefaStatusViewModel`.
+ *
+ * Embora nomeado "Redux*Adapter" pela convencao do core-sdk, NAO usa Redux —
+ * apenas `useState` local + `useCoreService().createController('tarefa')`
+ * para persistir via `PUT /tarefa/:id`.
+ *
+ * Backend: TarefaController montado em `@Controller("/")` + prefix `tarefa`
+ * → `/tarefa/:id` (root, sem prefixo /ordemDeServico). Tarefas com id UUID
+ * (recorrencia) tambem sao aceitas porque o service trata generico.
+ *
+ * Em caso de erro de persistencia, reverte o estado e dispara
+ * `useToast().warning(...)` informando o usuario.
+ */
+
+declare function useTarefaStatusViewModel(opts: UseTarefaStatusOptions): ITarefaStatusViewModel;
+
+/**
+ * Port para a lista de Observacoes (Justificativas) de uma Tarefa.
+ *
+ * Implementado por `ReduxObservacoesTarefaAdapter`. A UI apresentacional
+ * (`ObservacaoModal` em ui-kit-sgm) consome o contrato exclusivamente via
+ * `useObservacoesTarefaViewModel({ tarefaId })`, sem importar
+ * Redux/useCoreService.
+ *
+ * Endpoints (api-manutencao):
+ *  - `GET /ordemDeServico/tarefa/readObservacoesTarefa/:id`
+ *  - `POST /ordemDeServico/tarefa/addObservacaoTarefa/:tarefaId`
+ *
+ * `add(...)` dispara `load()` ao concluir, garantindo lista atualizada.
+ */
+interface ObservacaoTarefaPayload {
+    /** Texto livre da observacao/justificativa */
+    texto: string;
+    [k: string]: unknown;
+}
+interface IObservacoesTarefaViewModel {
+    /** Lista atual de observacoes carregadas (any[] preserva shape backend) */
+    list: any[];
+    /** True durante operacoes assincronas (load/add) */
+    loading: boolean;
+    /** Carrega lista do servidor */
+    load(): Promise<void>;
+    /**
+     * Adiciona observacao no servidor e dispara `load()` ao concluir.
+     * Nao mantem estado otimista — fluxo simples post-then-fetch.
+     */
+    add(obs: ObservacaoTarefaPayload): Promise<void>;
+}
+interface UseObservacoesTarefaOptions {
+    /** Id da tarefa alvo */
+    tarefaId: string | number;
+}
+
+/**
+ * Adapter default do Port `IObservacoesTarefaViewModel`.
+ *
+ * Embora nomeado "Redux*Adapter" pela convencao do core-sdk, NAO usa Redux —
+ * apenas `useState` local + `useCoreService().createController('tarefa')`
+ * para chamar:
+ *   - `GET /tarefa/readObservacoesTarefa/:id`  → `load()`
+ *   - `POST /tarefa/addObservacaoTarefa/:id`   → `add({ texto })`
+ *
+ * Backend: TarefaController em api-manutencao agora montado em `@Controller("/")`
+ * + prefix `tarefa` (sprint 2026-04-29-tarefa-item-unified — anteriormente
+ * `@Controller("/ordemDeServico")`).
+ *
+ * Em erro de persistencia, dispara `useToast().warning(...)` e mantem o
+ * estado local consistente.
+ */
+
+declare function useObservacoesTarefaViewModel(opts: UseObservacoesTarefaOptions): IObservacoesTarefaViewModel;
+
+/**
+ * IPickMantenedorTipoViewModel — Port para o fluxo "configurar OS antes
+ * de iniciar" (atribuir mantenedor + tipo de ordem).
+ *
+ * Promove o legacy SGM-OS PickMantenedorModal — usado tanto pelo
+ * Planejamento quanto pela tela Executar Ordem de Manutenção (statusBindChange).
+ *
+ * Design:
+ *  - Carrega `mantenedores` via GET mantenedor/mantenedorDashboard
+ *  - Carrega `tiposDeOrdem` via GET tipoDeOrdem
+ *  - Atribui mantenedor via POST ordemDeServico/atribuirMantenedor/:osId
+ *  - Atribui tipo via PUT  ordemDeServico/updateTipoDeOrdem/:osId
+ *  - Estado fica num slice flat (singleton — modal só aparece um por vez)
+ */
+interface PickMantenedorOption {
+    id: number | string;
+    userId?: number | string;
+    nomeUsuario?: string;
+    nome?: string;
+    [key: string]: unknown;
+}
+interface PickTipoDeOrdemOption {
+    id: number | string;
+    tipo: string;
+    [key: string]: unknown;
+}
+interface IPickMantenedorTipoViewModel {
+    readonly mantenedores: PickMantenedorOption[];
+    readonly tiposDeOrdem: PickTipoDeOrdemOption[];
+    readonly loading: boolean;
+    readonly assigning: boolean;
+    readonly error: string | null;
+    /** Carrega mantenedores + tipos em paralelo */
+    loadOptions(): Promise<void>;
+    /** POST ordemDeServico/atribuirMantenedor/:osId para cada item */
+    assignMantenedores(osId: number | string, mantenedores: PickMantenedorOption[]): Promise<void>;
+    /** PUT ordemDeServico/updateTipoDeOrdem/:osId */
+    assignTipo(osId: number | string, tipoId: number | string): Promise<void>;
+    /**
+     * Aplica os mesmos mantenedores em N OS (uma chamada bulk por mantenedor).
+     * Usa POST ordemDeServico/atribuirMantenedorBulk { osIds, mantenedorId, userId }.
+     */
+    assignMantenedoresMultiOs(osIds: Array<number | string>, mantenedores: PickMantenedorOption[]): Promise<void>;
+    /**
+     * Aplica o mesmo tipo em N OS via PUT ordemDeServico/updateTipoBulk { osIds, tipoId }.
+     */
+    assignTipoMultiOs(osIds: Array<number | string>, tipoId: number | string): Promise<void>;
+    /** Reseta estado (limpa cache de options) */
+    reset(): void;
+}
+
+declare function usePickMantenedorTipoViewModel(): IPickMantenedorTipoViewModel;
+
+interface PickMantenedorTipoSliceState {
+    mantenedores: PickMantenedorOption[];
+    tiposDeOrdem: PickTipoDeOrdemOption[];
+    loading: boolean;
+    assigning: boolean;
+    error: string | null;
+}
+declare const setPickMantenedorTipoOptions: _reduxjs_toolkit.ActionCreatorWithPayload<{
+    mantenedores: PickMantenedorOption[];
+    tiposDeOrdem: PickTipoDeOrdemOption[];
+}, "pickMantenedorTipo/setOptions">;
+declare const setPickMantenedorTipoLoading: _reduxjs_toolkit.ActionCreatorWithPayload<boolean, "pickMantenedorTipo/setLoading">;
+declare const setPickMantenedorTipoAssigning: _reduxjs_toolkit.ActionCreatorWithPayload<boolean, "pickMantenedorTipo/setAssigning">;
+declare const setPickMantenedorTipoError: _reduxjs_toolkit.ActionCreatorWithPayload<string | null, "pickMantenedorTipo/setError">;
+declare const resetPickMantenedorTipo: _reduxjs_toolkit.ActionCreatorWithoutPayload<"pickMantenedorTipo/reset">;
+declare const _default$2: redux.Reducer<PickMantenedorTipoSliceState>;
+
+/**
+ * Port umbrella para o componente `TarefaItem` (ui-kit-sgm).
+ *
+ * Composicao de cinco VMs ja existentes/novos no core-sdk:
+ *  - status            → `ITarefaStatusViewModel`        (PENDENTE↔ENCERRADO + persist)
+ *  - observacoes       → `IObservacoesTarefaViewModel`   (load/add justificativas)
+ *  - inspecao          → `IInspecaoModalViewModel`       (form de nova inspecao)
+ *  - unidadeMaterial   → `IUnidadeMaterialViewModel`     (composicao mat+un+qtd)
+ *  - anexos            → `IAnexoManagerViewModel`        (signed-URL, intent/confirm)
+ *
+ * Mais duas operacoes de nivel da tarefa:
+ *  - `updateDescricao(texto)` → `PUT /ordemDeServico/tarefa/:id` `{ descricao }`
+ *  - `subscribeLive()`         → ativa/desativa subscriptions RTDB (apenas em
+ *    `mode='execute'`); em outros modos retorna no-op (`() => {}`).
+ *
+ * Sobre `subscribeLive`:
+ *  - O caller (UI) chama dentro de `useEffect` para manter o ciclo de vida
+ *    em si — o Adapter NAO usa o hook `useMatchingObject` internamente
+ *    (regra das hooks: nao chamavel dentro de funcoes). Em vez disso,
+ *    delega a `useCoreService().subscribe/unsubscribe` (nao-hook).
+ *  - Em `mode='execute'` registra as MOs do legacy TarefaItem.js linhas
+ *    136-158: `tarefa{id}` e `tarefaJus{id}` com location `*`. O refresher
+ *    chama `observacoes.load()` (e `anexos.loadAnexos()` quando aplicavel).
+ *
+ * Consumo:
+ *   const vm = useTarefaItemViewModel({ tarefaId, mode: 'execute', fatherId })
+ *   useEffect(() => vm.subscribeLive(), [vm])
+ *   <TarefaItem vm={vm} mode="execute" tarefa={...} />
+ */
+
+type TarefaItemMode = 'edit' | 'execute' | 'readOnly';
+interface ITarefaItemViewModel {
+    /** Status da tarefa (PENDENTE↔ENCERRADO). Ativo em modo 'execute'. */
+    status: ITarefaStatusViewModel;
+    /** Lista de observacoes/justificativas da tarefa */
+    observacoes: IObservacoesTarefaViewModel;
+    /** Form de nova inspecao (delegado ao IInspecaoModalViewModel existente) */
+    inspecao: IInspecaoModalViewModel;
+    /** Composicao Material+Unidade+Quantidade (delegado ao IUnidadeMaterialViewModel) */
+    unidadeMaterial: IUnidadeMaterialViewModel;
+    /**
+     * Anexos via fluxo signed-URL (delegado ao IAnexoManagerViewModel — mesmo
+     * fluxo de `context: 'tarefa'`, `entityId: tarefaId`).
+     */
+    anexos: IAnexoManagerViewModel;
+    /**
+     * Persiste descricao via `PUT /ordemDeServico/tarefa/:tarefaId`
+     * com payload `{ descricao: texto }`.
+     */
+    updateDescricao(texto: string): Promise<void>;
+    /**
+     * Ativa subscription RTDB (apenas em `mode='execute'`).
+     * Retorna funcao de unsubscribe. Em outros modos retorna `() => {}`.
+     *
+     * O caller deve invocar dentro de `useEffect`:
+     *   useEffect(() => vm.subscribeLive(), [vm])
+     */
+    subscribeLive(): () => void;
+}
+interface UseTarefaItemViewModelOptions {
+    /** Id da tarefa alvo */
+    tarefaId: string | number;
+    /**
+     * Modo de operacao do componente:
+     *  - 'edit'     → edicao (TarefasTab no FormV2). Sem subscription RTDB.
+     *  - 'execute'  → execucao (OrdemDeServico tela). Subscription RTDB ativa.
+     *  - 'readOnly' → apenas leitura. Sem subscription, sem mutacao.
+     */
+    mode: TarefaItemMode;
+    /**
+     * Id da estrutura pai (ex: ordemDeServicoId). Repassado para
+     * `useTarefaStatusViewModel` ao alternar status.
+     */
+    fatherId?: number | null;
+    /** Status inicial da tarefa, repassado para `useTarefaStatusViewModel`. */
+    initialStatus?: ITarefaStatusViewModel['current'];
+}
+
+/**
+ * Adapter default do Port `ITarefaItemViewModel`.
+ *
+ * Compoe os 5 VMs (status, observacoes, inspecao, unidadeMaterial, anexos),
+ * adiciona `updateDescricao(...)` (PUT /ordemDeServico/tarefa/:id) e
+ * `subscribeLive()` (RTDB em modo execute, no-op nos demais).
+ *
+ * Sobre `subscribeLive`:
+ *  - `useMatchingObject` NAO pode ser invocado dentro de `subscribeLive`
+ *    (regra das hooks). Por isso usamos `subscribe`/`unsubscribe` do
+ *    `useCoreService()` que sao funcoes regulares.
+ *  - O caller (UI) deve chamar dentro de `useEffect`, fazendo do retorno
+ *    o cleanup:
+ *
+ *      useEffect(() => vm.subscribeLive(), [vm])
+ *
+ *  - Em `mode='execute'` registra MOs:
+ *      `{ context: 'tarefa{id}',    location: '*', refresher }`
+ *      `{ context: 'tarefaJus{id}', location: '*', refresher }`
+ *    O `refresher` dispara `observacoes.load()` (e poderia disparar mais
+ *    refreshes — anexos.loadAnexos — se necessario; mantido conservador
+ *    aqui para nao causar loops).
+ */
+
+declare function useTarefaItemViewModel(opts: UseTarefaItemViewModelOptions): ITarefaItemViewModel;
 
 interface BranchLevelForm {
     nome: string;
@@ -391,4 +1784,4 @@ declare function removeAccents(str: string): string;
 declare function slugify(str: string): string;
 declare function isBlank(str: string | null | undefined): boolean;
 
-export { BreadcrumbPayload, CoreService, CoreServiceBuilder, CoreServiceContext, FetchHttpAdapter, HttpController, IObservabilityPort, InteractionPayload, type NavigateFn, type NavigationConfig, type Notification, type NotificationState, NullCoreService, NullHttpController, NullObservabilityAdapter, NullToastService, RecursoDisplayer, type SolicitacaoDeServico, type StatusSolicitacao, ToastService, TracingHttpAdapter, VitalsPayload, addDays, _default$1 as branchLevelReducer, buildTraceparent, capitalize, clearBranchLevelForm, clearPicker, daysBetween, formatDate, formatDateTime, generateSpanId, generateTraceId, initWebVitals, isBlank, isDateAfter, isDateBefore, pickTextColorBasedOnBgColorAdvanced, _default as pickerReducer, populateToEdit, removeAccents, setColor, setExcludeLevels, setHaveComponente, setLevel, setLevels, setNome, setPickerContext, setPickerItems, setPickerSelected, setPickerVisible, slugify, toISOString, truncate, useAnexoUpload, useCoreService, useFetchData, useFormStorage, useHttpController, useMatchingObject, useNavigator, useNotifications, useObservability, usePostData, useSmartSearch, useToast, useValidation };
+export { type AnexoLocal, type AnexoPersistido, type Branch, type BranchLevelRef, type BranchNodeRef, BreadcrumbPayload, DEFAULT_KEY as CONTADOR_DEFAULT_KEY, type CalculoDeCorrecao, type ContadorBoundRule, type ContadorSliceState, type ContadorValidationResult, type ContadorValue, CoreService, CoreServiceBuilder, CoreServiceContext, FILTER_COMBINE_MODES, FetchHttpAdapter, type FilterCombineMode, type FilterCombineModeApi, type FindRecursoByTagAdapterOverrides, HttpController, type HttpErrorMeta, type HttpInterceptors, type HttpResponseMeta, type IAnexoManagerViewModel, type IAnexoPort, type IContadorViewModel, type IFindRecursoByTagViewModel, type IInspecaoModalViewModel, type IJustificativaModalViewModel, type IMantenedorPickerViewModel, DEFAULT_KEY$2 as INSPECAO_MODAL_DEFAULT_KEY, IObservabilityPort, type IObservacoesTarefaViewModel, type IPickMantenedorTipoViewModel, type IRecorrenciaViewModel, type IRecursoDisplayerViewModel, type ITarefaItemViewModel, type ITarefaStatusViewModel, type IUnidadeMaterialViewModel, type InspecaoModalSliceState, type InspecaoValidationResult, type InspecaoValue, InteractionPayload, type Justificativa, type JustificativaAdapterOptions, type JustificativaUserRef, type JustificativaValidationResult, type LimiteDeControle, type MantenedorOption, type MantenedorPickerSliceState, type MantenedorPickerSlot, type NavigateFn, type NavigationConfig, type Notification, type NotificationState, NullCoreService, NullHttpController, NullObservabilityAdapter, NullToastService, type ObservacaoTarefaPayload, type OrdemDeCorrecao, type OrdemDeCorrecaoFormState, type PickMantenedorOption, type PickMantenedorTipoSliceState, type PickTipoDeOrdemOption, DEFAULT_KEY$1 as RECORRENCIA_DEFAULT_KEY, type RecorrenciaEscala, type RecorrenciaSliceState, type RecorrenciaValidationResult, type RecorrenciaValue, type RecursoDisplayerAdapterOverrides, type RecursoTagRef, type RegraDeCorrecao, type RegraDeCorrecaoFormState, type SolicitacaoDeServico, type StatusOrdemDeCorrecao, type StatusSolicitacao, type TarefaDeCorrecao, type TarefaItemMode, type TarefaStatus, type TarefaUnidadeMaterial, type TimeFormatApi, ToastService, TracingHttpAdapter, DEFAULT_KEY$3 as UNIDADE_MATERIAL_DEFAULT_KEY, type UnidadeMaterialRef, type UnidadeMaterialSliceState, type UnidadeMaterialValue, type UploadIntent, type UseAnexoManagerOptions as UseAnexoManagerViewModelOptions, type UseObservacoesTarefaOptions, type UseTarefaItemViewModelOptions, type UseTarefaStatusOptions, type ValidationResult, VitalsPayload, addContadorLimite, addDays, _default$1 as branchLevelReducer, buildTraceparent, capitalize, clearBranchLevelForm, clearContador, clearInspecaoModal, clearMantenedorSlot, clearPicker, clearRecorrencia, clearUnidadeMaterial, _default$3 as contadorReducer, daysBetween, formatDate, formatDateTime, generateSpanId, generateTraceId, hmsToSeconds, initWebVitals, _default$6 as inspecaoModalReducer, isBlank, isDateAfter, isDateBefore, _default$4 as mantenedorPickerReducer, _default$2 as pickMantenedorTipoReducer, pickTextColorBasedOnBgColorAdvanced, _default as pickerReducer, populateContador, populateInspecaoModal, populateRecorrencia, populateToEdit, populateUnidadeMaterial, _default$5 as recorrenciaReducer, removeAccents, removeContadorLimiteAt, removeInspecaoLimiteAt, resetPickMantenedorTipo, secondsToHms, selectContador, selectInspecaoModal, selectRecorrencia, selectUnidadeMaterial, setColor, setContadorParametro, setContadorUnidade, setContadorValor, setExcludeLevels, setHaveComponente, setInspecaoLimites, setInspecaoNomeParametro, setInspecaoParametro, setInspecaoTipo, setInspecaoUnidadeParametro, setLevel, setLevels, setMantenedorError, setMantenedorLoading, setMantenedorOptions, setMantenedorPendingConfirm, setMantenedorSearchTerm, setNome, setPickMantenedorTipoAssigning, setPickMantenedorTipoError, setPickMantenedorTipoLoading, setPickMantenedorTipoOptions, setPickerContext, setPickerItems, setPickerSelected, setPickerVisible, setRecorrenciaDataInicio, setRecorrenciaEscala, setRecorrenciaValor, setMaterial as setUnidadeMaterialMaterial, setQuantidade as setUnidadeMaterialQuantidade, setUnidade as setUnidadeMaterialUnidade, slugify, toISOString, truncate, _default$7 as unidadeMaterialReducer, updateContadorLimiteAt, useAnexoManager, useAnexoManagerViewModel, useAnexoUpload, useContadorViewModel, useCoreService, useFetchData, useFilterCombineMode, useFindRecursoByTagViewModel, useFormStorage, useHttpController, useInspecaoModalViewModel, useJustificativaModalViewModel, useMantenedorPickerViewModel, useMatchingObject, useNavigator, useNotifications, useObservability, useObservacoesTarefaViewModel, usePickMantenedorTipoViewModel, usePostData, useRecorrenciaViewModel, useRecursoDisplayerViewModel, useSmartSearch, useTarefaItemViewModel, useTarefaStatusViewModel, useTimeFormat, useToast, useUnidadeMaterialViewModel, useValidation };