# 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
---

## Resumen

El método `uploadSourceFiles` carga archivos fuente en la plataforma de General Translation para su traducción.
Por lo general, este es el primer paso en 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 }[]` | array de archivos fuente para cargar    |
| `options` | `UploadFilesOptions`       | Opciones de configuración para la carga |

#### Estructura de FileUpload

| Nombre        | Tipo         | Descripción                                                                    |
| ------------- | ------------ | ------------------------------------------------------------------------------ |
| `content`     | `string`     | Contenido bruto del archivo como una cadena                                    |
| `fileName`    | `string`     | Identificador único del archivo (normalmente, la ruta del archivo + el nombre) |
| `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 fuente                     |
| `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 para todos los archivos cargados |
| `branchId?`      | `string` | ID de rama opcional a la que cargar                                  |
| `modelProvider?` | `string` | Preferencia opcional de 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 referencias a archivo.

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

| Propiedad       | Tipo              | Descripción                                                          |
| --------------- | ----------------- | -------------------------------------------------------------------- |
| `uploadedFiles` | `FileReference[]` | array de referencias a 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 JSON de traducción:

```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 explícita del formato de datos

Carga archivos especificando explícitamente el formato de 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 {
    // Buscar 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 al cargar:', 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 y, por lo general, incluir la ruta del archivo
* El campo `locale` de cada archivo debe coincidir con la opción `sourceLocale`
* Los archivos grandes o una gran cantidad de archivos pueden requerir valores de tiempo de espera más altos
* Las referencias a archivos devueltas por este método son necesarias para las operaciones posteriores
* Las referencias a archivos incluyen `branchId` para un control de versiones correcto con compatibilidad con el uso de ramas
* Los formatos de archivo compatibles incluyen JSON, MD, MDX, XML y otros; consultar el tipo `FileFormat` para ver la lista completa

## Próximos 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 trabajos de traducción
* Consulta [`uploadTranslations`](/docs/core/class/methods/translation/upload-translations) para cargar traducciones existentes
* Consulta `FileUpload` para ver la estructura detallada de los archivos