generaltranslation 7.6.4-alpha.1 → 7.6.4-alpha.2

package/dist/backwards-compatability/dataConversion.d.ts

@@ -0,0 +1,23 @@
+import { Variable as VariableObject, VariableType } from '../types';
+import { OldBranchType, OldGTProp, OldJsxChild, OldJsxChildren, OldJsxElement, OldVariableObject, OldVariableType } from './oldTypes.js';
+import { GTProp, JsxChild, JsxChildren, JsxElement } from '../types';
+/**
+ * Convert request data from old format to new format
+ */
+export declare function getNewJsxChild(child: OldJsxChild): JsxChild;
+export declare function getNewJsxChildren(children: OldJsxChildren): JsxChildren;
+export declare function getNewJsxElement(element: OldJsxElement): JsxElement;
+export declare function getNewBranchType(branch: OldBranchType): 'b' | 'p';
+export declare function getNewVariableType(variable: OldVariableType): VariableType;
+export declare function getNewVariableObject(variable: OldVariableObject): VariableObject;
+export declare function getNewGTProp(dataGT: OldGTProp): GTProp;
+/**
+ * Convert response data from old format to new format
+ */
+export declare function getOldJsxChild(child: JsxChild): OldJsxChild;
+export declare function getOldJsxChildren(children: JsxChildren | OldJsxChildren): OldJsxChildren;
+export declare function getOldJsxElement(element: JsxElement): OldJsxElement;
+export declare function getOldBranchType(branch: 'b' | 'p'): OldBranchType;
+export declare function getOldVariableType(variable: VariableType): OldVariableType;
+export declare function getOldVariableObject(variable: VariableObject): OldVariableObject;
+export declare function getOldGTProp(dataGT: GTProp, i: number): OldGTProp;

package/dist/backwards-compatability/oldHashJsxChildren.d.ts

@@ -0,0 +1,23 @@
+import { OldJsxChildren } from './oldTypes';
+/**
+ * Calculates a unique hash for a given string using sha256.
+ *
+ * @param {string} string - The string to be hashed.
+ * @returns {string} - The resulting hash as a hexadecimal string.
+ */
+export declare function oldHashString(string: string): string;
+/**
+ * Calculates a unique ID for the given children objects by hashing their sanitized JSON string representation.
+ *
+ * @param {any} childrenAsObjects - The children objects to be hashed.
+ * @param {string} context - The context for the children
+ * @param {string} id - The id for the JSX Children object
+ * @param {function} hashFunction custom hash function
+ * @returns {string} - The unique has of the children.
+ */
+export declare function oldHashJsxChildren({ source, context, id, dataFormat, }: {
+    source: OldJsxChildren;
+    context?: string;
+    id?: string;
+    dataFormat: string;
+}, hashFunction?: (string: string) => string): string;

package/dist/backwards-compatability/oldTypes.d.ts

@@ -0,0 +1,21 @@
+export type OldBranchType = 'branch' | 'plural';
+export type OldGTProp = {
+    id: number;
+    transformation?: OldBranchType;
+    branches?: Record<string, OldJsxChildren>;
+};
+export type OldJsxElement = {
+    type: string;
+    props: {
+        children?: OldJsxChildren;
+        'data-_gt': OldGTProp;
+    };
+};
+export type OldVariableType = 'number' | 'variable' | 'datetime' | 'currency';
+export type OldVariableObject = {
+    variable?: OldVariableType;
+    key: string;
+    id?: number;
+};
+export type OldJsxChild = OldJsxElement | OldVariableObject | string;
+export type OldJsxChildren = OldJsxChild | OldJsxChild[];

package/dist/backwards-compatability/typeChecking.d.ts

