You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: generated.rs
    path of file: ./repos/rusoto/rusoto/services/cloudformation/src
    
    the code of the file until where you have to start completion: // =================================================================
//
//                           * WARNING *
//
//                    This file is generated!
//
//  Changes made to this file will be overwritten. If changes are
//  required to the generated code, the service_crategen project
//  must be updated to generate the changes.
//
// =================================================================

use std::error::Error;
use std::fmt;

use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};

use rusoto_core::param::{Params, ServiceParams};
use rusoto_core::proto::xml::error::*;
use rusoto_core::proto::xml::util::{
    self as xml_util, deserialize_elements, find_start_element, skip_tree,
};
use rusoto_core::proto::xml::util::{Next, Peek, XmlParseError, XmlResponse};
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[cfg(feature = "deserialize_structs")]
use serde::Deserialize;
#[cfg(feature = "serialize_structs")]
use serde::Serialize;
use serde_urlencoded;
use std::str::FromStr;
use xml::EventReader;

impl CloudFormationClient {
    fn new_params(&self, operation_name: &str) -> Params {
        let mut params = Params::new();

    
    pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateStackSetError> {
        {
            let reader = EventReader::new(res.body.as_ref());
            let mut stack = XmlResponse::new(reader.into_iter().peekable());
            find_start_element(&mut stack);
            if let Ok(parsed_error) = Self::deserialize(&mut stack) {
                match &parsed_error.code[..] {
                    "InvalidOperationException" => {
                        return RusotoError::Service(UpdateStackSetError::InvalidOperation(
                            parsed_error.message,
                        ))
                    }
                    "OperationIdAlreadyExistsException" => {
                        return RusotoError::Service(UpdateStackSetError::OperationIdAlreadyExists(
                            parsed_error.message,
                        ))
                    }
                    "OperationInProgressException" => {
                        return RusotoError::Service(UpdateStackSetError::OperationInProgress(
                            parsed_error.message,
                        ))
                    }
                    "StackInstanceNotFoundException" => {
                        return RusotoError::Service(UpdateStackSetError::StackInstanceNotFound(
                            parsed_error.message,
                        ))
                    }
                    "StackSetNotFoundException" => {
                        return RusotoError::Service(UpdateStackSetError::StackSetNotFound(
                            parsed_error.message,
                        ))
                    }
                    "StaleRequestException" => {
                        return RusotoError::Service(UpdateStackSetError::StaleRequest(
                            parsed_error.message,
                        ))
                    }
                    _ => {}
                }
            }
        }
        RusotoError::Unknown(res)
    }