export interface DetectSentimentCommandInput {
    Text: string;
    LanguageCode: 'en' | 'es' | 'fr' | 'de' | 'it' | 'pt' | 'ar' | 'hi' | 'ja' | 'ko' | 'zh' | 'zh-TW';
}
export interface DetectSentimentCommandOutput {
    Sentiment: 'POSITIVE' | 'NEGATIVE' | 'NEUTRAL' | 'MIXED';
    SentimentScore: {
        Positive: number;
        Negative: number;
        Neutral: number;
        Mixed: number;
    };
}
export interface DetectEntitiesCommandInput {
    Text: string;
    LanguageCode: string;
    EndpointArn?: string;
    Bytes?: Uint8Array;
    DocumentReaderConfig?: {
        DocumentReadAction: 'TEXTRACT_DETECT_DOCUMENT_TEXT' | 'TEXTRACT_ANALYZE_DOCUMENT';
        DocumentReadMode?: 'SERVICE_DEFAULT' | 'FORCE_DOCUMENT_READ_ACTION';
        FeatureTypes?: ('TABLES' | 'FORMS')[];
    };
}
export interface Entity {
    Score?: number;
    Type?: 'PERSON' | 'LOCATION' | 'ORGANIZATION' | 'COMMERCIAL_ITEM' | 'EVENT' | 'DATE' | 'QUANTITY' | 'TITLE' | 'OTHER';
    Text?: string;
    BeginOffset?: number;
    EndOffset?: number;
    BlockReferences?: Array<{
        BlockId?: string;
        BeginOffset?: number;
        EndOffset?: number;
        ChildBlocks?: Array<{
            ChildBlockId?: string;
            BeginOffset?: number;
            EndOffset?: number;
        }>;
    }>;
}
export interface DetectEntitiesCommandOutput {
    Entities: Entity[];
    DocumentMetadata?: {
        Pages?: number;
        ExtractedCharacters?: Array<{
            Page?: number;
            Count?: number;
        }>;
    };
    DocumentType?: Array<{
        Page?: number;
        Type?: 'NATIVE_PDF' | 'SCANNED_PDF' | 'MS_WORD' | 'IMAGE' | 'PLAIN_TEXT' | 'TEXTRACT_DETECT_DOCUMENT_TEXT_JSON' | 'TEXTRACT_ANALYZE_DOCUMENT_JSON';
    }>;
    Blocks?: Array<{
        Id?: string;
        BlockType?: 'LINE' | 'WORD';
        Text?: string;
        Page?: number;
        Geometry?: {
            BoundingBox?: {
                Height?: number;
                Left?: number;
                Top?: number;
                Width?: number;
            };
            Polygon?: Array<{
                X?: number;
                Y?: number;
            }>;
        };
        Relationships?: Array<{
            Ids?: string[];
            Type?: 'CHILD';
        }>;
    }>;
    Errors?: Array<{
        Page?: number;
        ErrorCode?: 'TEXTRACT_BAD_PAGE' | 'TEXTRACT_PROVISIONED_THROUGHPUT_EXCEEDED' | 'PAGE_CHARACTERS_EXCEEDED' | 'PAGE_SIZE_EXCEEDED' | 'INTERNAL_SERVER_ERROR';
        ErrorMessage?: string;
    }>;
}
export interface DetectKeyPhrasesCommandInput {
    Text: string;
    LanguageCode: string;
}
export interface KeyPhrase {
    Score?: number;
    Text?: string;
    BeginOffset?: number;
    EndOffset?: number;
}
export interface DetectKeyPhrasesCommandOutput {
    KeyPhrases: KeyPhrase[];
}
export interface DetectDominantLanguageCommandInput {
    Text: string;
}
export interface DominantLanguage {
    LanguageCode?: string;
    Score?: number;
}
export interface DetectDominantLanguageCommandOutput {
    Languages: DominantLanguage[];
}
export interface DetectPiiEntitiesCommandInput {
    Text: string;
    LanguageCode: string;
}
export interface PiiEntity {
    Score?: number;
    Type?: 'BANK_ACCOUNT_NUMBER' | 'BANK_ROUTING' | 'CREDIT_DEBIT_NUMBER' | 'CREDIT_DEBIT_CVV' | 'CREDIT_DEBIT_EXPIRY' | 'PIN' | 'EMAIL' | 'ADDRESS' | 'NAME' | 'PHONE' | 'SSN' | 'DATE_TIME' | 'PASSPORT_NUMBER' | 'DRIVER_ID' | 'URL' | 'AGE' | 'USERNAME' | 'PASSWORD' | 'AWS_ACCESS_KEY' | 'AWS_SECRET_KEY' | 'IP_ADDRESS' | 'MAC_ADDRESS' | 'LICENSE_PLATE' | 'VEHICLE_IDENTIFICATION_NUMBER' | 'UK_NATIONAL_INSURANCE_NUMBER' | 'CA_SOCIAL_INSURANCE_NUMBER' | 'US_INDIVIDUAL_TAX_IDENTIFICATION_NUMBER' | 'UK_UNIQUE_TAXPAYER_REFERENCE_NUMBER' | 'IN_PERMANENT_ACCOUNT_NUMBER' | 'IN_NREGA' | 'INTERNATIONAL_BANK_ACCOUNT_NUMBER' | 'SWIFT_CODE' | 'UK_NATIONAL_HEALTH_SERVICE_NUMBER' | 'CA_HEALTH_NUMBER' | 'IN_AADHAAR' | 'IN_VOTER_NUMBER';
    BeginOffset?: number;
    EndOffset?: number;
}
export interface DetectPiiEntitiesCommandOutput {
    Entities: PiiEntity[];
}
export interface ContainsPiiEntitiesCommandInput {
    Text: string;
    LanguageCode: string;
}
export interface ContainsPiiEntitiesCommandOutput {
    Labels: Array<{
        Name?: string;
        Score?: number;
    }>;
}
export interface DetectSyntaxCommandInput {
    Text: string;
    LanguageCode: 'en' | 'es' | 'fr' | 'de' | 'it' | 'pt';
}
export interface SyntaxToken {
    TokenId?: number;
    Text?: string;
    BeginOffset?: number;
    EndOffset?: number;
    PartOfSpeech?: {
        Tag?: 'ADJ' | 'ADP' | 'ADV' | 'AUX' | 'CONJ' | 'CCONJ' | 'DET' | 'INTJ' | 'NOUN' | 'NUM' | 'O' | 'PART' | 'PRON' | 'PROPN' | 'PUNCT' | 'SCONJ' | 'SYM' | 'VERB';
        Score?: number;
    };
}
export interface DetectSyntaxCommandOutput {
    SyntaxTokens: SyntaxToken[];
}
export interface DetectTargetedSentimentCommandInput {
    Text: string;
    LanguageCode: string;
}
export interface TargetedSentimentEntity {
    DescriptiveMentionIndex?: number[];
    Mentions?: Array<{
        Score?: number;
        GroupScore?: number;
        Text?: string;
        Type?: 'PERSON' | 'LOCATION' | 'ORGANIZATION' | 'FACILITY' | 'BRAND' | 'COMMERCIAL_ITEM' | 'MOVIE' | 'MUSIC' | 'BOOK' | 'SOFTWARE' | 'GAME' | 'PERSONAL_TITLE' | 'EVENT' | 'DATE' | 'QUANTITY' | 'ATTRIBUTE' | 'OTHER';
        MentionSentiment?: {
            Sentiment?: 'POSITIVE' | 'NEGATIVE' | 'NEUTRAL' | 'MIXED';
            SentimentScore?: {
                Positive?: number;
                Negative?: number;
                Neutral?: number;
                Mixed?: number;
            };
        };
        BeginOffset?: number;
        EndOffset?: number;
    }>;
}
export interface DetectTargetedSentimentCommandOutput {
    Entities: TargetedSentimentEntity[];
}
export interface ClassifyDocumentCommandInput {
    Text?: string;
    EndpointArn: string;
    Bytes?: Uint8Array;
    DocumentReaderConfig?: {
        DocumentReadAction: 'TEXTRACT_DETECT_DOCUMENT_TEXT' | 'TEXTRACT_ANALYZE_DOCUMENT';
        DocumentReadMode?: 'SERVICE_DEFAULT' | 'FORCE_DOCUMENT_READ_ACTION';
        FeatureTypes?: ('TABLES' | 'FORMS')[];
    };
}
export interface ClassifyDocumentCommandOutput {
    Classes?: Array<{
        Name?: string;
        Score?: number;
        Page?: number;
    }>;
    Labels?: Array<{
        Name?: string;
        Score?: number;
        Page?: number;
    }>;
    DocumentMetadata?: {
        Pages?: number;
        ExtractedCharacters?: Array<{
            Page?: number;
            Count?: number;
        }>;
    };
    DocumentType?: Array<{
        Page?: number;
        Type?: string;
    }>;
    Errors?: Array<{
        Page?: number;
        ErrorCode?: string;
        ErrorMessage?: string;
    }>;
    Warnings?: Array<{
        Page?: number;
        WarnCode?: string;
        WarnMessage?: string;
    }>;
}
export interface BatchDetectSentimentCommandInput {
    TextList: string[];
    LanguageCode: string;
}
export interface BatchDetectSentimentCommandOutput {
    ResultList: Array<{
        Index?: number;
        Sentiment?: 'POSITIVE' | 'NEGATIVE' | 'NEUTRAL' | 'MIXED';
        SentimentScore?: {
            Positive?: number;
            Negative?: number;
            Neutral?: number;
            Mixed?: number;
        };
    }>;
    ErrorList: Array<{
        Index?: number;
        ErrorCode?: string;
        ErrorMessage?: string;
    }>;
}
export interface BatchDetectEntitiesCommandInput {
    TextList: string[];
    LanguageCode: string;
}
export interface BatchDetectEntitiesCommandOutput {
    ResultList: Array<{
        Index?: number;
        Entities?: Entity[];
    }>;
    ErrorList: Array<{
        Index?: number;
        ErrorCode?: string;
        ErrorMessage?: string;
    }>;
}
export interface BatchDetectKeyPhrasesCommandInput {
    TextList: string[];
    LanguageCode: string;
}
export interface BatchDetectKeyPhrasesCommandOutput {
    ResultList: Array<{
        Index?: number;
        KeyPhrases?: KeyPhrase[];
    }>;
    ErrorList: Array<{
        Index?: number;
        ErrorCode?: string;
        ErrorMessage?: string;
    }>;
}
export interface BatchDetectDominantLanguageCommandInput {
    TextList: string[];
}
export interface BatchDetectDominantLanguageCommandOutput {
    ResultList: Array<{
        Index?: number;
        Languages?: DominantLanguage[];
    }>;
    ErrorList: Array<{
        Index?: number;
        ErrorCode?: string;
        ErrorMessage?: string;
    }>;
}
export interface BatchDetectSyntaxCommandInput {
    TextList: string[];
    LanguageCode: string;
}
export interface BatchDetectSyntaxCommandOutput {
    ResultList: Array<{
        Index?: number;
        SyntaxTokens?: SyntaxToken[];
    }>;
    ErrorList: Array<{
        Index?: number;
        ErrorCode?: string;
        ErrorMessage?: string;
    }>;
}
export interface StartSentimentDetectionJobCommandInput {
    InputDataConfig: {
        S3Uri: string;
        InputFormat?: 'ONE_DOC_PER_FILE' | 'ONE_DOC_PER_LINE';
        DocumentReaderConfig?: {
            DocumentReadAction: 'TEXTRACT_DETECT_DOCUMENT_TEXT' | 'TEXTRACT_ANALYZE_DOCUMENT';
            DocumentReadMode?: 'SERVICE_DEFAULT' | 'FORCE_DOCUMENT_READ_ACTION';
            FeatureTypes?: ('TABLES' | 'FORMS')[];
        };
    };
    OutputDataConfig: {
        S3Uri: string;
        KmsKeyId?: string;
    };
    DataAccessRoleArn: string;
    JobName?: string;
    LanguageCode: string;
    ClientRequestToken?: string;
    VolumeKmsKeyId?: string;
    VpcConfig?: {
        SecurityGroupIds: string[];
        Subnets: string[];
    };
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface StartSentimentDetectionJobCommandOutput {
    JobId?: string;
    JobArn?: string;
    JobStatus?: 'SUBMITTED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'STOP_REQUESTED' | 'STOPPED';
}
export interface StartEntitiesDetectionJobCommandInput {
    InputDataConfig: {
        S3Uri: string;
        InputFormat?: 'ONE_DOC_PER_FILE' | 'ONE_DOC_PER_LINE';
        DocumentReaderConfig?: {
            DocumentReadAction: 'TEXTRACT_DETECT_DOCUMENT_TEXT' | 'TEXTRACT_ANALYZE_DOCUMENT';
            DocumentReadMode?: 'SERVICE_DEFAULT' | 'FORCE_DOCUMENT_READ_ACTION';
            FeatureTypes?: ('TABLES' | 'FORMS')[];
        };
    };
    OutputDataConfig: {
        S3Uri: string;
        KmsKeyId?: string;
    };
    DataAccessRoleArn: string;
    JobName?: string;
    EntityRecognizerArn?: string;
    LanguageCode: string;
    ClientRequestToken?: string;
    VolumeKmsKeyId?: string;
    VpcConfig?: {
        SecurityGroupIds: string[];
        Subnets: string[];
    };
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
    FlywheelArn?: string;
}
export interface StartEntitiesDetectionJobCommandOutput {
    JobId?: string;
    JobArn?: string;
    JobStatus?: 'SUBMITTED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'STOP_REQUESTED' | 'STOPPED';
    EntityRecognizerArn?: string;
}
export interface StartKeyPhrasesDetectionJobCommandInput {
    InputDataConfig: {
        S3Uri: string;
        InputFormat?: 'ONE_DOC_PER_FILE' | 'ONE_DOC_PER_LINE';
    };
    OutputDataConfig: {
        S3Uri: string;
        KmsKeyId?: string;
    };
    DataAccessRoleArn: string;
    JobName?: string;
    LanguageCode: string;
    ClientRequestToken?: string;
    VolumeKmsKeyId?: string;
    VpcConfig?: {
        SecurityGroupIds: string[];
        Subnets: string[];
    };
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface StartKeyPhrasesDetectionJobCommandOutput {
    JobId?: string;
    JobArn?: string;
    JobStatus?: 'SUBMITTED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'STOP_REQUESTED' | 'STOPPED';
}
export interface StartPiiEntitiesDetectionJobCommandInput {
    InputDataConfig: {
        S3Uri: string;
        InputFormat?: 'ONE_DOC_PER_FILE' | 'ONE_DOC_PER_LINE';
    };
    OutputDataConfig: {
        S3Uri: string;
        KmsKeyId?: string;
    };
    Mode: 'ONLY_REDACTION' | 'ONLY_OFFSETS';
    RedactionConfig?: {
        PiiEntityTypes?: string[];
        MaskMode?: 'MASK' | 'REPLACE_WITH_PII_ENTITY_TYPE';
        MaskCharacter?: string;
    };
    DataAccessRoleArn: string;
    JobName?: string;
    LanguageCode: string;
    ClientRequestToken?: string;
    Tags?: Array<{
        Key: string;
        Value: string;
    }>;
}
export interface StartPiiEntitiesDetectionJobCommandOutput {
    JobId?: string;
    JobArn?: string;
    JobStatus?: 'SUBMITTED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'STOP_REQUESTED' | 'STOPPED';
}
export interface DescribeSentimentDetectionJobCommandInput {
    JobId: string;
}
export interface DescribeSentimentDetectionJobCommandOutput {
    SentimentDetectionJobProperties?: {
        JobId?: string;
        JobArn?: string;
        JobName?: string;
        JobStatus?: 'SUBMITTED' | 'IN_PROGRESS' | 'COMPLETED' | 'FAILED' | 'STOP_REQUESTED' | 'STOPPED';
        Message?: string;
        SubmitTime?: string;
        EndTime?: string;
        InputDataConfig?: {
            S3Uri?: string;
            InputFormat?: string;
        };
        OutputDataConfig?: {
            S3Uri?: string;
            KmsKeyId?: string;
        };
        LanguageCode?: string;
        DataAccessRoleArn?: string;
        VolumeKmsKeyId?: string;
        VpcConfig?: {
            SecurityGroupIds?: string[];
            Subnets?: string[];
        };
    };
}
export declare class ComprehendClient {
    private client;
    private region;
    constructor(region?: string);
    private request;
    /**
     * Detect sentiment in text
     */
    detectSentiment(params: DetectSentimentCommandInput): Promise<DetectSentimentCommandOutput>;
    /**
     * Detect entities in text
     */
    detectEntities(params: DetectEntitiesCommandInput): Promise<DetectEntitiesCommandOutput>;
    /**
     * Detect key phrases in text
     */
    detectKeyPhrases(params: DetectKeyPhrasesCommandInput): Promise<DetectKeyPhrasesCommandOutput>;
    /**
     * Detect the dominant language of text
     */
    detectDominantLanguage(params: DetectDominantLanguageCommandInput): Promise<DetectDominantLanguageCommandOutput>;
    /**
     * Detect PII entities in text
     */
    detectPiiEntities(params: DetectPiiEntitiesCommandInput): Promise<DetectPiiEntitiesCommandOutput>;
    /**
     * Check if text contains PII
     */
    containsPiiEntities(params: ContainsPiiEntitiesCommandInput): Promise<ContainsPiiEntitiesCommandOutput>;
    /**
     * Detect syntax (parts of speech) in text
     */
    detectSyntax(params: DetectSyntaxCommandInput): Promise<DetectSyntaxCommandOutput>;
    /**
     * Detect targeted sentiment (sentiment per entity)
     */
    detectTargetedSentiment(params: DetectTargetedSentimentCommandInput): Promise<DetectTargetedSentimentCommandOutput>;
    /**
     * Classify a document using a custom endpoint
     */
    classifyDocument(params: ClassifyDocumentCommandInput): Promise<ClassifyDocumentCommandOutput>;
    /**
     * Batch detect sentiment
     */
    batchDetectSentiment(params: BatchDetectSentimentCommandInput): Promise<BatchDetectSentimentCommandOutput>;
    /**
     * Batch detect entities
     */
    batchDetectEntities(params: BatchDetectEntitiesCommandInput): Promise<BatchDetectEntitiesCommandOutput>;
    /**
     * Batch detect key phrases
     */
    batchDetectKeyPhrases(params: BatchDetectKeyPhrasesCommandInput): Promise<BatchDetectKeyPhrasesCommandOutput>;
    /**
     * Batch detect dominant language
     */
    batchDetectDominantLanguage(params: BatchDetectDominantLanguageCommandInput): Promise<BatchDetectDominantLanguageCommandOutput>;
    /**
     * Batch detect syntax
     */
    batchDetectSyntax(params: BatchDetectSyntaxCommandInput): Promise<BatchDetectSyntaxCommandOutput>;
    /**
     * Start an async sentiment detection job
     */
    startSentimentDetectionJob(params: StartSentimentDetectionJobCommandInput): Promise<StartSentimentDetectionJobCommandOutput>;
    /**
     * Start an async entities detection job
     */
    startEntitiesDetectionJob(params: StartEntitiesDetectionJobCommandInput): Promise<StartEntitiesDetectionJobCommandOutput>;
    /**
     * Start an async key phrases detection job
     */
    startKeyPhrasesDetectionJob(params: StartKeyPhrasesDetectionJobCommandInput): Promise<StartKeyPhrasesDetectionJobCommandOutput>;
    /**
     * Start an async PII entities detection job
     */
    startPiiEntitiesDetectionJob(params: StartPiiEntitiesDetectionJobCommandInput): Promise<StartPiiEntitiesDetectionJobCommandOutput>;
    /**
     * Describe a sentiment detection job
     */
    describeSentimentDetectionJob(params: DescribeSentimentDetectionJobCommandInput): Promise<DescribeSentimentDetectionJobCommandOutput>;
    /**
     * Simple sentiment analysis
     */
    analyzeSentiment(text: string, languageCode?: string): Promise<{
        sentiment: 'POSITIVE' | 'NEGATIVE' | 'NEUTRAL' | 'MIXED';
        scores: {
            positive: number;
            negative: number;
            neutral: number;
            mixed: number;
        };
    }>;
    /**
     * Extract entities from text
     */
    extractEntities(text: string, languageCode?: string): Promise<Array<{
        text: string;
        type: string;
        score: number;
    }>>;
    /**
     * Extract key phrases from text
     */
    extractKeyPhrases(text: string, languageCode?: string): Promise<string[]>;
    /**
     * Detect language of text
     */
    detectLanguage(text: string): Promise<{
        languageCode: string;
        confidence: number;
    }>;
    /**
     * Find PII in text
     */
    findPii(text: string, languageCode?: string): Promise<Array<{
        type: string;
        beginOffset: number;
        endOffset: number;
        score: number;
    }>>;
    /**
     * Check if text contains any PII
     */
    hasPii(text: string, languageCode?: string): Promise<boolean>;
    /**
     * Redact PII from text (replaces PII with [TYPE])
     */
    redactPii(text: string, languageCode?: string): Promise<string>;
}
/**
 * Quick sentiment analysis
 */
export declare function analyzeSentiment(text: string, options?: {
    languageCode?: string;
    region?: string;
}): Promise<{
    sentiment: string;
    confidence: number;
}>;
/**
 * Quick entity extraction
 */
export declare function extractEntities(text: string, options?: {
    languageCode?: string;
    region?: string;
}): Promise<Array<{
    text: string;
    type: string;
}>>;
/**
 * Quick language detection
 */
export declare function detectLanguage(text: string, region?: string): Promise<string>;
/**
 * Quick PII check
 */
export declare function containsPii(text: string, options?: {
    languageCode?: string;
    region?: string;
}): Promise<boolean>;
