# General Translation Platform: queryFileData
URL: https://generaltranslation.com/es/docs/platform/core/reference/gt-class-methods/translation/query-file-data.mdx
---

title: queryFileData
description: Consulta el estado y los metadatos de traducción de los archivos cargados o traducidos. Referencia de la API para queryFileData.

---

Consulta datos sobre uno o varios archivos origen o translation con General Translation. Úsalo para supervisar el progreso de la traducción, comprobar el estado de finalización y ver qué traducciones están disponibles.

## Descripción general [#overview]

Llama a `queryFileData` con un objeto que especifique los archivos de origen o traducidos que se van a consultar. Devuelve metadatos de cada archivo solicitado.

```typescript
const gt = new GT({ projectId: 'your-project-id', apiKey: 'your-api-key' });

const result = await gt.queryFileData({
  sourceFiles: [{ fileId: 'file-123', versionId: 'version-456', branchId: 'branch-789' }],
  translatedFiles: [
    { fileId: 'file-123', versionId: 'version-456', branchId: 'branch-789', locale: 'es' },
  ],
});
```

Firma:

```typescript
queryFileData(
  data: FileDataQuery,
  options?: CheckFileTranslationsOptions
): Promise<FileDataResult>
```

*Nota: `queryFileData` requiere una `apiKey` (o `devApiKey`) y un `projectId` en la instancia de GT.*

## Cómo funciona [#how-it-works]

* **Finalización.** Una traducción se considera completa cuando su `completedAt` no es `null`.
* **Ciclo de vida.** Una traducción completada aún puede requerir aprobación (`approvedAt`) antes de publicarse (`publishedAt`).
* **Supervisión por lotes.** Consulta varios archivos a la vez para comprobar de forma eficiente el estado de múltiples trabajos de traducción.
* **Control de versiones.** Todas las consultas de archivos requieren `branchId` para el control de versiones con compatibilidad con ramas.

## Parámetros [#parameters]

| Parámetro             | Descripción                                                              | Type                           | Opcional | Predeterminado |
| --------------------- | ------------------------------------------------------------------------ | ------------------------------ | -------- | -------------- |
| [`data`](#data)       | Objeto que contiene consultas para el origen y el archivo de traducción. | `FileDataQuery`                | No       | —              |
| [`options`](#options) | Configuración de la solicitud.                                           | `CheckFileTranslationsOptions` | Sí       | —              |

### `data` [#data]

**Tipo** `FileDataQuery` · **Obligatorio**

Los archivos que se van a consultar, divididos en archivos de origen y archivos traducidos:

```typescript
type FileDataQuery = {
  sourceFiles?: {
    fileId: string;
    versionId: string;
    branchId: string;
  }[];
  translatedFiles?: {
    fileId: string;
    versionId: string;
    branchId: string;
    locale: string;
  }[];
};
```

| Campo             | Descripción                                | Tipo       | Opcional |
| ----------------- | ------------------------------------------ | ---------- | -------- |
| `sourceFiles`     | Lista de consultas de archivos de origen.  | `object[]` | Sí       |
| `translatedFiles` | Lista de consultas de archivos traducidos. | `object[]` | Sí       |

### `options` [#options]

**Tipo** `CheckFileTranslationsOptions` · **Opcional**

| Campo     | Descripción                                       | Type     | Opcional |
| --------- | ------------------------------------------------- | -------- | -------- |
| `timeout` | Tiempo de espera de la solicitud en milisegundos. | `number` | Sí       |

## Devuelve [#returns]

**Tipo** `Promise<FileDataResult>`

Se resuelve con un `FileDataResult` que contiene metadatos del archivo de origen solicitado y de los archivos traducidos:

```typescript
type FileDataResult = {
  sourceFiles?: {
    branchId: string;
    fileId: string;
    versionId: string;
    fileName: string;
    fileFormat: string;
    dataFormat: string | null;
    createdAt: string;
    updatedAt: string;
    publishedAt: string | null;
    locales: string[];
    sourceLocale: string;
  }[];
  translatedFiles?: {
    fileId: string;
    versionId: string;
    branchId: string;
    locale: string;
    fileFormat: string;
    dataFormat: string | null;
    completedAt: string | null;
    approvedAt: string | null;
    publishedAt: string | null;
    createdAt: string;
    updatedAt: string;
  }[];
};
```

| Propiedad         | Descripción                               | Tipo       |
| ----------------- | ----------------------------------------- | ---------- |
| `sourceFiles`     | lista con datos de archivos de origen.    | `object[]` |
| `translatedFiles` | lista con datos del estado de traducción. | `object[]` |

## Ejemplos [#examples]

```typescript title="index.ts"
// (1) Crear una instancia de GT
const targetLocales = ['es', 'fr', 'de'];
const gt = new GT({
  projectId: 'your-project-id',
  apiKey: 'your-api-key',
});

// (2) Subir el archivo
const fileUpload = {
  content: fileContents,
  fileName: filePath,
  fileFormat: 'JSON',
  locale: 'en',
};
const files = [{ source: fileUpload }];
const { uploadedFiles } = await gt.uploadSourceFiles(files, { sourceLocale: 'en' });

// (3) Encolar el trabajo de traducción del archivo
const enqueueResult = await gt.enqueueFiles(uploadedFiles, {
  sourceLocale: 'en',
  targetLocales: targetLocales,
});

// (4) Esperar a que todas las traducciones se completen
const { fileId, versionId, branchId } = uploadedFiles[0];
const translatedFileQueries = targetLocales.map((locale) => ({
  fileId,
  versionId,
  branchId,
  locale,
}));

while (true) {
  const result = await gt.queryFileData({
    translatedFiles: translatedFileQueries,
  });

  const allCompleted = result.translatedFiles?.every((file) => file.completedAt !== null);

  if (allCompleted) {
    break;
  }

  await new Promise((resolve) => setTimeout(resolve, 1000));
}

// (5) Descargar los archivos
const downloadResult = await gt.downloadFileBatch(
  translatedFileQueries.map(({ fileId, branchId, locale }) => ({
    fileId,
    branchId,
    locale,
  }))
);
```

## Notas [#notes]

* Una traducción se considera completa cuando `completedAt` no es `null`.
* Las traducciones completadas pueden seguir requiriendo aprobación (`approvedAt`) antes de publicarse (`publishedAt`).
* Usa este método para comprobar el estado de forma eficiente al supervisar varios trabajos de traducción.
* Todas las consultas de archivos requieren `branchId` para el control de versiones con compatibilidad con ramas.