@@ -0,0 +1,21 @@
+import { JsxChild, JsxChildren } from '../types';
+import { OldJsxChild, OldJsxChildren, OldVariableObject } from './oldTypes.js';
+import { Variable as VariableObject } from '../types';
+/**
+ * Checks if a JSX child is an old variable object format
+ * @param child - The JSX child to check
+ * @returns True if the child is an old variable object (has 'key' property)
+ */
+export declare function isOldVariableObject(child: OldJsxChild | JsxChild): child is OldVariableObject;
+/**
+ * Checks if a JSX child is a new variable object format
+ * @param child - The JSX child to check
+ * @returns True if the child is a new variable object (has 'k' property)
+ */
+export declare function isNewVariableObject(child: OldJsxChild | JsxChild): child is VariableObject;
+/**
+ * Checks if JSX children follow the old format
+ * @param children - The JSX children to check (can be string, array, or single child)
+ * @returns True if all children are in the old format
+ */
+export declare function isOldJsxChildren(children: OldJsxChildren | JsxChildren): children is OldJsxChildren;

package/dist/cache/IntlCache.d.ts

@@ -0,0 +1,8 @@
+declare class IntlCache {
+    private cache;
+    constructor();
+    private _generateKey;
+    get<K extends keyof typeof Intl>(constructor: K, locales: string | string[], options?: {}): InstanceType<(typeof Intl)[K]>;
+}
+export declare const intlCache: IntlCache;
+export {};

package/dist/deprecated/batch/translateBatch.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/deprecated/icu/translate.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/deprecated/jsx/translateJsx.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/deprecated/translate/translate.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/formatting/format.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/id/hashSource.d.ts

@@ -0,0 +1,26 @@
+import { DataFormat, JsxChildren } from '../types';
+/**
+ * Calculates a unique hash for a given string using sha256.
+ *
+ * First 16 characters of hash, hex encoded.
+ *
+ * @param {string} string - The string to be hashed.
+ * @returns {string} - The resulting hash as a hexadecimal string.
+ */
+export declare function hashString(string: string): string;
+/**
+ * Calculates a unique ID for the given children objects by hashing their sanitized JSON string representation.
+ *
+ * @param {any} childrenAsObjects - The children objects to be hashed.
+ * @param {string} context - The context for the children
+ * @param {string} id - The id for the JSX Children object
+ * @param {string} dataFormat - The data format of the sources
+ * @param {function} hashFunction custom hash function
+ * @returns {string} - The unique has of the children.
+ */
+export declare function hashSource({ source, context, id, dataFormat, }: {
+    source: JsxChildren | string;
+    context?: string;
+    id?: string;
+    dataFormat: DataFormat;
+}, hashFunction?: (string: string) => string): string;

package/dist/id/hashTemplate.d.ts

@@ -0,0 +1,4 @@
+import { hashString } from './hashSource';
+export default function hashTemplate(template: {
+    [key: string]: string;
+}, hashFunction?: typeof hashString): string;

package/dist/locales/customLocaleMapping.d.ts

@@ -0,0 +1,5 @@
+import { LocaleProperties } from './getLocaleProperties';
+export type FullCustomMapping = Record<string, LocaleProperties>;
+export type CustomMapping = Record<string, string | Partial<LocaleProperties>>;
+export declare const getCustomProperty: (customMapping: CustomMapping, locale: string, property: keyof LocaleProperties) => string | undefined;
+export declare const shouldUseCanonicalLocale: (locale: string, customMapping: CustomMapping) => boolean;

package/dist/locales/determineLocale.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/locales/getLocaleDirection.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/locales/getLocaleEmoji.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultEmoji = "\uD83C\uDF0D";
+export declare const emojis: Record<string, string>;

package/dist/locales/getLocaleName.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/locales/getLocaleProperties.d.ts

