import { $ as UploadFilesOptions, A as AwaitJobsOptions, F as MoveMapping, H as FileDataResult, L as ProcessMovesOptions, N as CheckJobStatusResult, Q as FileUpload, R as ProcessMovesResponse, U as BranchQuery, V as FileDataQuery, W as BranchDataResult, X as PublishFileEntry, Y as DownloadFileOptions, Z as PublishFilesResult, _t as CheckFileTranslationsOptions, at as CreateTagResult, ct as DownloadFileBatchRequest, et as UploadFilesResponse, ht as EnqueueFilesResult, it as CreateTagOptions, j as AwaitJobsResult, k as SubmitUserEditDiffsPayload, lt as DownloadFileBatchResult, nt as SetupProjectOptions, ot as EnqueueFilesOptions, pt as FileReferenceIds, rt as SetupProjectResult, st as DownloadFileBatchOptions, tt as SetupProjectFileReference, vt as FileQuery, yt as FileQueryResult, z as GetOrphanedFilesResult } from "./types-f-_m5D_X.cjs";
import { GTConstructorParams, GTRuntime } from "./runtime.cjs";
import { n as declareVar, r as decodeVars, t as derive } from "./derive-DBCCXTmL.cjs";
import { LocaleConfig, LocaleConfigConstructorParams, determineLocale, formatCurrency, formatCutoff, formatDateTime, formatList, formatListToParts, formatMessage, formatNum, formatRelativeTime, formatRelativeTimeFromDate, getLocaleDirection, getLocaleEmoji, getLocaleName, getLocaleProperties, getRegionProperties, isSameDialect, isSameLanguage, isSupersetLocale, isValidLocale, requiresTranslation, resolveAliasLocale, resolveCanonicalLocale, standardizeLocale } from "@generaltranslation/format";

//#region src/types-dir/api/project.d.ts
type ProjectData = {
  id: string;
  name: string;
  orgId: string;
  defaultLocale: string;
  currentLocales: string[];
};
//#endregion
//#region src/translate/getProjectInfo.d.ts
type ProjectInfoResult = {
  id: string;
  name: string;
  orgId: string;
  defaultLocale: string;
  currentLocales: string[];
  autoApprove?: boolean;
};
type GetProjectInfoOptions = {
  timeout?: number;
};
//#endregion
//#region src/translate/createBranch.d.ts
type CreateBranchQuery = {
  branchName: string;
  defaultBranch: boolean;
};
type CreateBranchResult = {
  branch: {
    id: string;
    name: string;
  };
};
//#endregion
//#region src/index.d.ts
/**
 * GT is the core driver for the General Translation library.
 * It extends {@link GTRuntime} (locale management, formatting, and runtime
 * translation) with the project and file management API client used by
 * tooling such as the CLI.
 *
 * Browser-facing SDK code should construct {@link GTRuntime} instead so
 * production bundles do not ship the file management client.
 *
 * @class GT
 * @description A comprehensive toolkit for handling internationalization and localization.
 *
 * @example
 * const gt = new GT({
 *   sourceLocale: 'en-US',
 *   targetLocale: 'es-ES',
 *   locales: ['en-US', 'es-ES', 'fr-FR']
 * });
 */
