// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// <p>Compares a face in the <i>source</i> input image with
/// each of the 100 largest faces detected in the <i>target</i> input image.
/// </p>
/// <p> If the source image contains multiple faces, the service detects the largest face
/// and compares it with each face detected in the target image. </p>
/// <note>
/// <p>CompareFaces uses machine learning algorithms, which are probabilistic.
/// A false negative is an incorrect prediction that
/// a face in the target image has a low similarity confidence score when compared to the face
/// in the source image. To reduce the probability of false negatives,
/// we recommend that you compare the target image against multiple source images.
/// If you plan to use <code>CompareFaces</code> to make a decision that impacts an individual's rights,
/// privacy, or access to services, we recommend that you pass the result to a human for review and further
/// validation before taking action.</p>
/// </note>
/// <p>You pass the input and target images either as base64-encoded image bytes or as
/// references to images in an Amazon S3 bucket. If you use the
/// AWS
/// CLI to call Amazon Rekognition operations, passing image bytes isn't
/// supported. The image must be formatted as a PNG or JPEG file. </p>
/// <p>In response, the operation returns an array of face matches ordered by similarity score
/// in descending order. For each face match, the response provides a bounding box of the face,
/// facial landmarks, pose details (pitch, role, and yaw), quality (brightness and sharpness), and
/// confidence value (indicating the level of confidence that the bounding box contains a face).
/// The response also provides a similarity score, which indicates how closely the faces match. </p>
/// <note>
/// <p>By default, only faces with a similarity score of greater than or equal to 80% are
/// returned in the response. You can change this value by specifying the
/// <code>SimilarityThreshold</code> parameter.</p>
/// </note>
/// <p>
/// <code>CompareFaces</code> also returns an array of faces that don't match the source image.
/// For each face, it returns a bounding box, confidence value, landmarks, pose details, and quality.
/// The response also returns information about the face in the source image, including the bounding box
/// of the face and confidence value.</p>
/// <p>The <code>QualityFilter</code> input parameter allows you to filter out detected faces
/// that don’t meet a required quality bar. The quality bar is based on a
/// variety of common use cases.  Use <code>QualityFilter</code> to set the quality bar
/// by specifying <code>LOW</code>, <code>MEDIUM</code>, or <code>HIGH</code>.
/// If you do not want to filter detected faces, specify <code>NONE</code>. The default value is <code>NONE</code>. </p>
/// <p>If the image doesn't contain Exif metadata, <code>CompareFaces</code> returns orientation information for the
/// source and target images. Use these values to display the images with the correct image orientation.</p>
/// <p>If no faces are detected in the source or target images, <code>CompareFaces</code> returns an
/// <code>InvalidParameterException</code> error. </p>
/// <note>
/// <p> This is a stateless API operation. That is, data returned by this operation doesn't persist.</p>
/// </note>
/// <p>For an example, see Comparing Faces in Images in the Amazon Rekognition Developer Guide.</p>
/// <p>This operation requires permissions to perform the <code>rekognition:CompareFaces</code>
/// action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CompareFaces {
    _private: (),
}
impl CompareFaces {
    /// Creates a new builder-style object to manufacture [`CompareFacesInput`](crate::input::CompareFacesInput)
    pub fn builder() -> crate::input::compare_faces_input::Builder {
        crate::input::compare_faces_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for CompareFaces {
    type Output =
        std::result::Result<crate::output::CompareFacesOutput, crate::error::CompareFacesError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_compare_faces_error(response)
        } else {
            crate::operation_deser::parse_compare_faces_response(response)
        }
    }
}

/// <p>Creates a collection in an AWS Region. You can add faces to the collection using the
/// <a>IndexFaces</a> operation. </p>
/// <p>For example, you might create collections, one for each of your application users. A
/// user can then index faces using the <code>IndexFaces</code> operation and persist results in a
/// specific collection. Then, a user can search the collection for faces in the user-specific
/// container. </p>
/// <p>When you create a collection, it is associated with the latest version of the face model version.</p>
/// <note>
/// <p>Collection names are case-sensitive.</p>
/// </note>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:CreateCollection</code> action. If you want to tag your collection, you also require permission to perform the <code>rekognition:TagResource</code> operation.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateCollection {
    _private: (),
}
impl CreateCollection {
    /// Creates a new builder-style object to manufacture [`CreateCollectionInput`](crate::input::CreateCollectionInput)
    pub fn builder() -> crate::input::create_collection_input::Builder {
        crate::input::create_collection_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for CreateCollection {
    type Output = std::result::Result<
        crate::output::CreateCollectionOutput,
        crate::error::CreateCollectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_collection_error(response)
        } else {
            crate::operation_deser::parse_create_collection_response(response)
        }
    }
}

/// <p>Creates a new Amazon Rekognition Custom Labels project. A project is a logical grouping of resources (images, Labels, models)
/// and operations (training, evaluation and detection).  </p>
/// <p>This operation requires permissions to perform the <code>rekognition:CreateProject</code> action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateProject {
    _private: (),
}
impl CreateProject {
    /// Creates a new builder-style object to manufacture [`CreateProjectInput`](crate::input::CreateProjectInput)
    pub fn builder() -> crate::input::create_project_input::Builder {
        crate::input::create_project_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for CreateProject {
    type Output =
        std::result::Result<crate::output::CreateProjectOutput, crate::error::CreateProjectError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_project_error(response)
        } else {
            crate::operation_deser::parse_create_project_response(response)
        }
    }
}

/// <p>Creates a new version of a model and begins training.
/// Models are managed as part of an Amazon Rekognition Custom Labels project.  You can specify
/// one training dataset and one testing dataset. The response from <code>CreateProjectVersion</code>
/// is an Amazon Resource Name (ARN) for the version of the model. </p>
/// <p>Training takes a while to complete. You can get the current status by calling
/// <a>DescribeProjectVersions</a>.</p>
/// <p>Once training has successfully completed, call <a>DescribeProjectVersions</a> to
/// get the training results and evaluate the model.                 
/// </p>
/// <p>After evaluating the model, you start the model
/// by calling <a>StartProjectVersion</a>.</p>
/// <p>This operation requires permissions to perform the <code>rekognition:CreateProjectVersion</code> action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateProjectVersion {
    _private: (),
}
impl CreateProjectVersion {
    /// Creates a new builder-style object to manufacture [`CreateProjectVersionInput`](crate::input::CreateProjectVersionInput)
    pub fn builder() -> crate::input::create_project_version_input::Builder {
        crate::input::create_project_version_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for CreateProjectVersion {
    type Output = std::result::Result<
        crate::output::CreateProjectVersionOutput,
        crate::error::CreateProjectVersionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_project_version_error(response)
        } else {
            crate::operation_deser::parse_create_project_version_response(response)
        }
    }
}

/// <p>Creates an Amazon Rekognition stream processor that you can use to detect and recognize faces in a streaming video.</p>
/// <p>Amazon Rekognition Video is a consumer of live video from Amazon Kinesis Video Streams. Amazon Rekognition Video sends analysis results to Amazon Kinesis Data Streams.</p>
/// <p>You provide as input a Kinesis video stream (<code>Input</code>) and a Kinesis data stream (<code>Output</code>) stream. You also specify the
/// face recognition criteria in <code>Settings</code>. For example, the collection containing faces that you want to recognize.
/// Use <code>Name</code> to assign an identifier for the stream processor. You use <code>Name</code>
/// to manage the stream processor. For example, you can start processing the source video by calling <a>StartStreamProcessor</a> with
/// the <code>Name</code> field. </p>
/// <p>After you have finished analyzing a streaming video, use <a>StopStreamProcessor</a> to
/// stop processing. You can delete the stream processor by calling <a>DeleteStreamProcessor</a>.</p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:CreateStreamProcessor</code> action. If you want to tag your stream processor, you also require permission to perform the <code>rekognition:TagResource</code> operation.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct CreateStreamProcessor {
    _private: (),
}
impl CreateStreamProcessor {
    /// Creates a new builder-style object to manufacture [`CreateStreamProcessorInput`](crate::input::CreateStreamProcessorInput)
    pub fn builder() -> crate::input::create_stream_processor_input::Builder {
        crate::input::create_stream_processor_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for CreateStreamProcessor {
    type Output = std::result::Result<
        crate::output::CreateStreamProcessorOutput,
        crate::error::CreateStreamProcessorError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_create_stream_processor_error(response)
        } else {
            crate::operation_deser::parse_create_stream_processor_response(response)
        }
    }
}

/// <p>Deletes the specified collection. Note that this operation
/// removes all faces in the collection. For an example, see <a>delete-collection-procedure</a>.</p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:DeleteCollection</code> action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteCollection {
    _private: (),
}
impl DeleteCollection {
    /// Creates a new builder-style object to manufacture [`DeleteCollectionInput`](crate::input::DeleteCollectionInput)
    pub fn builder() -> crate::input::delete_collection_input::Builder {
        crate::input::delete_collection_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteCollection {
    type Output = std::result::Result<
        crate::output::DeleteCollectionOutput,
        crate::error::DeleteCollectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_collection_error(response)
        } else {
            crate::operation_deser::parse_delete_collection_response(response)
        }
    }
}

/// <p>Deletes faces from a collection. You specify a collection ID and an array of face IDs
/// to remove from the collection.</p>
/// <p>This operation requires permissions to perform the <code>rekognition:DeleteFaces</code>
/// action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteFaces {
    _private: (),
}
impl DeleteFaces {
    /// Creates a new builder-style object to manufacture [`DeleteFacesInput`](crate::input::DeleteFacesInput)
    pub fn builder() -> crate::input::delete_faces_input::Builder {
        crate::input::delete_faces_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteFaces {
    type Output =
        std::result::Result<crate::output::DeleteFacesOutput, crate::error::DeleteFacesError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_faces_error(response)
        } else {
            crate::operation_deser::parse_delete_faces_response(response)
        }
    }
}

