@stacksjs/ts-cloud 0.2.3 → 0.2.5

package/dist/aws/rekognition.d.ts

@@ -0,0 +1,691 @@
+/**
+ * AWS Rekognition Client
+ * Image and video analysis - face detection, object detection, celebrity recognition
+ * No external SDK dependencies - implements AWS Signature V4 directly
+ */
+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>;