@aws-sdk/client-rekognition 3.50.0 → 3.51.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2866 @@
+import { LazyJsonString as __LazyJsonString } from "@aws-sdk/smithy-client";
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface AgeRange {
+    
+    Low?: number;
+    
+    High?: number;
+}
+export declare namespace AgeRange {
+    
+    const filterSensitiveLog: (obj: AgeRange) => any;
+}
+
+export interface S3Object {
+    
+    Bucket?: string;
+    
+    Name?: string;
+    
+    Version?: string;
+}
+export declare namespace S3Object {
+    
+    const filterSensitiveLog: (obj: S3Object) => any;
+}
+
+export interface GroundTruthManifest {
+    
+    S3Object?: S3Object;
+}
+export declare namespace GroundTruthManifest {
+    
+    const filterSensitiveLog: (obj: GroundTruthManifest) => any;
+}
+
+export interface Asset {
+    
+    GroundTruthManifest?: GroundTruthManifest;
+}
+export declare namespace Asset {
+    
+    const filterSensitiveLog: (obj: Asset) => any;
+}
+export declare enum Attribute {
+    ALL = "ALL",
+    DEFAULT = "DEFAULT"
+}
+
+export interface AudioMetadata {
+    
+    Codec?: string;
+    
+    DurationMillis?: number;
+    
+    SampleRate?: number;
+    
+    NumberOfChannels?: number;
+}
+export declare namespace AudioMetadata {
+    
+    const filterSensitiveLog: (obj: AudioMetadata) => any;
+}
+
+export interface Beard {
+    
+    Value?: boolean;
+    
+    Confidence?: number;
+}
+export declare namespace Beard {
+    
+    const filterSensitiveLog: (obj: Beard) => any;
+}
+
+export interface BlackFrame {
+    
+    MaxPixelThreshold?: number;
+    
+    MinCoveragePercentage?: number;
+}
+export declare namespace BlackFrame {
+    
+    const filterSensitiveLog: (obj: BlackFrame) => any;
+}
+export declare enum BodyPart {
+    FACE = "FACE",
+    HEAD = "HEAD",
+    LEFT_HAND = "LEFT_HAND",
+    RIGHT_HAND = "RIGHT_HAND"
+}
+
+export interface BoundingBox {
+    
+    Width?: number;
+    
+    Height?: number;
+    
+    Left?: number;
+    
+    Top?: number;
+}
+export declare namespace BoundingBox {
+    
+    const filterSensitiveLog: (obj: BoundingBox) => any;
+}
+
+export interface CoversBodyPart {
+    
+    Confidence?: number;
+    
+    Value?: boolean;
+}
+export declare namespace CoversBodyPart {
+    
+    const filterSensitiveLog: (obj: CoversBodyPart) => any;
+}
+export declare enum ProtectiveEquipmentType {
+    FACE_COVER = "FACE_COVER",
+    HAND_COVER = "HAND_COVER",
+    HEAD_COVER = "HEAD_COVER"
+}
+
+export interface EquipmentDetection {
+    
+    BoundingBox?: BoundingBox;
+    
+    Confidence?: number;
+    
+    Type?: ProtectiveEquipmentType | string;
+    
+    CoversBodyPart?: CoversBodyPart;
+}
+export declare namespace EquipmentDetection {
+    
+    const filterSensitiveLog: (obj: EquipmentDetection) => any;
+}
+
+export interface ProtectiveEquipmentBodyPart {
+    
+    Name?: BodyPart | string;
+    
+    Confidence?: number;
+    
+    EquipmentDetections?: EquipmentDetection[];
+}
+export declare namespace ProtectiveEquipmentBodyPart {
+    
+    const filterSensitiveLog: (obj: ProtectiveEquipmentBodyPart) => any;
+}
+export declare type EmotionName = "ANGRY" | "CALM" | "CONFUSED" | "DISGUSTED" | "FEAR" | "HAPPY" | "SAD" | "SURPRISED" | "UNKNOWN";
+
+export interface Emotion {
+    
+    Type?: EmotionName | string;
+    
+    Confidence?: number;
+}
+export declare namespace Emotion {
+    
+    const filterSensitiveLog: (obj: Emotion) => any;
+}
+export declare enum LandmarkType {
+    chinBottom = "chinBottom",
+    eyeLeft = "eyeLeft",
+    eyeRight = "eyeRight",
+    leftEyeBrowLeft = "leftEyeBrowLeft",
+    leftEyeBrowRight = "leftEyeBrowRight",
+    leftEyeBrowUp = "leftEyeBrowUp",
+    leftEyeDown = "leftEyeDown",
+    leftEyeLeft = "leftEyeLeft",
+    leftEyeRight = "leftEyeRight",
+    leftEyeUp = "leftEyeUp",
+    leftPupil = "leftPupil",
+    midJawlineLeft = "midJawlineLeft",
+    midJawlineRight = "midJawlineRight",
+    mouthDown = "mouthDown",
+    mouthLeft = "mouthLeft",
+    mouthRight = "mouthRight",
+    mouthUp = "mouthUp",
+    nose = "nose",
+    noseLeft = "noseLeft",
+    noseRight = "noseRight",
+    rightEyeBrowLeft = "rightEyeBrowLeft",
+    rightEyeBrowRight = "rightEyeBrowRight",
+    rightEyeBrowUp = "rightEyeBrowUp",
+    rightEyeDown = "rightEyeDown",
+    rightEyeLeft = "rightEyeLeft",
+    rightEyeRight = "rightEyeRight",
+    rightEyeUp = "rightEyeUp",
+    rightPupil = "rightPupil",
+    upperJawlineLeft = "upperJawlineLeft",
+    upperJawlineRight = "upperJawlineRight"
+}
+
+export interface Landmark {
+    
+    Type?: LandmarkType | string;
+    
+    X?: number;
+    
+    Y?: number;
+}
+export declare namespace Landmark {
+    
+    const filterSensitiveLog: (obj: Landmark) => any;
+}
+
+export interface Pose {
+    
+    Roll?: number;
+    
+    Yaw?: number;
+    
+    Pitch?: number;
+}
+export declare namespace Pose {
+    
+    const filterSensitiveLog: (obj: Pose) => any;
+}
+
+export interface ImageQuality {
+    
+    Brightness?: number;
+    
+    Sharpness?: number;
+}
+export declare namespace ImageQuality {
+    
+    const filterSensitiveLog: (obj: ImageQuality) => any;
+}
+
+export interface Smile {
+    
+    Value?: boolean;
+    
+    Confidence?: number;
+}
+export declare namespace Smile {
+    
+    const filterSensitiveLog: (obj: Smile) => any;
+}
+
+export interface ComparedFace {
+    
+    BoundingBox?: BoundingBox;
+    
+    Confidence?: number;
+    
+    Landmarks?: Landmark[];
+    
+    Pose?: Pose;
+    
+    Quality?: ImageQuality;
+    
+    Emotions?: Emotion[];
+    
+    Smile?: Smile;
+}
+export declare namespace ComparedFace {
+    
+    const filterSensitiveLog: (obj: ComparedFace) => any;
+}
+export declare enum KnownGenderType {
+    Female = "Female",
+    Male = "Male",
+    Nonbinary = "Nonbinary",
+    Unlisted = "Unlisted"
+}
+
+export interface KnownGender {
+    
+    Type?: KnownGenderType | string;
+}
+export declare namespace KnownGender {
+    
+    const filterSensitiveLog: (obj: KnownGender) => any;
+}
+
+export interface Celebrity {
+    
+    Urls?: string[];
+    
+    Name?: string;
+    
+    Id?: string;
+    
+    Face?: ComparedFace;
+    
+    MatchConfidence?: number;
+    
+    KnownGender?: KnownGender;
+}
+export declare namespace Celebrity {
+    
+    const filterSensitiveLog: (obj: Celebrity) => any;
+}
+
+export interface Eyeglasses {
+    
+    Value?: boolean;
+    
+    Confidence?: number;
+}
+export declare namespace Eyeglasses {
+    
+    const filterSensitiveLog: (obj: Eyeglasses) => any;
+}
+
+export interface EyeOpen {
+    
+    Value?: boolean;
+    
+    Confidence?: number;
+}
+export declare namespace EyeOpen {
+    
+    const filterSensitiveLog: (obj: EyeOpen) => any;
+}
+export declare enum GenderType {
+    Female = "Female",
+    Male = "Male"
+}
+
+export interface Gender {
+    
+    Value?: GenderType | string;
+    
+    Confidence?: number;
+}
+export declare namespace Gender {
+    
+    const filterSensitiveLog: (obj: Gender) => any;
+}
+
+export interface MouthOpen {
+    
+    Value?: boolean;
+    
+    Confidence?: number;
+}
+export declare namespace MouthOpen {
+    
+    const filterSensitiveLog: (obj: MouthOpen) => any;
+}
+
+export interface Mustache {
+    
+    Value?: boolean;
+    
+    Confidence?: number;
+}
+export declare namespace Mustache {
+    
+    const filterSensitiveLog: (obj: Mustache) => any;
+}
+
+export interface Sunglasses {
+    
+    Value?: boolean;
+    
+    Confidence?: number;
+}
+export declare namespace Sunglasses {
+    
+    const filterSensitiveLog: (obj: Sunglasses) => any;
+}
+
+export interface FaceDetail {
+    
+    BoundingBox?: BoundingBox;
+    
+    AgeRange?: AgeRange;
+    
+    Smile?: Smile;
+    
+    Eyeglasses?: Eyeglasses;
+    
+    Sunglasses?: Sunglasses;
+    
+    Gender?: Gender;
+    
+    Beard?: Beard;
+    
+    Mustache?: Mustache;
+    
+    EyesOpen?: EyeOpen;
+    
+    MouthOpen?: MouthOpen;
+    
+    Emotions?: Emotion[];
+    
+    Landmarks?: Landmark[];
+    
+    Pose?: Pose;
+    
+    Quality?: ImageQuality;
+    
+    Confidence?: number;
+}
+export declare namespace FaceDetail {
+    
+    const filterSensitiveLog: (obj: FaceDetail) => any;
+}
+
+export interface CelebrityDetail {
+    
+    Urls?: string[];
+    
+    Name?: string;
+    
+    Id?: string;
+    
+    Confidence?: number;
+    
+    BoundingBox?: BoundingBox;
+    
+    Face?: FaceDetail;
+    
+    KnownGender?: KnownGender;
+}
+export declare namespace CelebrityDetail {
+    
+    const filterSensitiveLog: (obj: CelebrityDetail) => any;
+}
+
+export interface CelebrityRecognition {
+    
+    Timestamp?: number;
+    
+    Celebrity?: CelebrityDetail;
+}
+export declare namespace CelebrityRecognition {
+    
+    const filterSensitiveLog: (obj: CelebrityRecognition) => any;
+}
+export declare enum CelebrityRecognitionSortBy {
+    ID = "ID",
+    TIMESTAMP = "TIMESTAMP"
+}
+
+export interface ComparedSourceImageFace {
+    
+    BoundingBox?: BoundingBox;
+    
+    Confidence?: number;
+}
+export declare namespace ComparedSourceImageFace {
+    
+    const filterSensitiveLog: (obj: ComparedSourceImageFace) => any;
+}
+export declare enum QualityFilter {
+    AUTO = "AUTO",
+    HIGH = "HIGH",
+    LOW = "LOW",
+    MEDIUM = "MEDIUM",
+    NONE = "NONE"
+}
+
+export interface Image {
+    
+    Bytes?: Uint8Array;
+    
+    S3Object?: S3Object;
+}
+export declare namespace Image {
+    
+    const filterSensitiveLog: (obj: Image) => any;
+}
+export interface CompareFacesRequest {
+    
+    SourceImage: Image | undefined;
+    
+    TargetImage: Image | undefined;
+    
+    SimilarityThreshold?: number;
+    
+    QualityFilter?: QualityFilter | string;
+}
+export declare namespace CompareFacesRequest {
+    
+    const filterSensitiveLog: (obj: CompareFacesRequest) => any;
+}
+
+export interface CompareFacesMatch {
+    
+    Similarity?: number;
+    
+    Face?: ComparedFace;
+}
+export declare namespace CompareFacesMatch {
+    
+    const filterSensitiveLog: (obj: CompareFacesMatch) => any;
+}
+export declare enum OrientationCorrection {
+    ROTATE_0 = "ROTATE_0",
+    ROTATE_180 = "ROTATE_180",
+    ROTATE_270 = "ROTATE_270",
+    ROTATE_90 = "ROTATE_90"
+}
+export interface CompareFacesResponse {
+    
+    SourceImageFace?: ComparedSourceImageFace;
+    
+    FaceMatches?: CompareFacesMatch[];
+    
+    UnmatchedFaces?: ComparedFace[];
+    
+    SourceImageOrientationCorrection?: OrientationCorrection | string;
+    
+    TargetImageOrientationCorrection?: OrientationCorrection | string;
+}
+export declare namespace CompareFacesResponse {
+    
+    const filterSensitiveLog: (obj: CompareFacesResponse) => any;
+}
+
+export interface ImageTooLargeException extends __SmithyException, $MetadataBearer {
+    name: "ImageTooLargeException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface InternalServerError extends __SmithyException, $MetadataBearer {
+    name: "InternalServerError";
+    $fault: "server";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface InvalidImageFormatException extends __SmithyException, $MetadataBearer {
+    name: "InvalidImageFormatException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface InvalidParameterException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParameterException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface InvalidS3ObjectException extends __SmithyException, $MetadataBearer {
+    name: "InvalidS3ObjectException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface ProvisionedThroughputExceededException extends __SmithyException, $MetadataBearer {
+    name: "ProvisionedThroughputExceededException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "server";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+export declare enum ContentClassifier {
+    FREE_OF_ADULT_CONTENT = "FreeOfAdultContent",
+    FREE_OF_PERSONALLY_IDENTIFIABLE_INFORMATION = "FreeOfPersonallyIdentifiableInformation"
+}
+
+export interface ModerationLabel {
+    
+    Confidence?: number;
+    
+    Name?: string;
+    
+    ParentName?: string;
+}
+export declare namespace ModerationLabel {
+    
+    const filterSensitiveLog: (obj: ModerationLabel) => any;
+}
+
+export interface ContentModerationDetection {
+    
+    Timestamp?: number;
+    
+    ModerationLabel?: ModerationLabel;
+}
+export declare namespace ContentModerationDetection {
+    
+    const filterSensitiveLog: (obj: ContentModerationDetection) => any;
+}
+export declare enum ContentModerationSortBy {
+    NAME = "NAME",
+    TIMESTAMP = "TIMESTAMP"
+}
+export interface CreateCollectionRequest {
+    
+    CollectionId: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateCollectionRequest {
+    
+    const filterSensitiveLog: (obj: CreateCollectionRequest) => any;
+}
+export interface CreateCollectionResponse {
+    
+    StatusCode?: number;
+    
+    CollectionArn?: string;
+    
+    FaceModelVersion?: string;
+}
+export declare namespace CreateCollectionResponse {
+    
+    const filterSensitiveLog: (obj: CreateCollectionResponse) => any;
+}
+
+export interface ResourceAlreadyExistsException extends __SmithyException, $MetadataBearer {
+    name: "ResourceAlreadyExistsException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface ServiceQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "ServiceQuotaExceededException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface DatasetSource {
+    
+    GroundTruthManifest?: GroundTruthManifest;
+    
+    DatasetArn?: string;
+}
+export declare namespace DatasetSource {
+    
+    const filterSensitiveLog: (obj: DatasetSource) => any;
+}
+export declare enum DatasetType {
+    TEST = "TEST",
+    TRAIN = "TRAIN"
+}
+export interface CreateDatasetRequest {
+    
+    DatasetSource?: DatasetSource;
+    
+    DatasetType: DatasetType | string | undefined;
+    
+    ProjectArn: string | undefined;
+}
+export declare namespace CreateDatasetRequest {
+    
+    const filterSensitiveLog: (obj: CreateDatasetRequest) => any;
+}
+export interface CreateDatasetResponse {
+    
+    DatasetArn?: string;
+}
+export declare namespace CreateDatasetResponse {
+    
+    const filterSensitiveLog: (obj: CreateDatasetResponse) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+export interface CreateProjectRequest {
+    
+    ProjectName: string | undefined;
+}
+export declare namespace CreateProjectRequest {
+    
+    const filterSensitiveLog: (obj: CreateProjectRequest) => any;
+}
+export interface CreateProjectResponse {
+    
+    ProjectArn?: string;
+}
+export declare namespace CreateProjectResponse {
+    
+    const filterSensitiveLog: (obj: CreateProjectResponse) => any;
+}
+
+export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
+    name: "ResourceInUseException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface OutputConfig {
+    
+    S3Bucket?: string;
+    
+    S3KeyPrefix?: string;
+}
+export declare namespace OutputConfig {
+    
+    const filterSensitiveLog: (obj: OutputConfig) => any;
+}
+
+export interface TestingData {
+    
+    Assets?: Asset[];
+    
+    AutoCreate?: boolean;
+}
+export declare namespace TestingData {
+    
+    const filterSensitiveLog: (obj: TestingData) => any;
+}
+
+export interface TrainingData {
+    
+    Assets?: Asset[];
+}
+export declare namespace TrainingData {
+    
+    const filterSensitiveLog: (obj: TrainingData) => any;
+}
+export interface CreateProjectVersionRequest {
+    
+    ProjectArn: string | undefined;
+    
+    VersionName: string | undefined;
+    
+    OutputConfig: OutputConfig | undefined;
+    
+    TrainingData?: TrainingData;
+    
+    TestingData?: TestingData;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+    
+    KmsKeyId?: string;
+}
+export declare namespace CreateProjectVersionRequest {
+    
+    const filterSensitiveLog: (obj: CreateProjectVersionRequest) => any;
+}
+export interface CreateProjectVersionResponse {
+    
+    ProjectVersionArn?: string;
+}
+export declare namespace CreateProjectVersionResponse {
+    
+    const filterSensitiveLog: (obj: CreateProjectVersionResponse) => any;
+}
+
+export interface KinesisVideoStream {
+    
+    Arn?: string;
+}
+export declare namespace KinesisVideoStream {
+    
+    const filterSensitiveLog: (obj: KinesisVideoStream) => any;
+}
+
+export interface StreamProcessorInput {
+    
+    KinesisVideoStream?: KinesisVideoStream;
+}
+export declare namespace StreamProcessorInput {
+    
+    const filterSensitiveLog: (obj: StreamProcessorInput) => any;
+}
+
+export interface KinesisDataStream {
+    
+    Arn?: string;
+}
+export declare namespace KinesisDataStream {
+    
+    const filterSensitiveLog: (obj: KinesisDataStream) => any;
+}
+
+export interface StreamProcessorOutput {
+    
+    KinesisDataStream?: KinesisDataStream;
+}
+export declare namespace StreamProcessorOutput {
+    
+    const filterSensitiveLog: (obj: StreamProcessorOutput) => any;
+}
+
+export interface FaceSearchSettings {
+    
+    CollectionId?: string;
+    
+    FaceMatchThreshold?: number;
+}
+export declare namespace FaceSearchSettings {
+    
+    const filterSensitiveLog: (obj: FaceSearchSettings) => any;
+}
+
+export interface StreamProcessorSettings {
+    
+    FaceSearch?: FaceSearchSettings;
+}
+export declare namespace StreamProcessorSettings {
+    
+    const filterSensitiveLog: (obj: StreamProcessorSettings) => any;
+}
+export interface CreateStreamProcessorRequest {
+    
+    Input: StreamProcessorInput | undefined;
+    
+    Output: StreamProcessorOutput | undefined;
+    
+    Name: string | undefined;
+    
+    Settings: StreamProcessorSettings | undefined;
+    
+    RoleArn: string | undefined;
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateStreamProcessorRequest {
+    
+    const filterSensitiveLog: (obj: CreateStreamProcessorRequest) => any;
+}
+export interface CreateStreamProcessorResponse {
+    
+    StreamProcessorArn?: string;
+}
+export declare namespace CreateStreamProcessorResponse {
+    
+    const filterSensitiveLog: (obj: CreateStreamProcessorResponse) => any;
+}
+
+export interface Point {
+    
+    X?: number;
+    
+    Y?: number;
+}
+export declare namespace Point {
+    
+    const filterSensitiveLog: (obj: Point) => any;
+}
+
+export interface Geometry {
+    
+    BoundingBox?: BoundingBox;
+    
+    Polygon?: Point[];
+}
+export declare namespace Geometry {
+    
+    const filterSensitiveLog: (obj: Geometry) => any;
+}
+
+export interface CustomLabel {
+    
+    Name?: string;
+    
+    Confidence?: number;
+    
+    Geometry?: Geometry;
+}
+export declare namespace CustomLabel {
+    
+    const filterSensitiveLog: (obj: CustomLabel) => any;
+}
+
+export interface DatasetChanges {
+    
+    GroundTruth: Uint8Array | undefined;
+}
+export declare namespace DatasetChanges {
+    
+    const filterSensitiveLog: (obj: DatasetChanges) => any;
+}
+
+export interface DatasetStats {
+    
+    LabeledEntries?: number;
+    
+    TotalEntries?: number;
+    
+    TotalLabels?: number;
+    
+    ErrorEntries?: number;
+}
+export declare namespace DatasetStats {
+    
+    const filterSensitiveLog: (obj: DatasetStats) => any;
+}
+export declare enum DatasetStatus {
+    CREATE_COMPLETE = "CREATE_COMPLETE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    UPDATE_COMPLETE = "UPDATE_COMPLETE",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATE_IN_PROGRESS = "UPDATE_IN_PROGRESS"
+}
+export declare enum DatasetStatusMessageCode {
+    CLIENT_ERROR = "CLIENT_ERROR",
+    SERVICE_ERROR = "SERVICE_ERROR",
+    SUCCESS = "SUCCESS"
+}
+
+export interface DatasetDescription {
+    
+    CreationTimestamp?: Date;
+    
+    LastUpdatedTimestamp?: Date;
+    
+    Status?: DatasetStatus | string;
+    
+    StatusMessage?: string;
+    
+    StatusMessageCode?: DatasetStatusMessageCode | string;
+    
+    DatasetStats?: DatasetStats;
+}
+export declare namespace DatasetDescription {
+    
+    const filterSensitiveLog: (obj: DatasetDescription) => any;
+}
+
+export interface DatasetLabelStats {
+    
+    EntryCount?: number;
+    
+    BoundingBoxCount?: number;
+}
+export declare namespace DatasetLabelStats {
+    
+    const filterSensitiveLog: (obj: DatasetLabelStats) => any;
+}
+
+export interface DatasetLabelDescription {
+    
+    LabelName?: string;
+    
+    LabelStats?: DatasetLabelStats;
+}
+export declare namespace DatasetLabelDescription {
+    
+    const filterSensitiveLog: (obj: DatasetLabelDescription) => any;
+}
+
+export interface DatasetMetadata {
+    
+    CreationTimestamp?: Date;
+    
+    DatasetType?: DatasetType | string;
+    
+    DatasetArn?: string;
+    
+    Status?: DatasetStatus | string;
+    
+    StatusMessage?: string;
+    
+    StatusMessageCode?: DatasetStatusMessageCode | string;
+}
+export declare namespace DatasetMetadata {
+    
+    const filterSensitiveLog: (obj: DatasetMetadata) => any;
+}
+export interface DeleteCollectionRequest {
+    
+    CollectionId: string | undefined;
+}
+export declare namespace DeleteCollectionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteCollectionRequest) => any;
+}
+export interface DeleteCollectionResponse {
+    
+    StatusCode?: number;
+}
+export declare namespace DeleteCollectionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteCollectionResponse) => any;
+}
+export interface DeleteDatasetRequest {
+    
+    DatasetArn: string | undefined;
+}
+export declare namespace DeleteDatasetRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDatasetRequest) => any;
+}
+export interface DeleteDatasetResponse {
+}
+export declare namespace DeleteDatasetResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDatasetResponse) => any;
+}
+export interface DeleteFacesRequest {
+    
+    CollectionId: string | undefined;
+    
+    FaceIds: string[] | undefined;
+}
+export declare namespace DeleteFacesRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFacesRequest) => any;
+}
+export interface DeleteFacesResponse {
+    
+    DeletedFaces?: string[];
+}
+export declare namespace DeleteFacesResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFacesResponse) => any;
+}
+export interface DeleteProjectRequest {
+    
+    ProjectArn: string | undefined;
+}
+export declare namespace DeleteProjectRequest {
+    
+    const filterSensitiveLog: (obj: DeleteProjectRequest) => any;
+}
+export declare enum ProjectStatus {
+    CREATED = "CREATED",
+    CREATING = "CREATING",
+    DELETING = "DELETING"
+}
+export interface DeleteProjectResponse {
+    
+    Status?: ProjectStatus | string;
+}
+export declare namespace DeleteProjectResponse {
+    
+    const filterSensitiveLog: (obj: DeleteProjectResponse) => any;
+}
+export interface DeleteProjectVersionRequest {
+    
+    ProjectVersionArn: string | undefined;
+}
+export declare namespace DeleteProjectVersionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteProjectVersionRequest) => any;
+}
+export declare enum ProjectVersionStatus {
+    DELETING = "DELETING",
+    FAILED = "FAILED",
+    RUNNING = "RUNNING",
+    STARTING = "STARTING",
+    STOPPED = "STOPPED",
+    STOPPING = "STOPPING",
+    TRAINING_COMPLETED = "TRAINING_COMPLETED",
+    TRAINING_FAILED = "TRAINING_FAILED",
+    TRAINING_IN_PROGRESS = "TRAINING_IN_PROGRESS"
+}
+export interface DeleteProjectVersionResponse {
+    
+    Status?: ProjectVersionStatus | string;
+}
+export declare namespace DeleteProjectVersionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteProjectVersionResponse) => any;
+}
+export interface DeleteStreamProcessorRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteStreamProcessorRequest {
+    
+    const filterSensitiveLog: (obj: DeleteStreamProcessorRequest) => any;
+}
+export interface DeleteStreamProcessorResponse {
+}
+export declare namespace DeleteStreamProcessorResponse {
+    
+    const filterSensitiveLog: (obj: DeleteStreamProcessorResponse) => any;
+}
+export interface DescribeCollectionRequest {
+    
+    CollectionId: string | undefined;
+}
+export declare namespace DescribeCollectionRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCollectionRequest) => any;
+}
+export interface DescribeCollectionResponse {
+    
+    FaceCount?: number;
+    
+    FaceModelVersion?: string;
+    
+    CollectionARN?: string;
+    
+    CreationTimestamp?: Date;
+}
+export declare namespace DescribeCollectionResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCollectionResponse) => any;
+}
+export interface DescribeDatasetRequest {
+    
+    DatasetArn: string | undefined;
+}
+export declare namespace DescribeDatasetRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDatasetRequest) => any;
+}
+export interface DescribeDatasetResponse {
+    
+    DatasetDescription?: DatasetDescription;
+}
+export declare namespace DescribeDatasetResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDatasetResponse) => any;
+}
+export interface DescribeProjectsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ProjectNames?: string[];
+}
+export declare namespace DescribeProjectsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeProjectsRequest) => any;
+}
+
+export interface ProjectDescription {
+    
+    ProjectArn?: string;
+    
+    CreationTimestamp?: Date;
+    
+    Status?: ProjectStatus | string;
+    
+    Datasets?: DatasetMetadata[];
+}
+export declare namespace ProjectDescription {
+    
+    const filterSensitiveLog: (obj: ProjectDescription) => any;
+}
+export interface DescribeProjectsResponse {
+    
+    ProjectDescriptions?: ProjectDescription[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeProjectsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeProjectsResponse) => any;
+}
+
+export interface InvalidPaginationTokenException extends __SmithyException, $MetadataBearer {
+    name: "InvalidPaginationTokenException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+export interface DescribeProjectVersionsRequest {
+    
+    ProjectArn: string | undefined;
+    
+    VersionNames?: string[];
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeProjectVersionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeProjectVersionsRequest) => any;
+}
+
+export interface Summary {
+    
+    S3Object?: S3Object;
+}
+export declare namespace Summary {
+    
+    const filterSensitiveLog: (obj: Summary) => any;
+}
+
+export interface EvaluationResult {
+    
+    F1Score?: number;
+    
+    Summary?: Summary;
+}
+export declare namespace EvaluationResult {
+    
+    const filterSensitiveLog: (obj: EvaluationResult) => any;
+}
+
+export interface ValidationData {
+    
+    Assets?: Asset[];
+}
+export declare namespace ValidationData {
+    
+    const filterSensitiveLog: (obj: ValidationData) => any;
+}
+
+export interface TestingDataResult {
+    
+    Input?: TestingData;
+    
+    Output?: TestingData;
+    
+    Validation?: ValidationData;
+}
+export declare namespace TestingDataResult {
+    
+    const filterSensitiveLog: (obj: TestingDataResult) => any;
+}
+
+export interface TrainingDataResult {
+    
+    Input?: TrainingData;
+    
+    Output?: TrainingData;
+    
+    Validation?: ValidationData;
+}
+export declare namespace TrainingDataResult {
+    
+    const filterSensitiveLog: (obj: TrainingDataResult) => any;
+}
+
+export interface ProjectVersionDescription {
+    
+    ProjectVersionArn?: string;
+    
+    CreationTimestamp?: Date;
+    
+    MinInferenceUnits?: number;
+    
+    Status?: ProjectVersionStatus | string;
+    
+    StatusMessage?: string;
+    
+    BillableTrainingTimeInSeconds?: number;
+    
+    TrainingEndTimestamp?: Date;
+    
+    OutputConfig?: OutputConfig;
+    
+    TrainingDataResult?: TrainingDataResult;
+    
+    TestingDataResult?: TestingDataResult;
+    
+    EvaluationResult?: EvaluationResult;
+    
+    ManifestSummary?: GroundTruthManifest;
+    
+    KmsKeyId?: string;
+}
+export declare namespace ProjectVersionDescription {
+    
+    const filterSensitiveLog: (obj: ProjectVersionDescription) => any;
+}
+export interface DescribeProjectVersionsResponse {
+    
+    ProjectVersionDescriptions?: ProjectVersionDescription[];
+    
+    NextToken?: string;
+}
+export declare namespace DescribeProjectVersionsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeProjectVersionsResponse) => any;
+}
+export interface DescribeStreamProcessorRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace DescribeStreamProcessorRequest {
+    
+    const filterSensitiveLog: (obj: DescribeStreamProcessorRequest) => any;
+}
+export declare enum StreamProcessorStatus {
+    FAILED = "FAILED",
+    RUNNING = "RUNNING",
+    STARTING = "STARTING",
+    STOPPED = "STOPPED",
+    STOPPING = "STOPPING"
+}
+export interface DescribeStreamProcessorResponse {
+    
+    Name?: string;
+    
+    StreamProcessorArn?: string;
+    
+    Status?: StreamProcessorStatus | string;
+    
+    StatusMessage?: string;
+    
+    CreationTimestamp?: Date;
+    
+    LastUpdateTimestamp?: Date;
+    
+    Input?: StreamProcessorInput;
+    
+    Output?: StreamProcessorOutput;
+    
+    RoleArn?: string;
+    
+    Settings?: StreamProcessorSettings;
+}
+export declare namespace DescribeStreamProcessorResponse {
+    
+    const filterSensitiveLog: (obj: DescribeStreamProcessorResponse) => any;
+}
+export interface DetectCustomLabelsRequest {
+    
+    ProjectVersionArn: string | undefined;
+    
+    Image: Image | undefined;
+    
+    MaxResults?: number;
+    
+    MinConfidence?: number;
+}
+export declare namespace DetectCustomLabelsRequest {
+    
+    const filterSensitiveLog: (obj: DetectCustomLabelsRequest) => any;
+}
+export interface DetectCustomLabelsResponse {
+    
+    CustomLabels?: CustomLabel[];
+}
+export declare namespace DetectCustomLabelsResponse {
+    
+    const filterSensitiveLog: (obj: DetectCustomLabelsResponse) => any;
+}
+
+export interface ResourceNotReadyException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotReadyException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+export interface DetectFacesRequest {
+    
+    Image: Image | undefined;
+    
+    Attributes?: (Attribute | string)[];
+}
+export declare namespace DetectFacesRequest {
+    
+    const filterSensitiveLog: (obj: DetectFacesRequest) => any;
+}
+export interface DetectFacesResponse {
+    
+    FaceDetails?: FaceDetail[];
+    
+    OrientationCorrection?: OrientationCorrection | string;
+}
+export declare namespace DetectFacesResponse {
+    
+    const filterSensitiveLog: (obj: DetectFacesResponse) => any;
+}
+
+export interface DetectionFilter {
+    
+    MinConfidence?: number;
+    
+    MinBoundingBoxHeight?: number;
+    
+    MinBoundingBoxWidth?: number;
+}
+export declare namespace DetectionFilter {
+    
+    const filterSensitiveLog: (obj: DetectionFilter) => any;
+}
+export interface DetectLabelsRequest {
+    
+    Image: Image | undefined;
+    
+    MaxLabels?: number;
+    
+    MinConfidence?: number;
+}
+export declare namespace DetectLabelsRequest {
+    
+    const filterSensitiveLog: (obj: DetectLabelsRequest) => any;
+}
+
+export interface Instance {
+    
+    BoundingBox?: BoundingBox;
+    
+    Confidence?: number;
+}
+export declare namespace Instance {
+    
+    const filterSensitiveLog: (obj: Instance) => any;
+}
+
+export interface Parent {
+    
+    Name?: string;
+}
+export declare namespace Parent {
+    
+    const filterSensitiveLog: (obj: Parent) => any;
+}
+
+export interface Label {
+    
+    Name?: string;
+    
+    Confidence?: number;
+    
+    Instances?: Instance[];
+    
+    Parents?: Parent[];
+}
+export declare namespace Label {
+    
+    const filterSensitiveLog: (obj: Label) => any;
+}
+export interface DetectLabelsResponse {
+    
+    Labels?: Label[];
+    
+    OrientationCorrection?: OrientationCorrection | string;
+    
+    LabelModelVersion?: string;
+}
+export declare namespace DetectLabelsResponse {
+    
+    const filterSensitiveLog: (obj: DetectLabelsResponse) => any;
+}
+
+export interface HumanLoopDataAttributes {
+    
+    ContentClassifiers?: (ContentClassifier | string)[];
+}
+export declare namespace HumanLoopDataAttributes {
+    
+    const filterSensitiveLog: (obj: HumanLoopDataAttributes) => any;
+}
+
+export interface HumanLoopConfig {
+    
+    HumanLoopName: string | undefined;
+    
+    FlowDefinitionArn: string | undefined;
+    
+    DataAttributes?: HumanLoopDataAttributes;
+}
+export declare namespace HumanLoopConfig {
+    
+    const filterSensitiveLog: (obj: HumanLoopConfig) => any;
+}
+export interface DetectModerationLabelsRequest {
+    
+    Image: Image | undefined;
+    
+    MinConfidence?: number;
+    
+    HumanLoopConfig?: HumanLoopConfig;
+}
+export declare namespace DetectModerationLabelsRequest {
+    
+    const filterSensitiveLog: (obj: DetectModerationLabelsRequest) => any;
+}
+
+export interface HumanLoopActivationOutput {
+    
+    HumanLoopArn?: string;
+    
+    HumanLoopActivationReasons?: string[];
+    
+    HumanLoopActivationConditionsEvaluationResults?: __LazyJsonString | string;
+}
+export declare namespace HumanLoopActivationOutput {
+    
+    const filterSensitiveLog: (obj: HumanLoopActivationOutput) => any;
+}
+export interface DetectModerationLabelsResponse {
+    
+    ModerationLabels?: ModerationLabel[];
+    
+    ModerationModelVersion?: string;
+    
+    HumanLoopActivationOutput?: HumanLoopActivationOutput;
+}
+export declare namespace DetectModerationLabelsResponse {
+    
+    const filterSensitiveLog: (obj: DetectModerationLabelsResponse) => any;
+}
+
+export interface HumanLoopQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "HumanLoopQuotaExceededException";
+    $fault: "client";
+    
+    ResourceType?: string;
+    
+    QuotaCode?: string;
+    
+    ServiceCode?: string;
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+
+export interface ProtectiveEquipmentSummarizationAttributes {
+    
+    MinConfidence: number | undefined;
+    
+    RequiredEquipmentTypes: (ProtectiveEquipmentType | string)[] | undefined;
+}
+export declare namespace ProtectiveEquipmentSummarizationAttributes {
+    
+    const filterSensitiveLog: (obj: ProtectiveEquipmentSummarizationAttributes) => any;
+}
+export interface DetectProtectiveEquipmentRequest {
+    
+    Image: Image | undefined;
+    
+    SummarizationAttributes?: ProtectiveEquipmentSummarizationAttributes;
+}
+export declare namespace DetectProtectiveEquipmentRequest {
+    
+    const filterSensitiveLog: (obj: DetectProtectiveEquipmentRequest) => any;
+}
+
+export interface ProtectiveEquipmentPerson {
+    
+    BodyParts?: ProtectiveEquipmentBodyPart[];
+    
+    BoundingBox?: BoundingBox;
+    
+    Confidence?: number;
+    
+    Id?: number;
+}
+export declare namespace ProtectiveEquipmentPerson {
+    
+    const filterSensitiveLog: (obj: ProtectiveEquipmentPerson) => any;
+}
+
+export interface ProtectiveEquipmentSummary {
+    
+    PersonsWithRequiredEquipment?: number[];
+    
+    PersonsWithoutRequiredEquipment?: number[];
+    
+    PersonsIndeterminate?: number[];
+}
+export declare namespace ProtectiveEquipmentSummary {
+    
+    const filterSensitiveLog: (obj: ProtectiveEquipmentSummary) => any;
+}
+export interface DetectProtectiveEquipmentResponse {
+    
+    ProtectiveEquipmentModelVersion?: string;
+    
+    Persons?: ProtectiveEquipmentPerson[];
+    
+    Summary?: ProtectiveEquipmentSummary;
+}
+export declare namespace DetectProtectiveEquipmentResponse {
+    
+    const filterSensitiveLog: (obj: DetectProtectiveEquipmentResponse) => any;
+}
+
+export interface RegionOfInterest {
+    
+    BoundingBox?: BoundingBox;
+}
+export declare namespace RegionOfInterest {
+    
+    const filterSensitiveLog: (obj: RegionOfInterest) => any;
+}
+
+export interface DetectTextFilters {
+    
+    WordFilter?: DetectionFilter;
+    
+    RegionsOfInterest?: RegionOfInterest[];
+}
+export declare namespace DetectTextFilters {
+    
+    const filterSensitiveLog: (obj: DetectTextFilters) => any;
+}
+export interface DetectTextRequest {
+    
+    Image: Image | undefined;
+    
+    Filters?: DetectTextFilters;
+}
+export declare namespace DetectTextRequest {
+    
+    const filterSensitiveLog: (obj: DetectTextRequest) => any;
+}
+export declare enum TextTypes {
+    LINE = "LINE",
+    WORD = "WORD"
+}
+
+export interface TextDetection {
+    
+    DetectedText?: string;
+    
+    Type?: TextTypes | string;
+    
+    Id?: number;
+    
+    ParentId?: number;
+    
+    Confidence?: number;
+    
+    Geometry?: Geometry;
+}
+export declare namespace TextDetection {
+    
+    const filterSensitiveLog: (obj: TextDetection) => any;
+}
+export interface DetectTextResponse {
+    
+    TextDetections?: TextDetection[];
+    
+    TextModelVersion?: string;
+}
+export declare namespace DetectTextResponse {
+    
+    const filterSensitiveLog: (obj: DetectTextResponse) => any;
+}
+
+export interface DistributeDataset {
+    
+    Arn: string | undefined;
+}
+export declare namespace DistributeDataset {
+    
+    const filterSensitiveLog: (obj: DistributeDataset) => any;
+}
+export interface DistributeDatasetEntriesRequest {
+    
+    Datasets: DistributeDataset[] | undefined;
+}
+export declare namespace DistributeDatasetEntriesRequest {
+    
+    const filterSensitiveLog: (obj: DistributeDatasetEntriesRequest) => any;
+}
+export interface DistributeDatasetEntriesResponse {
+}
+export declare namespace DistributeDatasetEntriesResponse {
+    
+    const filterSensitiveLog: (obj: DistributeDatasetEntriesResponse) => any;
+}
+
+export interface Face {
+    
+    FaceId?: string;
+    
+    BoundingBox?: BoundingBox;
+    
+    ImageId?: string;
+    
+    ExternalImageId?: string;
+    
+    Confidence?: number;
+    
+    IndexFacesModelVersion?: string;
+}
+export declare namespace Face {
+    
+    const filterSensitiveLog: (obj: Face) => any;
+}
+export declare enum FaceAttributes {
+    ALL = "ALL",
+    DEFAULT = "DEFAULT"
+}
+
+export interface FaceDetection {
+    
+    Timestamp?: number;
+    
+    Face?: FaceDetail;
+}
+export declare namespace FaceDetection {
+    
+    const filterSensitiveLog: (obj: FaceDetection) => any;
+}
+
+export interface FaceMatch {
+    
+    Similarity?: number;
+    
+    Face?: Face;
+}
+export declare namespace FaceMatch {
+    
+    const filterSensitiveLog: (obj: FaceMatch) => any;
+}
+
+export interface FaceRecord {
+    
+    Face?: Face;
+    
+    FaceDetail?: FaceDetail;
+}
+export declare namespace FaceRecord {
+    
+    const filterSensitiveLog: (obj: FaceRecord) => any;
+}
+export declare enum FaceSearchSortBy {
+    INDEX = "INDEX",
+    TIMESTAMP = "TIMESTAMP"
+}
+export interface GetCelebrityInfoRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetCelebrityInfoRequest {
+    
+    const filterSensitiveLog: (obj: GetCelebrityInfoRequest) => any;
+}
+export interface GetCelebrityInfoResponse {
+    
+    Urls?: string[];
+    
+    Name?: string;
+    
+    KnownGender?: KnownGender;
+}
+export declare namespace GetCelebrityInfoResponse {
+    
+    const filterSensitiveLog: (obj: GetCelebrityInfoResponse) => any;
+}
+export interface GetCelebrityRecognitionRequest {
+    
+    JobId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    SortBy?: CelebrityRecognitionSortBy | string;
+}
+export declare namespace GetCelebrityRecognitionRequest {
+    
+    const filterSensitiveLog: (obj: GetCelebrityRecognitionRequest) => any;
+}
+export declare enum VideoJobStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCEEDED = "SUCCEEDED"
+}
+export declare enum VideoColorRange {
+    FULL = "FULL",
+    LIMITED = "LIMITED"
+}
+
+export interface VideoMetadata {
+    
+    Codec?: string;
+    
+    DurationMillis?: number;
+    
+    Format?: string;
+    
+    FrameRate?: number;
+    
+    FrameHeight?: number;
+    
+    FrameWidth?: number;
+    
+    ColorRange?: VideoColorRange | string;
+}
+export declare namespace VideoMetadata {
+    
+    const filterSensitiveLog: (obj: VideoMetadata) => any;
+}
+export interface GetCelebrityRecognitionResponse {
+    
+    JobStatus?: VideoJobStatus | string;
+    
+    StatusMessage?: string;
+    
+    VideoMetadata?: VideoMetadata;
+    
+    NextToken?: string;
+    
+    Celebrities?: CelebrityRecognition[];
+}
+export declare namespace GetCelebrityRecognitionResponse {
+    
+    const filterSensitiveLog: (obj: GetCelebrityRecognitionResponse) => any;
+}
+export interface GetContentModerationRequest {
+    
+    JobId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    SortBy?: ContentModerationSortBy | string;
+}
+export declare namespace GetContentModerationRequest {
+    
+    const filterSensitiveLog: (obj: GetContentModerationRequest) => any;
+}
+export interface GetContentModerationResponse {
+    
+    JobStatus?: VideoJobStatus | string;
+    
+    StatusMessage?: string;
+    
+    VideoMetadata?: VideoMetadata;
+    
+    ModerationLabels?: ContentModerationDetection[];
+    
+    NextToken?: string;
+    
+    ModerationModelVersion?: string;
+}
+export declare namespace GetContentModerationResponse {
+    
+    const filterSensitiveLog: (obj: GetContentModerationResponse) => any;
+}
+export interface GetFaceDetectionRequest {
+    
+    JobId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetFaceDetectionRequest {
+    
+    const filterSensitiveLog: (obj: GetFaceDetectionRequest) => any;
+}
+export interface GetFaceDetectionResponse {
+    
+    JobStatus?: VideoJobStatus | string;
+    
+    StatusMessage?: string;
+    
+    VideoMetadata?: VideoMetadata;
+    
+    NextToken?: string;
+    
+    Faces?: FaceDetection[];
+}
+export declare namespace GetFaceDetectionResponse {
+    
+    const filterSensitiveLog: (obj: GetFaceDetectionResponse) => any;
+}
+export interface GetFaceSearchRequest {
+    
+    JobId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    SortBy?: FaceSearchSortBy | string;
+}
+export declare namespace GetFaceSearchRequest {
+    
+    const filterSensitiveLog: (obj: GetFaceSearchRequest) => any;
+}
+
+export interface PersonDetail {
+    
+    Index?: number;
+    
+    BoundingBox?: BoundingBox;
+    
+    Face?: FaceDetail;
+}
+export declare namespace PersonDetail {
+    
+    const filterSensitiveLog: (obj: PersonDetail) => any;
+}
+
+export interface PersonMatch {
+    
+    Timestamp?: number;
+    
+    Person?: PersonDetail;
+    
+    FaceMatches?: FaceMatch[];
+}
+export declare namespace PersonMatch {
+    
+    const filterSensitiveLog: (obj: PersonMatch) => any;
+}
+export interface GetFaceSearchResponse {
+    
+    JobStatus?: VideoJobStatus | string;
+    
+    StatusMessage?: string;
+    
+    NextToken?: string;
+    
+    VideoMetadata?: VideoMetadata;
+    
+    Persons?: PersonMatch[];
+}
+export declare namespace GetFaceSearchResponse {
+    
+    const filterSensitiveLog: (obj: GetFaceSearchResponse) => any;
+}
+export declare enum LabelDetectionSortBy {
+    NAME = "NAME",
+    TIMESTAMP = "TIMESTAMP"
+}
+export interface GetLabelDetectionRequest {
+    
+    JobId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    SortBy?: LabelDetectionSortBy | string;
+}
+export declare namespace GetLabelDetectionRequest {
+    
+    const filterSensitiveLog: (obj: GetLabelDetectionRequest) => any;
+}
+
+export interface LabelDetection {
+    
+    Timestamp?: number;
+    
+    Label?: Label;
+}
+export declare namespace LabelDetection {
+    
+    const filterSensitiveLog: (obj: LabelDetection) => any;
+}
+export interface GetLabelDetectionResponse {
+    
+    JobStatus?: VideoJobStatus | string;
+    
+    StatusMessage?: string;
+    
+    VideoMetadata?: VideoMetadata;
+    
+    NextToken?: string;
+    
+    Labels?: LabelDetection[];
+    
+    LabelModelVersion?: string;
+}
+export declare namespace GetLabelDetectionResponse {
+    
+    const filterSensitiveLog: (obj: GetLabelDetectionResponse) => any;
+}
+export declare enum PersonTrackingSortBy {
+    INDEX = "INDEX",
+    TIMESTAMP = "TIMESTAMP"
+}
+export interface GetPersonTrackingRequest {
+    
+    JobId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    SortBy?: PersonTrackingSortBy | string;
+}
+export declare namespace GetPersonTrackingRequest {
+    
+    const filterSensitiveLog: (obj: GetPersonTrackingRequest) => any;
+}
+
+export interface PersonDetection {
+    
+    Timestamp?: number;
+    
+    Person?: PersonDetail;
+}
+export declare namespace PersonDetection {
+    
+    const filterSensitiveLog: (obj: PersonDetection) => any;
+}
+export interface GetPersonTrackingResponse {
+    
+    JobStatus?: VideoJobStatus | string;
+    
+    StatusMessage?: string;
+    
+    VideoMetadata?: VideoMetadata;
+    
+    NextToken?: string;
+    
+    Persons?: PersonDetection[];
+}
+export declare namespace GetPersonTrackingResponse {
+    
+    const filterSensitiveLog: (obj: GetPersonTrackingResponse) => any;
+}
+export interface GetSegmentDetectionRequest {
+    
+    JobId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetSegmentDetectionRequest {
+    
+    const filterSensitiveLog: (obj: GetSegmentDetectionRequest) => any;
+}
+
+export interface ShotSegment {
+    
+    Index?: number;
+    
+    Confidence?: number;
+}
+export declare namespace ShotSegment {
+    
+    const filterSensitiveLog: (obj: ShotSegment) => any;
+}
+export declare enum TechnicalCueType {
+    BLACK_FRAMES = "BlackFrames",
+    COLOR_BARS = "ColorBars",
+    CONTENT = "Content",
+    END_CREDITS = "EndCredits",
+    OPENING_CREDITS = "OpeningCredits",
+    SLATE = "Slate",
+    STUDIO_LOGO = "StudioLogo"
+}
+
+export interface TechnicalCueSegment {
+    
+    Type?: TechnicalCueType | string;
+    
+    Confidence?: number;
+}
+export declare namespace TechnicalCueSegment {
+    
+    const filterSensitiveLog: (obj: TechnicalCueSegment) => any;
+}
+export declare enum SegmentType {
+    SHOT = "SHOT",
+    TECHNICAL_CUE = "TECHNICAL_CUE"
+}
+
+export interface SegmentDetection {
+    
+    Type?: SegmentType | string;
+    
+    StartTimestampMillis?: number;
+    
+    EndTimestampMillis?: number;
+    
+    DurationMillis?: number;
+    
+    StartTimecodeSMPTE?: string;
+    
+    EndTimecodeSMPTE?: string;
+    
+    DurationSMPTE?: string;
+    
+    TechnicalCueSegment?: TechnicalCueSegment;
+    
+    ShotSegment?: ShotSegment;
+    
+    StartFrameNumber?: number;
+    
+    EndFrameNumber?: number;
+    
+    DurationFrames?: number;
+}
+export declare namespace SegmentDetection {
+    
+    const filterSensitiveLog: (obj: SegmentDetection) => any;
+}
+
+export interface SegmentTypeInfo {
+    
+    Type?: SegmentType | string;
+    
+    ModelVersion?: string;
+}
+export declare namespace SegmentTypeInfo {
+    
+    const filterSensitiveLog: (obj: SegmentTypeInfo) => any;
+}
+export interface GetSegmentDetectionResponse {
+    
+    JobStatus?: VideoJobStatus | string;
+    
+    StatusMessage?: string;
+    
+    VideoMetadata?: VideoMetadata[];
+    
+    AudioMetadata?: AudioMetadata[];
+    
+    NextToken?: string;
+    
+    Segments?: SegmentDetection[];
+    
+    SelectedSegmentTypes?: SegmentTypeInfo[];
+}
+export declare namespace GetSegmentDetectionResponse {
+    
+    const filterSensitiveLog: (obj: GetSegmentDetectionResponse) => any;
+}
+export interface GetTextDetectionRequest {
+    
+    JobId: string | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetTextDetectionRequest {
+    
+    const filterSensitiveLog: (obj: GetTextDetectionRequest) => any;
+}
+
+export interface TextDetectionResult {
+    
+    Timestamp?: number;
+    
+    TextDetection?: TextDetection;
+}
+export declare namespace TextDetectionResult {
+    
+    const filterSensitiveLog: (obj: TextDetectionResult) => any;
+}
+export interface GetTextDetectionResponse {
+    
+    JobStatus?: VideoJobStatus | string;
+    
+    StatusMessage?: string;
+    
+    VideoMetadata?: VideoMetadata;
+    
+    TextDetections?: TextDetectionResult[];
+    
+    NextToken?: string;
+    
+    TextModelVersion?: string;
+}
+export declare namespace GetTextDetectionResponse {
+    
+    const filterSensitiveLog: (obj: GetTextDetectionResponse) => any;
+}
+
+export interface IdempotentParameterMismatchException extends __SmithyException, $MetadataBearer {
+    name: "IdempotentParameterMismatchException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+export interface IndexFacesRequest {
+    
+    CollectionId: string | undefined;
+    
+    Image: Image | undefined;
+    
+    ExternalImageId?: string;
+    
+    DetectionAttributes?: (Attribute | string)[];
+    
+    MaxFaces?: number;
+    
+    QualityFilter?: QualityFilter | string;
+}
+export declare namespace IndexFacesRequest {
+    
+    const filterSensitiveLog: (obj: IndexFacesRequest) => any;
+}
+export declare enum Reason {
+    EXCEEDS_MAX_FACES = "EXCEEDS_MAX_FACES",
+    EXTREME_POSE = "EXTREME_POSE",
+    LOW_BRIGHTNESS = "LOW_BRIGHTNESS",
+    LOW_CONFIDENCE = "LOW_CONFIDENCE",
+    LOW_FACE_QUALITY = "LOW_FACE_QUALITY",
+    LOW_SHARPNESS = "LOW_SHARPNESS",
+    SMALL_BOUNDING_BOX = "SMALL_BOUNDING_BOX"
+}
+
+export interface UnindexedFace {
+    
+    Reasons?: (Reason | string)[];
+    
+    FaceDetail?: FaceDetail;
+}
+export declare namespace UnindexedFace {
+    
+    const filterSensitiveLog: (obj: UnindexedFace) => any;
+}
+export interface IndexFacesResponse {
+    
+    FaceRecords?: FaceRecord[];
+    
+    OrientationCorrection?: OrientationCorrection | string;
+    
+    FaceModelVersion?: string;
+    
+    UnindexedFaces?: UnindexedFace[];
+}
+export declare namespace IndexFacesResponse {
+    
+    const filterSensitiveLog: (obj: IndexFacesResponse) => any;
+}
+export interface ListCollectionsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListCollectionsRequest {
+    
+    const filterSensitiveLog: (obj: ListCollectionsRequest) => any;
+}
+export interface ListCollectionsResponse {
+    
+    CollectionIds?: string[];
+    
+    NextToken?: string;
+    
+    FaceModelVersions?: string[];
+}
+export declare namespace ListCollectionsResponse {
+    
+    const filterSensitiveLog: (obj: ListCollectionsResponse) => any;
+}
+export interface ListDatasetEntriesRequest {
+    
+    DatasetArn: string | undefined;
+    
+    ContainsLabels?: string[];
+    
+    Labeled?: boolean;
+    
+    SourceRefContains?: string;
+    
+    HasErrors?: boolean;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDatasetEntriesRequest {
+    
+    const filterSensitiveLog: (obj: ListDatasetEntriesRequest) => any;
+}
+export interface ListDatasetEntriesResponse {
+    
+    DatasetEntries?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDatasetEntriesResponse {
+    
+    const filterSensitiveLog: (obj: ListDatasetEntriesResponse) => any;
+}
+export interface ListDatasetLabelsRequest {
+    
+    DatasetArn: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDatasetLabelsRequest {
+    
+    const filterSensitiveLog: (obj: ListDatasetLabelsRequest) => any;
+}
+export interface ListDatasetLabelsResponse {
+    
+    DatasetLabelDescriptions?: DatasetLabelDescription[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDatasetLabelsResponse {
+    
+    const filterSensitiveLog: (obj: ListDatasetLabelsResponse) => any;
+}
+export interface ListFacesRequest {
+    
+    CollectionId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListFacesRequest {
+    
+    const filterSensitiveLog: (obj: ListFacesRequest) => any;
+}
+export interface ListFacesResponse {
+    
+    Faces?: Face[];
+    
+    NextToken?: string;
+    
+    FaceModelVersion?: string;
+}
+export declare namespace ListFacesResponse {
+    
+    const filterSensitiveLog: (obj: ListFacesResponse) => any;
+}
+export interface ListStreamProcessorsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListStreamProcessorsRequest {
+    
+    const filterSensitiveLog: (obj: ListStreamProcessorsRequest) => any;
+}
+
+export interface StreamProcessor {
+    
+    Name?: string;
+    
+    Status?: StreamProcessorStatus | string;
+}
+export declare namespace StreamProcessor {
+    
+    const filterSensitiveLog: (obj: StreamProcessor) => any;
+}
+export interface ListStreamProcessorsResponse {
+    
+    NextToken?: string;
+    
+    StreamProcessors?: StreamProcessor[];
+}
+export declare namespace ListStreamProcessorsResponse {
+    
+    const filterSensitiveLog: (obj: ListStreamProcessorsResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+
+export interface NotificationChannel {
+    
+    SNSTopicArn: string | undefined;
+    
+    RoleArn: string | undefined;
+}
+export declare namespace NotificationChannel {
+    
+    const filterSensitiveLog: (obj: NotificationChannel) => any;
+}
+export interface RecognizeCelebritiesRequest {
+    
+    Image: Image | undefined;
+}
+export declare namespace RecognizeCelebritiesRequest {
+    
+    const filterSensitiveLog: (obj: RecognizeCelebritiesRequest) => any;
+}
+export interface RecognizeCelebritiesResponse {
+    
+    CelebrityFaces?: Celebrity[];
+    
+    UnrecognizedFaces?: ComparedFace[];
+    
+    OrientationCorrection?: OrientationCorrection | string;
+}
+export declare namespace RecognizeCelebritiesResponse {
+    
+    const filterSensitiveLog: (obj: RecognizeCelebritiesResponse) => any;
+}
+export interface SearchFacesRequest {
+    
+    CollectionId: string | undefined;
+    
+    FaceId: string | undefined;
+    
+    MaxFaces?: number;
+    
+    FaceMatchThreshold?: number;
+}
+export declare namespace SearchFacesRequest {
+    
+    const filterSensitiveLog: (obj: SearchFacesRequest) => any;
+}
+export interface SearchFacesResponse {
+    
+    SearchedFaceId?: string;
+    
+    FaceMatches?: FaceMatch[];
+    
+    FaceModelVersion?: string;
+}
+export declare namespace SearchFacesResponse {
+    
+    const filterSensitiveLog: (obj: SearchFacesResponse) => any;
+}
+export interface SearchFacesByImageRequest {
+    
+    CollectionId: string | undefined;
+    
+    Image: Image | undefined;
+    
+    MaxFaces?: number;
+    
+    FaceMatchThreshold?: number;
+    
+    QualityFilter?: QualityFilter | string;
+}
+export declare namespace SearchFacesByImageRequest {
+    
+    const filterSensitiveLog: (obj: SearchFacesByImageRequest) => any;
+}
+export interface SearchFacesByImageResponse {
+    
+    SearchedFaceBoundingBox?: BoundingBox;
+    
+    SearchedFaceConfidence?: number;
+    
+    FaceMatches?: FaceMatch[];
+    
+    FaceModelVersion?: string;
+}
+export declare namespace SearchFacesByImageResponse {
+    
+    const filterSensitiveLog: (obj: SearchFacesByImageResponse) => any;
+}
+
+export interface Video {
+    
+    S3Object?: S3Object;
+}
+export declare namespace Video {
+    
+    const filterSensitiveLog: (obj: Video) => any;
+}
+export interface StartCelebrityRecognitionRequest {
+    
+    Video: Video | undefined;
+    
+    ClientRequestToken?: string;
+    
+    NotificationChannel?: NotificationChannel;
+    
+    JobTag?: string;
+}
+export declare namespace StartCelebrityRecognitionRequest {
+    
+    const filterSensitiveLog: (obj: StartCelebrityRecognitionRequest) => any;
+}
+export interface StartCelebrityRecognitionResponse {
+    
+    JobId?: string;
+}
+export declare namespace StartCelebrityRecognitionResponse {
+    
+    const filterSensitiveLog: (obj: StartCelebrityRecognitionResponse) => any;
+}
+
+export interface VideoTooLargeException extends __SmithyException, $MetadataBearer {
+    name: "VideoTooLargeException";
+    $fault: "client";
+    Message?: string;
+    Code?: string;
+    
+    Logref?: string;
+}
+export interface StartContentModerationRequest {
+    
+    Video: Video | undefined;
+    
+    MinConfidence?: number;
+    
+    ClientRequestToken?: string;
+    
+    NotificationChannel?: NotificationChannel;
+    
+    JobTag?: string;
+}
+export declare namespace StartContentModerationRequest {
+    
+    const filterSensitiveLog: (obj: StartContentModerationRequest) => any;
+}
+export interface StartContentModerationResponse {
+    
+    JobId?: string;
+}
+export declare namespace StartContentModerationResponse {
+    
+    const filterSensitiveLog: (obj: StartContentModerationResponse) => any;
+}
+export interface StartFaceDetectionRequest {
+    
+    Video: Video | undefined;
+    
+    ClientRequestToken?: string;
+    
+    NotificationChannel?: NotificationChannel;
+    
+    FaceAttributes?: FaceAttributes | string;
+    
+    JobTag?: string;
+}
+export declare namespace StartFaceDetectionRequest {
+    
+    const filterSensitiveLog: (obj: StartFaceDetectionRequest) => any;
+}
+export interface StartFaceDetectionResponse {
+    
+    JobId?: string;
+}
+export declare namespace StartFaceDetectionResponse {
+    
+    const filterSensitiveLog: (obj: StartFaceDetectionResponse) => any;
+}
+export interface StartFaceSearchRequest {
+    
+    Video: Video | undefined;
+    
+    ClientRequestToken?: string;
+    
+    FaceMatchThreshold?: number;
+    
+    CollectionId: string | undefined;
+    
+    NotificationChannel?: NotificationChannel;
+    
+    JobTag?: string;
+}
+export declare namespace StartFaceSearchRequest {
+    
+    const filterSensitiveLog: (obj: StartFaceSearchRequest) => any;
+}
+export interface StartFaceSearchResponse {
+    
+    JobId?: string;
+}
+export declare namespace StartFaceSearchResponse {
+    
+    const filterSensitiveLog: (obj: StartFaceSearchResponse) => any;
+}
+export interface StartLabelDetectionRequest {
+    
+    Video: Video | undefined;
+    
+    ClientRequestToken?: string;
+    
+    MinConfidence?: number;
+    
+    NotificationChannel?: NotificationChannel;
+    
+    JobTag?: string;
+}
+export declare namespace StartLabelDetectionRequest {
+    
+    const filterSensitiveLog: (obj: StartLabelDetectionRequest) => any;
+}
+export interface StartLabelDetectionResponse {
+    
+    JobId?: string;
+}
+export declare namespace StartLabelDetectionResponse {
+    
+    const filterSensitiveLog: (obj: StartLabelDetectionResponse) => any;
+}
+export interface StartPersonTrackingRequest {
+    
+    Video: Video | undefined;
+    
+    ClientRequestToken?: string;
+    
+    NotificationChannel?: NotificationChannel;
+    
+    JobTag?: string;
+}
+export declare namespace StartPersonTrackingRequest {
+    
+    const filterSensitiveLog: (obj: StartPersonTrackingRequest) => any;
+}
+export interface StartPersonTrackingResponse {
+    
+    JobId?: string;
+}
+export declare namespace StartPersonTrackingResponse {
+    
+    const filterSensitiveLog: (obj: StartPersonTrackingResponse) => any;
+}
+export interface StartProjectVersionRequest {
+    
+    ProjectVersionArn: string | undefined;
+    
+    MinInferenceUnits: number | undefined;
+}
+export declare namespace StartProjectVersionRequest {
+    
+    const filterSensitiveLog: (obj: StartProjectVersionRequest) => any;
+}
+export interface StartProjectVersionResponse {
+    
+    Status?: ProjectVersionStatus | string;
+}
+export declare namespace StartProjectVersionResponse {
+    
+    const filterSensitiveLog: (obj: StartProjectVersionResponse) => any;
+}
+
+export interface StartShotDetectionFilter {
+    
+    MinSegmentConfidence?: number;
+}
+export declare namespace StartShotDetectionFilter {
+    
+    const filterSensitiveLog: (obj: StartShotDetectionFilter) => any;
+}
+
+export interface StartTechnicalCueDetectionFilter {
+    
+    MinSegmentConfidence?: number;
+    
+    BlackFrame?: BlackFrame;
+}
+export declare namespace StartTechnicalCueDetectionFilter {
+    
+    const filterSensitiveLog: (obj: StartTechnicalCueDetectionFilter) => any;
+}
+
+export interface StartSegmentDetectionFilters {
+    
+    TechnicalCueFilter?: StartTechnicalCueDetectionFilter;
+    
+    ShotFilter?: StartShotDetectionFilter;
+}
+export declare namespace StartSegmentDetectionFilters {
+    
+    const filterSensitiveLog: (obj: StartSegmentDetectionFilters) => any;
+}
+export interface StartSegmentDetectionRequest {
+    
+    Video: Video | undefined;
+    
+    ClientRequestToken?: string;
+    
+    NotificationChannel?: NotificationChannel;
+    
+    JobTag?: string;
+    
+    Filters?: StartSegmentDetectionFilters;
+    
+    SegmentTypes: (SegmentType | string)[] | undefined;
+}
+export declare namespace StartSegmentDetectionRequest {
+    
+    const filterSensitiveLog: (obj: StartSegmentDetectionRequest) => any;
+}
+export interface StartSegmentDetectionResponse {
+    
+    JobId?: string;
+}
+export declare namespace StartSegmentDetectionResponse {
+    
+    const filterSensitiveLog: (obj: StartSegmentDetectionResponse) => any;
+}
+export interface StartStreamProcessorRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace StartStreamProcessorRequest {
+    
+    const filterSensitiveLog: (obj: StartStreamProcessorRequest) => any;
+}
+export interface StartStreamProcessorResponse {
+}
+export declare namespace StartStreamProcessorResponse {
+    
+    const filterSensitiveLog: (obj: StartStreamProcessorResponse) => any;
+}
+
+export interface StartTextDetectionFilters {
+    
+    WordFilter?: DetectionFilter;
+    
+    RegionsOfInterest?: RegionOfInterest[];
+}
+export declare namespace StartTextDetectionFilters {
+    
+    const filterSensitiveLog: (obj: StartTextDetectionFilters) => any;
+}
+export interface StartTextDetectionRequest {
+    
+    Video: Video | undefined;
+    
+    ClientRequestToken?: string;
+    
+    NotificationChannel?: NotificationChannel;
+    
+    JobTag?: string;
+    
+    Filters?: StartTextDetectionFilters;
+}
+export declare namespace StartTextDetectionRequest {
+    
+    const filterSensitiveLog: (obj: StartTextDetectionRequest) => any;
+}
+export interface StartTextDetectionResponse {
+    
+    JobId?: string;
+}
+export declare namespace StartTextDetectionResponse {
+    
+    const filterSensitiveLog: (obj: StartTextDetectionResponse) => any;
+}
+export interface StopProjectVersionRequest {
+    
+    ProjectVersionArn: string | undefined;
+}
+export declare namespace StopProjectVersionRequest {
+    
+    const filterSensitiveLog: (obj: StopProjectVersionRequest) => any;
+}
+export interface StopProjectVersionResponse {
+    
+    Status?: ProjectVersionStatus | string;
+}
+export declare namespace StopProjectVersionResponse {
+    
+    const filterSensitiveLog: (obj: StopProjectVersionResponse) => any;
+}
+export interface StopStreamProcessorRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace StopStreamProcessorRequest {
+    
+    const filterSensitiveLog: (obj: StopStreamProcessorRequest) => any;
+}
+export interface StopStreamProcessorResponse {
+}
+export declare namespace StopStreamProcessorResponse {
+    
+    const filterSensitiveLog: (obj: StopStreamProcessorResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateDatasetEntriesRequest {
+    
+    DatasetArn: string | undefined;
+    
+    Changes: DatasetChanges | undefined;
+}
+export declare namespace UpdateDatasetEntriesRequest {
+    
+    const filterSensitiveLog: (obj: UpdateDatasetEntriesRequest) => any;
+}
+export interface UpdateDatasetEntriesResponse {
+}
+export declare namespace UpdateDatasetEntriesResponse {
+    
+    const filterSensitiveLog: (obj: UpdateDatasetEntriesResponse) => any;
+}