/// <p>Deletes an Amazon Rekognition Custom Labels project.  To delete a project you must first delete all models associated
/// with the project. To delete a model, see <a>DeleteProjectVersion</a>.</p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:DeleteProject</code> action. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteProject {
    _private: (),
}
impl DeleteProject {
    /// Creates a new builder-style object to manufacture [`DeleteProjectInput`](crate::input::DeleteProjectInput)
    pub fn builder() -> crate::input::delete_project_input::Builder {
        crate::input::delete_project_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteProject {
    type Output =
        std::result::Result<crate::output::DeleteProjectOutput, crate::error::DeleteProjectError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_project_error(response)
        } else {
            crate::operation_deser::parse_delete_project_response(response)
        }
    }
}

/// <p>Deletes an Amazon Rekognition Custom Labels model.  </p>
/// <p>You can't delete a model if it is running or if it is training.
/// To check the status of a model, use the <code>Status</code> field returned
/// from <a>DescribeProjectVersions</a>.
/// To stop a running model call <a>StopProjectVersion</a>. If the model
/// is training, wait until it finishes.</p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:DeleteProjectVersion</code> action. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteProjectVersion {
    _private: (),
}
impl DeleteProjectVersion {
    /// Creates a new builder-style object to manufacture [`DeleteProjectVersionInput`](crate::input::DeleteProjectVersionInput)
    pub fn builder() -> crate::input::delete_project_version_input::Builder {
        crate::input::delete_project_version_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteProjectVersion {
    type Output = std::result::Result<
        crate::output::DeleteProjectVersionOutput,
        crate::error::DeleteProjectVersionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_project_version_error(response)
        } else {
            crate::operation_deser::parse_delete_project_version_response(response)
        }
    }
}

/// <p>Deletes the stream processor identified by <code>Name</code>. You assign the value for <code>Name</code> when you create the stream processor with
/// <a>CreateStreamProcessor</a>. You might not be able to use the same name for a stream processor for a few seconds after calling <code>DeleteStreamProcessor</code>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DeleteStreamProcessor {
    _private: (),
}
impl DeleteStreamProcessor {
    /// Creates a new builder-style object to manufacture [`DeleteStreamProcessorInput`](crate::input::DeleteStreamProcessorInput)
    pub fn builder() -> crate::input::delete_stream_processor_input::Builder {
        crate::input::delete_stream_processor_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DeleteStreamProcessor {
    type Output = std::result::Result<
        crate::output::DeleteStreamProcessorOutput,
        crate::error::DeleteStreamProcessorError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_delete_stream_processor_error(response)
        } else {
            crate::operation_deser::parse_delete_stream_processor_response(response)
        }
    }
}

/// <p>Describes the specified collection. You can use <code>DescribeCollection</code> to get
/// information, such as the number of faces indexed into a collection and the version of the
/// model used by the collection for face detection.</p>
/// <p>For more information, see Describing a Collection in the
/// Amazon Rekognition Developer Guide.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DescribeCollection {
    _private: (),
}
impl DescribeCollection {
    /// Creates a new builder-style object to manufacture [`DescribeCollectionInput`](crate::input::DescribeCollectionInput)
    pub fn builder() -> crate::input::describe_collection_input::Builder {
        crate::input::describe_collection_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DescribeCollection {
    type Output = std::result::Result<
        crate::output::DescribeCollectionOutput,
        crate::error::DescribeCollectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_describe_collection_error(response)
        } else {
            crate::operation_deser::parse_describe_collection_response(response)
        }
    }
}

/// <p>Lists and gets information about your Amazon Rekognition Custom Labels projects.</p>
/// <p>This operation requires permissions to perform the <code>rekognition:DescribeProjects</code> action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DescribeProjects {
    _private: (),
}
impl DescribeProjects {
    /// Creates a new builder-style object to manufacture [`DescribeProjectsInput`](crate::input::DescribeProjectsInput)
    pub fn builder() -> crate::input::describe_projects_input::Builder {
        crate::input::describe_projects_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DescribeProjects {
    type Output = std::result::Result<
        crate::output::DescribeProjectsOutput,
        crate::error::DescribeProjectsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_describe_projects_error(response)
        } else {
            crate::operation_deser::parse_describe_projects_response(response)
        }
    }
}

/// <p>Lists and describes the models in an Amazon Rekognition Custom Labels project. You
/// can specify up to 10 model versions in <code>ProjectVersionArns</code>. If
/// you don't specify a value, descriptions for all models are returned.</p>
/// <p>This operation requires permissions to perform the <code>rekognition:DescribeProjectVersions</code>
/// action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DescribeProjectVersions {
    _private: (),
}
impl DescribeProjectVersions {
    /// Creates a new builder-style object to manufacture [`DescribeProjectVersionsInput`](crate::input::DescribeProjectVersionsInput)
    pub fn builder() -> crate::input::describe_project_versions_input::Builder {
        crate::input::describe_project_versions_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DescribeProjectVersions {
    type Output = std::result::Result<
        crate::output::DescribeProjectVersionsOutput,
        crate::error::DescribeProjectVersionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_describe_project_versions_error(response)
        } else {
            crate::operation_deser::parse_describe_project_versions_response(response)
        }
    }
}

/// <p>Provides information about a stream processor created by <a>CreateStreamProcessor</a>. You can get information about the input and output streams, the input parameters for the face recognition being performed,
/// and the current status of the stream processor.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DescribeStreamProcessor {
    _private: (),
}
impl DescribeStreamProcessor {
    /// Creates a new builder-style object to manufacture [`DescribeStreamProcessorInput`](crate::input::DescribeStreamProcessorInput)
    pub fn builder() -> crate::input::describe_stream_processor_input::Builder {
        crate::input::describe_stream_processor_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DescribeStreamProcessor {
    type Output = std::result::Result<
        crate::output::DescribeStreamProcessorOutput,
        crate::error::DescribeStreamProcessorError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_describe_stream_processor_error(response)
        } else {
            crate::operation_deser::parse_describe_stream_processor_response(response)
        }
    }
}

/// <p>Detects custom labels in a supplied image by using an Amazon Rekognition Custom Labels model. </p>
/// <p>You specify which version of a model version to use by using the <code>ProjectVersionArn</code> input
/// parameter. </p>      
/// <p>You pass the input image as base64-encoded image bytes or as a reference to an image in
/// an Amazon S3 bucket. If you use the AWS CLI to call Amazon Rekognition operations, passing
/// image bytes is not supported. The image must be either a PNG or JPEG formatted file. </p>
/// <p> For each object that the model version detects on an image, the API returns a
/// (<code>CustomLabel</code>) object in an array (<code>CustomLabels</code>).
/// Each <code>CustomLabel</code> object provides the label name (<code>Name</code>), the level
/// of confidence that the image contains the object (<code>Confidence</code>), and
/// object location information, if it exists,  for the label on the image (<code>Geometry</code>). </p>
/// <p>To filter labels that are returned, specify a value for <code>MinConfidence</code>.
/// <code>DetectCustomLabelsLabels</code> only returns labels with a confidence that's higher than
/// the specified value.
/// The value of <code>MinConfidence</code> maps to the assumed threshold values
/// created during training. For more information, see <i>Assumed threshold</i>
/// in the Amazon Rekognition Custom Labels Developer Guide.
/// Amazon Rekognition Custom Labels metrics expresses an assumed threshold as a floating point value between 0-1. The range of
/// <code>MinConfidence</code> normalizes the threshold value to a percentage value (0-100). Confidence
/// responses from <code>DetectCustomLabels</code> are also returned as a percentage.
/// You can use <code>MinConfidence</code> to change the precision and recall or your model.
/// For more information, see
/// <i>Analyzing an image</i> in the Amazon Rekognition Custom Labels Developer Guide. </p>
/// <p>If you don't specify a value for <code>MinConfidence</code>,  <code>DetectCustomLabels</code>
/// returns labels based on the assumed threshold of each label.</p>
/// <p>This is a stateless API operation. That is, the operation does not persist any
/// data.</p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:DetectCustomLabels</code> action. </p>
/// <p>For more information, see
/// <i>Analyzing an image</i> in the Amazon Rekognition Custom Labels Developer Guide. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DetectCustomLabels {
    _private: (),
}
impl DetectCustomLabels {
    /// Creates a new builder-style object to manufacture [`DetectCustomLabelsInput`](crate::input::DetectCustomLabelsInput)
    pub fn builder() -> crate::input::detect_custom_labels_input::Builder {
        crate::input::detect_custom_labels_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DetectCustomLabels {
    type Output = std::result::Result<
        crate::output::DetectCustomLabelsOutput,
        crate::error::DetectCustomLabelsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_detect_custom_labels_error(response)
        } else {
            crate::operation_deser::parse_detect_custom_labels_response(response)
        }
    }
}

/// <p>Detects faces within an image that is provided as input.</p>
/// <p>
/// <code>DetectFaces</code> detects the 100 largest faces in the image. For each face
/// detected, the operation returns face details. These details include a bounding box of the
/// face, a confidence value (that the bounding box contains a face), and a fixed set of
/// attributes such as facial landmarks (for example, coordinates of eye and mouth),
/// presence of beard, sunglasses, and so on. </p>
/// <p>The face-detection algorithm is most effective on frontal faces. For non-frontal or
/// obscured faces, the algorithm might not detect the faces or might detect faces with lower
/// confidence. </p>
/// <p>You pass the input image either as base64-encoded image bytes or as a reference to an
/// image in an Amazon S3 bucket. If you use the AWS CLI
/// to call Amazon Rekognition operations, passing image bytes is not
/// supported. The image must be either a PNG or JPEG formatted file. </p>
/// <note>
/// <p>This is a stateless API operation. That is, the operation does not persist any
/// data.</p>
/// </note>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:DetectFaces</code> action. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DetectFaces {
    _private: (),
}
impl DetectFaces {
    /// Creates a new builder-style object to manufacture [`DetectFacesInput`](crate::input::DetectFacesInput)
    pub fn builder() -> crate::input::detect_faces_input::Builder {
        crate::input::detect_faces_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DetectFaces {
    type Output =
        std::result::Result<crate::output::DetectFacesOutput, crate::error::DetectFacesError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_detect_faces_error(response)
        } else {
            crate::operation_deser::parse_detect_faces_response(response)
        }
    }
}

