@jvsoft/mat-form-controls 1.0.0-alpha.13

package/jvs-file-upload/README.md

@@ -0,0 +1,613 @@
+# JvsFileUploadComponent
+
+Componente de subida de archivos reutilizable para proyectos `@jvsoft`, construido con el estándar más moderno de Angular 19+: **signals**, `input()`, `output()`, `computed()` y control flow declarativo (`@if`, `@for`, `@switch`).
+
+Implementa `ControlValueAccessor` para integrarse de forma nativa con formularios reactivos y template-driven. No depende de ningún servicio de negocio: el componente padre inyecta las funciones de subida y eliminación como `input()`, lo que lo hace completamente reutilizable entre proyectos.
+
+---
+
+## Características
+
+- ✅ **Angular 19+ Signals**: `input()`, `output()`, `signal()`, `computed()` — sin decoradores legacy.
+- ✅ **Dos modos de operación**: Subida manual (pre-form) y subida automática inmediata (temporal).
+- ✅ **Drag & Drop**: Zona de arrastrar y soltar integrada con la directiva `jvsFileUpload`.
+- ✅ **Validación de archivos**: por extensión, tamaño máximo, parte de nombre obligatoria o nombre exclusivo.
+- ✅ **Barra de progreso individual** por cada archivo (modo temporal).
+- ✅ **Soporte de formularios**: `formControlName`, `formControl`, `ngModel`.
+- ✅ **Inversión de dependencias**: las funciones de upload/remove se pasan como `input()`, sin acoplamiento a servicios concretos.
+- ✅ **Firma electrónica delegada**: emite un `output()` para que el padre gestione la firma.
+- ✅ **Modo readonly**: solo muestra la lista de archivos, oculta la zona de drop.
+
+---
+
+## Instalación y uso
+
+### 1. Importar el componente
+
+El componente es standalone y se publica como **secondary entry point**:
+
+```typescript
+import { JvsFileUploadComponent } from '@jvsoft/mat-form-controls/jvs-file-upload';
+
+@Component({
+  standalone: true,
+  imports: [JvsFileUploadComponent, ReactiveFormsModule],
+})
+export class MiFormulario {}
+```
+
+---
+
+## Modos de operación
+
+### Modo A — Subida manual (`temporal = false`, defecto)
+
+Los archivos se seleccionan localmente y **no se suben hasta que el padre llame a `uploadFilesPreForm()`**.
+Ideal para formularios donde se quiere controlar cuándo se envían los datos.
+
+```html
+<jvs-file-upload
+  [extensionesPermitidas]="['pdf', 'docx', 'xlsx']"
+  [tamanoMaximoMB]="10"
+  formControlName="archivos"
+/>
+```
+
+```typescript
+// En el método de guardado del formulario:
+const archivosSubidos = await this.fileUpload.uploadFilesPreForm('documentos/2024');
+// archivosSubidos: JvsArchivoServidor[]
+```
+
+### Modo B — Subida automática (`temporal = true`)
+
+Cada archivo se sube **inmediatamente** al ser seleccionado o arrastrado.
+La barra de progreso es visible por cada ítem. El valor del control se actualiza en tiempo real.
+
+```html
+<jvs-file-upload
+  [temporal]="true"
+  [extensionesPermitidas]="['pdf']"
+  [tamanoMaximoMB]="5"
+  [uploadFn]="uploadFn"
+  [removeFn]="removeFn"
+  (archivoDescarga)="onDescargar($event)"
+  (firmarArchivo)="onFirmar($event)"
+  formControlName="archivos"
+/>
+```
+
+```typescript
+// Definir la función de subida (provista por el proyecto consumidor)
+readonly uploadFn: JvsUploadFn = (formData, anonimo) =>
+  this.filesQueryService.uploadFile(formData, anonimo);
+
+// Definir la función de eliminación
+// servFile.key  → archivo registrado en BD con key de almacenamiento externo
+// servFile.path → archivo recién subido (solo path disponible) o archivo de BD con path local
+readonly removeFn: JvsRemoveFn = async ({ servFile }) => {
+  if (servFile.key) {
+    // Archivo registrado en BD: eliminar via mantenimiento (limpia BD + storage)
+    await this.queryService.guardarDatos(
+      'mantenimiento#archivos',
+      { id: servFile.id },
+      'grl', 'toastr'
+    );
+  } else if (servFile.path) {
+    // Archivo en storage local (recién subido o BD sin key)
+    // El backend espera la ruta relativa sin el prefijo "storage/"
+    const path = (servFile.path as string).replace('storage/', '');
+    await this.filesQueryService.removeFile({ f: path });
+  }
+};
+```
+
+### Modo C — Solo lectura (`readonly = true`)
+
+Muestra la lista de archivos existentes sin zona de drop ni controles de edición.
+
+```html
+<jvs-file-upload
+  [readonly]="true"
+  [temporal]="true"
+  formControlName="archivos"
+/>
+```
+
+---
+
+## API del Componente
+
+### Entry Point
+
+```
+@jvsoft/mat-form-controls/jvs-file-upload
+```
+
+### Selector
+
+```
+jvs-file-upload
+```
+
+---
+
+### Inputs
+
+| Propiedad | Tipo | Defecto | Descripción |
+|:---|:---|:---|:---|
+| `temporal` | `boolean` | `false` | Activa la subida inmediata de archivos al seleccionarlos. |
+| `permitirEliminar` | `boolean` | `true` | Muestra el botón de eliminar en cada ítem. |
+| `readonly` | `boolean` | `false` | Oculta la zona de drop y solo muestra la lista. |
+| `multiple` | `boolean` | `true` | Permite seleccionar más de un archivo. |
+| `extensionesPermitidas` | `string[]` | `[]` | Lista de extensiones válidas (sin punto, minúsculas). Array vacío = todas. |
+| `parteDeNombre` | `string[]` | `[]` | El nombre del archivo debe contener **todos** estos fragmentos. |
+| `parteDeNombreExclusivo` | `string[]` | `[]` | Si el nombre contiene **alguno** de estos fragmentos, el archivo se acepta sin checar extensión. Tiene prioridad sobre `parteDeNombre`. |
+| `tamanoMaximoMB` | `number \| null` | `null` | Tamaño máximo en MB. `null` = sin límite. |
+| `nombreArchivoFijo` | `string \| null` | `null` | Si se provee, se envía como `nombreArchivo` en el `FormData` al servidor. |
+| `carpetaSubida` | `string \| null` | `null` | Carpeta destino en el servidor. Si es `null`, usa `temp/YYYY-MM-DD_HH`. |
+| `diskSubida` | `string \| null` | `null` | Disk de Laravel (`local`, `s3`, etc.). `null` = usar el default del servidor. |
+| `uploadFn` | `JvsUploadFn \| null` | `null` | **Función de subida**. Requerida en modo `temporal` o al llamar `uploadFilesPreForm()`. |
+| `removeFn` | `JvsRemoveFn \| null` | `null` | **Función de eliminación**. Si es `null`, el archivo se elimina solo de la lista local sin llamar al servidor. |
+| `cssContenedorAgregados` | `string` | `''` | Clase CSS adicional para el contenedor de la lista en modo temporal. |
+| `cssContenedorAgregadosLista` | `string` | `''` | Clase CSS adicional para el contenedor de archivos válidos/inválidos en modo no-temporal. |
+
+---
+
+### Outputs
+
+| Evento | Emite | Descripción |
+|:---|:---|:---|
+| `resultadoEliminado` | `JvsArchivoServidor[]` | Emite la lista de archivos del servidor restante tras eliminar un elemento. |
+| `archivoDescarga` | `JvsFileEntry` | El usuario hizo click en "Descargar". El padre ejecuta la descarga real. |
+| `firmarArchivo` | `JvsArchivoServidor` | El usuario hizo click en "Firmar". El padre abre el diálogo de firma electrónica. |
+
+---
+
+### Métodos públicos
+
+Accede a estos métodos vía `ViewChild`:
+
+```typescript
+@ViewChild(JvsFileUploadComponent) fileUpload!: JvsFileUploadComponent;
+```
+
+| Método | Firma | Descripción |
+|:---|:---|:---|
+| `uploadFilesPreForm()` | `(carpeta?, anonimo?, disk?) => Promise<JvsArchivoServidor[]>` | Sube todos los archivos pendientes. Muestra confirmación si alguno falla. Retorna los archivos subidos. |
+| `reset()` | `() => void` | Limpia toda la lista de archivos y notifica al `FormControl`. |
+
+---
+
+### Propiedades de estado (signals públicos)
+
+| Signal | Tipo | Descripción |
+|:---|:---|:---|
+| `fileList` | `Signal<JvsFileEntry[]>` | Lista interna de archivos (locales y del servidor). |
+| `invalidFiles` | `Signal<File[]>` | Archivos rechazados por la última selección. |
+| `isDisabled` | `Signal<boolean>` | Estado disabled del control. |
+| `isEmpty` | `Signal<boolean>` | `true` cuando no hay archivos en la lista. |
+
+---
+
+## Interfaces y Tipos
+
+```typescript
+import {
+  JvsArchivoServidor,
+  JvsFileEntry,
+  JvsUploadFn,
+  JvsRemoveFn,
+} from '@jvsoft/mat-form-controls/jvs-file-upload';
+```
+
+### `JvsArchivoServidor`
+
+Representa un archivo ya guardado en el servidor.
+
+```typescript
+interface JvsArchivoServidor {
+  id?: number | string;   // ID en la BD
+  key?: string;           // Key en S3/almacenamiento externo
+  path?: string;          // Path en storage local
+  nombre?: string;        // Nombre legible del archivo
+  extension?: string;     // Extensión (sin punto)
+  cArchivoData?: string;  // JSON string con metadata de generación PDF
+  [key: string]: any;     // Campos adicionales del servidor
+}
+```
+
+### `JvsFileEntry`
+
+Entrada interna de la lista. Encapsula tanto archivos locales como los ya subidos.
+
+```typescript
+interface JvsFileEntry {
+  file?: File | { name: string };  // Objeto File nativo o wrapper mínimo
+  desdeServidor: boolean;           // true si proviene de writeValue()
+  inProgress: boolean;              // true mientras se está subiendo
+  progress: number;                 // 0-100
+  errorSubida?: boolean;            // true si ocurrió un error
+  servFile?: JvsArchivoServidor;    // Datos del servidor tras subida exitosa
+}
+```
+
+### `JvsUploadFn`
+
+Tipo de la función de subida que el consumidor debe proveer:
+
+```typescript
+type JvsUploadFn = (formData: FormData, anonimo?: boolean) => Observable<HttpEvent<any>>;
+```
+
+### `JvsRemoveFn`
+
+Tipo de la función de eliminación que el consumidor debe proveer:
+
+```typescript
+type JvsRemoveFn = (params: Record<string, any>) => Promise<any>;
+// params.servFile contiene el JvsArchivoServidor a eliminar
+```
+
+---
+
+## Lógica de validación de archivos
+
+La directiva `JvsFileUploadDirective` implementa la siguiente cadena de decisión al recibir archivos (por click o drag & drop):
+
+```
+Para cada archivo recibido:
+  1. ¿Excede tamanoMaximoMB?
+     → SÍ: Rechazado. Toast de error. Siguiente archivo.
+
+  2. ¿parteDeNombreExclusivo está definido Y el nombre del archivo
+     contiene ALGUNO de sus valores?
+     → SÍ: Aceptado sin verificar extensión. (Siguiente archivo.)
+
+  3. ¿La extensión está en extensionesPermitidas (o la lista está vacía)
+     Y el nombre contiene TODOS los valores de parteDeNombre?
+     → SÍ: Aceptado.
+
+  4. En cualquier otro caso:
+     → Rechazado. Toast de error.
+```
+
+---
+
+## Flujo de datos (Diagrama)
+
+```
+Usuario selecciona / arrastra archivos
+          │
+          ▼
+  JvsFileUploadDirective.filtrarArchivos()
+     │                │
+  válidos          inválidos
+     │                │
+     │           invalidFiles.set()
+     │
+onFilesChange()
+     │
+     ├─ [temporal=false] → fileList.set(entries sin progress)
+     │                      _notifyChange() → onChange(File[])
+     │
+     └─ [temporal=true]  → fileList.update([...nuevos])
+                           uploadFileTemporal(entry) por cada nuevo
+                                │
+                                ▼
+                         uploadFn(FormData).pipe(
+                           UploadProgress → fileList.update(progress)
+                           Response       → fileList.update(servFile)
+                                           _notifyChange() → onChange(JvsArchivoServidor[])
+                         )
+```
+
+---
+
+## Integración con formularios reactivos
+
+### Con `formControlName`
+
+```typescript
+form = this.fb.group({
+  titulo: ['', Validators.required],
+  archivos: [[]], // Valor inicial: array vacío
+});
+```
+
+```html
+<form [formGroup]="form" (ngSubmit)="guardar()">
+  <jvs-file-upload
+    formControlName="archivos"
+    [temporal]="true"
+    [uploadFn]="uploadFn"
+  />
+</form>
+```
+
+**Valor del control:**
+- Modo `temporal = false`: `File[]` — objetos File del browser (solo archivos locales nuevos; los archivos precargados del servidor no se incluyen en el valor pero sí se muestran en la lista).
+- Modo `temporal = true`: `JvsArchivoServidor[]` — objetos retornados por el servidor.
+
+### Validación de formulario
+
+El componente implementa la interfaz `Validator` de Angular. Registra errores en el `FormControl` automáticamente:
+
+| Error | Cuándo aparece |
+|:---|:---|
+| `uploadEnProgreso: true` | Hay al menos un archivo siendo subido en este momento. |
+| `errorSubida: true` | Al menos un archivo terminó con error de subida. |
+
+```typescript
+// Leer los errores desde el componente padre
+const ctrl = this.form.get('archivos');
+
+if (ctrl?.hasError('uploadEnProgreso')) {
+  // Subida en curso — no guardar aún
+}
+if (ctrl?.hasError('errorSubida')) {
+  // Hubo un fallo — mostrar mensaje al usuario
+}
+```
+
+```html
+<!-- Mostrar mensajes de error en el template -->
+<jvs-file-upload formControlName="archivos" [temporal]="true" [uploadFn]="uploadFn">
+  <span validator>
+    @if (form.get('archivos')?.hasError('uploadEnProgreso')) {
+      Espere a que terminen de subir los archivos.
+    }
+    @if (form.get('archivos')?.hasError('errorSubida')) {
+      Algunos archivos no se pudieron subir. Elimínalos e inténtalo de nuevo.
+    }
+  </span>
+</jvs-file-upload>
+```
+
+> Los errores se actualizan automáticamente: Angular re-ejecuta `validate()` cada vez que cambia el estado de progreso o error en la lista.
+
+---
+
+### Cargar archivos existentes (`writeValue`)
+
+Cuando el formulario se carga con datos del servidor (ej: editando un registro):
+
+```typescript
+this.form.patchValue({
+  archivos: registro.archivos, // JvsArchivoServidor[]
+});
+// El componente reconstruye la lista mostrando los archivos "En servidor".
+// Funciona en ambos modos (temporal = true y temporal = false).
+//
+// En temporal = false: los archivos del servidor se muestran en la lista pero NO se
+// re-suben al llamar uploadFilesPreForm() (ya están en el servidor). El valor que
+// emite onChange solo incluye los File locales nuevos que el usuario agregue.
+```
+
+---
+
+## Ejemplos completos
+
+### Formulario de registro de documentos
+
+```typescript
+@Component({
+  template: `
+    <jvs-file-upload
+      #fileUpload
+      [extensionesPermitidas]="['pdf', 'docx']"
+      [tamanoMaximoMB]="10"
+      [multiple]="false"
+      [uploadFn]="uploadFn"
+      [carpetaSubida]="'contratos/2024'"
+      (resultadoEliminado)="onEliminado($event)"
+      formControlName="contrato"
+    />
+  `
+})
+export class RegistroContratoComponent {
+  @ViewChild('fileUpload') fileUpload!: JvsFileUploadComponent;
+
+  readonly uploadFn: JvsUploadFn = (fd) =>
+    inject(FilesQueryService).uploadFile(fd);
+
+  async guardar() {
+    const archivos = await this.fileUpload.uploadFilesPreForm();
+    if (!archivos.length) return; // El usuario canceló o hubo error
+
+    this.form.patchValue({ contrato: archivos[0] });
+    await this.registroService.guardar(this.form.value);
+  }
+}
+```
+
+### Vista de detalle con descarga y firma
+
+```typescript
+@Component({
+  template: `
+    <jvs-file-upload
+      [temporal]="true"
+      [readonly]="!puedeEditar"
+      [uploadFn]="uploadFn"
+      [removeFn]="removeFn"
+      (archivoDescarga)="descargar($event)"
+      (firmarArchivo)="firmar($event)"
+      formControlName="adjuntos"
+    />
+  `
+})
+export class DetalleExpedienteComponent {
+
+  descargar(entry: JvsFileEntry) {
+    if (entry.servFile?.key) {
+      this.filesService.downloadFile({ cArchivoKey: entry.servFile.key });
+    }
+  }
+
+  firmar(archivo: JvsArchivoServidor) {
+    this.dlgFirmaService.firmarPorTipo(this.tipoFirma, archivo);
+  }
+}
+```
+
+---
+
+## Comparativa con la versión legada (`fc-file-upload`)
+
+| Característica | Versión legada | `jvs-file-upload` |
+|:---|:---|:---|
+| Inputs | `@Input()` decorador | `input()` signal |
+| Outputs | `@Output() EventEmitter` | `output()` signal |
+| Estado | `any[]` mutable | `signal<JvsFileEntry[]>()` |
+| Derivados | Lógica en template | `computed()` signals |
+| HTTP | `toPromise()` (deprecado) | `lastValueFrom()` |
+| Control flow | `*ngIf`, `*ngFor` | `@if`, `@for`, `@switch` |
+| Servicios | Inyectados (acoplados) | `input<JvsUploadFn>()` (inversión de dependencia) |
+| Firma | Dependencia directa a `FirmaService` | `output()` — el padre gestiona |
+| `@Output() resultado` | Declarado, nunca emitía | Eliminado |
+| `@Input() contieneEnNombre` | Declarado, sin implementar | Eliminado |
+| `validarExtensionesV1()` | Bug en condición lógica | Eliminado |
+| `console.log` en `mostrarDataArchivo` | Presente | Eliminado |
+| Tipado | `fileList: any[]` | `fileList: signal<JvsFileEntry[]>` |
+
+---
+
+---
+
+## Referencia de API del backend (JVSoft Laravel)
+
+El componente consume tres endpoints del módulo `grl` del backend. Los mismos existen en versión autenticada y anónima.
+
+### POST `/grl/archivos/cargar` · `/grl/archivos/anonimo/cargar`
+
+Sube un archivo al disco de Laravel.
+
+**Request** (`multipart/form-data` o JSON con base64):
+
+| Campo | Tipo | Requerido | Descripción |
+|:---|:---|:---|:---|
+| `archivo` | `File` | ✓ (o `base64`) | Archivo multipart |
+| `base64` | `string` | ✓ (o `archivo`) | Contenido en base64. Incluir prefijo `data:<mime>;base64,` o enviar `mime` por separado |
+| `carpeta` | `string` | ✓ | Ruta destino en el disco (ej: `"temp/2024-01-15_14"`, `"tramites/adjuntos"`) |
+| `disk` | `string` | — | Nombre del disco Laravel (`local`, `s3`, `tramite`, etc.). Default: el configurado en `filesystems.default` |
+| `nombreArchivo` | `string` | — | Nombre fijo (sin extensión). Si se omite, se genera: `timestamp-[prefijo-]nombre_original[-sufijo].ext` |
+| `prefijo` | `string` | — | Prefijo añadido al nombre generado automáticamente |
+| `sufijo` | `string` | — | Sufijo añadido al nombre generado automáticamente |
+
+**Respuesta** `200 OK`:
+```json
+"temp/2024-01-15_14/1705326000-documento.pdf"
+```
+> ⚠️ El backend devuelve un **string plano** (la ruta relativa en el disco), no un objeto JSON.
+> El componente lo normaliza automáticamente a `{ path: "..." }` para uso uniforme.
+
+---
+
+### POST `/grl/archivos/eliminar` · `/grl/archivos/anonimo/eliminar`
+
+Elimina un archivo del disco de Laravel por su ruta relativa.
+
+**Request** (JSON):
+
+| Campo | Tipo | Descripción |
+|:---|:---|:---|
+| `f` | `string` | Ruta relativa del archivo en el disco (sin prefijo `storage/`) |
+
+**Respuesta** `200 OK`:
+```json
+{ "msg": "Se eliminó correctamente" }
+```
+
+---
+
+### GET `/grl/archivos/descargar` · `/grl/archivos/anonimo/descargar`
+
+Sirve un archivo almacenado. Acepta dos modos de identificación:
+
+**Por `key` (archivos registrados en BD):**
+
+| Parámetro | Descripción |
+|:---|:---|
+| `cArchivoKey` | Key del archivo en la BD |
+| `cArchivoCVD` | Alternativa: código de verificación digital |
+
+Si el archivo tiene firmas electrónicas, el backend genera el PDF con QR de firma incrustado antes de servirlo.
+
+**Por ruta (`f`):**
+
+| Parámetro | Descripción |
+|:---|:---|
+| `f` | Ruta relativa en el disco (ej: `"temp/2024-01-15_14/file.pdf"`) |
+| `porTipoAutomatico` | `1` → inline si < 50 MB, descarga si es mayor |
+| `type` | `"view_pdf"` o `"view_img"` → fuerza inline |
+| `disk` | Disco alternativo (opcional) |
+| `name` | Nombre de descarga personalizado (opcional) |
+
+**Ejemplo desde el componente padre:**
+```typescript
+descargar(entry: JvsFileEntry) {
+  const sf = entry.servFile;
+  if (!sf) return;
+
+  if (sf.key) {
+    // Archivo en BD: el backend busca por key y aplica firmas si corresponde
+    this.filesQueryService.downloadFile({ cArchivoKey: sf.key });
+  } else if (sf.cArchivoData) {
+    // PDF generado dinámicamente con metadata
+    const meta = JSON.parse(sf.cArchivoData);
+    this.filesQueryService.downloadFile({ cArchivoKey: meta.key ?? sf.key });
+  } else if (sf.path) {
+    // Archivo recién subido (solo path disponible)
+    this.filesQueryService.downloadFile({ f: sf.path, porTipoAutomatico: 1 });
+  }
+}
+```
+
+---
+
+## Storybook
+
+Para explorar el componente de forma interactiva:
+
+```bash
+npx nx run mat-form-controls:storybook
+```
+
+---
+
+## Directiva `JvsFileUploadDirective`
+
+La directiva interna que gestiona el drag-and-drop. También puede usarse independientemente:
+
+```typescript
+import { JvsFileUploadDirective } from '@jvsoft/mat-form-controls/jvs-file-upload';
+```
+
+### Inputs
+
+| Input | Tipo | Defecto | Descripción |
+|:---|:---|:---|:---|
+| `controlFile` | `HTMLInputElement` | **requerido** | Referencia al `<input type="file">` para determinar si es multiple. |
+| `extensionesPermitidas` | `string[]` | `[]` | Extensiones aceptadas al soltar archivos. |
+| `parteDeNombre` | `string[]` | `[]` | Fragmentos requeridos en el nombre. |
+| `parteDeNombreExclusivo` | `string[]` | `[]` | Fragmentos exclusivos (aceptan sin checar extensión). |
+| `tamanoMaximoMB` | `number \| null` | `null` | Límite de tamaño en MB. |
+| `isDisabled` | `boolean` | `false` | Deshabilita el drag-and-drop. |
+| `fondoInicial` | `string` | `''` | Color de fondo del elemento en estado normal. |
+| `fondoDragOver` | `string` | `'#e5e7eb'` | Color de fondo al arrastrar sobre el elemento. |
+
+### Outputs
+
+| Output | Emite | Descripción |
+|:---|:---|:---|
+| `filesChange` | `File[]` | Archivos válidos al soltar en la zona. |
+| `filesInvalidChange` | `File[]` | Archivos rechazados al soltar en la zona. |
+
+### Método estático
+
+```typescript
+JvsFileUploadDirective.filtrarArchivos(files, params, multiple?): { valid: File[], invalid: File[] }
+```
+
+Útil para validar archivos desde un `input[type=file]` sin necesidad del drop.

