// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Operation shape for `DeleteObject`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`delete_object`](crate::client::Client::delete_object).
///
/// See [`crate::client::fluent_builders::DeleteObject`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteObject {
    _private: (),
}
impl DeleteObject {
    /// Creates a new builder-style object to manufacture [`DeleteObjectInput`](crate::input::DeleteObjectInput).
    pub fn builder() -> crate::input::delete_object_input::Builder {
        crate::input::delete_object_input::Builder::default()
    }
    /// Creates a new `DeleteObject` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteObject {
    type Output =
        std::result::Result<crate::output::DeleteObjectOutput, crate::error::DeleteObjectError>;
    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_object_error(response)
        } else {
            crate::operation_deser::parse_delete_object_response(response)
        }
    }
}

/// Operation shape for `GetChunk`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_chunk`](crate::client::Client::get_chunk).
///
/// See [`crate::client::fluent_builders::GetChunk`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetChunk {
    _private: (),
}
impl GetChunk {
    /// Creates a new builder-style object to manufacture [`GetChunkInput`](crate::input::GetChunkInput).
    pub fn builder() -> crate::input::get_chunk_input::Builder {
        crate::input::get_chunk_input::Builder::default()
    }
    /// Creates a new `GetChunk` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseHttpResponse for GetChunk {
    type Output = std::result::Result<crate::output::GetChunkOutput, crate::error::GetChunkError>;
    fn parse_unloaded(
        &self,
        response: &mut aws_smithy_http::operation::Response,
    ) -> Option<Self::Output> {
        // This is an error, defer to the non-streaming parser
        if !response.http().status().is_success() && response.http().status().as_u16() != 200 {
            return None;
        }
        Some(crate::operation_deser::parse_get_chunk(response))
    }
    fn parse_loaded(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        // if streaming, we only hit this case if its an error
        crate::operation_deser::parse_get_chunk_error(response)
    }
}

/// Operation shape for `GetObjectMetadata`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`get_object_metadata`](crate::client::Client::get_object_metadata).
///
/// See [`crate::client::fluent_builders::GetObjectMetadata`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct GetObjectMetadata {
    _private: (),
}
impl GetObjectMetadata {
    /// Creates a new builder-style object to manufacture [`GetObjectMetadataInput`](crate::input::GetObjectMetadataInput).
    pub fn builder() -> crate::input::get_object_metadata_input::Builder {
        crate::input::get_object_metadata_input::Builder::default()
    }
    /// Creates a new `GetObjectMetadata` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseHttpResponse for GetObjectMetadata {
    type Output = std::result::Result<
        crate::output::GetObjectMetadataOutput,
        crate::error::GetObjectMetadataError,
    >;
    fn parse_unloaded(
        &self,
        response: &mut aws_smithy_http::operation::Response,
    ) -> Option<Self::Output> {
        // This is an error, defer to the non-streaming parser
        if !response.http().status().is_success() && response.http().status().as_u16() != 200 {
            return None;
        }
        Some(crate::operation_deser::parse_get_object_metadata(response))
    }
    fn parse_loaded(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        // if streaming, we only hit this case if its an error
        crate::operation_deser::parse_get_object_metadata_error(response)
    }
}

/// Operation shape for `ListChunks`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_chunks`](crate::client::Client::list_chunks).
///
/// See [`crate::client::fluent_builders::ListChunks`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListChunks {
    _private: (),
}
impl ListChunks {
    /// Creates a new builder-style object to manufacture [`ListChunksInput`](crate::input::ListChunksInput).
    pub fn builder() -> crate::input::list_chunks_input::Builder {
        crate::input::list_chunks_input::Builder::default()
    }
    /// Creates a new `ListChunks` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListChunks {
    type Output =
        std::result::Result<crate::output::ListChunksOutput, crate::error::ListChunksError>;
    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_chunks_error(response)
        } else {
            crate::operation_deser::parse_list_chunks_response(response)
        }
    }
}

