export interface TranslateTextCommandInput {
    Text: string;
    SourceLanguageCode: string;
    TargetLanguageCode: string;
    TerminologyNames?: string[];
    Settings?: {
        Formality?: 'FORMAL' | 'INFORMAL';
        Profanity?: 'MASK';
        Brevity?: 'ON';
    };
}
export interface TranslatedDocument {
    Content: Uint8Array;
}
export interface AppliedTerminology {
    Name?: string;
    Terms?: Array<{
        SourceText?: string;
        TargetText?: string;
    }>;
}
export interface TranslateTextCommandOutput {
    TranslatedText: string;
    SourceLanguageCode: string;
    TargetLanguageCode: string;
    AppliedTerminologies?: AppliedTerminology[];
    AppliedSettings?: {
        Formality?: 'FORMAL' | 'INFORMAL';
        Profanity?: 'MASK';
        Brevity?: 'ON';
    };
}
export interface TranslateDocumentCommandInput {
    Document: {
        Content: Uint8Array;
        ContentType: 'text/html' | 'text/plain' | 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
    };
    SourceLanguageCode: string;
    TargetLanguageCode: string;
    TerminologyNames?: string[];
    Settings?: {
        Formality?: 'FORMAL' | 'INFORMAL';
        Profanity?: 'MASK';
        Brevity?: 'ON';
    };
}
export interface TranslateDocumentCommandOutput {
    TranslatedDocument: TranslatedDocument;
    SourceLanguageCode: string;
    TargetLanguageCode: string;
    AppliedTerminologies?: AppliedTerminology[];
    AppliedSettings?: {
        Formality?: 'FORMAL' | 'INFORMAL';
        Profanity?: 'MASK';
        Brevity?: 'ON';
    };
}
export interface StartTextTranslationJobCommandInput {
    JobName?: string;
    InputDataConfig: {
        S3Uri: string;
        ContentType: 'text/html' | 'text/plain' | 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' | 'application/vnd.openxmlformats-officedocument.presentationml.presentation' | 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' | 'application/x-xliff+xml';
    };
    OutputDataConfig: {
        S3Uri: string;
        EncryptionKey?: {
            Type: 'KMS';
            Id: string;
        };
    };
    DataAccessRoleArn: string;
    SourceLanguageCode: string;
    TargetLanguageCodes: string[];
    TerminologyNames?: string[];
    ParallelDataNames?: string[];
    ClientToken?: string;
    Settings?: {
        Formality?: 'FORMAL' | 'INFORMAL';
        Profanity?: 'MASK';
        Brevity?: 'ON';
    };
}
export interface StartTextTranslationJobCommandOutput {
    JobId?: string;
    JobStatus?: 'SUBMITTED' | 'IN_PROGRESS' | 'COMPLETED' | 'COMPLETED_WITH_ERROR' | 'FAILED' | 'STOP_REQUESTED' | 'STOPPED';
}
export interface DescribeTextTranslationJobCommandInput {
    JobId: string;
}
export interface TextTranslationJobProperties {
    JobId?: string;
    JobName?: string;
    JobStatus?: 'SUBMITTED' | 'IN_PROGRESS' | 'COMPLETED' | 'COMPLETED_WITH_ERROR' | 'FAILED' | 'STOP_REQUESTED' | 'STOPPED';
    JobDetails?: {
        TranslatedDocumentsCount?: number;
        DocumentsWithErrorsCount?: number;
        InputDocumentsCount?: number;
    };
    SourceLanguageCode?: string;
    TargetLanguageCodes?: string[];
    TerminologyNames?: string[];
    ParallelDataNames?: string[];
    Message?: string;
    SubmittedTime?: string;
    EndTime?: string;
    InputDataConfig?: {
        S3Uri?: string;
        ContentType?: string;
    };
    OutputDataConfig?: {
        S3Uri?: string;
        EncryptionKey?: {
            Type?: string;
            Id?: string;
        };
    };
    DataAccessRoleArn?: string;
    Settings?: {
        Formality?: 'FORMAL' | 'INFORMAL';
        Profanity?: 'MASK';
        Brevity?: 'ON';
    };
}
export interface DescribeTextTranslationJobCommandOutput {
    TextTranslationJobProperties?: TextTranslationJobProperties;
}
export interface ListTextTranslationJobsCommandInput {
    Filter?: {
        JobName?: string;
        JobStatus?: 'SUBMITTED' | 'IN_PROGRESS' | 'COMPLETED' | 'COMPLETED_WITH_ERROR' | 'FAILED' | 'STOP_REQUESTED' | 'STOPPED';
        SubmittedBeforeTime?: string;
        SubmittedAfterTime?: string;
    };
    NextToken?: string;
    MaxResults?: number;
}
export interface ListTextTranslationJobsCommandOutput {
    TextTranslationJobPropertiesList?: TextTranslationJobProperties[];
    NextToken?: string;
}
export interface StopTextTranslationJobCommandInput {
    JobId: string;
}
export interface StopTextTranslationJobCommandOutput {
    JobId?: string;
    JobStatus?: 'SUBMITTED' | 'IN_PROGRESS' | 'COMPLETED' | 'COMPLETED_WITH_ERROR' | 'FAILED' | 'STOP_REQUESTED' | 'STOPPED';
}
export interface ListLanguagesCommandInput {
    DisplayLanguageCode?: string;
    NextToken?: string;
    MaxResults?: number;
}
export interface Language {
    LanguageName?: string;
    LanguageCode?: string;
}
export interface ListLanguagesCommandOutput {
    Languages?: Language[];
    DisplayLanguageCode?: string;
    NextToken?: string;
}
export interface ImportTerminologyCommandInput {
    Name: string;
    MergeStrategy: 'OVERWRITE';
    Description?: string;
    TerminologyData: {
        File: Uint8Array;
        Format: 'CSV' | 'TMX' | 'TSV';
        Directionality?: 'UNI' | 'MULTI';
    };
    EncryptionKey?: {
        Type: 'KMS';
        Id: string;
    };
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface TerminologyProperties {
    Name?: string;
    Description?: string;
    Arn?: string;
    SourceLanguageCode?: string;
    TargetLanguageCodes?: string[];
    EncryptionKey?: {
        Type?: string;
        Id?: string;
    };
    SizeBytes?: number;
    TermCount?: number;
    CreatedAt?: string;
    LastUpdatedAt?: string;
    Directionality?: 'UNI' | 'MULTI';
    Message?: string;
    SkippedTermCount?: number;
    Format?: 'CSV' | 'TMX' | 'TSV';
}
export interface ImportTerminologyCommandOutput {
    TerminologyProperties?: TerminologyProperties;
    AuxiliaryDataLocation?: {
        RepositoryType?: string;
        Location?: string;
    };
}
export interface GetTerminologyCommandInput {
    Name: string;
    TerminologyDataFormat?: 'CSV' | 'TMX' | 'TSV';
}
export interface GetTerminologyCommandOutput {
    TerminologyProperties?: TerminologyProperties;
    TerminologyDataLocation?: {
        RepositoryType?: string;
        Location?: string;
    };
    AuxiliaryDataLocation?: {
        RepositoryType?: string;
        Location?: string;
    };
}
export interface ListTerminologiesCommandInput {
    NextToken?: string;
    MaxResults?: number;
}
export interface ListTerminologiesCommandOutput {
    TerminologyPropertiesList?: TerminologyProperties[];
    NextToken?: string;
}
export interface DeleteTerminologyCommandInput {
    Name: string;
}
export interface DeleteTerminologyCommandOutput {
}
export interface CreateParallelDataCommandInput {
    Name: string;
    Description?: string;
    ParallelDataConfig: {
        S3Uri: string;
        Format: 'TSV' | 'CSV' | 'TMX';
    };
    EncryptionKey?: {
        Type: 'KMS';
        Id: string;
    };
    ClientToken?: string;
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface ParallelDataProperties {
    Name?: string;
    Arn?: string;
    Description?: string;
    Status?: 'CREATING' | 'UPDATING' | 'ACTIVE' | 'DELETING' | 'FAILED';
    SourceLanguageCode?: string;
    TargetLanguageCodes?: string[];
    ParallelDataConfig?: {
        S3Uri?: string;
        Format?: 'TSV' | 'CSV' | 'TMX';
    };
    Message?: string;
    ImportedDataSize?: number;
    ImportedRecordCount?: number;
    FailedRecordCount?: number;
    SkippedRecordCount?: number;
    EncryptionKey?: {
        Type?: string;
        Id?: string;
    };
    CreatedAt?: string;
    LastUpdatedAt?: string;
    LatestUpdateAttemptStatus?: 'CREATING' | 'UPDATING' | 'ACTIVE' | 'DELETING' | 'FAILED';
    LatestUpdateAttemptAt?: string;
}
export interface CreateParallelDataCommandOutput {
    Name?: string;
    Status?: 'CREATING' | 'UPDATING' | 'ACTIVE' | 'DELETING' | 'FAILED';
}
export interface GetParallelDataCommandInput {
    Name: string;
}
export interface GetParallelDataCommandOutput {
    ParallelDataProperties?: ParallelDataProperties;
    DataLocation?: {
        RepositoryType?: string;
        Location?: string;
    };
    AuxiliaryDataLocation?: {
        RepositoryType?: string;
        Location?: string;
    };
    LatestUpdateAttemptAuxiliaryDataLocation?: {
        RepositoryType?: string;
        Location?: string;
    };
}
export interface ListParallelDataCommandInput {
    NextToken?: string;
    MaxResults?: number;
}
export interface ListParallelDataCommandOutput {
    ParallelDataPropertiesList?: ParallelDataProperties[];
    NextToken?: string;
}
export interface DeleteParallelDataCommandInput {
    Name: string;
}
export interface DeleteParallelDataCommandOutput {
    Name?: string;
    Status?: 'CREATING' | 'UPDATING' | 'ACTIVE' | 'DELETING' | 'FAILED';
}
export declare class TranslateClient {
    private client;
    private region;
    constructor(region?: string);
    private request;
    /**
     * Translate text
     */
    translateText(params: TranslateTextCommandInput): Promise<TranslateTextCommandOutput>;
    /**
     * Translate a document
     */
    translateDocument(params: TranslateDocumentCommandInput): Promise<TranslateDocumentCommandOutput>;
    /**
     * Start a batch translation job
     */
    startTextTranslationJob(params: StartTextTranslationJobCommandInput): Promise<StartTextTranslationJobCommandOutput>;
    /**
     * Describe a batch translation job
     */
    describeTextTranslationJob(params: DescribeTextTranslationJobCommandInput): Promise<DescribeTextTranslationJobCommandOutput>;
    /**
     * List batch translation jobs
     */
    listTextTranslationJobs(params?: ListTextTranslationJobsCommandInput): Promise<ListTextTranslationJobsCommandOutput>;
    /**
     * Stop a batch translation job
     */
    stopTextTranslationJob(params: StopTextTranslationJobCommandInput): Promise<StopTextTranslationJobCommandOutput>;
    /**
     * List supported languages
     */
    listLanguages(params?: ListLanguagesCommandInput): Promise<ListLanguagesCommandOutput>;
    /**
     * Import a custom terminology
     */
    importTerminology(params: ImportTerminologyCommandInput): Promise<ImportTerminologyCommandOutput>;
    /**
     * Get a terminology
     */
    getTerminology(params: GetTerminologyCommandInput): Promise<GetTerminologyCommandOutput>;
    /**
     * List terminologies
     */
    listTerminologies(params?: ListTerminologiesCommandInput): Promise<ListTerminologiesCommandOutput>;
    /**
     * Delete a terminology
     */
    deleteTerminology(params: DeleteTerminologyCommandInput): Promise<DeleteTerminologyCommandOutput>;
    /**
     * Create parallel data for custom translation
     */
    createParallelData(params: CreateParallelDataCommandInput): Promise<CreateParallelDataCommandOutput>;
    /**
     * Get parallel data
     */
    getParallelData(params: GetParallelDataCommandInput): Promise<GetParallelDataCommandOutput>;
    /**
     * List parallel data
     */
    listParallelData(params?: ListParallelDataCommandInput): Promise<ListParallelDataCommandOutput>;
    /**
     * Delete parallel data
     */
    deleteParallelData(params: DeleteParallelDataCommandInput): Promise<DeleteParallelDataCommandOutput>;
    /**
     * Simple translation
     */
    translate(text: string, targetLanguage: string, sourceLanguage?: string): Promise<string>;
    /**
     * Translate with formality setting
     */
    translateFormal(text: string, targetLanguage: string, sourceLanguage?: string, formality?: 'FORMAL' | 'INFORMAL'): Promise<string>;
    /**
     * Translate to multiple languages
     */
    translateToMultiple(text: string, targetLanguages: string[], sourceLanguage?: string): Promise<Record<string, string>>;
    /**
     * Wait for batch translation job to complete
     */
    waitForJob(jobId: string, options?: {
        maxWaitMs?: number;
        pollIntervalMs?: number;
    }): Promise<TextTranslationJobProperties>;
    /**
     * Get all supported language codes
     */
    getSupportedLanguages(): Promise<string[]>;
}
/**
 * Quick translation
 */
export declare function translate(text: string, targetLanguage: string, options?: {
    sourceLanguage?: string;
    region?: string;
}): Promise<string>;
/**
 * Translate to multiple languages
 */
export declare function translateToMultiple(text: string, targetLanguages: string[], options?: {
    sourceLanguage?: string;
    region?: string;
}): Promise<Record<string, string>>;
/**
 * List supported languages
 */
export declare function listLanguages(region?: string): Promise<Language[]>;