@@ -0,0 +1,32 @@
+import { CustomMapping } from './customLocaleMapping';
+export type LocaleProperties = {
+    code: string;
+    name: string;
+    nativeName: string;
+    languageCode: string;
+    languageName: string;
+    nativeLanguageName: string;
+    nameWithRegionCode: string;
+    nativeNameWithRegionCode: string;
+    regionCode: string;
+    regionName: string;
+    nativeRegionName: string;
+    scriptCode: string;
+    scriptName: string;
+    nativeScriptName: string;
+    maximizedCode: string;
+    maximizedName: string;
+    nativeMaximizedName: string;
+    minimizedCode: string;
+    minimizedName: string;
+    nativeMinimizedName: string;
+    emoji: string;
+};
+/**
+ * Creates a set of custom locale properties from a custom mapping.
+ *
+ * @param lArray - An array of locale codes to search for in the custom mapping.
+ * @param customMapping - Optional custom mapping of locale codes to names.
+ * @returns A partial set of locale properties, or undefined if no custom mapping is provided.
+ */
+export declare function createCustomLocaleProperties(lArray: string[], customMapping?: CustomMapping): Partial<LocaleProperties> | undefined;

package/dist/locales/getPluralForm.d.ts

@@ -0,0 +1,9 @@
+import { PluralType } from '../settings/plurals';
+/**
+ * Given a number and a list of allowed plural forms, return the plural form that best fits the number.
+ *
+ * @param {number} n - The number to determine the plural form for.
+ * @param {locales[]} forms - The allowed plural forms.
+ * @returns {PluralType} The determined plural form, or an empty string if none fit.
+ */
+export default function _getPluralForm(n: number, forms?: PluralType[], locales?: string[]): PluralType | '';

package/dist/locales/getRegionProperties.d.ts

@@ -0,0 +1,7 @@
+export type CustomRegionMapping = {
+    [region: string]: {
+        name?: string;
+        emoji?: string;
+        locale?: string;
+    };
+};

package/dist/locales/isSameDialect.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/locales/isSameLanguage.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/locales/isSupersetLocale.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/locales/isValidLocale.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/locales/requiresTranslation.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/locales/resolveAliasLocale.d.ts

@@ -0,0 +1,8 @@
+import { CustomMapping } from './customLocaleMapping';
+/**
+ * Resolves the alias locale for a given locale.
+ * @param locale - The locale to resolve the alias locale for
+ * @param customMapping - The custom mapping to use for resolving the alias locale
+ * @returns The alias locale
+ */
+export declare function _resolveAliasLocale(locale: string, customMapping?: CustomMapping): string;

package/dist/logging/errors.d.ts

@@ -0,0 +1,10 @@
+export declare const translationTimeoutError: (timeout: number) => string;
+export declare const translationRequestFailedError: (error: string) => string;
+export declare const apiError: (status: number, statusText: string, error: string) => string;
+export declare const invalidAuthError = "GT Error: Invalid authentication.";
+export declare const noTargetLocaleProvidedError: (functionName: string) => string;
+export declare const noSourceLocaleProvidedError: (functionName: string) => string;
+export declare const noProjectIdProvidedError: (functionName: string) => string;
+export declare const noApiKeyProvidedError: (functionName: string) => string;
+export declare const invalidLocaleError: (locale: string) => string;
+export declare const invalidLocalesError: (locales: string[]) => string;