/// Operation shape for `ListObjects`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`list_objects`](crate::client::Client::list_objects).
///
/// See [`crate::client::fluent_builders::ListObjects`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListObjects {
    _private: (),
}
impl ListObjects {
    /// Creates a new builder-style object to manufacture [`ListObjectsInput`](crate::input::ListObjectsInput).
    pub fn builder() -> crate::input::list_objects_input::Builder {
        crate::input::list_objects_input::Builder::default()
    }
    /// Creates a new `ListObjects` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ListObjects {
    type Output =
        std::result::Result<crate::output::ListObjectsOutput, crate::error::ListObjectsError>;
    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_objects_error(response)
        } else {
            crate::operation_deser::parse_list_objects_response(response)
        }
    }
}

/// Operation shape for `NotifyObjectComplete`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`notify_object_complete`](crate::client::Client::notify_object_complete).
///
/// See [`crate::client::fluent_builders::NotifyObjectComplete`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct NotifyObjectComplete {
    _private: (),
}
impl NotifyObjectComplete {
    /// Creates a new builder-style object to manufacture [`NotifyObjectCompleteInput`](crate::input::NotifyObjectCompleteInput).
    pub fn builder() -> crate::input::notify_object_complete_input::Builder {
        crate::input::notify_object_complete_input::Builder::default()
    }
    /// Creates a new `NotifyObjectComplete` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for NotifyObjectComplete {
    type Output = std::result::Result<
        crate::output::NotifyObjectCompleteOutput,
        crate::error::NotifyObjectCompleteError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_notify_object_complete_error(response)
        } else {
            crate::operation_deser::parse_notify_object_complete_response(response)
        }
    }
}

/// Operation shape for `PutChunk`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`put_chunk`](crate::client::Client::put_chunk).
///
/// See [`crate::client::fluent_builders::PutChunk`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct PutChunk {
    _private: (),
}
impl PutChunk {
    /// Creates a new builder-style object to manufacture [`PutChunkInput`](crate::input::PutChunkInput).
    pub fn builder() -> crate::input::put_chunk_input::Builder {
        crate::input::put_chunk_input::Builder::default()
    }
    /// Creates a new `PutChunk` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for PutChunk {
    type Output = std::result::Result<crate::output::PutChunkOutput, crate::error::PutChunkError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_put_chunk_error(response)
        } else {
            crate::operation_deser::parse_put_chunk_response(response)
        }
    }
}

/// Operation shape for `PutObject`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`put_object`](crate::client::Client::put_object).
///
/// See [`crate::client::fluent_builders::PutObject`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct PutObject {
    _private: (),
}
impl PutObject {
    /// Creates a new builder-style object to manufacture [`PutObjectInput`](crate::input::PutObjectInput).
    pub fn builder() -> crate::input::put_object_input::Builder {
        crate::input::put_object_input::Builder::default()
    }
    /// Creates a new `PutObject` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for PutObject {
    type Output = std::result::Result<crate::output::PutObjectOutput, crate::error::PutObjectError>;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_put_object_error(response)
        } else {
            crate::operation_deser::parse_put_object_response(response)
        }
    }
}

/// Operation shape for `StartObject`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`start_object`](crate::client::Client::start_object).
///
/// See [`crate::client::fluent_builders::StartObject`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct StartObject {
    _private: (),
}
impl StartObject {
    /// Creates a new builder-style object to manufacture [`StartObjectInput`](crate::input::StartObjectInput).
    pub fn builder() -> crate::input::start_object_input::Builder {
        crate::input::start_object_input::Builder::default()
    }
    /// Creates a new `StartObject` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for StartObject {
    type Output =
        std::result::Result<crate::output::StartObjectOutput, crate::error::StartObjectError>;
    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_object_error(response)
        } else {
            crate::operation_deser::parse_start_object_response(response)
        }
    }
}

/// Operation customization and supporting types
pub mod customize;