/// <p>Detects instances of real-world entities within an image (JPEG or PNG)
/// provided as input. This includes objects like flower, tree, and table; events like
/// wedding, graduation, and birthday party; and concepts like landscape, evening, and nature.
/// </p>
/// <p>For an example, see Analyzing Images Stored in an Amazon S3 Bucket in the Amazon Rekognition Developer Guide.</p>
/// <note>
/// <p>
/// <code>DetectLabels</code> does not support the detection of activities. However, activity detection
/// is supported for label detection in videos. For more information, see StartLabelDetection in the Amazon Rekognition Developer Guide.</p>
/// </note>
/// <p>You pass the input image as base64-encoded image bytes or as a reference to an image in
/// an Amazon S3 bucket. If you use the
/// AWS
/// CLI to call Amazon Rekognition operations, passing image bytes is not
/// supported. The image must be either a PNG or JPEG formatted file. </p>
/// <p> For each object, scene, and concept the API returns one or more labels. Each label
/// provides the object name, and the level of confidence that the image contains the object. For
/// example, suppose the input image has a lighthouse, the sea, and a rock. The response includes
/// all three labels, one for each object. </p>
/// <p>
/// <code>{Name: lighthouse, Confidence: 98.4629}</code>
/// </p>
/// <p>
/// <code>{Name: rock,Confidence: 79.2097}</code>
/// </p>
/// <p>
/// <code> {Name: sea,Confidence: 75.061}</code>
/// </p>
/// <p>In the preceding example, the operation returns one label for each of the three
/// objects. The operation can also return multiple labels for the same object in the image. For
/// example, if the input image shows a flower (for example, a tulip), the operation might return
/// the following three labels. </p>
/// <p>
/// <code>{Name: flower,Confidence: 99.0562}</code>
/// </p>
/// <p>
/// <code>{Name: plant,Confidence: 99.0562}</code>
/// </p>
/// <p>
/// <code>{Name: tulip,Confidence: 99.0562}</code>
/// </p>
/// <p>In this example, the detection algorithm more precisely identifies the flower as a
/// tulip.</p>
/// <p>In response, the API returns an array of labels. In addition, the response also
/// includes the orientation correction. Optionally, you can specify <code>MinConfidence</code> to
/// control the confidence threshold for the labels returned. The default is 55%. You can also add
/// the <code>MaxLabels</code> parameter to limit the number of labels returned. </p>
/// <note>
/// <p>If the object detected is a person, the operation doesn't provide the same facial
/// details that the <a>DetectFaces</a> operation provides.</p>
/// </note>
/// <p>
/// <code>DetectLabels</code> returns bounding boxes for instances of common object labels in an array of
/// <a>Instance</a> objects. An <code>Instance</code> object contains a
/// <a>BoundingBox</a> object, for the location of the label on the image. It also includes
/// the confidence by which the bounding box was detected.</p>
/// <p>
/// <code>DetectLabels</code> also returns a hierarchical taxonomy of detected labels. For example,
/// a detected car might be assigned the label <i>car</i>. The label <i>car</i>
/// has two parent labels: <i>Vehicle</i> (its parent) and <i>Transportation</i> (its
/// grandparent).  
/// The response returns the entire list of ancestors for a label. Each ancestor is a unique label in the response.
/// In the previous example, <i>Car</i>, <i>Vehicle</i>, and <i>Transportation</i>
/// are returned as unique labels in the response.
/// </p>
/// <p>This is a stateless API operation. That is, the operation does not persist any
/// data.</p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:DetectLabels</code> action. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DetectLabels {
    _private: (),
}
impl DetectLabels {
    /// Creates a new builder-style object to manufacture [`DetectLabelsInput`](crate::input::DetectLabelsInput)
    pub fn builder() -> crate::input::detect_labels_input::Builder {
        crate::input::detect_labels_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DetectLabels {
    type Output =
        std::result::Result<crate::output::DetectLabelsOutput, crate::error::DetectLabelsError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_detect_labels_error(response)
        } else {
            crate::operation_deser::parse_detect_labels_response(response)
        }
    }
}

/// <p>Detects unsafe content in a specified JPEG or PNG format image.
/// Use <code>DetectModerationLabels</code> to moderate images depending on your requirements.
/// For example, you might want to filter images that contain nudity, but not images containing
/// suggestive content.</p>
/// <p>To filter images, use the labels returned by <code>DetectModerationLabels</code>
/// to determine which types of content are appropriate.</p>
/// <p>For information about moderation labels,
/// see Detecting Unsafe Content in the Amazon Rekognition Developer Guide.</p>
/// <p>You pass the input image either as base64-encoded image bytes or as a reference to an
/// image in an Amazon S3 bucket. If you use the
/// AWS
/// CLI to call Amazon Rekognition operations, passing image bytes is not
/// supported. The image must be either a PNG or JPEG formatted file. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DetectModerationLabels {
    _private: (),
}
impl DetectModerationLabels {
    /// Creates a new builder-style object to manufacture [`DetectModerationLabelsInput`](crate::input::DetectModerationLabelsInput)
    pub fn builder() -> crate::input::detect_moderation_labels_input::Builder {
        crate::input::detect_moderation_labels_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DetectModerationLabels {
    type Output = std::result::Result<
        crate::output::DetectModerationLabelsOutput,
        crate::error::DetectModerationLabelsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_detect_moderation_labels_error(response)
        } else {
            crate::operation_deser::parse_detect_moderation_labels_response(response)
        }
    }
}

/// <p>Detects Personal Protective Equipment (PPE) worn by people detected in an image. Amazon Rekognition can detect the
/// following types of PPE.</p>
/// <ul>
/// <li>
/// <p>Face cover</p>
/// </li>
/// <li>
/// <p>Hand cover</p>
/// </li>
/// <li>
/// <p>Head cover</p>
/// </li>
/// </ul>
/// <p>You pass the input image as base64-encoded image bytes or as a reference to an image in an Amazon S3 bucket.
/// The image must be either a PNG or JPG formatted file. </p>
/// <p>
/// <code>DetectProtectiveEquipment</code> detects PPE worn by up to 15 persons detected in an image.</p>
/// <p>For each person detected in the image the API returns an array of body parts (face, head, left-hand, right-hand).
/// For each body part, an array of detected items of PPE is returned, including an indicator of whether or not the PPE
/// covers the body part. The API returns the confidence it has in each detection
/// (person, PPE, body part and body part coverage). It also returns a bounding box (<a>BoundingBox</a>) for each detected
/// person and each detected item of PPE. </p>
/// <p>You can optionally request a summary of detected PPE items with the <code>SummarizationAttributes</code> input parameter.
/// The summary provides the following information. </p>
/// <ul>
/// <li>
/// <p>The persons detected as wearing all of the types of PPE that you specify.</p>
/// </li>
/// <li>
/// <p>The persons detected as not wearing all of the types PPE that you specify.</p>
/// </li>
/// <li>
/// <p>The persons detected where PPE adornment could not be determined. </p>
/// </li>
/// </ul>
/// <p>This is a stateless API operation. That is, the operation does not persist any data.</p>
/// <p>This operation requires permissions to perform the <code>rekognition:DetectProtectiveEquipment</code> action. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DetectProtectiveEquipment {
    _private: (),
}
impl DetectProtectiveEquipment {
    /// Creates a new builder-style object to manufacture [`DetectProtectiveEquipmentInput`](crate::input::DetectProtectiveEquipmentInput)
    pub fn builder() -> crate::input::detect_protective_equipment_input::Builder {
        crate::input::detect_protective_equipment_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DetectProtectiveEquipment {
    type Output = std::result::Result<
        crate::output::DetectProtectiveEquipmentOutput,
        crate::error::DetectProtectiveEquipmentError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_detect_protective_equipment_error(response)
        } else {
            crate::operation_deser::parse_detect_protective_equipment_response(response)
        }
    }
}

/// <p>Detects text in the input image and converts it into machine-readable text.</p>
/// <p>Pass the input image as base64-encoded image bytes or as a reference to an image in an
/// Amazon S3 bucket. If you use the AWS CLI to call Amazon Rekognition operations, you must pass it as a
/// reference to an image in an Amazon S3 bucket. For the AWS CLI, passing image bytes is not
/// supported. The image must be either a .png or .jpeg formatted file. </p>
/// <p>The <code>DetectText</code> operation returns text in an array of <a>TextDetection</a> elements, <code>TextDetections</code>. Each
/// <code>TextDetection</code> element provides information about a single word or line of text
/// that was detected in the image. </p>
/// <p>A word is one or more ISO basic latin script characters that are not separated by spaces.
/// <code>DetectText</code> can detect up to 100 words in an image.</p>
/// <p>A line is a string of equally spaced words. A line isn't necessarily a complete
/// sentence. For example, a driver's license number is detected as a line. A line ends when there
/// is no aligned text after it. Also, a line ends when there is a large gap between words,
/// relative to the length of the words. This means, depending on the gap between words, Amazon Rekognition
/// may detect multiple lines in text aligned in the same direction. Periods don't represent the
/// end of a line. If a sentence spans multiple lines, the <code>DetectText</code> operation
/// returns multiple lines.</p>
/// <p>To determine whether a <code>TextDetection</code> element is a line of text or a word,
/// use the <code>TextDetection</code> object <code>Type</code> field. </p>
/// <p>To be detected, text must be within +/- 90 degrees orientation of the horizontal axis.</p>
/// <p>For more information, see DetectText in the Amazon Rekognition Developer Guide.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct DetectText {
    _private: (),
}
impl DetectText {
    /// Creates a new builder-style object to manufacture [`DetectTextInput`](crate::input::DetectTextInput)
    pub fn builder() -> crate::input::detect_text_input::Builder {
        crate::input::detect_text_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for DetectText {
    type Output =
        std::result::Result<crate::output::DetectTextOutput, crate::error::DetectTextError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_detect_text_error(response)
        } else {
            crate::operation_deser::parse_detect_text_response(response)
        }
    }
}

