diff --git a/src/components/apontamento/SeletorItensOtimizado.tsx b/src/components/apontamento/SeletorItensOtimizado.tsx
index 6b029f7..0bffa5f 100644
--- a/src/components/apontamento/SeletorItensOtimizado.tsx
+++ b/src/components/apontamento/SeletorItensOtimizado.tsx
@@ -28,6 +28,25 @@ interface ItemDisponivel {
   processo_atual_permitido: number;
 }
 
+interface ComponenteItemData {
+  id: string;
+  marca_componente: string;
+  perfil?: string;
+  peso_unitario?: number;
+  quantidade_por_peca?: number;
+  descricao?: string;
+}
+
+interface ApontamentoPecaRecord {
+  id: string;
+  quantidade_produzida: number;
+  data_apontamento?: string;
+  created_at: string;
+  usuario_id?: string;
+  processo?: { nome?: string; ordem?: number } | null;
+  peca?: { marca?: string; of_number?: string } | null;
+}
+
 interface SeletorItensOtimizadoProps {
   pecasDisponiveis?: ItemDisponivel[];
   componentesDisponiveis?: ItemDisponivel[];
@@ -36,12 +55,13 @@ interface SeletorItensOtimizadoProps {
   onBatchSelect?: (items: ItemDisponivel[], tipo: 'peca' | 'componente') => Promise<void>;
   loading?: boolean;
   onSelectPeca?: (peca: PecaWithComponents) => void;
-  onSelectComponente?: (componente: any) => void;
+  onSelectComponente?: (componente: ComponenteItemData) => void;
   pecaId?: string | null;
 }
 
 interface PecaWithComponents extends Peca {
-  componentes?: any[];
+  componentes?: ComponenteItemData[];
+  processo_atual_permitido?: number;
 }
 
 export const SeletorItensOtimizado: React.FC<SeletorItensOtimizadoProps> = ({
@@ -61,14 +81,14 @@ export const SeletorItensOtimizado: React.FC<SeletorItensOtimizadoProps> = ({
   const [pecasFiltradas, setPecasFiltradas] = useState<PecaWithComponents[]>([]);
   const [loadingPecas, setLoadingPecas] = useState(false);
   const [loadingComponentes, setLoadingComponentes] = useState(false);
-  const [componentes, setComponentes] = useState<any[]>([]);
+  const [componentes, setComponentes] = useState<ComponenteItemData[]>([]);
   const [showComponentes, setShowComponentes] = useState(false);
   const inputRef = useRef<HTMLInputElement>(null);
 
   // Estados para funcionalidade administrativa
   const [showAdminModal, setShowAdminModal] = useState(false);
   const [selectedPecaForAdmin, setSelectedPecaForAdmin] = useState<ItemDisponivel | null>(null);
-  const [apontamentosPeca, setApontamentosPeca] = useState<any[]>([]);
+  const [apontamentosPeca, setApontamentosPeca] = useState<ApontamentoPecaRecord[]>([]);
   const [loadingApontamentos, setLoadingApontamentos] = useState(false);
 
   const { isAdmin } = useUserRole();
@@ -158,18 +178,6 @@ export const SeletorItensOtimizado: React.FC<SeletorItensOtimizadoProps> = ({
     }
   }, []);
 
-  useEffect(() => {
-    if (onSelectPeca) {
-      fetchPecas(debouncedSearchTerm);
-    }
-  }, [debouncedSearchTerm, fetchPecas, onSelectPeca]);
-
-  useEffect(() => {
-    if (pecaId && onSelectComponente) {
-      loadComponentes(pecaId);
-    }
-  }, [pecaId, onSelectComponente]);
-
   const loadComponentes = useCallback(async (pecaId: string) => {
     try {
       setLoadingComponentes(true);
@@ -184,6 +192,18 @@ export const SeletorItensOtimizado: React.FC<SeletorItensOtimizadoProps> = ({
     }
   }, [fetchComponentesPeca]);
 
+  useEffect(() => {
+    if (onSelectPeca) {
+      fetchPecas(debouncedSearchTerm);
+    }
+  }, [debouncedSearchTerm, fetchPecas, onSelectPeca]);
+
+  useEffect(() => {
+    if (pecaId && onSelectComponente) {
+      loadComponentes(pecaId);
+    }
+  }, [pecaId, onSelectComponente, loadComponentes]);
+
   const handlePecaSelect = useCallback((peca: PecaWithComponents) => {
     if (onSelectPeca) {
       onSelectPeca(peca);
@@ -194,13 +214,13 @@ export const SeletorItensOtimizado: React.FC<SeletorItensOtimizadoProps> = ({
         descricao: peca.descricao || '',
         tipo: 'peca',
         quantidade_disponivel: peca.quantidadeDisponivel || 0,
-        processo_atual_permitido: (peca as any).processo_atual_permitido || 0
+        processo_atual_permitido: peca.processo_atual_permitido || 0
       };
       onItemSelect(itemDisponivel);
     }
   }, [onSelectPeca, onItemSelect]);
 
-  const handleComponenteSelect = useCallback((componente: any) => {
+  const handleComponenteSelect = useCallback((componente: ComponenteItemData) => {
     if (onSelectComponente) {
       onSelectComponente(componente);
     }
@@ -601,7 +621,7 @@ export const SeletorItensOtimizado: React.FC<SeletorItensOtimizadoProps> = ({
                           {apontamentosPeca.map((apontamento, index) => (
                             <div key={apontamento.id || index} className="bg-slate-800 p-3 rounded border border-slate-600">
                               <div className="grid grid-cols-2 gap-2 text-sm">
-                                <div><span className="text-slate-400">Processo:</span> <span className="text-blue-300">{apontamento.processos?.nome || 'N/A'}</span></div>
+                                <div><span className="text-slate-400">Processo:</span> <span className="text-blue-300">{apontamento.processo?.nome || 'N/A'}</span></div>
                                 <div><span className="text-slate-400">Quantidade:</span> <span className="text-green-400">{apontamento.quantidade_produzida}</span></div>
                                 <div><span className="text-slate-400">Data:</span> <span className="text-slate-300">{new Date(apontamento.created_at).toLocaleString('pt-BR')}</span></div>
                                 <div><span className="text-slate-400">Usuário:</span> <span className="text-slate-300">{apontamento.usuario_id}</span></div>
diff --git a/src/hooks/useApontamentoDiarioChart.tsx b/src/hooks/useApontamentoDiarioChart.tsx
index 55524c7..8eb5cb8 100644
--- a/src/hooks/useApontamentoDiarioChart.tsx
+++ b/src/hooks/useApontamentoDiarioChart.tsx
@@ -216,6 +216,7 @@ export const useApontamentoDiarioChart = (periodo: PeriodoType) => {
 
   useEffect(() => {
     fetchData();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [periodo]);
 
   return { 
diff --git a/src/hooks/useDashboardProducao.tsx b/src/hooks/useDashboardProducao.tsx
index 943c450..2f8ef59 100644
--- a/src/hooks/useDashboardProducao.tsx
+++ b/src/hooks/useDashboardProducao.tsx
@@ -172,6 +172,7 @@ export const useDashboardProducao = (ofNumber: string) => {
 
   useEffect(() => {
     fetchDashboardData();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [ofNumber]);
 
   return {
diff --git a/src/hooks/useRelatorioDiario.tsx b/src/hooks/useRelatorioDiario.tsx
index 41be437..d72ac97 100644
--- a/src/hooks/useRelatorioDiario.tsx
+++ b/src/hooks/useRelatorioDiario.tsx
@@ -136,6 +136,7 @@ export const useRelatorioDiario = (selectedDate: string) => {
 
   useEffect(() => {
     fetchApontamentos();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [selectedDate]);
 
   // Calcular resumo por processo
diff --git a/src/hooks/useValidacaoSequencialProcessos.tsx b/src/hooks/useValidacaoSequencialProcessos.tsx
index a150818..74e0938 100644
--- a/src/hooks/useValidacaoSequencialProcessos.tsx
+++ b/src/hooks/useValidacaoSequencialProcessos.tsx
@@ -163,15 +163,33 @@ export const useValidacaoSequencialProcessos = () => {
     return { valido: true };
   }, [historico, processos]);
 
+  // Função auxiliar para calcular quantidade disponível do processo anterior
+  const calcularQuantidadeDisponivelProcessoAnterior = useCallback(async (
+    marcaItem: string,
+    ordemProcessoAnterior: number,
+    ofNumber: string,
+    tipoItem: 'peca' | 'componente'
+  ): Promise<number> => {
+    const processoAnterior = processos.find(p => p.ordem === ordemProcessoAnterior);
+    if (!processoAnterior) return 0;
+
+    return await buscarQuantidadeProcessada(
+      marcaItem,
+      processoAnterior.id,
+      ofNumber,
+      tipoItem
+    );
+  }, [processos, buscarQuantidadeProcessada]);
+
   // Calcular itens disponíveis para um processo específico
   const calcularItensDisponiveis = useCallback(async (
     ofNumber: string,
     processoId: string,
-    pecas: any[],
-    componentes: any[]
+    pecas: Record<string, unknown>[],
+    componentes: Record<string, unknown>[]
   ): Promise<{
-    pecasDisponiveis: any[];
-    componentesDisponiveis: any[];
+    pecasDisponiveis: Record<string, unknown>[];
+    componentesDisponiveis: Record<string, unknown>[];
   }> => {
     const processoAtual = processos.find(p => p.id === processoId);
     if (!processoAtual) {
@@ -179,28 +197,31 @@ export const useValidacaoSequencialProcessos = () => {
     }
 
     const ordemAtual = processoAtual.ordem;
-    const pecasDisponiveis: any[] = [];
-    const componentesDisponiveis: any[] = [];
+    const pecasDisponiveis: Record<string, unknown>[] = [];
+    const componentesDisponiveis: Record<string, unknown>[] = [];
 
     // Processar peças
     for (const peca of pecas) {
+      const marcaPeca = String(peca.marca || '');
+      const qtdPeca = Number(peca.quantidade || 0);
+
       if (ordemAtual === 1) {
         // Primeiro processo: todas as peças estão disponíveis
         pecasDisponiveis.push({
           ...peca,
-          quantidade_disponivel: peca.quantidade || 0
+          quantidade_disponivel: qtdPeca
         });
       } else {
         // Calcular quantidade disponível baseada no processo anterior
         const quantidadeProcessadaAnterior = await calcularQuantidadeDisponivelProcessoAnterior(
-          peca.marca,
+          marcaPeca,
           ordemAtual - 1,
           ofNumber,
           'peca'
         );
 
         const quantidadeJaProcessadaAtual = await buscarQuantidadeProcessada(
-          peca.marca,
+          marcaPeca,
           processoId,
           ofNumber,
           'peca'
@@ -219,23 +240,26 @@ export const useValidacaoSequencialProcessos = () => {
 
     // Processar componentes
     for (const componente of componentes) {
+      const marcaComp = String(componente.marca_componente || '');
+      const qtdComp = Number(componente.quantidade_total || 0);
+
       if (ordemAtual === 1) {
         // Primeiro processo: todos os componentes estão disponíveis
         componentesDisponiveis.push({
           ...componente,
-          quantidade_disponivel: componente.quantidade_total || 0
+          quantidade_disponivel: qtdComp
         });
       } else {
         // Calcular quantidade disponível baseada no processo anterior
         const quantidadeProcessadaAnterior = await calcularQuantidadeDisponivelProcessoAnterior(
-          componente.marca_componente,
+          marcaComp,
           ordemAtual - 1,
           ofNumber,
           'componente'
         );
 
         const quantidadeJaProcessadaAtual = await buscarQuantidadeProcessada(
-          componente.marca_componente,
+          marcaComp,
           processoId,
           ofNumber,
           'componente'
@@ -253,25 +277,7 @@ export const useValidacaoSequencialProcessos = () => {
     }
 
     return { pecasDisponiveis, componentesDisponiveis };
-  }, [processos, buscarQuantidadeProcessada]);
-
-  // Função auxiliar para calcular quantidade disponível do processo anterior
-  const calcularQuantidadeDisponivelProcessoAnterior = async (
-    marcaItem: string,
-    ordemProcessoAnterior: number,
-    ofNumber: string,
-    tipoItem: 'peca' | 'componente'
-  ): Promise<number> => {
-    const processoAnterior = processos.find(p => p.ordem === ordemProcessoAnterior);
-    if (!processoAnterior) return 0;
-
-    return await buscarQuantidadeProcessada(
-      marcaItem,
-      processoAnterior.id,
-      ofNumber,
-      tipoItem
-    );
-  };
+  }, [processos, buscarQuantidadeProcessada, calcularQuantidadeDisponivelProcessoAnterior]);
 
   return {
     historico,