package/jvs-file-upload/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@jvsoft/mat-form-controls/jvs-file-upload" />
+export * from './public-api';

package/jvs-file-upload/jvs-file-upload-item/jvs-file-upload-item.component.d.ts

@@ -0,0 +1,29 @@
+import { convertirBytes } from '@jvsoft/utils';
+import { JvsFileEntry, JvsArchivoServidor } from '../jvs-file-upload.interfaces';
+import * as i0 from "@angular/core";
+/**
+ * Componente de ítem individual de la lista de archivos en modo `temporal`.
+ * Muestra nombre, tamaño, barra de progreso y acciones (descargar, firmar, eliminar).
+ */
+export declare class JvsFileUploadItemComponent {
+    file: import("@angular/core").InputSignal<JvsFileEntry>;
+    permitirEliminar: import("@angular/core").InputSignal<boolean>;
+    isDisabled: import("@angular/core").InputSignal<boolean>;
+    eliminar: import("@angular/core").OutputEmitterRef<JvsFileEntry>;
+    descargar: import("@angular/core").OutputEmitterRef<JvsFileEntry>;
+    firmar: import("@angular/core").OutputEmitterRef<JvsArchivoServidor>;
+    readonly extension: import("@angular/core").Signal<string>;
+    readonly nombreMostrado: import("@angular/core").Signal<string>;
+    readonly estadoProgreso: import("@angular/core").Signal<"" | "cargando" | "incompleto" | "completado">;
+    readonly modoProgreso: import("@angular/core").Signal<"indeterminate" | "determinate">;
+    readonly mostrarBotonDescargar: import("@angular/core").Signal<boolean>;
+    readonly mostrarBotonFirmar: import("@angular/core").Signal<boolean>;
+    readonly mostrarBotonEliminar: import("@angular/core").Signal<boolean>;
+    readonly tamanioArchivo: import("@angular/core").Signal<number>;
+    readonly convertirBytes: typeof convertirBytes;
+    onEliminar(): void;
+    onDescargar(): void;
+    onFirmar(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JvsFileUploadItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<JvsFileUploadItemComponent, "jvs-file-upload-item", never, { "file": { "alias": "file"; "required": true; "isSignal": true; }; "permitirEliminar": { "alias": "permitirEliminar"; "required": false; "isSignal": true; }; "isDisabled": { "alias": "isDisabled"; "required": false; "isSignal": true; }; }, { "eliminar": "eliminar"; "descargar": "descargar"; "firmar": "firmar"; }, never, never, true, never>;
+}