/// <p>Gets the name and additional information about a celebrity based on their Amazon Rekognition ID.
/// The additional information is returned as an array of URLs. If there is no additional
/// information about the celebrity, this list is empty.</p>
/// <p>For more information, see Recognizing Celebrities in an Image in
/// the Amazon Rekognition Developer Guide.</p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:GetCelebrityInfo</code> action. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetCelebrityInfo {
    _private: (),
}
impl GetCelebrityInfo {
    /// Creates a new builder-style object to manufacture [`GetCelebrityInfoInput`](crate::input::GetCelebrityInfoInput)
    pub fn builder() -> crate::input::get_celebrity_info_input::Builder {
        crate::input::get_celebrity_info_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetCelebrityInfo {
    type Output = std::result::Result<
        crate::output::GetCelebrityInfoOutput,
        crate::error::GetCelebrityInfoError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_celebrity_info_error(response)
        } else {
            crate::operation_deser::parse_get_celebrity_info_response(response)
        }
    }
}

/// <p>Gets the celebrity recognition results for a Amazon Rekognition Video analysis started by
/// <a>StartCelebrityRecognition</a>.</p>
/// <p>Celebrity recognition in a video is an asynchronous operation. Analysis is started by a call
/// to <a>StartCelebrityRecognition</a>  which returns a job identifier (<code>JobId</code>).
/// When the celebrity recognition operation finishes, Amazon Rekognition Video publishes a completion status to the Amazon Simple Notification Service
/// topic registered in the initial call to <code>StartCelebrityRecognition</code>.
/// To get the results of the celebrity recognition analysis, first check that the status value published to the Amazon SNS
/// topic is <code>SUCCEEDED</code>. If so, call  <code>GetCelebrityDetection</code> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartCelebrityDetection</code>. </p>
/// <p>For more information, see Working With Stored Videos in the Amazon Rekognition Developer Guide.</p>
/// <p>
/// <code>GetCelebrityRecognition</code> returns detected celebrities and the time(s) they are detected in an array
/// (<code>Celebrities</code>) of <a>CelebrityRecognition</a>
/// objects. Each <code>CelebrityRecognition</code> contains information about the celebrity in a <a>CelebrityDetail</a>
/// object and the time, <code>Timestamp</code>, the celebrity was detected.
/// </p>
/// <note>
/// <p>
/// <code>GetCelebrityRecognition</code> only returns the default  
/// facial attributes (<code>BoundingBox</code>, <code>Confidence</code>,
/// <code>Landmarks</code>, <code>Pose</code>, and <code>Quality</code>). The other facial attributes listed
/// in the <code>Face</code> object of the following response syntax are not returned. For more information,
/// see FaceDetail in the Amazon Rekognition Developer Guide. </p>
/// </note>
/// <p>By default, the <code>Celebrities</code> array is sorted by time (milliseconds from the start of the video).
/// You can also sort the array by celebrity by specifying the value <code>ID</code> in the <code>SortBy</code> input parameter.</p>
/// <p>The <code>CelebrityDetail</code> object includes the celebrity identifer and additional information urls. If you don't store
/// the additional information urls, you can get them later by calling <a>GetCelebrityInfo</a> with the celebrity identifer.</p>
/// <p>No information is returned for faces not recognized as celebrities.</p>
/// <p>Use MaxResults parameter to limit the number of labels returned. If there are more results than
/// specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains a
/// pagination token for getting the next set of results. To get the next page of results, call <code>GetCelebrityDetection</code>
/// and populate the <code>NextToken</code> request parameter with the token
/// value returned from the previous call to <code>GetCelebrityRecognition</code>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetCelebrityRecognition {
    _private: (),
}
impl GetCelebrityRecognition {
    /// Creates a new builder-style object to manufacture [`GetCelebrityRecognitionInput`](crate::input::GetCelebrityRecognitionInput)
    pub fn builder() -> crate::input::get_celebrity_recognition_input::Builder {
        crate::input::get_celebrity_recognition_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetCelebrityRecognition {
    type Output = std::result::Result<
        crate::output::GetCelebrityRecognitionOutput,
        crate::error::GetCelebrityRecognitionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_celebrity_recognition_error(response)
        } else {
            crate::operation_deser::parse_get_celebrity_recognition_response(response)
        }
    }
}

/// <p>Gets the inappropriate, unwanted, or offensive content analysis results for a Amazon Rekognition Video analysis started by
/// <a>StartContentModeration</a>. For a list of moderation labels in Amazon Rekognition, see
/// <a href="https://docs.aws.amazon.com/rekognition/latest/dg/moderation.html#moderation-api">Using the image and video moderation APIs</a>.</p>
/// <p>Amazon Rekognition Video inappropriate or offensive content detection in a stored video is an asynchronous operation. You start analysis by calling
/// <a>StartContentModeration</a> which returns a job identifier (<code>JobId</code>).
/// When analysis finishes, Amazon Rekognition Video publishes a completion status to the Amazon Simple Notification Service
/// topic registered in the initial call to <code>StartContentModeration</code>.
/// To get the results of the content analysis, first check that the status value published to the Amazon SNS
/// topic is <code>SUCCEEDED</code>. If so, call  <code>GetContentModeration</code> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartContentModeration</code>. </p>
/// <p>For more information, see Working with Stored Videos in the
/// Amazon Rekognition Devlopers Guide.</p>
/// <p>
/// <code>GetContentModeration</code> returns detected inappropriate, unwanted, or offensive content moderation labels,
/// and the time they are detected, in an array, <code>ModerationLabels</code>, of
/// <a>ContentModerationDetection</a> objects.
/// </p>
/// <p>By default, the moderated labels are returned sorted by time, in milliseconds from the start of the
/// video. You can also sort them by moderated label by specifying <code>NAME</code> for the <code>SortBy</code>
/// input parameter. </p>
/// <p>Since video analysis can return a large number of results, use the <code>MaxResults</code> parameter to limit
/// the number of labels returned in a single call to <code>GetContentModeration</code>. If there are more results than
/// specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains a
/// pagination token for getting the next set of results. To get the next page of results, call <code>GetContentModeration</code>
/// and populate the <code>NextToken</code> request parameter with the value of <code>NextToken</code>
/// returned from the previous call to <code>GetContentModeration</code>.</p>
/// <p>For more information, see Content moderation in the Amazon Rekognition Developer Guide.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetContentModeration {
    _private: (),
}
impl GetContentModeration {
    /// Creates a new builder-style object to manufacture [`GetContentModerationInput`](crate::input::GetContentModerationInput)
    pub fn builder() -> crate::input::get_content_moderation_input::Builder {
        crate::input::get_content_moderation_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetContentModeration {
    type Output = std::result::Result<
        crate::output::GetContentModerationOutput,
        crate::error::GetContentModerationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_content_moderation_error(response)
        } else {
            crate::operation_deser::parse_get_content_moderation_response(response)
        }
    }
}

/// <p>Gets face detection results for a Amazon Rekognition Video analysis started by <a>StartFaceDetection</a>.</p>
/// <p>Face detection with Amazon Rekognition Video is an asynchronous operation. You start face detection by calling <a>StartFaceDetection</a>
/// which returns a job identifier (<code>JobId</code>). When the face detection operation finishes, Amazon Rekognition Video publishes a completion status to
/// the Amazon Simple Notification Service topic registered in the initial call to <code>StartFaceDetection</code>. To get the results
/// of the face detection operation, first check that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
/// If so, call  <a>GetFaceDetection</a> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartFaceDetection</code>.</p>
/// <p>
/// <code>GetFaceDetection</code> returns an array of detected faces (<code>Faces</code>) sorted by the time the faces were detected. </p>
/// <p>Use MaxResults parameter to limit the number of labels returned. If there are more results than
/// specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains a pagination token for getting the next set
/// of results. To get the next page of results, call <code>GetFaceDetection</code> and populate the <code>NextToken</code> request parameter with the token
/// value returned from the previous call to <code>GetFaceDetection</code>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetFaceDetection {
    _private: (),
}
impl GetFaceDetection {
    /// Creates a new builder-style object to manufacture [`GetFaceDetectionInput`](crate::input::GetFaceDetectionInput)
    pub fn builder() -> crate::input::get_face_detection_input::Builder {
        crate::input::get_face_detection_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetFaceDetection {
    type Output = std::result::Result<
        crate::output::GetFaceDetectionOutput,
        crate::error::GetFaceDetectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_face_detection_error(response)
        } else {
            crate::operation_deser::parse_get_face_detection_response(response)
        }
    }
}

/// <p>Gets the face search results for Amazon Rekognition Video face search started by
/// <a>StartFaceSearch</a>. The search returns faces in a collection that match the faces
/// of persons detected in a video. It also includes the time(s) that faces are matched in the video.</p>
/// <p>Face search in a video is an asynchronous operation. You start face search by calling
/// to <a>StartFaceSearch</a> which returns a job identifier (<code>JobId</code>).
/// When the search operation finishes, Amazon Rekognition Video publishes a completion status to the Amazon Simple Notification Service
/// topic registered in the initial call to <code>StartFaceSearch</code>.
/// To get the search results, first check that the status value published to the Amazon SNS
/// topic is <code>SUCCEEDED</code>. If so, call  <code>GetFaceSearch</code> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartFaceSearch</code>.</p>
/// <p>For more information, see Searching Faces in a Collection in the
/// Amazon Rekognition Developer Guide.</p>
/// <p>The search results are retured in an array, <code>Persons</code>, of
/// <a>PersonMatch</a> objects. Each<code>PersonMatch</code> element contains
/// details about the matching faces in the input collection, person information (facial attributes,
/// bounding boxes, and person identifer)
/// for the matched person, and the time the person was matched in the video.</p>
/// <note>
/// <p>
/// <code>GetFaceSearch</code> only returns the default  
/// facial attributes (<code>BoundingBox</code>, <code>Confidence</code>,
/// <code>Landmarks</code>, <code>Pose</code>, and <code>Quality</code>). The other facial attributes listed
/// in the <code>Face</code> object of the following response syntax are not returned. For more information,
/// see FaceDetail in the Amazon Rekognition Developer Guide. </p>
/// </note>
/// <p>By default, the <code>Persons</code> array is sorted by the time, in milliseconds from the
/// start of the video, persons are matched.
/// You can also sort by persons by specifying <code>INDEX</code> for the <code>SORTBY</code> input
/// parameter.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetFaceSearch {
    _private: (),
}
impl GetFaceSearch {
    /// Creates a new builder-style object to manufacture [`GetFaceSearchInput`](crate::input::GetFaceSearchInput)
    pub fn builder() -> crate::input::get_face_search_input::Builder {
        crate::input::get_face_search_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetFaceSearch {
    type Output =
        std::result::Result<crate::output::GetFaceSearchOutput, crate::error::GetFaceSearchError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_face_search_error(response)
        } else {
            crate::operation_deser::parse_get_face_search_response(response)
        }
    }
}

