# generaltranslation: General Translation Core SDK: uploadSourceFiles
URL: https://generaltranslation.com/es/docs/core/class/methods/translation/upload-source-files.mdx
---
title: uploadSourceFiles
description: Referencia de la API del método uploadSourceFiles para cargar archivos fuente para su traducción
---

## Descripción general

El método `uploadSourceFiles` carga archivos fuente en la plataforma de General Translation para su procesamiento de traducción.
Este suele ser el primer paso de un flujo de trabajo de traducción, antes de configurar proyectos o poner en cola trabajos de traducción.

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

const result = await gt.uploadSourceFiles(files, {
  sourceLocale: 'en'
});
```

<Mermaid
  chart="
graph TD;
A[uploadSourceFiles];
B[setupProject];
C[enqueueFiles];
E[queryFileData];
F[downloadFileBatch];
A --> B;
B --> C;
C --> E;
E --> F;
"
/>


## Referencia

### Parámetros

| Nombre    | Tipo                       | Descripción                             |
| --------- | -------------------------- | --------------------------------------- |
| `files`   | `{ source: FileUpload }[]` | Lista de archivos fuente para cargar    |
| `options` | `UploadFilesOptions`       | Opciones de configuración para la carga |

#### Estructura de FileUpload

| Nombre        | Tipo         | Descripción                                                              |
| ------------- | ------------ | ------------------------------------------------------------------------ |
| `content`     | `string`     | Contenido sin procesar del archivo como una cadena                       |
| `fileName`    | `string`     | Identificador único del archivo (normalmente, ruta + nombre del archivo) |
| `fileFormat`  | `FileFormat` | Formato del archivo (JSON, MDX, MD, XML, etc.)                           |
| `dataFormat?` | `DataFormat` | Formato opcional de los datos dentro del archivo (ICU, I18NEXT, JSX)     |
| `locale`      | `string`     | Configuración regional del contenido del archivo de origen               |
| `versionId?`  | `string`     | ID de versión opcional para casos de uso avanzados                       |
| `fileId?`     | `string`     | ID de archivo opcional para casos de uso avanzados                       |

#### UploadFilesOptions

| Nombre           | Tipo     | Descripción                                                        |
| ---------------- | -------- | ------------------------------------------------------------------ |
| `sourceLocale`   | `string` | La configuración regional de origen de todos los archivos cargados |
| `branchId?`      | `string` | ID opcional de la rama a la que se hará la carga                   |
| `modelProvider?` | `string` | Preferencia opcional por un proveedor de modelos de IA             |
| `timeout?`       | `number` | Tiempo de espera de la solicitud en milisegundos                   |

### Devuelve

`Promise<UploadFilesResponse>` - Contiene los resultados de la carga y las referencias de archivo.

```typescript
type UploadFilesResponse = {
  uploadedFiles: FileReference[];
  count: number;
  message: string;
}
```

| Propiedad       | Tipo              | Descripción                                                           |
| --------------- | ----------------- | --------------------------------------------------------------------- |
| `uploadedFiles` | `FileReference[]` | Lista de referencias de archivo cargados para operaciones posteriores |
| `count`         | `number`          | Número de archivos cargados correctamente                             |
| `message`       | `string`          | Mensaje de estado de la API                                           |


#### Estructura de FileReference

```typescript
type FileReference = {
  fileId: string;
  versionId: string;
  branchId: string;
  fileName: string;
  fileFormat: FileFormat;
  dataFormat?: DataFormat;
  locale?: string;
}
```

***


## Ejemplos

### Uso básico

Carga archivos de traducción en JSON:

```typescript copy
import { GT } from 'generaltranslation';
import fs from 'fs';

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

const files = [
  {
    source: {
      content: fs.readFileSync('./locales/en/common.json', 'utf8'),
      fileName: 'common.json',
      fileFormat: 'JSON' as const,
      locale: 'en'
    }
  },
  {
    source: {
      content: fs.readFileSync('./locales/en/navigation.json', 'utf8'),
      fileName: 'navigation.json',
      fileFormat: 'JSON' as const,
      locale: 'en'
    }
  }
];

const result = await gt.uploadSourceFiles(files, {
  sourceLocale: 'en'
});

console.log(`Uploaded ${result.count} files`);
result.uploadedFiles.forEach(file => {
  console.log(`  ${file.fileName}: ${file.fileId} (branch: ${file.branchId})`);
});
```


### Con especificación del formato de los datos

Carga archivos especificando explícitamente el formato de los datos:

```typescript copy
const files = [
  {
    source: {
      content: '{"welcome": "Welcome, {name}!"}',
      fileName: 'messages.json',
      fileFormat: 'JSON' as const,
      dataFormat: 'ICU' as const, // formato de mensaje ICU
      locale: 'en'
    }
  },
  {
    source: {
      content: '{"greeting": "Hello {{name}}"}',
      fileName: 'i18next.json',
      fileFormat: 'JSON' as const,
      dataFormat: 'I18NEXT' as const,
      locale: 'en'
    }
  }
];

const result = await gt.uploadSourceFiles(files, {
  sourceLocale: 'en',
  modelProvider: 'gpt-4',
  timeout: 30000
});
```


### Carga por lotes con gestión de errores

Carga varios archivos con una gestión de errores completa:

```typescript copy
import { glob } from 'glob';
import path from 'path';

async function uploadAllJsonFiles() {
  try {
    // Encontrar todos los archivos JSON
    const jsonPaths = await glob('./locales/en/**/*.json');

    const files = jsonPaths.map(filePath => ({
      source: {
        content: fs.readFileSync(filePath, 'utf8'),
        fileName: path.relative('./locales/en', filePath),
        fileFormat: 'JSON' as const,
        locale: 'en'
      }
    }));

    console.log(`Cargando ${files.length} archivos...`);

    const result = await gt.uploadSourceFiles(files, {
      sourceLocale: 'en',
      timeout: 60000 // Tiempo de espera de 60 segundos para cargas grandes
    });

    if (result.count !== files.length) {
      console.warn(`Se esperaban ${files.length} archivos, pero solo se cargaron ${result.count}`);
    }

    return result.uploadedFiles;

  } catch (error) {
    console.error('Error en la carga:', error);
    throw error;
  }
}

const uploadedFiles = await uploadAllJsonFiles();
```

***


## Notas

* El contenido del archivo se codifica automáticamente en Base64 para transmitirlo de forma segura
* Los nombres de archivo deben ser identificadores únicos, por lo general incluyendo la ruta del archivo
* El campo `locale` de cada archivo debe coincidir con la opción `sourceLocale`
* Los archivos grandes o un gran número de archivos pueden requerir valores de tiempo de espera más altos
* Las referencias de archivo devueltas por este método son necesarias para las operaciones posteriores
* Las referencias de archivo incluyen `branchId` para un control de versiones adecuado con compatibilidad con ramas
* Los formatos de archivo compatibles incluyen JSON, MD, MDX, XML y otros; consulta el tipo `FileFormat` para ver la lista completa

## Siguientes pasos

* Consulta [`setupProject`](/docs/core/class/methods/translation/setup-project) para preparar los archivos cargados para su traducción
* Consulta [`enqueueFiles`](/docs/core/class/methods/translation/enqueue-files) para iniciar tareas de traducción
* Consulta [`uploadTranslations`](/docs/core/class/methods/translation/upload-translations) para cargar traducciones ya existentes
* Consulta `FileUpload` para ver la estructura detallada de los archivos