declare class GT extends GTRuntime {
  /**
   * Queries branch information from the API.
   *
   * @param {BranchQuery} query - Object mapping the current branch and incoming branches
   * @returns {Promise<BranchDataResult>} The branch information.
   */
  queryBranchData(query: BranchQuery): Promise<BranchDataResult>;
  /**
   * Creates a new branch in the API. If the branch already exists, it will be returned.
   *
   * @param {CreateBranchQuery} query - Object mapping the branch name and default branch flag
   * @returns {Promise<CreateBranchResult>} The created branch information.
   */
  createBranch(query: CreateBranchQuery): Promise<CreateBranchResult>;
  /**
   * Processes file moves by cloning source files and translations with new fileIds.
   * This is called when files have been moved/renamed and we want to preserve translations.
   *
   * @param {MoveMapping[]} moves - Array of move mappings (old fileId to new fileId)
   * @param {ProcessMovesOptions} options - Options including branchId and timeout
   * @returns {Promise<ProcessMovesResponse>} The move processing results.
   *
   * @example
   * const result = await gt.processFileMoves([
   *   { oldFileId: 'abc123', newFileId: 'def456', newFileName: 'locales/en.json' }
   * ], { branchId: 'main' });
   */
  processFileMoves(moves: MoveMapping[], options?: ProcessMovesOptions): Promise<ProcessMovesResponse>;
  /**
   * Gets orphaned files for a branch - files that exist on the branch
   * but whose fileIds are not in the provided list.
   * Used for move detection.
   *
   * @param {string} branchId - The branch to check for orphaned files.
   * @param {string[]} fileIds - List of current file IDs (files that are NOT orphaned)
   * @param {Object} options - Options including timeout.
   * @returns {Promise<GetOrphanedFilesResult>} The orphaned files.
   *
   * @example
   * const result = await gt.getOrphanedFiles('branch-id', ['file-1', 'file-2']);
   */
  getOrphanedFiles(branchId: string, fileIds: string[], options?: {
    timeout?: number;
  }): Promise<GetOrphanedFilesResult>;
  /**
   * Enqueues project setup job using the specified file references
   *
   * This method creates setup jobs that will process source file references
   * and generate a project setup. The files parameter contains references (IDs) to source
   * files that have already been uploaded via uploadSourceFiles. The setup jobs are queued
   * for processing and will generate a project setup based on the source files.
   *
   * @param {SetupProjectFileReference[]} files - Array of file references containing IDs of previously uploaded source files
   * @param {SetupProjectOptions} [options] - Optional settings for target locales and timeout.
   * @returns {Promise<SetupProjectResult>} Object containing the jobId and status
   */
  setupProject(files: SetupProjectFileReference[], options?: SetupProjectOptions): Promise<SetupProjectResult>;
  /**
   * Checks the current status of one or more project jobs by their unique identifiers.
   *
   * This method polls the API to determine whether one or more jobs are still running,
   * have completed successfully, or have failed. Jobs are created after calling either enqueueFiles or setupProject.
   *
   * @param {string[]} jobIds - The unique identifiers of the jobs to check.
   * @param {number} [timeoutMs] - Optional timeout in milliseconds for the API request.
   * @returns {Promise<CheckJobStatusResult>} Object containing the job status.
   *
   * @example
   * const result = await gt.checkJobStatus([
   *   'job-123',
   *   'job-456',
   * ], 10000);
   */
  checkJobStatus(jobIds: string[], timeoutMs?: number): Promise<CheckJobStatusResult>;
  /**
   * Polls job statuses until all jobs from enqueueFiles are finished or the timeout is reached.
   *
   * @param {EnqueueFilesResult} enqueueResult - The result returned from enqueueFiles.
   * @param {AwaitJobsOptions} [options] - Polling configuration (interval, timeout).
   * @returns {Promise<AwaitJobsResult>} The final status of all jobs and whether they all completed.
   */
  awaitJobs(enqueueResult: EnqueueFilesResult, options?: AwaitJobsOptions): Promise<AwaitJobsResult>;
  /**
   * Enqueues translation jobs for previously uploaded source files.
   *
   * This method creates translation jobs that will process existing source files
   * and generate translations in the specified target languages. The files parameter
   * contains references (IDs) to source files that have already been uploaded via
   * uploadSourceFiles. The translation jobs are queued for processing and will
   * generate translated content based on the source files and target locales provided.
   *
   * @param {FileReferenceIds[]} files - Array of file references containing IDs of previously uploaded source files
   * @param {EnqueueFilesOptions} options - Configuration options including source locale, target locales, and job settings.
   * @returns {Promise<EnqueueFilesResult>} Result containing job IDs, queue status, and processing information.
   */
  enqueueFiles(files: FileReferenceIds[], options: EnqueueFilesOptions): Promise<EnqueueFilesResult>;
  /**
   * Creates or upserts a file tag, associating a set of source files
   * with a user-defined tag ID and optional message.
   *
   * @param {CreateTagOptions} options - Tag creation options including tagId, sourceFileIds, and optional message
   * @returns {Promise<CreateTagResult>} The created or updated tag.
   */
  createTag(options: CreateTagOptions): Promise<CreateTagResult>;
  /**
   * Publishes or unpublishes files on the CDN.
   *
   * @param {PublishFileEntry[]} files - Array of file entries with publish flags
   * @returns {Promise<PublishFilesResult>} Result containing per-file success/failure
   */
  publishFiles(files: PublishFileEntry[]): Promise<PublishFilesResult>;
  /**
   * Submits user edit diffs for existing translations so future generations preserve user intent.
   *
   * @param {SubmitUserEditDiffsPayload} payload - Project-scoped diff payload.
   * @returns {Promise<void>} Resolves when submission succeeds.
   */
  submitUserEditDiffs(payload: SubmitUserEditDiffsPayload): Promise<void>;
  /**
   * Queries data about one or more source or translation files.
   *
   * @param {FileDataQuery} data - Object mapping source and translation file information.
   * @param {CheckFileTranslationsOptions} options - Options for the API call.
   * @returns {Promise<FileDataResult>} The source and translation file data information.
   *
   * @example
   * const result = await gt.queryFileData({
   *   sourceFiles: [
   *     { fileId: '1234567890', versionId: '1234567890', branchId: '1234567890' },
   *   ],
   *   translatedFiles: [
   *     { fileId: '1234567890', versionId: '1234567890', branchId: '1234567890', locale: 'es-ES' },
   *   ],
   * }, {
   *   timeout: 10000,
   * });
   *
   */
  /**
   * Fetches project info (name, locales, review settings) for the
   * authenticated project.
   * @param options - The options for the API call.
   * @returns The project info.
   */
  getProjectInfo(options?: GetProjectInfoOptions): Promise<ProjectInfoResult>;
  queryFileData(data: FileDataQuery, options?: CheckFileTranslationsOptions): Promise<FileDataResult>;
  /**
   * Gets source and translation information for a given file ID and version ID.
   *
   * @param {FileQuery} data - File query containing file ID and version ID.
   * @param {CheckFileTranslationsOptions} options - Options for getting source and translation information.
   * @returns {Promise<FileQueryResult>} The source file and translation information.
   *
   * @example
   * const result = await gt.querySourceFile(
   *   { fileId: '1234567890', versionId: '1234567890' },
   *   { timeout: 10000 }
   * );
   *
   */
  querySourceFile(data: FileQuery, options?: CheckFileTranslationsOptions): Promise<FileQueryResult>;
  /**
   * Get project data for a given project ID.
   *
   * @param {string} projectId - The ID of the project to get the data for.
   * @returns {Promise<ProjectData>} The project data.
   *
   * @example
   * const result = await gt.getProjectData(
   *   '1234567890'
   * );
   *
   */
  getProjectData(projectId: string, options?: {
    timeout?: number;
  }): Promise<ProjectData>;
  /**
   * Downloads a single file.
   *
   * @param file - The file query object.
   * @param {string} file.fileId - The ID of the file to download.
   * @param {string} [file.branchId] - The ID of the branch to download the file from. If not provided, the default branch will be used.
   * @param {string} [file.locale] - The locale to download the file for. If not provided, the source file will be downloaded.
   * @param {string} [file.versionId] - The version ID to download the file from. If not provided, the latest version will be used.
   * @param {DownloadFileOptions} options - Options for downloading the file.
   * @returns {Promise<string>} The downloaded file content.
   *
   * @example
   * const result = await gt.downloadFile({
   *   fileId: '1234567890',
   *   branchId: '1234567890',
   *   locale: 'es-ES',
   *   versionId: '1234567890',
   * }, {
   *   timeout: 10000,
   * });
   */
  downloadFile(file: {
    fileId: string;
    branchId?: string;
    locale?: string;
    versionId?: string;
    useLatestAvailableVersion?: boolean;
  }, options?: DownloadFileOptions): Promise<string>;
  /**
   * Downloads multiple files in a batch.
   *
   * @param {DownloadFileBatchRequest} requests - Array of file query objects to download.
   * @param {DownloadFileBatchOptions} options - Options for the batch download.
   * @returns {Promise<DownloadFileBatchResult>} The batch download results.
   *
   * @example
   * const result = await gt.downloadFileBatch([{
   *   fileId: '1234567890',
   *   locale: 'es-ES',
   *   versionId: '1234567890',
   * }], {
   *   timeout: 10000,
   * });
   */
  downloadFileBatch(requests: DownloadFileBatchRequest, options?: DownloadFileBatchOptions): Promise<DownloadFileBatchResult>;
  /**
   * Uploads source files to the translation service without any translation content.
   *
   * This method creates or replaces source file entries in your project. Each uploaded
   * file becomes a source that can later be translated into target languages. The files
   * are processed and stored as base entries that serve as the foundation for generating
   * translations through the translation workflow.
   *
   * @param {Array<{source: FileUpload}>} files - Array of objects containing source file data to upload
   * @param {UploadFilesOptions} options - Configuration options including source locale and other upload settings.
   * @returns {Promise<UploadFilesResponse>} Upload result containing file IDs, version information, and upload status.
   */
  uploadSourceFiles(files: {
    source: FileUpload;
  }[], options: UploadFilesOptions): Promise<UploadFilesResponse>;
  /**
   * Uploads translation files that correspond to previously uploaded source files.
   *
   * This method allows you to provide translated content for existing source files in your project.
   * Each translation must reference an existing source file and include the translated content
   * along with the target locale information. This is used when you have pre-existing translations
   * that you want to upload directly rather than generating them through the translation service.
   *
   * @param {Array<{source: FileUpload, translations: FileUpload[]}>} files - Array of file objects where:
   *   - `source`: Reference to the existing source file (contains IDs but no content).
   *   - `translations`: Array of translated files, each containing content, locale, and reference IDs
   * @param {UploadFilesOptions} options - Configuration options including source locale and upload settings.
   * @returns {Promise<UploadFilesResponse>} Upload result containing translation IDs, status, and processing information.
   */
  uploadTranslations(files: {
    source: FileUpload;
    translations: FileUpload[];
  }[], options: UploadFilesOptions): Promise<UploadFilesResponse>;
}
//#endregion
export { GT, type GTConstructorParams, GTRuntime, LocaleConfig, type LocaleConfigConstructorParams, declareVar, decodeVars, derive, determineLocale, formatCurrency, formatCutoff, formatDateTime, formatList, formatListToParts, formatMessage, formatNum, formatRelativeTime, formatRelativeTimeFromDate, getLocaleDirection, getLocaleEmoji, getLocaleName, getLocaleProperties, getRegionProperties, isSameDialect, isSameLanguage, isSupersetLocale, isValidLocale, requiresTranslation, resolveAliasLocale, resolveCanonicalLocale, standardizeLocale };
//# sourceMappingURL=index.d.cts.map