package/dist/logging/logger.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Comprehensive logging system for the General Translation library
+ * Provides structured logging with multiple levels and configurable output
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'off';
+export interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp: Date;
+    context?: string;
+    metadata?: Record<string, any>;
+}
+export interface LoggerConfig {
+    /** Minimum log level to output */
+    level: LogLevel;
+    /** Whether to include timestamps in log output */
+    includeTimestamp: boolean;
+    /** Whether to include context information */
+    includeContext: boolean;
+    /** Custom prefix for all log messages */
+    prefix?: string;
+    /** Whether to output to console (default: true) */
+    enableConsole: boolean;
+    /** Custom log handlers */
+    handlers?: LogHandler[];
+}
+export interface LogHandler {
+    handle(entry: LogEntry): void;
+}
+/**
+ * Console log handler that outputs formatted messages to console
+ */
+export declare class ConsoleLogHandler implements LogHandler {
+    private config;
+    constructor(config: LoggerConfig);
+    handle(entry: LogEntry): void;
+}
+/**
+ * Main Logger class providing structured logging capabilities
+ */
+export declare class Logger {
+    private config;
+    private handlers;
+    constructor(config?: Partial<LoggerConfig>);
+    /**
+     * Add a custom log handler
+     */
+    addHandler(handler: LogHandler): void;
+    /**
+     * Remove a log handler
+     */
+    removeHandler(handler: LogHandler): void;
+    /**
+     * Update logger configuration
+     */
+    configure(config: Partial<LoggerConfig>): void;
+    /**
+     * Check if a log level should be output based on current configuration
+     */
+    private shouldLog;
+    /**
+     * Internal logging method that creates log entries and passes them to handlers
+     */
+    private log;
+    /**
+     * Log a debug message
+     * Used for detailed diagnostic information, typically of interest only when diagnosing problems
+     */
+    debug(message: string, context?: string, metadata?: Record<string, any>): void;
+    /**
+     * Log an info message
+     * Used for general information about application operation
+     */
+    info(message: string, context?: string, metadata?: Record<string, any>): void;
+    /**
+     * Log a warning message
+     * Used for potentially problematic situations that don't prevent operation
+     */
+    warn(message: string, context?: string, metadata?: Record<string, any>): void;
+    /**
+     * Log an error message
+     * Used for error events that might still allow the application to continue
+     */
+    error(message: string, context?: string, metadata?: Record<string, any>): void;
+    /**
+     * Create a child logger with a specific context
+     */
+    child(context: string): ContextLogger;
+    /**
+     * Get current logger configuration
+     */
+    getConfig(): LoggerConfig;
+}
+/**
+ * Context logger that automatically includes context information
+ */
+export declare class ContextLogger {
+    private logger;
+    private context;
+    constructor(logger: Logger, context: string);
+    debug(message: string, metadata?: Record<string, any>): void;
+    info(message: string, metadata?: Record<string, any>): void;
+    warn(message: string, metadata?: Record<string, any>): void;
+    error(message: string, metadata?: Record<string, any>): void;
+    child(childContext: string): ContextLogger;
+}
+export declare const defaultLogger: Logger;
+export declare const debug: (message: string, context?: string, metadata?: Record<string, any>) => void;
+export declare const info: (message: string, context?: string, metadata?: Record<string, any>) => void;
+export declare const warn: (message: string, context?: string, metadata?: Record<string, any>) => void;
+export declare const error: (message: string, context?: string, metadata?: Record<string, any>) => void;
+export declare const fetchLogger: ContextLogger;
+export declare const validationLogger: ContextLogger;
+export declare const formattingLogger: ContextLogger;
+export declare const localeLogger: ContextLogger;
+export declare const gtInstanceLogger: ContextLogger;
+export { Logger as GTLogger };

package/dist/logging/warnings.d.ts

@@ -0,0 +1,2 @@
+export declare const formatI18nextWarning = "Warning: formatI18next is not currently supported but will be implemented in a future version. Use _formatMessage for current ICU message format support.";
+export declare const formatJsxWarning = "Warning: formatJsx is not currently supported but will be implemented in a future version. Use _formatMessage for current ICU message format support.";

package/dist/projects/getProjectData.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/settings/plurals.d.ts

@@ -0,0 +1,3 @@
+export declare const pluralForms: readonly ["singular", "plural", "dual", "zero", "one", "two", "few", "many", "other"];
+export type PluralType = (typeof pluralForms)[number];
+export declare function isAcceptedPluralForm(form: string): form is PluralType;

package/dist/settings/settings.d.ts

@@ -0,0 +1,2 @@
+export declare const libraryDefaultLocale: "en";
+export declare const maxTimeout = 60000;

package/dist/settings/settingsUrls.d.ts

@@ -0,0 +1,9 @@
+export declare const defaultCacheUrl: "https://cdn.gtx.dev";
+export declare const defaultBaseUrl: "https://api2.gtx.dev";
+export declare const defaultRuntimeApiUrl: "https://runtime2.gtx.dev";
+export declare const translateBatchUrl: "/v1/translate/batch";
+export declare const translateJsxUrl: "/v1/translate/react";
+export declare const translateContentUrl: "/v1/translate/content";
+export declare const translateIcuUrl: "/v1/translate/icu";
+export declare const updateProjectTranslationsUrl: "/v1/project/translations/update";
+export declare const getProjectLocalesUrl: "/v1/project/locales";