/// <p>Gets the label detection results of a Amazon Rekognition Video analysis started by <a>StartLabelDetection</a>.  </p>
/// <p>The label detection operation is started by a call to <a>StartLabelDetection</a>
/// which returns a job identifier (<code>JobId</code>). When the label detection operation finishes, Amazon Rekognition publishes a completion status to
/// the Amazon Simple Notification Service topic registered in the initial call to <code>StartlabelDetection</code>. To get the results
/// of the label detection operation, first check that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
/// If so, call  <a>GetLabelDetection</a> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartLabelDetection</code>.</p>
/// <p>
/// <code>GetLabelDetection</code> returns an array of detected labels (<code>Labels</code>) sorted by the time
/// the labels were detected. You can also sort by the label name by specifying <code>NAME</code> for the
/// <code>SortBy</code> input parameter.</p>
/// <p>The labels returned include the label name, the percentage confidence in the accuracy of the detected label,
/// and the time the label was detected in the video.</p>
/// <p>The returned labels also include bounding box information for common objects, a
/// hierarchical taxonomy of detected labels, and the version of the label model used for detection.</p>
/// <p>Use MaxResults parameter to limit the number of labels returned. If there are more results than
/// specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains a pagination token for getting the next set
/// of results. To get the next page of results, call <code>GetlabelDetection</code> and populate the <code>NextToken</code> request parameter with the token
/// value returned from the previous call to <code>GetLabelDetection</code>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetLabelDetection {
    _private: (),
}
impl GetLabelDetection {
    /// Creates a new builder-style object to manufacture [`GetLabelDetectionInput`](crate::input::GetLabelDetectionInput)
    pub fn builder() -> crate::input::get_label_detection_input::Builder {
        crate::input::get_label_detection_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetLabelDetection {
    type Output = std::result::Result<
        crate::output::GetLabelDetectionOutput,
        crate::error::GetLabelDetectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_label_detection_error(response)
        } else {
            crate::operation_deser::parse_get_label_detection_response(response)
        }
    }
}

/// <p>Gets the path tracking results of a Amazon Rekognition Video analysis started by <a>StartPersonTracking</a>.</p>
/// <p>The person path tracking operation is started by a call to <code>StartPersonTracking</code>
/// which returns a job identifier (<code>JobId</code>). When the operation finishes, Amazon Rekognition Video publishes a completion status to
/// the Amazon Simple Notification Service topic registered in the initial call to <code>StartPersonTracking</code>.</p>
/// <p>To get the results of the person path tracking operation, first check
/// that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
/// If so, call  <a>GetPersonTracking</a> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartPersonTracking</code>.</p>
/// <p>
/// <code>GetPersonTracking</code> returns an array, <code>Persons</code>, of tracked persons and the time(s) their
/// paths were tracked in the video. </p>
/// <note>
/// <p>
/// <code>GetPersonTracking</code> only returns the default  
/// facial attributes (<code>BoundingBox</code>, <code>Confidence</code>,
/// <code>Landmarks</code>, <code>Pose</code>, and <code>Quality</code>). The other facial attributes listed
/// in the <code>Face</code> object of the following response syntax are not returned. </p>
/// <p>For more information, see FaceDetail in the Amazon Rekognition Developer Guide.</p>
/// </note>
/// <p>By default, the array is sorted by the time(s) a person's path is tracked in the video.
/// You can sort by tracked persons by specifying <code>INDEX</code> for the <code>SortBy</code> input parameter.</p>
/// <p>Use the <code>MaxResults</code> parameter to limit the number of items returned. If there are more results than
/// specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains a pagination token for getting the next set
/// of results. To get the next page of results, call <code>GetPersonTracking</code> and populate the <code>NextToken</code> request parameter with the token
/// value returned from the previous call to <code>GetPersonTracking</code>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetPersonTracking {
    _private: (),
}
impl GetPersonTracking {
    /// Creates a new builder-style object to manufacture [`GetPersonTrackingInput`](crate::input::GetPersonTrackingInput)
    pub fn builder() -> crate::input::get_person_tracking_input::Builder {
        crate::input::get_person_tracking_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetPersonTracking {
    type Output = std::result::Result<
        crate::output::GetPersonTrackingOutput,
        crate::error::GetPersonTrackingError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_person_tracking_error(response)
        } else {
            crate::operation_deser::parse_get_person_tracking_response(response)
        }
    }
}

/// <p>Gets the segment detection results of a Amazon Rekognition Video analysis started by <a>StartSegmentDetection</a>.</p>
/// <p>Segment detection with Amazon Rekognition Video is an asynchronous operation. You start segment detection by
/// calling <a>StartSegmentDetection</a> which returns a job identifier (<code>JobId</code>).
/// When the segment detection operation finishes, Amazon Rekognition publishes a completion status to the Amazon Simple Notification Service
/// topic registered in the initial call to <code>StartSegmentDetection</code>. To get the results
/// of the segment detection operation, first check that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
/// if so, call <code>GetSegmentDetection</code> and pass the job identifier (<code>JobId</code>) from the initial call
/// of <code>StartSegmentDetection</code>.</p>
/// <p>
/// <code>GetSegmentDetection</code> returns detected segments in an array (<code>Segments</code>)
/// of <a>SegmentDetection</a> objects. <code>Segments</code> is sorted by the segment types
/// specified in the <code>SegmentTypes</code> input parameter of <code>StartSegmentDetection</code>.
/// Each element of the array includes the detected segment, the precentage confidence in the acuracy
/// of the detected segment, the type of the segment, and the frame in which the segment was detected.</p>
/// <p>Use <code>SelectedSegmentTypes</code> to find out the type of segment detection requested in the
/// call to <code>StartSegmentDetection</code>.</p>
/// <p>Use the <code>MaxResults</code> parameter to limit the number of segment detections returned. If there are more results than
/// specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains
/// a pagination token for getting the next set of results. To get the next page of results, call <code>GetSegmentDetection</code>
/// and populate the <code>NextToken</code> request parameter with the token value returned from the previous
/// call to <code>GetSegmentDetection</code>.</p>
/// <p>For more information, see Detecting Video Segments in Stored Video in the Amazon Rekognition Developer Guide.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetSegmentDetection {
    _private: (),
}
impl GetSegmentDetection {
    /// Creates a new builder-style object to manufacture [`GetSegmentDetectionInput`](crate::input::GetSegmentDetectionInput)
    pub fn builder() -> crate::input::get_segment_detection_input::Builder {
        crate::input::get_segment_detection_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetSegmentDetection {
    type Output = std::result::Result<
        crate::output::GetSegmentDetectionOutput,
        crate::error::GetSegmentDetectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_segment_detection_error(response)
        } else {
            crate::operation_deser::parse_get_segment_detection_response(response)
        }
    }
}

/// <p>Gets the text detection results of a Amazon Rekognition Video analysis started by <a>StartTextDetection</a>.</p>
/// <p>Text detection with Amazon Rekognition Video is an asynchronous operation. You start text detection by
/// calling <a>StartTextDetection</a> which returns a job identifier (<code>JobId</code>)
/// When the text detection operation finishes, Amazon Rekognition publishes a completion status to the Amazon Simple Notification Service
/// topic registered in the initial call to <code>StartTextDetection</code>. To get the results
/// of the text detection operation, first check that the status value published to the Amazon SNS topic is <code>SUCCEEDED</code>.
/// if so, call <code>GetTextDetection</code> and pass the job identifier (<code>JobId</code>) from the initial call
/// of <code>StartLabelDetection</code>.</p>
/// <p>
/// <code>GetTextDetection</code> returns an array of detected text (<code>TextDetections</code>) sorted by
/// the time the text was detected, up to 50 words per frame of video.</p>
/// <p>Each element of the array includes the detected text, the precentage confidence in the acuracy
/// of the detected text, the time the text was detected, bounding box information for where the text
/// was located, and unique identifiers for words and their lines.</p>
/// <p>Use MaxResults parameter to limit the number of text detections returned. If there are more results than
/// specified in <code>MaxResults</code>, the value of <code>NextToken</code> in the operation response contains
/// a pagination token for getting the next set of results. To get the next page of results, call <code>GetTextDetection</code>
/// and populate the <code>NextToken</code> request parameter with the token value returned from the previous
/// call to <code>GetTextDetection</code>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct GetTextDetection {
    _private: (),
}
impl GetTextDetection {
    /// Creates a new builder-style object to manufacture [`GetTextDetectionInput`](crate::input::GetTextDetectionInput)
    pub fn builder() -> crate::input::get_text_detection_input::Builder {
        crate::input::get_text_detection_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for GetTextDetection {
    type Output = std::result::Result<
        crate::output::GetTextDetectionOutput,
        crate::error::GetTextDetectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_get_text_detection_error(response)
        } else {
            crate::operation_deser::parse_get_text_detection_response(response)
        }
    }
}

