// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// Operation shape for `ChangeGuideVisibility`.
///
/// This is usually constructed for you using the the fluent builder returned by
/// [`change_guide_visibility`](crate::client::Client::change_guide_visibility).
///
/// See [`crate::client::fluent_builders::ChangeGuideVisibility`] for more details about the operation.
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ChangeGuideVisibility {
    _private: (),
}
impl ChangeGuideVisibility {
    /// Creates a new builder-style object to manufacture [`ChangeGuideVisibilityInput`](crate::input::ChangeGuideVisibilityInput).
    pub fn builder() -> crate::input::change_guide_visibility_input::Builder {
        crate::input::change_guide_visibility_input::Builder::default()
    }
    /// Creates a new `ChangeGuideVisibility` operation.
    pub fn new() -> Self {
        Self { _private: () }
    }
}
impl aws_smithy_http::response::ParseStrictResponse for ChangeGuideVisibility {
    type Output = std::result::Result<
        crate::output::ChangeGuideVisibilityOutput,
        crate::error::ChangeGuideVisibilityError,
    >;
    fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
        if !response.status().is_success() && response.status().as_u16() != 200 {
            crate::operation_deser::parse_change_guide_visibility_error(response)
        } else {
            crate::operation_deser::parse_change_guide_visibility_response(response)
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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