package/dist/translate/checkFileTranslations.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/checkSetupStatus.d.ts

@@ -0,0 +1,8 @@
+export type SetupJobStatus = 'queued' | 'processing' | 'completed' | 'failed';
+export type CheckSetupStatusResult = {
+    jobId: string;
+    status: SetupJobStatus;
+    error?: {
+        message: string;
+    };
+};

package/dist/translate/checkTranslationStatus.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/downloadFile.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/downloadFileBatch.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/enqueueEntries.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/enqueueFiles.d.ts

@@ -0,0 +1,9 @@
+export type EnqueueOptions = {
+    sourceLocale: string;
+    targetLocales: string[];
+    publish?: boolean;
+    requireApproval?: boolean;
+    modelProvider?: string;
+    force?: boolean;
+    timeout?: number;
+};

package/dist/translate/fetchTranslations.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/querySourceFile.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/setupProject.d.ts

@@ -0,0 +1,4 @@
+export type SetupProjectResult = {
+    setupJobId: string;
+    status: 'queued';
+};

package/dist/translate/shouldSetupProject.d.ts

@@ -0,0 +1,3 @@
+export type ShouldSetupProjectResult = {
+    shouldSetupProject: boolean;
+};

package/dist/translate/translate.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/translateMany.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/uploadSourceFiles.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/uploadTranslations.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/utils/fetchWithTimeout.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/translate/utils/generateRequestHeaders.d.ts

@@ -0,0 +1,2 @@
+import { TranslationRequestConfig } from '../../types';
+export default function generateRequestHeaders(config: TranslationRequestConfig, excludeContentType?: boolean): Record<string, string>;

package/dist/translate/utils/handleFetchError.d.ts

@@ -0,0 +1 @@
+export default function handleFetchError(error: unknown, timeout: number): never;

package/dist/translate/utils/validateResponse.d.ts

@@ -0,0 +1 @@
+export default function validateResponse(response: Response): Promise<void>;

package/dist/types-dir/checkFileTranslations.d.ts

@@ -0,0 +1,40 @@
+import { CompletedFileTranslationData } from './file';
+export type FileTranslationQuery = {
+    versionId: string;
+    fileName?: string;
+    fileId?: string;
+    locale: string;
+};
+export type CheckFileTranslationsOptions = {
+    timeout?: number;
+};
+export type CheckFileTranslationsResult = {
+    translations: CompletedFileTranslationData[];
+};
+export type FileQuery = {
+    fileId: string;
+    versionId?: string;
+};
+export type FileQueryResult = {
+    sourceFile: {
+        id: string;
+        fileId: string;
+        versionId: string;
+        sourceLocale: string;
+        fileName: string;
+        fileFormat: string;
+        dataFormat: string | null;
+        createdAt: string;
+        updatedAt: string;
+        approvalRequiredAt: string | null;
+        locales: string[];
+    };
+    translations: {
+        locale: string;
+        completedAt: string | null;
+        approvedAt: string | null;
+        publishedAt: string | null;
+        createdAt: string | null;
+        updatedAt: string | null;
+    }[];
+};

package/dist/types-dir/content.d.ts