/// <p>Detects faces in the input image and adds them to the specified collection. </p>
/// <p>Amazon Rekognition doesn't save the actual faces that are detected. Instead, the underlying
/// detection algorithm first detects the faces in the input image. For each face, the algorithm
/// extracts facial features into a feature vector, and stores it in the backend database.
/// Amazon Rekognition uses feature vectors when it performs face match and search operations using the
/// <a>SearchFaces</a> and <a>SearchFacesByImage</a>
/// operations.</p>
/// <p>For more information, see Adding Faces to a Collection in the Amazon Rekognition
/// Developer Guide.</p>
/// <p>To get the number of faces in a collection, call <a>DescribeCollection</a>. </p>
/// <p>If you're using version 1.0 of the face detection model, <code>IndexFaces</code>
/// indexes the 15 largest faces in the input image. Later versions of the face detection model
/// index the 100 largest faces in the input image. </p>
/// <p>If you're using version 4 or later of the face model, image orientation information
/// is not returned in the <code>OrientationCorrection</code> field. </p>
/// <p>To determine which version of the model you're using, call <a>DescribeCollection</a>
/// and supply the collection ID. You can also get the model version from the value of <code>FaceModelVersion</code> in the response
/// from <code>IndexFaces</code>
/// </p>
/// <p>For more information, see Model Versioning in the Amazon Rekognition Developer
/// Guide.</p>
/// <p>If you provide the optional <code>ExternalImageId</code> for the input image you
/// provided, Amazon Rekognition associates this ID with all faces that it detects. When you call the <a>ListFaces</a> operation, the response returns the external ID. You can use this
/// external image ID to create a client-side index to associate the faces with each image. You
/// can then use the index to find all faces in an image.</p>
/// <p>You can specify the maximum number of faces to index with the <code>MaxFaces</code> input
/// parameter. This is useful when you want to index the largest faces in an image and don't want to index
/// smaller faces, such as those belonging to people standing in the background.</p>
/// <p>The <code>QualityFilter</code> input parameter allows you to filter out detected faces
/// that don’t meet a required quality bar. The quality bar is based on a
/// variety of common use cases. By default, <code>IndexFaces</code> chooses the quality bar that's
/// used to filter faces.  You can also explicitly choose
/// the quality bar. Use <code>QualityFilter</code>, to set the quality bar
/// by specifying <code>LOW</code>, <code>MEDIUM</code>, or <code>HIGH</code>.
/// If you do not want to filter detected faces, specify <code>NONE</code>. </p>
/// <note>
/// <p>To use quality filtering, you need a collection associated with version 3 of the
/// face model or higher. To get the version of the face model associated with a collection, call
/// <a>DescribeCollection</a>. </p>
/// </note>
/// <p>Information about faces detected in an image, but not indexed, is returned in an array of
/// <a>UnindexedFace</a> objects, <code>UnindexedFaces</code>. Faces aren't
/// indexed for reasons such as:</p>
/// <ul>
/// <li>
/// <p>The number of faces detected exceeds the value of the <code>MaxFaces</code> request
/// parameter.</p>
/// </li>
/// <li>
/// <p>The face is too small compared to the image dimensions.</p>
/// </li>
/// <li>
/// <p>The face is too blurry.</p>
/// </li>
/// <li>
/// <p>The image is too dark.</p>
/// </li>
/// <li>
/// <p>The face has an extreme pose.</p>
/// </li>
/// <li>
/// <p>The face doesn’t have enough detail to be suitable for face search.</p>
/// </li>
/// </ul>
/// <p>In response, the <code>IndexFaces</code> operation returns an array of metadata for
/// all detected faces, <code>FaceRecords</code>. This includes: </p>
/// <ul>
/// <li>
/// <p>The bounding box, <code>BoundingBox</code>, of the detected face. </p>
/// </li>
/// <li>
/// <p>A confidence value, <code>Confidence</code>, which indicates the confidence that the
/// bounding box contains a face.</p>
/// </li>
/// <li>
/// <p>A face ID, <code>FaceId</code>, assigned by the service for each face that's detected
/// and stored.</p>
/// </li>
/// <li>
/// <p>An image ID, <code>ImageId</code>, assigned by the service for the input image.</p>
/// </li>
/// </ul>
/// <p>If you request all facial attributes (by using the <code>detectionAttributes</code>
/// parameter), Amazon Rekognition returns detailed facial attributes, such as facial landmarks (for
/// example, location of eye and mouth) and other facial attributes. If you provide
/// the same image, specify the same collection, and use the same external ID in the
/// <code>IndexFaces</code> operation, Amazon Rekognition doesn't save duplicate face metadata.</p>
/// <p></p>
/// <p>The input image is passed either as base64-encoded image bytes, or as a reference to an
/// image in an Amazon S3 bucket. If you use the AWS CLI to call Amazon Rekognition operations,
/// passing image bytes isn't supported. The image must be formatted as a PNG or JPEG file. </p>
/// <p>This operation requires permissions to perform the <code>rekognition:IndexFaces</code>
/// action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct IndexFaces {
    _private: (),
}
impl IndexFaces {
    /// Creates a new builder-style object to manufacture [`IndexFacesInput`](crate::input::IndexFacesInput)
    pub fn builder() -> crate::input::index_faces_input::Builder {
        crate::input::index_faces_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for IndexFaces {
    type Output =
        std::result::Result<crate::output::IndexFacesOutput, crate::error::IndexFacesError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_index_faces_error(response)
        } else {
            crate::operation_deser::parse_index_faces_response(response)
        }
    }
}

/// <p>Returns list of collection IDs in your account.
/// If the result is truncated, the response also provides a <code>NextToken</code>
/// that you can use in the subsequent request to fetch the next set of collection IDs.</p>
/// <p>For an example, see Listing Collections in the Amazon Rekognition Developer Guide.</p>
/// <p>This operation requires permissions to perform the <code>rekognition:ListCollections</code> action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListCollections {
    _private: (),
}
impl ListCollections {
    /// Creates a new builder-style object to manufacture [`ListCollectionsInput`](crate::input::ListCollectionsInput)
    pub fn builder() -> crate::input::list_collections_input::Builder {
        crate::input::list_collections_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListCollections {
    type Output = std::result::Result<
        crate::output::ListCollectionsOutput,
        crate::error::ListCollectionsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_collections_error(response)
        } else {
            crate::operation_deser::parse_list_collections_response(response)
        }
    }
}

/// <p>Returns metadata for faces in the specified collection.
/// This metadata includes information such as the bounding box coordinates, the confidence
/// (that the bounding box contains a face), and face ID. For an example, see Listing Faces in a Collection
/// in the Amazon Rekognition Developer Guide.</p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:ListFaces</code> action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListFaces {
    _private: (),
}
impl ListFaces {
    /// Creates a new builder-style object to manufacture [`ListFacesInput`](crate::input::ListFacesInput)
    pub fn builder() -> crate::input::list_faces_input::Builder {
        crate::input::list_faces_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListFaces {
    type Output = std::result::Result<crate::output::ListFacesOutput, crate::error::ListFacesError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_faces_error(response)
        } else {
            crate::operation_deser::parse_list_faces_response(response)
        }
    }
}

/// <p>Gets a list of stream processors that you have created with <a>CreateStreamProcessor</a>. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListStreamProcessors {
    _private: (),
}
impl ListStreamProcessors {
    /// Creates a new builder-style object to manufacture [`ListStreamProcessorsInput`](crate::input::ListStreamProcessorsInput)
    pub fn builder() -> crate::input::list_stream_processors_input::Builder {
        crate::input::list_stream_processors_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListStreamProcessors {
    type Output = std::result::Result<
        crate::output::ListStreamProcessorsOutput,
        crate::error::ListStreamProcessorsError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_stream_processors_error(response)
        } else {
            crate::operation_deser::parse_list_stream_processors_response(response)
        }
    }
}

