export interface S3Object {
    Bucket?: string;
    Name?: string;
    Version?: string;
}
export interface Image {
    Bytes?: Uint8Array;
    S3Object?: S3Object;
}
export interface Video {
    S3Object?: S3Object;
}
export interface BoundingBox {
    Width?: number;
    Height?: number;
    Left?: number;
    Top?: number;
}
export interface Landmark {
    Type?: string;
    X?: number;
    Y?: number;
}
export interface Pose {
    Roll?: number;
    Yaw?: number;
    Pitch?: number;
}
export interface ImageQuality {
    Brightness?: number;
    Sharpness?: number;
}
export interface Emotion {
    Type?: 'HAPPY' | 'SAD' | 'ANGRY' | 'CONFUSED' | 'DISGUSTED' | 'SURPRISED' | 'CALM' | 'UNKNOWN' | 'FEAR';
    Confidence?: number;
}
export interface FaceDetail {
    BoundingBox?: BoundingBox;
    AgeRange?: {
        Low?: number;
        High?: number;
    };
    Smile?: {
        Value?: boolean;
        Confidence?: number;
    };
    Eyeglasses?: {
        Value?: boolean;
        Confidence?: number;
    };
    Sunglasses?: {
        Value?: boolean;
        Confidence?: number;
    };
    Gender?: {
        Value?: 'Male' | 'Female';
        Confidence?: number;
    };
    Beard?: {
        Value?: boolean;
        Confidence?: number;
    };
    Mustache?: {
        Value?: boolean;
        Confidence?: number;
    };
    EyesOpen?: {
        Value?: boolean;
        Confidence?: number;
    };
    MouthOpen?: {
        Value?: boolean;
        Confidence?: number;
    };
    Emotions?: Emotion[];
    Landmarks?: Landmark[];
    Pose?: Pose;
    Quality?: ImageQuality;
    Confidence?: number;
    FaceOccluded?: {
        Value?: boolean;
        Confidence?: number;
    };
    EyeDirection?: {
        Yaw?: number;
        Pitch?: number;
        Confidence?: number;
    };
}
export interface DetectFacesCommandInput {
    Image: Image;
    Attributes?: ('DEFAULT' | 'ALL' | 'AGE_RANGE' | 'BEARD' | 'EMOTIONS' | 'EYE_DIRECTION' | 'EYEGLASSES' | 'EYES_OPEN' | 'FACE_OCCLUDED' | 'GENDER' | 'MOUTH_OPEN' | 'MUSTACHE' | 'POSE' | 'QUALITY' | 'SMILE' | 'SUNGLASSES')[];
}
export interface DetectFacesCommandOutput {
    FaceDetails?: FaceDetail[];
    OrientationCorrection?: 'ROTATE_0' | 'ROTATE_90' | 'ROTATE_180' | 'ROTATE_270';
}
export interface Label {
    Name?: string;
    Confidence?: number;
    Instances?: Array<{
        BoundingBox?: BoundingBox;
        Confidence?: number;
        DominantColors?: Array<{
            Red?: number;
            Green?: number;
            Blue?: number;
            HexCode?: string;
            SimplifiedColor?: string;
            CSSColor?: string;
            PixelPercent?: number;
        }>;
    }>;
    Parents?: Array<{
        Name?: string;
    }>;
    Aliases?: Array<{
        Name?: string;
    }>;
    Categories?: Array<{
        Name?: string;
    }>;
}
export interface DetectLabelsCommandInput {
    Image: Image;
    MaxLabels?: number;
    MinConfidence?: number;
    Features?: ('GENERAL_LABELS' | 'IMAGE_PROPERTIES')[];
    Settings?: {
        GeneralLabels?: {
            LabelInclusionFilters?: string[];
            LabelExclusionFilters?: string[];
            LabelCategoryInclusionFilters?: string[];
            LabelCategoryExclusionFilters?: string[];
        };
        ImageProperties?: {
            MaxDominantColors?: number;
        };
    };
}
export interface DetectLabelsCommandOutput {
    Labels?: Label[];
    OrientationCorrection?: string;
    LabelModelVersion?: string;
    ImageProperties?: {
        Quality?: {
            Brightness?: number;
            Sharpness?: number;
            Contrast?: number;
        };
        DominantColors?: Array<{
            Red?: number;
            Green?: number;
            Blue?: number;
            HexCode?: string;
            SimplifiedColor?: string;
            CSSColor?: string;
            PixelPercent?: number;
        }>;
        Foreground?: {
            Quality?: {
                Brightness?: number;
                Sharpness?: number;
            };
            DominantColors?: Array<{
                Red?: number;
                Green?: number;
                Blue?: number;
                HexCode?: string;
                CSSColor?: string;
                PixelPercent?: number;
            }>;
        };
        Background?: {
            Quality?: {
                Brightness?: number;
                Sharpness?: number;
            };
            DominantColors?: Array<{
                Red?: number;
                Green?: number;
                Blue?: number;
                HexCode?: string;
                CSSColor?: string;
                PixelPercent?: number;
            }>;
        };
    };
}
export interface DetectTextCommandInput {
    Image: Image;
    Filters?: {
        WordFilter?: {
            MinConfidence?: number;
            MinBoundingBoxHeight?: number;
            MinBoundingBoxWidth?: number;
        };
        RegionsOfInterest?: Array<{
            BoundingBox?: BoundingBox;
            Polygon?: Array<{
                X?: number;
                Y?: number;
            }>;
        }>;
    };
}
export interface TextDetection {
    DetectedText?: string;
    Type?: 'LINE' | 'WORD';
    Id?: number;
    ParentId?: number;
    Confidence?: number;
    Geometry?: {
        BoundingBox?: BoundingBox;
        Polygon?: Array<{
            X?: number;
            Y?: number;
        }>;
    };
}
export interface DetectTextCommandOutput {
    TextDetections?: TextDetection[];
    TextModelVersion?: string;
}
export interface DetectModerationLabelsCommandInput {
    Image: Image;
    MinConfidence?: number;
    HumanLoopConfig?: {
        HumanLoopName: string;
        FlowDefinitionArn: string;
        DataAttributes?: {
            ContentClassifiers?: ('FreeOfPersonallyIdentifiableInformation' | 'FreeOfAdultContent')[];
        };
    };
    ProjectVersion?: string;
}
export interface ModerationLabel {
    Confidence?: number;
    Name?: string;
    ParentName?: string;
    TaxonomyLevel?: number;
}
export interface DetectModerationLabelsCommandOutput {
    ModerationLabels?: ModerationLabel[];
    ModerationModelVersion?: string;
    HumanLoopActivationOutput?: {
        HumanLoopArn?: string;
        HumanLoopActivationReasons?: string[];
        HumanLoopActivationConditionsEvaluationResults?: string;
    };
    ProjectVersion?: string;
    ContentTypes?: Array<{
        Confidence?: number;
        Name?: string;
    }>;
}
export interface Celebrity {
    Urls?: string[];
    Name?: string;
    Id?: string;
    Face?: {
        BoundingBox?: BoundingBox;
        Confidence?: number;
        Landmarks?: Landmark[];
        Pose?: Pose;
        Quality?: ImageQuality;
        Emotions?: Emotion[];
        Smile?: {
            Value?: boolean;
            Confidence?: number;
        };
    };
    MatchConfidence?: number;
    KnownGender?: {
        Type?: 'Male' | 'Female' | 'Nonbinary' | 'Unlisted';
    };
}
export interface RecognizeCelebritiesCommandInput {
    Image: Image;
}
export interface RecognizeCelebritiesCommandOutput {
    CelebrityFaces?: Celebrity[];
    UnrecognizedFaces?: FaceDetail[];
    OrientationCorrection?: string;
}
export interface CompareFacesCommandInput {
    SourceImage: Image;
    TargetImage: Image;
    SimilarityThreshold?: number;
    QualityFilter?: 'NONE' | 'AUTO' | 'LOW' | 'MEDIUM' | 'HIGH';
}
export interface CompareFacesMatch {
    Similarity?: number;
    Face?: {
        BoundingBox?: BoundingBox;
        Confidence?: number;
        Landmarks?: Landmark[];
        Pose?: Pose;
        Quality?: ImageQuality;
        Emotions?: Emotion[];
        Smile?: {
            Value?: boolean;
            Confidence?: number;
        };
    };
}
export interface CompareFacesCommandOutput {
    SourceImageFace?: {
        BoundingBox?: BoundingBox;
        Confidence?: number;
    };
    FaceMatches?: CompareFacesMatch[];
    UnmatchedFaces?: FaceDetail[];
    SourceImageOrientationCorrection?: string;
    TargetImageOrientationCorrection?: string;
}
export interface CreateCollectionCommandInput {
    CollectionId: string;
    Tags?: Record<string, string>;
}
export interface CreateCollectionCommandOutput {
    StatusCode?: number;
    CollectionArn?: string;
    FaceModelVersion?: string;
}
export interface DeleteCollectionCommandInput {
    CollectionId: string;
}
export interface DeleteCollectionCommandOutput {
    StatusCode?: number;
}
export interface ListCollectionsCommandInput {
    NextToken?: string;
    MaxResults?: number;
}
export interface ListCollectionsCommandOutput {
    CollectionIds?: string[];
    NextToken?: string;
    FaceModelVersions?: string[];
}
export interface IndexFacesCommandInput {
    CollectionId: string;
    Image: Image;
    ExternalImageId?: string;
    DetectionAttributes?: ('DEFAULT' | 'ALL')[];
    MaxFaces?: number;
    QualityFilter?: 'NONE' | 'AUTO' | 'LOW' | 'MEDIUM' | 'HIGH';
}
export interface FaceRecord {
    Face?: {
        FaceId?: string;
        BoundingBox?: BoundingBox;
        ImageId?: string;
        ExternalImageId?: string;
        Confidence?: number;
        IndexFacesModelVersion?: string;
    };
    FaceDetail?: FaceDetail;
}
export interface IndexFacesCommandOutput {
    FaceRecords?: FaceRecord[];
    OrientationCorrection?: string;
    FaceModelVersion?: string;
    UnindexedFaces?: Array<{
        Reasons?: ('EXCEEDS_MAX_FACES' | 'EXTREME_POSE' | 'LOW_BRIGHTNESS' | 'LOW_SHARPNESS' | 'LOW_CONFIDENCE' | 'SMALL_BOUNDING_BOX' | 'LOW_FACE_QUALITY')[];
        FaceDetail?: FaceDetail;
    }>;
}
export interface SearchFacesByImageCommandInput {
    CollectionId: string;
    Image: Image;
    MaxFaces?: number;
    FaceMatchThreshold?: number;
    QualityFilter?: 'NONE' | 'AUTO' | 'LOW' | 'MEDIUM' | 'HIGH';
}
export interface FaceMatch {
    Similarity?: number;
    Face?: {
        FaceId?: string;
        BoundingBox?: BoundingBox;
        ImageId?: string;
        ExternalImageId?: string;
        Confidence?: number;
        IndexFacesModelVersion?: string;
    };
}
export interface SearchFacesByImageCommandOutput {
    SearchedFaceBoundingBox?: BoundingBox;
    SearchedFaceConfidence?: number;
    FaceMatches?: FaceMatch[];
    FaceModelVersion?: string;
}
export interface SearchFacesCommandInput {
    CollectionId: string;
    FaceId: string;
    MaxFaces?: number;
    FaceMatchThreshold?: number;
}
export interface SearchFacesCommandOutput {
    SearchedFaceId?: string;
    FaceMatches?: FaceMatch[];
    FaceModelVersion?: string;
}
export interface StartLabelDetectionCommandInput {
    Video: Video;
    ClientRequestToken?: string;
    MinConfidence?: number;
    NotificationChannel?: {
        SNSTopicArn: string;
        RoleArn: string;
    };
    JobTag?: string;
    Features?: ('GENERAL_LABELS' | 'IMAGE_PROPERTIES')[];
    Settings?: {
        GeneralLabels?: {
            LabelInclusionFilters?: string[];
            LabelExclusionFilters?: string[];
            LabelCategoryInclusionFilters?: string[];
            LabelCategoryExclusionFilters?: string[];
        };
    };
}
export interface StartLabelDetectionCommandOutput {
    JobId?: string;
}
export interface GetLabelDetectionCommandInput {
    JobId: string;
    MaxResults?: number;
    NextToken?: string;
    SortBy?: 'NAME' | 'TIMESTAMP';
    AggregateBy?: 'TIMESTAMPS' | 'SEGMENTS';
}
export interface LabelDetection {
    Timestamp?: number;
    Label?: Label;
    StartTimestampMillis?: number;
    EndTimestampMillis?: number;
    DurationMillis?: number;
}
export interface GetLabelDetectionCommandOutput {
    JobStatus?: 'IN_PROGRESS' | 'SUCCEEDED' | 'FAILED';
    StatusMessage?: string;
    VideoMetadata?: {
        Codec?: string;
        DurationMillis?: number;
        Format?: string;
        FrameRate?: number;
        FrameHeight?: number;
        FrameWidth?: number;
        ColorRange?: string;
    };
    NextToken?: string;
    Labels?: LabelDetection[];
    LabelModelVersion?: string;
    JobId?: string;
    Video?: {
        S3Object?: S3Object;
    };
    JobTag?: string;
    GetRequestMetadata?: {
        SortBy?: string;
        AggregateBy?: string;
    };
}
export interface StartFaceDetectionCommandInput {
    Video: Video;
    ClientRequestToken?: string;
    NotificationChannel?: {
        SNSTopicArn: string;
        RoleArn: string;
    };
    FaceAttributes?: 'DEFAULT' | 'ALL';
    JobTag?: string;
}
export interface StartFaceDetectionCommandOutput {
    JobId?: string;
}
export interface GetFaceDetectionCommandInput {
    JobId: string;
    MaxResults?: number;
    NextToken?: string;
}
export interface FaceDetection {
    Timestamp?: number;
    Face?: FaceDetail;
}
export interface GetFaceDetectionCommandOutput {
    JobStatus?: 'IN_PROGRESS' | 'SUCCEEDED' | 'FAILED';
    StatusMessage?: string;
    VideoMetadata?: {
        Codec?: string;
        DurationMillis?: number;
        Format?: string;
        FrameRate?: number;
        FrameHeight?: number;
        FrameWidth?: number;
    };
    NextToken?: string;
    Faces?: FaceDetection[];
    JobId?: string;
    Video?: {
        S3Object?: S3Object;
    };
    JobTag?: string;
}
export interface StartContentModerationCommandInput {
    Video: Video;
    MinConfidence?: number;
    ClientRequestToken?: string;
    NotificationChannel?: {
        SNSTopicArn: string;
        RoleArn: string;
    };
    JobTag?: string;
}
export interface StartContentModerationCommandOutput {
    JobId?: string;
}
export interface GetContentModerationCommandInput {
    JobId: string;
    MaxResults?: number;
    NextToken?: string;
    SortBy?: 'NAME' | 'TIMESTAMP';
    AggregateBy?: 'TIMESTAMPS' | 'SEGMENTS';
}
export interface ContentModerationDetection {
    Timestamp?: number;
    ModerationLabel?: ModerationLabel;
    StartTimestampMillis?: number;
    EndTimestampMillis?: number;
    DurationMillis?: number;
    ContentTypes?: Array<{
        Confidence?: number;
        Name?: string;
    }>;
}
export interface GetContentModerationCommandOutput {
    JobStatus?: 'IN_PROGRESS' | 'SUCCEEDED' | 'FAILED';
    StatusMessage?: string;
    VideoMetadata?: {
        Codec?: string;
        DurationMillis?: number;
        Format?: string;
        FrameRate?: number;
        FrameHeight?: number;
        FrameWidth?: number;
    };
    ModerationLabels?: ContentModerationDetection[];
    NextToken?: string;
    ModerationModelVersion?: string;
    JobId?: string;
    Video?: {
        S3Object?: S3Object;
    };
    JobTag?: string;
    GetRequestMetadata?: {
        SortBy?: string;
        AggregateBy?: string;
    };
}
export declare class RekognitionClient {
    private client;
    private region;
    constructor(region?: string);
    private request;
    /**
     * Detect faces in an image
     */
    detectFaces(params: DetectFacesCommandInput): Promise<DetectFacesCommandOutput>;
    /**
     * Detect labels (objects, scenes, concepts) in an image
     */
    detectLabels(params: DetectLabelsCommandInput): Promise<DetectLabelsCommandOutput>;
    /**
     * Detect text in an image
     */
    detectText(params: DetectTextCommandInput): Promise<DetectTextCommandOutput>;
    /**
     * Detect moderation labels (unsafe content)
     */
    detectModerationLabels(params: DetectModerationLabelsCommandInput): Promise<DetectModerationLabelsCommandOutput>;
    /**
     * Recognize celebrities in an image
     */
    recognizeCelebrities(params: RecognizeCelebritiesCommandInput): Promise<RecognizeCelebritiesCommandOutput>;
    /**
     * Compare faces between source and target images
     */
    compareFaces(params: CompareFacesCommandInput): Promise<CompareFacesCommandOutput>;
    /**
     * Create a face collection
     */
    createCollection(params: CreateCollectionCommandInput): Promise<CreateCollectionCommandOutput>;
    /**
     * Delete a face collection
     */
    deleteCollection(params: DeleteCollectionCommandInput): Promise<DeleteCollectionCommandOutput>;
    /**
     * List face collections
     */
    listCollections(params?: ListCollectionsCommandInput): Promise<ListCollectionsCommandOutput>;
    /**
     * Index faces from an image into a collection
     */
    indexFaces(params: IndexFacesCommandInput): Promise<IndexFacesCommandOutput>;
    /**
     * Search for faces in a collection using an image
     */
    searchFacesByImage(params: SearchFacesByImageCommandInput): Promise<SearchFacesByImageCommandOutput>;
    /**
     * Search for faces in a collection using a face ID
     */
    searchFaces(params: SearchFacesCommandInput): Promise<SearchFacesCommandOutput>;
    /**
     * Start async label detection on video
     */
    startLabelDetection(params: StartLabelDetectionCommandInput): Promise<StartLabelDetectionCommandOutput>;
    /**
     * Get results of label detection job
     */
    getLabelDetection(params: GetLabelDetectionCommandInput): Promise<GetLabelDetectionCommandOutput>;
    /**
     * Start async face detection on video
     */
    startFaceDetection(params: StartFaceDetectionCommandInput): Promise<StartFaceDetectionCommandOutput>;
    /**
     * Get results of face detection job
     */
    getFaceDetection(params: GetFaceDetectionCommandInput): Promise<GetFaceDetectionCommandOutput>;
    /**
     * Start async content moderation on video
     */
    startContentModeration(params: StartContentModerationCommandInput): Promise<StartContentModerationCommandOutput>;
    /**
     * Get results of content moderation job
     */
    getContentModeration(params: GetContentModerationCommandInput): Promise<GetContentModerationCommandOutput>;
    /**
     * Analyze an image from S3 and get all labels
     */
    analyzeS3Image(bucket: string, key: string, options?: {
        maxLabels?: number;
        minConfidence?: number;
    }): Promise<Label[]>;
    /**
     * Analyze image bytes and get all labels
     */
    analyzeImageBytes(bytes: Uint8Array, options?: {
        maxLabels?: number;
        minConfidence?: number;
    }): Promise<Label[]>;
    /**
     * Check if image is safe (no moderation labels above threshold)
     */
    isImageSafe(image: Image, threshold?: number): Promise<boolean>;
    /**
     * Count faces in an image
     */
    countFaces(image: Image): Promise<number>;
    /**
     * Extract text from an image
     */
    extractText(image: Image): Promise<string[]>;
    /**
     * Find matching face in collection
     */
    findFace(collectionId: string, image: Image, threshold?: number): Promise<FaceMatch | null>;
}
/**
 * Quick image label detection from S3
 */
export declare function detectLabelsFromS3(bucket: string, key: string, options?: {
    region?: string;
    maxLabels?: number;
}): Promise<string[]>;
/**
 * Quick face count from S3 image
 */
export declare function countFacesInS3Image(bucket: string, key: string, region?: string): Promise<number>;
/**
 * Quick content moderation check
 */
export declare function isContentSafe(bucket: string, key: string, options?: {
    region?: string;
    threshold?: number;
}): Promise<boolean>;