@@ -0,0 +1,49 @@
+import { Variable } from './variables';
+/**
+ * Map of data-_gt properties to their corresponding React props
+ */
+export declare const HTML_CONTENT_PROPS: {
+    readonly pl: "placeholder";
+    readonly ti: "title";
+    readonly alt: "alt";
+    readonly arl: "aria-label";
+    readonly arb: "aria-labelledby";
+    readonly ard: "aria-describedby";
+};
+export type HtmlContentPropKeysRecord = Partial<Record<keyof typeof HTML_CONTENT_PROPS, string>>;
+export type HtmlContentPropValuesRecord = Partial<Record<(typeof HTML_CONTENT_PROPS)[keyof typeof HTML_CONTENT_PROPS], string>>;
+/**
+ * GTProp is an internal property used to contain data for translating and rendering elements.
+ * note, transformations are only read on the server side if they are 'plural' or 'branch'
+ */
+export type GTProp = {
+    b?: Record<string, JsxChildren>;
+    t?: 'p' | 'b';
+} & HtmlContentPropKeysRecord;
+export type JsxElement = {
+    t?: string;
+    i?: number;
+    d?: GTProp;
+    c?: JsxChildren;
+};
+export type JsxChild = string | JsxElement | Variable;
+/**
+ * The format of the content
+ */
+export type DataFormat = 'JSX' | 'ICU' | 'I18NEXT';
+/**
+ * A content type representing JSX, ICU, and I18next messages
+ */
+export type Content = JsxChildren | IcuMessage | I18nextMessage;
+/**
+ * A content type representing JSX elements
+ */
+export type JsxChildren = JsxChild | JsxChild[];
+/**
+ * A content type representing ICU messages
+ */
+export type IcuMessage = string;
+/**
+ * A content type representing I18next messages
+ */
+export type I18nextMessage = string;

package/dist/types-dir/downloadFile.d.ts

@@ -0,0 +1,3 @@
+export type DownloadFileOptions = {
+    timeout?: number;
+};

package/dist/types-dir/downloadFileBatch.d.ts

@@ -0,0 +1,22 @@
+export type DownloadFileBatchOptions = {
+    timeout?: number;
+};
+export type BatchDownloadResult = {
+    translationId: string;
+    fileName?: string;
+    success: boolean;
+    content?: string;
+    contentType?: string;
+    error?: string;
+};
+type File = {
+    id: string;
+    fileName: string;
+    data: string;
+    metadata: any;
+};
+export type DownloadFileBatchResult = {
+    files: File[];
+    count: number;
+};
+export {};

package/dist/types-dir/enqueueEntries.d.ts

@@ -0,0 +1,21 @@
+import { DataFormat } from './content';
+export type { Updates } from './enqueueFiles';
+export type EnqueueEntriesOptions = {
+    timeout?: number;
+    sourceLocale?: string;
+    targetLocales?: string[];
+    dataFormat?: DataFormat;
+    version?: string;
+    description?: string;
+    requireApproval?: boolean;
+    modelProvider?: string;
+};
+export type EnqueueEntriesResult = {
+    versionId: string;
+    locales: string[];
+    message: string;
+    projectSettings: {
+        cdnEnabled: boolean;
+        requireApproval: boolean;
+    };
+};

package/dist/types-dir/enqueueFiles.d.ts

@@ -0,0 +1,62 @@
+import { DataFormat, JsxChildren } from './content';
+import { CompletedFileTranslationData, FileFormat } from './file';
+export type Updates = ({
+    metadata: Record<string, any>;
+} & ({
+    dataFormat: 'JSX';
+    source: JsxChildren;
+} | {
+    dataFormat: 'ICU';
+    source: string;
+} | {
+    dataFormat: 'I18NEXT';
+    source: string;
+}))[];
+/**
+ * File object structure for enqueueing files
+ * @param content - Content of the file
+ * @param fileName - Unique identifier for the file (such as the file path + file name)
+ * @param fileFormat - The format of the file (JSON, MDX, MD, etc.)
+ * @param formatMetadata - Optional metadata for the file, specific to the format of the file
+ * @param dataFormat - Optional format of the data within the file
+ */
+export type FileToTranslate = {
+    content: string;
+    fileName: string;
+    fileFormat: FileFormat;
+    formatMetadata?: Record<string, any>;
+    dataFormat?: DataFormat;
+};
+/**
+ * Options for enqueueing files
+ * @param publish - Whether to publish the files
+ * @param requireApproval - Whether to require approval for the files
+ * @param description - Optional description for the project
+ * @param sourceLocale - The project's source locale
+ * @param targetLocales - The locales to translate the files to
+ * @param version - Optional custom version ID to specify
+ * @param timeout - Optional timeout for the request
+ * @param modelProvider - Optional model provider to use
+ */
+export type EnqueueFilesOptions = {
+    publish?: boolean;
+    requireApproval?: boolean;
+    description?: string;
+    sourceLocale?: string;
+    targetLocales: string[];
+    version?: string;
+    _versionId?: string;
+    timeout?: number;
+    modelProvider?: string;
+    force?: boolean;
+};
+export type RequiredEnqueueFilesOptions = EnqueueFilesOptions & Required<Pick<EnqueueFilesOptions, 'sourceLocale'>>;
+export type EnqueueFilesResult = {
+    translations: CompletedFileTranslationData[];
+    data: Record<string, {
+        fileName: string;
+        versionId: string;
+    }>;
+    locales: string[];
+    message: string;
+};

