aws-sdk-migrationhuborchestrator 0.5.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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