aws-sdk-route53domains 0.24.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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