package/dist/types-dir/entry.d.ts

@@ -0,0 +1,39 @@
+import { Content, DataFormat } from '../types';
+/**
+ * ActionType is the type of action to perform on the request.
+ *
+ * @param standard - The standard action type (standard model).
+ * @param fast - The fast action type (mini model).
+ * @param string - Other model
+ */
+export type ActionType = 'standard' | 'fast' | string;
+/**
+ * EntryMetadata is the metadata for a GTRequest.
+ *
+ * @param context - The context of the request.
+ * @param id - The id of the request.
+ * @param hash - The hash of the request.
+ */
+export type EntryMetadata = {
+    context?: string;
+    id?: string;
+    hash?: string;
+    dataFormat?: DataFormat;
+    sourceLocale?: string;
+    actionType?: ActionType;
+    timeout?: number;
+    regionCode?: string;
+    scriptCode?: string;
+};
+/**
+ * GTRequest is a translation request object for {@link JsxChildren} | {@link IcuMessage} | {@link I18nextMessage}
+ *
+ * @param source - The source content to translate.
+ * @param targetLocale - The target locale to translate to.
+ * @param metadata - The metadata for the request.
+ */
+export type Entry = {
+    source: Content;
+    targetLocale?: string;
+    metadata?: EntryMetadata;
+};

package/dist/types-dir/fetchTranslations.d.ts

@@ -0,0 +1,11 @@
+export type FetchTranslationsOptions = {
+    timeout?: number;
+};
+export type RetrievedTranslation = {
+    locale: string;
+    translation: any;
+};
+export type RetrievedTranslations = RetrievedTranslation[];
+export type FetchTranslationsResult = {
+    translations: RetrievedTranslations;
+};

package/dist/types-dir/file.d.ts

@@ -0,0 +1,23 @@
+import { Entry } from './entry';
+export type FileFormat = 'GTJSON' | 'JSON' | 'YAML' | 'MDX' | 'MD' | 'TS' | 'JS' | 'HTML';
+export type FileMetadata = {
+    filePath: string;
+    fileFormat: FileFormat;
+    context?: string;
+    sourceLocale?: string;
+    hash?: string;
+};
+export type File = {
+    source: Entry[] | string;
+    fileMetadata: FileMetadata;
+};
+export type CompletedFileTranslationData = {
+    locale: string;
+    metadata: any;
+    fileId: string;
+    fileName: string;
+    versionId: string;
+    id: string;
+    isReady: boolean;
+    downloadUrl: string;
+};

package/dist/types-dir/project.d.ts

@@ -0,0 +1,7 @@
+export type ProjectData = {
+    id: string;
+    name: string;
+    orgId: string;
+    defaultLocale: string;
+    currentLocales: string[];
+};

package/dist/types-dir/translate.d.ts