/// <p>
/// Returns a list of tags in an Amazon Rekognition collection, stream processor, or Custom Labels model.
/// </p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:ListTagsForResource</code> action. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct ListTagsForResource {
    _private: (),
}
impl ListTagsForResource {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceInput`](crate::input::ListTagsForResourceInput)
    pub fn builder() -> crate::input::list_tags_for_resource_input::Builder {
        crate::input::list_tags_for_resource_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for ListTagsForResource {
    type Output = std::result::Result<
        crate::output::ListTagsForResourceOutput,
        crate::error::ListTagsForResourceError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_list_tags_for_resource_error(response)
        } else {
            crate::operation_deser::parse_list_tags_for_resource_response(response)
        }
    }
}

/// <p>Returns an array of celebrities recognized in the input image.  For more information, see Recognizing Celebrities
/// in the Amazon Rekognition Developer Guide. </p>
/// <p>
/// <code>RecognizeCelebrities</code> returns the 64 largest faces in the image. It lists
/// recognized celebrities in the <code>CelebrityFaces</code> array and unrecognized faces in the
/// <code>UnrecognizedFaces</code> array. <code>RecognizeCelebrities</code> doesn't return
/// celebrities whose faces aren't among the largest 64 faces in the image.</p>
/// <p>For each celebrity recognized, <code>RecognizeCelebrities</code> returns a
/// <code>Celebrity</code> object. The <code>Celebrity</code> object contains the celebrity
/// name, ID, URL links to additional information, match confidence, and a
/// <code>ComparedFace</code> object that you can use to locate the celebrity's face on the
/// image.</p>
/// <p>Amazon Rekognition doesn't retain information about which images a celebrity has been recognized
/// in. Your application must store this information and use the <code>Celebrity</code> ID
/// property as a unique identifier for the celebrity. If you don't store the celebrity name or
/// additional information URLs returned by <code>RecognizeCelebrities</code>, you will need the
/// ID to identify the celebrity in a call to the <a>GetCelebrityInfo</a>
/// operation.</p>
/// <p>You pass the input image either as base64-encoded image bytes or as a reference to an
/// image in an Amazon S3 bucket. If you use the
/// AWS
/// CLI to call Amazon Rekognition operations, passing image bytes is not
/// supported. The image must be either a PNG or JPEG formatted file. </p>
/// <p>For an example, see Recognizing Celebrities in an Image in the Amazon Rekognition Developer Guide.</p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:RecognizeCelebrities</code> operation.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct RecognizeCelebrities {
    _private: (),
}
impl RecognizeCelebrities {
    /// Creates a new builder-style object to manufacture [`RecognizeCelebritiesInput`](crate::input::RecognizeCelebritiesInput)
    pub fn builder() -> crate::input::recognize_celebrities_input::Builder {
        crate::input::recognize_celebrities_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for RecognizeCelebrities {
    type Output = std::result::Result<
        crate::output::RecognizeCelebritiesOutput,
        crate::error::RecognizeCelebritiesError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_recognize_celebrities_error(response)
        } else {
            crate::operation_deser::parse_recognize_celebrities_response(response)
        }
    }
}

/// <p>For a given input face ID, searches for matching faces in the collection the face
/// belongs to. You get a face ID when you add a face to the collection using the <a>IndexFaces</a> operation. The operation compares the features of the input face with
/// faces in the specified collection. </p>
/// <note>
/// <p>You can also search faces without indexing faces by using the
/// <code>SearchFacesByImage</code> operation.</p>
/// </note>
/// <p>
/// The operation response returns
/// an array of faces that match, ordered by similarity score with the highest
/// similarity first. More specifically, it is an
/// array of metadata for each face match that is found. Along with the metadata, the response also
/// includes a <code>confidence</code> value for each face match, indicating the confidence
/// that the specific face matches the input face.
/// </p>
/// <p>For an example, see Searching for a Face Using Its Face ID in the Amazon Rekognition Developer Guide.</p>
/// <p>This operation requires permissions to perform the <code>rekognition:SearchFaces</code>
/// action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SearchFaces {
    _private: (),
}
impl SearchFaces {
    /// Creates a new builder-style object to manufacture [`SearchFacesInput`](crate::input::SearchFacesInput)
    pub fn builder() -> crate::input::search_faces_input::Builder {
        crate::input::search_faces_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for SearchFaces {
    type Output =
        std::result::Result<crate::output::SearchFacesOutput, crate::error::SearchFacesError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_search_faces_error(response)
        } else {
            crate::operation_deser::parse_search_faces_response(response)
        }
    }
}

/// <p>For a given input image, first detects the largest face in the image, and then searches
/// the specified collection for matching faces. The operation compares the features of the input
/// face with faces in the specified collection. </p>
/// <note>
/// <p>To search for all faces in an input image, you might first call the <a>IndexFaces</a> operation, and then use the face IDs returned in subsequent
/// calls to the <a>SearchFaces</a> operation. </p>
/// <p> You can also call the <code>DetectFaces</code> operation and use the bounding boxes
/// in the response to make face crops, which then you can pass in to the
/// <code>SearchFacesByImage</code> operation. </p>
/// </note>
/// <p>You pass the input image either as base64-encoded image bytes or as a reference to an
/// image in an Amazon S3 bucket. If you use the
/// AWS
/// CLI to call Amazon Rekognition operations, passing image bytes is not
/// supported. The image must be either a PNG or JPEG formatted file. </p>
/// <p>
/// The response returns an array of faces that match, ordered by similarity score with the
/// highest similarity first. More specifically, it is an
/// array of metadata for each face match found. Along with the metadata, the response also
/// includes a <code>similarity</code> indicating how similar the face is
/// to the input face.
/// In the response, the operation also returns the bounding
/// box (and a confidence level that the bounding box contains a face) of the face that Amazon Rekognition
/// used for the input image.
/// </p>
/// <p>If no faces are detected in the input image, <code>SearchFacesByImage</code> returns an
/// <code>InvalidParameterException</code> error. </p>
/// <p>For an example, Searching for a Face Using an Image in the Amazon Rekognition Developer Guide.</p>
/// <p>The <code>QualityFilter</code> input parameter allows you to filter out detected faces
/// that don’t meet a required quality bar. The quality bar is based on a
/// variety of common use cases.
/// Use <code>QualityFilter</code> to set the quality bar for
/// filtering by specifying <code>LOW</code>, <code>MEDIUM</code>, or <code>HIGH</code>.
/// If you do not want to filter detected faces, specify <code>NONE</code>. The default
/// value is <code>NONE</code>.</p>
/// <note>
/// <p>To use quality filtering, you need a collection associated with version 3 of the
/// face model or higher. To get the version of the face model associated with a collection, call
/// <a>DescribeCollection</a>. </p>
/// </note>
/// <p>This operation requires permissions to perform the <code>rekognition:SearchFacesByImage</code>
/// action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct SearchFacesByImage {
    _private: (),
}
impl SearchFacesByImage {
    /// Creates a new builder-style object to manufacture [`SearchFacesByImageInput`](crate::input::SearchFacesByImageInput)
    pub fn builder() -> crate::input::search_faces_by_image_input::Builder {
        crate::input::search_faces_by_image_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for SearchFacesByImage {
    type Output = std::result::Result<
        crate::output::SearchFacesByImageOutput,
        crate::error::SearchFacesByImageError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_search_faces_by_image_error(response)
        } else {
            crate::operation_deser::parse_search_faces_by_image_response(response)
        }
    }
}

/// <p>Starts asynchronous recognition of celebrities in a stored video.</p>
/// <p>Amazon Rekognition Video can detect celebrities in a video must be stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name
/// and the filename of the video.
/// <code>StartCelebrityRecognition</code>
/// returns a job identifier (<code>JobId</code>) which you use to get the results of the analysis.
/// When celebrity recognition analysis is finished, Amazon Rekognition Video publishes a completion status
/// to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</code>.
/// To get the results of the celebrity recognition analysis, first check that the status value published to the Amazon SNS
/// topic is <code>SUCCEEDED</code>. If so, call  <a>GetCelebrityRecognition</a> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartCelebrityRecognition</code>. </p>
/// <p>For more information, see Recognizing Celebrities in the Amazon Rekognition Developer Guide.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StartCelebrityRecognition {
    _private: (),
}
impl StartCelebrityRecognition {
    /// Creates a new builder-style object to manufacture [`StartCelebrityRecognitionInput`](crate::input::StartCelebrityRecognitionInput)
    pub fn builder() -> crate::input::start_celebrity_recognition_input::Builder {
        crate::input::start_celebrity_recognition_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StartCelebrityRecognition {
    type Output = std::result::Result<
        crate::output::StartCelebrityRecognitionOutput,
        crate::error::StartCelebrityRecognitionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_celebrity_recognition_error(response)
        } else {
            crate::operation_deser::parse_start_celebrity_recognition_response(response)
        }
    }
}

/// <p> Starts asynchronous detection of inappropriate, unwanted, or offensive content in a stored video. For a list of moderation labels in Amazon Rekognition, see
/// <a href="https://docs.aws.amazon.com/rekognition/latest/dg/moderation.html#moderation-api">Using the image and video moderation APIs</a>.</p>
/// <p>Amazon Rekognition Video can moderate content in a video stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name
/// and the filename of the video. <code>StartContentModeration</code>
/// returns a job identifier (<code>JobId</code>) which you use to get the results of the analysis.
/// When content analysis is finished, Amazon Rekognition Video publishes a completion status
/// to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</code>.</p>
/// <p>To get the results of the content analysis, first check that the status value published to the Amazon SNS
/// topic is <code>SUCCEEDED</code>. If so, call <a>GetContentModeration</a> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartContentModeration</code>. </p>
/// <p>For more information, see Content moderation in the Amazon Rekognition Developer Guide.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StartContentModeration {
    _private: (),
}
impl StartContentModeration {
    /// Creates a new builder-style object to manufacture [`StartContentModerationInput`](crate::input::StartContentModerationInput)
    pub fn builder() -> crate::input::start_content_moderation_input::Builder {
        crate::input::start_content_moderation_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StartContentModeration {
    type Output = std::result::Result<
        crate::output::StartContentModerationOutput,
        crate::error::StartContentModerationError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_content_moderation_error(response)
        } else {
            crate::operation_deser::parse_start_content_moderation_response(response)
        }
    }
}

/// <p>Starts asynchronous detection of faces in a stored video.</p>
/// <p>Amazon Rekognition Video can detect faces in a video stored in an Amazon S3 bucket.
/// Use <a>Video</a> to specify the bucket name and the filename of the video.
/// <code>StartFaceDetection</code> returns a job identifier (<code>JobId</code>) that you
/// use to get the results of the operation.
/// When face detection is finished, Amazon Rekognition Video publishes a completion status
/// to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</code>.
/// To get the results of the face detection operation, first check that the status value published to the Amazon SNS
/// topic is <code>SUCCEEDED</code>. If so, call  <a>GetFaceDetection</a> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartFaceDetection</code>.</p>
/// <p>For more information, see Detecting Faces in a Stored Video in the
/// Amazon Rekognition Developer Guide.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StartFaceDetection {
    _private: (),
}
impl StartFaceDetection {
    /// Creates a new builder-style object to manufacture [`StartFaceDetectionInput`](crate::input::StartFaceDetectionInput)
    pub fn builder() -> crate::input::start_face_detection_input::Builder {
        crate::input::start_face_detection_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StartFaceDetection {
    type Output = std::result::Result<
        crate::output::StartFaceDetectionOutput,
        crate::error::StartFaceDetectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_face_detection_error(response)
        } else {
            crate::operation_deser::parse_start_face_detection_response(response)
        }
    }
}

/// <p>Starts the asynchronous search for faces in a collection that match the faces of persons detected in a stored video.</p>
/// <p>The video must be stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name
/// and the filename of the video. <code>StartFaceSearch</code>
/// returns a job identifier (<code>JobId</code>) which you use to get the search results once the search has completed.
/// When searching is finished, Amazon Rekognition Video publishes a completion status
/// to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</code>.
/// To get the search results, first check that the status value published to the Amazon SNS
/// topic is <code>SUCCEEDED</code>. If so, call <a>GetFaceSearch</a> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartFaceSearch</code>. For more information, see
/// <a>procedure-person-search-videos</a>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StartFaceSearch {
    _private: (),
}
impl StartFaceSearch {
    /// Creates a new builder-style object to manufacture [`StartFaceSearchInput`](crate::input::StartFaceSearchInput)
    pub fn builder() -> crate::input::start_face_search_input::Builder {
        crate::input::start_face_search_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StartFaceSearch {
    type Output = std::result::Result<
        crate::output::StartFaceSearchOutput,
        crate::error::StartFaceSearchError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_face_search_error(response)
        } else {
            crate::operation_deser::parse_start_face_search_response(response)
        }
    }
}

/// <p>Starts asynchronous detection of labels in a stored video.</p>
/// <p>Amazon Rekognition Video can detect labels in a video. Labels are instances of real-world entities.
/// This includes objects like flower, tree, and table; events like
/// wedding, graduation, and birthday party; concepts like landscape, evening, and nature; and activities
/// like a person getting out of a car or a person skiing.</p>
/// <p>The video must be stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name
/// and the filename of the video.
/// <code>StartLabelDetection</code> returns a job identifier (<code>JobId</code>) which you use to get the
/// results of the operation. When label detection is finished, Amazon Rekognition Video publishes a completion status
/// to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</code>.</p>
/// <p>To get the results of the label detection operation, first check that the status value published to the Amazon SNS
/// topic is <code>SUCCEEDED</code>. If so, call  <a>GetLabelDetection</a> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartLabelDetection</code>.</p>
/// <p></p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StartLabelDetection {
    _private: (),
}
impl StartLabelDetection {
    /// Creates a new builder-style object to manufacture [`StartLabelDetectionInput`](crate::input::StartLabelDetectionInput)
    pub fn builder() -> crate::input::start_label_detection_input::Builder {
        crate::input::start_label_detection_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StartLabelDetection {
    type Output = std::result::Result<
        crate::output::StartLabelDetectionOutput,
        crate::error::StartLabelDetectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_label_detection_error(response)
        } else {
            crate::operation_deser::parse_start_label_detection_response(response)
        }
    }
}

/// <p>Starts the asynchronous tracking of a person's path in a stored video.</p>
/// <p>Amazon Rekognition Video can track the path of people in a video stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name
/// and the filename of the video. <code>StartPersonTracking</code>
/// returns a job identifier (<code>JobId</code>) which you use to get the results of the operation.
/// When label detection is finished, Amazon Rekognition publishes a completion status
/// to the Amazon Simple Notification Service topic that you specify in <code>NotificationChannel</code>. </p>
/// <p>To get the results of the person detection operation, first check that the status value published to the Amazon SNS
/// topic is <code>SUCCEEDED</code>. If so, call  <a>GetPersonTracking</a> and pass the job identifier
/// (<code>JobId</code>) from the initial call to <code>StartPersonTracking</code>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StartPersonTracking {
    _private: (),
}
impl StartPersonTracking {
    /// Creates a new builder-style object to manufacture [`StartPersonTrackingInput`](crate::input::StartPersonTrackingInput)
    pub fn builder() -> crate::input::start_person_tracking_input::Builder {
        crate::input::start_person_tracking_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StartPersonTracking {
    type Output = std::result::Result<
        crate::output::StartPersonTrackingOutput,
        crate::error::StartPersonTrackingError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_person_tracking_error(response)
        } else {
            crate::operation_deser::parse_start_person_tracking_response(response)
        }
    }
}

/// <p>Starts the running of the version of a model. Starting a model takes a while
/// to complete. To check the current state of the model, use <a>DescribeProjectVersions</a>.</p>
/// <p>Once the model is running, you can detect custom labels in new images by calling
/// <a>DetectCustomLabels</a>.</p>
/// <note>
/// <p>You are charged for the amount of time that the model is running. To stop a running
/// model, call <a>StopProjectVersion</a>.</p>
/// </note>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:StartProjectVersion</code> action.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StartProjectVersion {
    _private: (),
}
impl StartProjectVersion {
    /// Creates a new builder-style object to manufacture [`StartProjectVersionInput`](crate::input::StartProjectVersionInput)
    pub fn builder() -> crate::input::start_project_version_input::Builder {
        crate::input::start_project_version_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StartProjectVersion {
    type Output = std::result::Result<
        crate::output::StartProjectVersionOutput,
        crate::error::StartProjectVersionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_project_version_error(response)
        } else {
            crate::operation_deser::parse_start_project_version_response(response)
        }
    }
}

/// <p>Starts asynchronous detection of segment detection in a stored video.</p>
/// <p>Amazon Rekognition Video can detect segments in a video stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name and
/// the filename of the video. <code>StartSegmentDetection</code> returns a job identifier (<code>JobId</code>) which you use to get
/// the results of the operation. When segment detection is finished, Amazon Rekognition Video publishes a completion status to the Amazon Simple Notification Service topic
/// that you specify in <code>NotificationChannel</code>.</p>
/// <p>You can use the <code>Filters</code> (<a>StartSegmentDetectionFilters</a>)
/// input parameter to specify the minimum detection confidence returned in the response.
/// Within <code>Filters</code>, use <code>ShotFilter</code> (<a>StartShotDetectionFilter</a>)
/// to filter detected shots. Use  <code>TechnicalCueFilter</code> (<a>StartTechnicalCueDetectionFilter</a>)
/// to filter technical cues. </p>
/// <p>To get the results of the segment detection operation, first check that the status value published to the Amazon SNS
/// topic is <code>SUCCEEDED</code>. if so, call <a>GetSegmentDetection</a> and pass the job identifier (<code>JobId</code>)
/// from the initial call to <code>StartSegmentDetection</code>. </p>
/// <p>For more information, see Detecting Video Segments in Stored Video in the Amazon Rekognition Developer Guide.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StartSegmentDetection {
    _private: (),
}
impl StartSegmentDetection {
    /// Creates a new builder-style object to manufacture [`StartSegmentDetectionInput`](crate::input::StartSegmentDetectionInput)
    pub fn builder() -> crate::input::start_segment_detection_input::Builder {
        crate::input::start_segment_detection_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StartSegmentDetection {
    type Output = std::result::Result<
        crate::output::StartSegmentDetectionOutput,
        crate::error::StartSegmentDetectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_segment_detection_error(response)
        } else {
            crate::operation_deser::parse_start_segment_detection_response(response)
        }
    }
}

/// <p>Starts processing a stream processor. You create a stream processor by calling <a>CreateStreamProcessor</a>.
/// To tell <code>StartStreamProcessor</code> which stream processor to start, use the value of the <code>Name</code> field specified in the call to
/// <code>CreateStreamProcessor</code>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StartStreamProcessor {
    _private: (),
}
impl StartStreamProcessor {
    /// Creates a new builder-style object to manufacture [`StartStreamProcessorInput`](crate::input::StartStreamProcessorInput)
    pub fn builder() -> crate::input::start_stream_processor_input::Builder {
        crate::input::start_stream_processor_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StartStreamProcessor {
    type Output = std::result::Result<
        crate::output::StartStreamProcessorOutput,
        crate::error::StartStreamProcessorError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_stream_processor_error(response)
        } else {
            crate::operation_deser::parse_start_stream_processor_response(response)
        }
    }
}

/// <p>Starts asynchronous detection of text in a stored video.</p>
/// <p>Amazon Rekognition Video can detect text in a video stored in an Amazon S3 bucket. Use <a>Video</a> to specify the bucket name and
/// the filename of the video. <code>StartTextDetection</code> returns a job identifier (<code>JobId</code>) which you use to get
/// the results of the operation. When text detection is finished, Amazon Rekognition Video publishes a completion status to the Amazon Simple Notification Service topic
/// that you specify in <code>NotificationChannel</code>.</p>
/// <p>To get the results of the text detection operation, first check that the status value published to the Amazon SNS
/// topic is <code>SUCCEEDED</code>. if so, call <a>GetTextDetection</a> and pass the job identifier (<code>JobId</code>)
/// from the initial call to <code>StartTextDetection</code>. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StartTextDetection {
    _private: (),
}
impl StartTextDetection {
    /// Creates a new builder-style object to manufacture [`StartTextDetectionInput`](crate::input::StartTextDetectionInput)
    pub fn builder() -> crate::input::start_text_detection_input::Builder {
        crate::input::start_text_detection_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StartTextDetection {
    type Output = std::result::Result<
        crate::output::StartTextDetectionOutput,
        crate::error::StartTextDetectionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_start_text_detection_error(response)
        } else {
            crate::operation_deser::parse_start_text_detection_response(response)
        }
    }
}

/// <p>Stops a running model. The operation might take a while to complete. To
/// check the current status, call <a>DescribeProjectVersions</a>. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StopProjectVersion {
    _private: (),
}
impl StopProjectVersion {
    /// Creates a new builder-style object to manufacture [`StopProjectVersionInput`](crate::input::StopProjectVersionInput)
    pub fn builder() -> crate::input::stop_project_version_input::Builder {
        crate::input::stop_project_version_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StopProjectVersion {
    type Output = std::result::Result<
        crate::output::StopProjectVersionOutput,
        crate::error::StopProjectVersionError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_stop_project_version_error(response)
        } else {
            crate::operation_deser::parse_stop_project_version_response(response)
        }
    }
}

/// <p>Stops a running stream processor that was created by <a>CreateStreamProcessor</a>.</p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct StopStreamProcessor {
    _private: (),
}
impl StopStreamProcessor {
    /// Creates a new builder-style object to manufacture [`StopStreamProcessorInput`](crate::input::StopStreamProcessorInput)
    pub fn builder() -> crate::input::stop_stream_processor_input::Builder {
        crate::input::stop_stream_processor_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for StopStreamProcessor {
    type Output = std::result::Result<
        crate::output::StopStreamProcessorOutput,
        crate::error::StopStreamProcessorError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_stop_stream_processor_error(response)
        } else {
            crate::operation_deser::parse_stop_stream_processor_response(response)
        }
    }
}

/// <p>
/// Adds one or more key-value tags to an Amazon Rekognition collection, stream processor, or Custom Labels model. For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging AWS Resources</a>.
/// </p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:TagResource</code> action. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct TagResource {
    _private: (),
}
impl TagResource {
    /// Creates a new builder-style object to manufacture [`TagResourceInput`](crate::input::TagResourceInput)
    pub fn builder() -> crate::input::tag_resource_input::Builder {
        crate::input::tag_resource_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for TagResource {
    type Output =
        std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_tag_resource_error(response)
        } else {
            crate::operation_deser::parse_tag_resource_response(response)
        }
    }
}

/// <p>
/// Removes one or more tags from an Amazon Rekognition collection, stream processor, or Custom Labels model.
/// </p>
/// <p>This operation requires permissions to perform the
/// <code>rekognition:UntagResource</code> action. </p>
#[derive(std::default::Default, std::clone::Clone, std::fmt::Debug)]
pub struct UntagResource {
    _private: (),
}
impl UntagResource {
    /// Creates a new builder-style object to manufacture [`UntagResourceInput`](crate::input::UntagResourceInput)
    pub fn builder() -> crate::input::untag_resource_input::Builder {
        crate::input::untag_resource_input::Builder::default()
    }
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl smithy_http::response::ParseStrictResponse for UntagResource {
    type Output =
        std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_untag_resource_error(response)
        } else {
            crate::operation_deser::parse_untag_resource_response(response)
        }
    }
}
