aws-sdk-codecatalyst 0.2.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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