@@ -0,0 +1,34 @@
+import { I18nextMessage, IcuMessage, JsxChildren } from './content';
+/**
+ * TranslationResultReference is used to store the reference for a translation result.
+ */
+export type TranslationResultReference = {
+    id?: string;
+    hash: string;
+};
+/**
+ * TypedResult is a union type that represents the different types of translations that can be returned.
+ */
+export type TypedResult = {
+    translation: JsxChildren;
+    dataFormat: 'JSX';
+} | {
+    translation: I18nextMessage | IcuMessage;
+    dataFormat: 'ICU' | 'I18NEXT';
+};
+/**
+ * RequestError is a type that represents an error that occurred during a translation request.
+ */
+export type TranslationError = {
+    error: string;
+    code: number;
+    reference?: TranslationResultReference;
+};
+/**
+ * RequestSuccess is a type that represents a successful translation request.
+ */
+export type RequestSuccess = TypedResult & {
+    locale: string;
+    reference: TranslationResultReference;
+};
+export type TranslationResult = RequestSuccess | TranslationError;

package/dist/types-dir/translateMany.d.ts

@@ -0,0 +1,5 @@
+import { TranslationResult } from './translate';
+/**
+ * BatchTranslationResult is the result of a batch translation request.
+ */
+export type TranslateManyResult = Array<TranslationResult>;

package/dist/types-dir/translationStatus.d.ts

@@ -0,0 +1,9 @@
+export type TranslationStatusResult = {
+    count: number;
+    availableLocales: string[];
+    locales: string[];
+    localesWaitingForApproval: any[];
+};
+export type CheckTranslationStatusOptions = {
+    timeout?: number;
+};

package/dist/types-dir/uploadFiles.d.ts

@@ -0,0 +1,38 @@
+import { DataFormat } from './content';
+import { FileFormat } from './file';
+export type FileUpload = {
+    content: string;
+    fileName: string;
+    fileFormat: FileFormat;
+    dataFormat?: DataFormat;
+    locale: string;
+    versionId?: string;
+    fileId?: string;
+};
+export type FileUploadRef = {
+    fileId: string;
+    versionId: string;
+    fileName: string;
+    fileFormat: FileFormat;
+    dataFormat?: DataFormat;
+    locale?: string;
+};
+export type UploadData = {
+    data: {
+        source: FileUpload;
+        translations: FileUpload[];
+    }[];
+    sourceLocale: string;
+    modelProvider?: string;
+};
+export type UploadFilesOptions = {
+    sourceLocale: string;
+    modelProvider?: string;
+    timeout?: number;
+};
+export type UploadFilesResponse = {
+    uploadedFiles: FileUploadRef[];
+    count: number;
+    message: string;
+};
+export type RequiredUploadFilesOptions = UploadFilesOptions & Required<Pick<UploadFilesOptions, 'sourceLocale'>>;

package/dist/types-dir/variables.d.ts

@@ -0,0 +1,9 @@
+export type VariableType = 'v' | 'n' | 'd' | 'c';
+/**
+ * Variables are used to store the variable name and type.
+ */
+export type Variable = {
+    k: string;
+    i?: number;
+    v?: VariableType;
+};

package/dist/utils/base64.d.ts

@@ -0,0 +1,2 @@
+export declare function encode(data: string): string;
+export declare function decode(base64: string): string;

package/dist/utils/isVariable.d.ts

@@ -0,0 +1,2 @@
+import { Variable } from '../types';
+export default function isVariable(obj: unknown): obj is Variable;

package/dist/utils/minify.d.ts

@@ -0,0 +1,2 @@
+import { VariableTransformationSuffix, VariableType } from '../types';
+export declare function minifyVariableType(variableType: VariableTransformationSuffix): VariableType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "generaltranslation",
-  "version": "7.6.4-alpha.1",
+  "version": "7.6.4-alpha.2",
   "description": "A language toolkit for AI developers",
   "main": "dist/index.cjs.min.cjs",
   "module": "dist/index.esm.min.mjs",
@@ -100,7 +100,7 @@
   },
   "scripts": {
     "build:release": "pnpm run build:clean",
-    "build:clean": "rm -rf dist; pnpm run build",
+    "build:clean": "rm -rf dist && rm tsconfig.tsbuildinfo && pnpm run build",
     "build": "rollup -c",
     "lint": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\"",
     "lint:fix": "eslint \"src/**/*.{js,ts}\" \"./**/__tests__/**/*.{js,ts}\" --fix",