1#[async_trait::async_trait]
3impl<B, Fun, Fut>
4 crate::server_operation_handler_trait::Handler<B, (), crate::input::HealthcheckOperationInput>
5 for Fun
6where
7 Fun: FnOnce(crate::input::HealthcheckOperationInput) -> Fut + Clone + Send + 'static,
8 Fut: std::future::Future<
9 Output = Result<
10 crate::output::HealthcheckOperationOutput,
11 crate::error::HealthcheckOperationError,
12 >,
13 > + Send,
14 B: aws_smithy_http_server::HttpBody + Send + 'static,
15 B::Data: Send,
16 B::Error: Into<aws_smithy_http_server::BoxError>,
17 aws_smithy_http_server::rejection::SmithyRejection:
18 From<<B as aws_smithy_http_server::HttpBody>::Error>,
19{
20 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
21 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
22 let mut req = axum_core::extract::RequestParts::new(req);
23 use axum_core::extract::FromRequest;
24 use axum_core::response::IntoResponse;
25 let input_wrapper =
26 match crate::operation::HealthcheckOperationOperationInputWrapper::from_request(
27 &mut req,
28 )
29 .await
30 {
31 Ok(v) => v,
32 Err(r) => {
33 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
34 let mut response = r.into_response();
35 response.extensions_mut().insert(error);
36 return response.map(aws_smithy_http_server::boxed);
37 }
38 };
39 let input_inner = input_wrapper.into();
40 let output_inner = self(input_inner).await;
41 let output_wrapper: crate::operation::HealthcheckOperationOperationOutputWrapper =
42 output_inner.into();
43 output_wrapper
44 .into_response()
45 .map(aws_smithy_http_server::boxed)
46 }
47}
48#[async_trait::async_trait]
49impl<B, Fun, Fut>
50 crate::server_operation_handler_trait::Handler<B, (), crate::input::ListOperationInput> for Fun
51where
52 Fun: FnOnce(crate::input::ListOperationInput) -> Fut + Clone + Send + 'static,
53 Fut: std::future::Future<Output = crate::output::ListOperationOutput> + Send,
54 B: aws_smithy_http_server::HttpBody + Send + 'static,
55 B::Data: Send,
56 B::Error: Into<aws_smithy_http_server::BoxError>,
57 aws_smithy_http_server::rejection::SmithyRejection:
58 From<<B as aws_smithy_http_server::HttpBody>::Error>,
59{
60 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
61 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
62 let mut req = axum_core::extract::RequestParts::new(req);
63 use axum_core::extract::FromRequest;
64 use axum_core::response::IntoResponse;
65 let input_wrapper =
66 match crate::operation::ListOperationOperationInputWrapper::from_request(&mut req).await
67 {
68 Ok(v) => v,
69 Err(r) => {
70 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
71 let mut response = r.into_response();
72 response.extensions_mut().insert(error);
73 return response.map(aws_smithy_http_server::boxed);
74 }
75 };
76 let input_inner = input_wrapper.into();
77 let output_inner = self(input_inner).await;
78 let output_wrapper: crate::operation::ListOperationOperationOutputWrapper =
79 output_inner.into();
80 output_wrapper
81 .into_response()
82 .map(aws_smithy_http_server::boxed)
83 }
84}
85#[async_trait::async_trait]
86impl<B, Fun, Fut>
87 crate::server_operation_handler_trait::Handler<
88 B,
89 (),
90 crate::input::PrometheusTargetOperationInput,
91 > for Fun
92where
93 Fun: FnOnce(crate::input::PrometheusTargetOperationInput) -> Fut + Clone + Send + 'static,
94 Fut: std::future::Future<
95 Output = Result<
96 crate::output::PrometheusTargetOperationOutput,
97 crate::error::PrometheusTargetOperationError,
98 >,
99 > + Send,
100 B: aws_smithy_http_server::HttpBody + Send + 'static,
101 B::Data: Send,
102 B::Error: Into<aws_smithy_http_server::BoxError>,
103 aws_smithy_http_server::rejection::SmithyRejection:
104 From<<B as aws_smithy_http_server::HttpBody>::Error>,
105{
106 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
107 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
108 let mut req = axum_core::extract::RequestParts::new(req);
109 use axum_core::extract::FromRequest;
110 use axum_core::response::IntoResponse;
111 let input_wrapper =
112 match crate::operation::PrometheusTargetOperationOperationInputWrapper::from_request(
113 &mut req,
114 )
115 .await
116 {
117 Ok(v) => v,
118 Err(r) => {
119 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
120 let mut response = r.into_response();
121 response.extensions_mut().insert(error);
122 return response.map(aws_smithy_http_server::boxed);
123 }
124 };
125 let input_inner = input_wrapper.into();
126 let output_inner = self(input_inner).await;
127 let output_wrapper: crate::operation::PrometheusTargetOperationOperationOutputWrapper =
128 output_inner.into();
129 output_wrapper
130 .into_response()
131 .map(aws_smithy_http_server::boxed)
132 }
133}
134#[async_trait::async_trait]
135impl<B, Fun, Fut>
136 crate::server_operation_handler_trait::Handler<B, (), crate::input::RestartOperationInput>
137 for Fun
138where
139 Fun: FnOnce(crate::input::RestartOperationInput) -> Fut + Clone + Send + 'static,
140 Fut: std::future::Future<
141 Output = Result<
142 crate::output::RestartOperationOutput,
143 crate::error::RestartOperationError,
144 >,
145 > + Send,
146 B: aws_smithy_http_server::HttpBody + Send + 'static,
147 B::Data: Send,
148 B::Error: Into<aws_smithy_http_server::BoxError>,
149 aws_smithy_http_server::rejection::SmithyRejection:
150 From<<B as aws_smithy_http_server::HttpBody>::Error>,
151{
152 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
153 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
154 let mut req = axum_core::extract::RequestParts::new(req);
155 use axum_core::extract::FromRequest;
156 use axum_core::response::IntoResponse;
157 let input_wrapper =
158 match crate::operation::RestartOperationOperationInputWrapper::from_request(&mut req)
159 .await
160 {
161 Ok(v) => v,
162 Err(r) => {
163 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
164 let mut response = r.into_response();
165 response.extensions_mut().insert(error);
166 return response.map(aws_smithy_http_server::boxed);
167 }
168 };
169 let input_inner = input_wrapper.into();
170 let output_inner = self(input_inner).await;
171 let output_wrapper: crate::operation::RestartOperationOperationOutputWrapper =
172 output_inner.into();
173 output_wrapper
174 .into_response()
175 .map(aws_smithy_http_server::boxed)
176 }
177}
178#[async_trait::async_trait]
179impl<B, Fun, Fut>
180 crate::server_operation_handler_trait::Handler<B, (), crate::input::StartOperationInput> for Fun
181where
182 Fun: FnOnce(crate::input::StartOperationInput) -> Fut + Clone + Send + 'static,
183 Fut: std::future::Future<
184 Output = Result<crate::output::StartOperationOutput, crate::error::StartOperationError>,
185 > + Send,
186 B: aws_smithy_http_server::HttpBody + Send + 'static,
187 B::Data: Send,
188 B::Error: Into<aws_smithy_http_server::BoxError>,
189 aws_smithy_http_server::rejection::SmithyRejection:
190 From<<B as aws_smithy_http_server::HttpBody>::Error>,
191{
192 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
193 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
194 let mut req = axum_core::extract::RequestParts::new(req);
195 use axum_core::extract::FromRequest;
196 use axum_core::response::IntoResponse;
197 let input_wrapper =
198 match crate::operation::StartOperationOperationInputWrapper::from_request(&mut req)
199 .await
200 {
201 Ok(v) => v,
202 Err(r) => {
203 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
204 let mut response = r.into_response();
205 response.extensions_mut().insert(error);
206 return response.map(aws_smithy_http_server::boxed);
207 }
208 };
209 let input_inner = input_wrapper.into();
210 let output_inner = self(input_inner).await;
211 let output_wrapper: crate::operation::StartOperationOperationOutputWrapper =
212 output_inner.into();
213 output_wrapper
214 .into_response()
215 .map(aws_smithy_http_server::boxed)
216 }
217}
218#[async_trait::async_trait]
219impl<B, Fun, Fut>
220 crate::server_operation_handler_trait::Handler<B, (), crate::input::StopOperationInput> for Fun
221where
222 Fun: FnOnce(crate::input::StopOperationInput) -> Fut + Clone + Send + 'static,
223 Fut: std::future::Future<
224 Output = Result<crate::output::StopOperationOutput, crate::error::StopOperationError>,
225 > + Send,
226 B: aws_smithy_http_server::HttpBody + Send + 'static,
227 B::Data: Send,
228 B::Error: Into<aws_smithy_http_server::BoxError>,
229 aws_smithy_http_server::rejection::SmithyRejection:
230 From<<B as aws_smithy_http_server::HttpBody>::Error>,
231{
232 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
233 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
234 let mut req = axum_core::extract::RequestParts::new(req);
235 use axum_core::extract::FromRequest;
236 use axum_core::response::IntoResponse;
237 let input_wrapper =
238 match crate::operation::StopOperationOperationInputWrapper::from_request(&mut req).await
239 {
240 Ok(v) => v,
241 Err(r) => {
242 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
243 let mut response = r.into_response();
244 response.extensions_mut().insert(error);
245 return response.map(aws_smithy_http_server::boxed);
246 }
247 };
248 let input_inner = input_wrapper.into();
249 let output_inner = self(input_inner).await;
250 let output_wrapper: crate::operation::StopOperationOperationOutputWrapper =
251 output_inner.into();
252 output_wrapper
253 .into_response()
254 .map(aws_smithy_http_server::boxed)
255 }
256}
257#[async_trait::async_trait]
258impl<B, Fun, Fut, S>
259 crate::server_operation_handler_trait::Handler<
260 B,
261 aws_smithy_http_server::Extension<S>,
262 crate::input::HealthcheckOperationInput,
263 > for Fun
264where
265 S: Send + Clone + Sync + 'static,
266 Fun: FnOnce(crate::input::HealthcheckOperationInput, aws_smithy_http_server::Extension<S>) -> Fut
267 + Clone
268 + Send
269 + 'static,
270 Fut: std::future::Future<
271 Output = Result<
272 crate::output::HealthcheckOperationOutput,
273 crate::error::HealthcheckOperationError,
274 >,
275 > + Send,
276 B: aws_smithy_http_server::HttpBody + Send + 'static,
277 B::Data: Send,
278 B::Error: Into<aws_smithy_http_server::BoxError>,
279 aws_smithy_http_server::rejection::SmithyRejection:
280 From<<B as aws_smithy_http_server::HttpBody>::Error>,
281{
282 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
283 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
284 let mut req = axum_core::extract::RequestParts::new(req);
285 use axum_core::extract::FromRequest;
286 use axum_core::response::IntoResponse;
287 let input_wrapper =
288 match crate::operation::HealthcheckOperationOperationInputWrapper::from_request(
289 &mut req,
290 )
291 .await
292 {
293 Ok(v) => v,
294 Err(r) => {
295 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
296 let mut response = r.into_response();
297 response.extensions_mut().insert(error);
298 return response.map(aws_smithy_http_server::boxed);
299 }
300 };
301 let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
302 Ok(v) => v,
303 Err(r) => {
304 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
305 let mut response = r.into_response();
306 response.extensions_mut().insert(error);
307 return response.map(aws_smithy_http_server::boxed);
308 }
309 };
310 let input_inner = input_wrapper.into();
311 let output_inner = self(input_inner, state).await;
312 let output_wrapper: crate::operation::HealthcheckOperationOperationOutputWrapper =
313 output_inner.into();
314 output_wrapper
315 .into_response()
316 .map(aws_smithy_http_server::boxed)
317 }
318}
319#[async_trait::async_trait]
320impl<B, Fun, Fut, S>
321 crate::server_operation_handler_trait::Handler<
322 B,
323 aws_smithy_http_server::Extension<S>,
324 crate::input::ListOperationInput,
325 > for Fun
326where
327 S: Send + Clone + Sync + 'static,
328 Fun: FnOnce(crate::input::ListOperationInput, aws_smithy_http_server::Extension<S>) -> Fut
329 + Clone
330 + Send
331 + 'static,
332 Fut: std::future::Future<Output = crate::output::ListOperationOutput> + Send,
333 B: aws_smithy_http_server::HttpBody + Send + 'static,
334 B::Data: Send,
335 B::Error: Into<aws_smithy_http_server::BoxError>,
336 aws_smithy_http_server::rejection::SmithyRejection:
337 From<<B as aws_smithy_http_server::HttpBody>::Error>,
338{
339 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
340 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
341 let mut req = axum_core::extract::RequestParts::new(req);
342 use axum_core::extract::FromRequest;
343 use axum_core::response::IntoResponse;
344 let input_wrapper =
345 match crate::operation::ListOperationOperationInputWrapper::from_request(&mut req).await
346 {
347 Ok(v) => v,
348 Err(r) => {
349 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
350 let mut response = r.into_response();
351 response.extensions_mut().insert(error);
352 return response.map(aws_smithy_http_server::boxed);
353 }
354 };
355 let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
356 Ok(v) => v,
357 Err(r) => {
358 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
359 let mut response = r.into_response();
360 response.extensions_mut().insert(error);
361 return response.map(aws_smithy_http_server::boxed);
362 }
363 };
364 let input_inner = input_wrapper.into();
365 let output_inner = self(input_inner, state).await;
366 let output_wrapper: crate::operation::ListOperationOperationOutputWrapper =
367 output_inner.into();
368 output_wrapper
369 .into_response()
370 .map(aws_smithy_http_server::boxed)
371 }
372}
373#[async_trait::async_trait]
374impl<B, Fun, Fut, S>
375 crate::server_operation_handler_trait::Handler<
376 B,
377 aws_smithy_http_server::Extension<S>,
378 crate::input::PrometheusTargetOperationInput,
379 > for Fun
380where
381 S: Send + Clone + Sync + 'static,
382 Fun: FnOnce(
383 crate::input::PrometheusTargetOperationInput,
384 aws_smithy_http_server::Extension<S>,
385 ) -> Fut
386 + Clone
387 + Send
388 + 'static,
389 Fut: std::future::Future<
390 Output = Result<
391 crate::output::PrometheusTargetOperationOutput,
392 crate::error::PrometheusTargetOperationError,
393 >,
394 > + Send,
395 B: aws_smithy_http_server::HttpBody + Send + 'static,
396 B::Data: Send,
397 B::Error: Into<aws_smithy_http_server::BoxError>,
398 aws_smithy_http_server::rejection::SmithyRejection:
399 From<<B as aws_smithy_http_server::HttpBody>::Error>,
400{
401 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
402 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
403 let mut req = axum_core::extract::RequestParts::new(req);
404 use axum_core::extract::FromRequest;
405 use axum_core::response::IntoResponse;
406 let input_wrapper =
407 match crate::operation::PrometheusTargetOperationOperationInputWrapper::from_request(
408 &mut req,
409 )
410 .await
411 {
412 Ok(v) => v,
413 Err(r) => {
414 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
415 let mut response = r.into_response();
416 response.extensions_mut().insert(error);
417 return response.map(aws_smithy_http_server::boxed);
418 }
419 };
420 let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
421 Ok(v) => v,
422 Err(r) => {
423 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
424 let mut response = r.into_response();
425 response.extensions_mut().insert(error);
426 return response.map(aws_smithy_http_server::boxed);
427 }
428 };
429 let input_inner = input_wrapper.into();
430 let output_inner = self(input_inner, state).await;
431 let output_wrapper: crate::operation::PrometheusTargetOperationOperationOutputWrapper =
432 output_inner.into();
433 output_wrapper
434 .into_response()
435 .map(aws_smithy_http_server::boxed)
436 }
437}
438#[async_trait::async_trait]
439impl<B, Fun, Fut, S>
440 crate::server_operation_handler_trait::Handler<
441 B,
442 aws_smithy_http_server::Extension<S>,
443 crate::input::RestartOperationInput,
444 > for Fun
445where
446 S: Send + Clone + Sync + 'static,
447 Fun: FnOnce(crate::input::RestartOperationInput, aws_smithy_http_server::Extension<S>) -> Fut
448 + Clone
449 + Send
450 + 'static,
451 Fut: std::future::Future<
452 Output = Result<
453 crate::output::RestartOperationOutput,
454 crate::error::RestartOperationError,
455 >,
456 > + Send,
457 B: aws_smithy_http_server::HttpBody + Send + 'static,
458 B::Data: Send,
459 B::Error: Into<aws_smithy_http_server::BoxError>,
460 aws_smithy_http_server::rejection::SmithyRejection:
461 From<<B as aws_smithy_http_server::HttpBody>::Error>,
462{
463 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
464 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
465 let mut req = axum_core::extract::RequestParts::new(req);
466 use axum_core::extract::FromRequest;
467 use axum_core::response::IntoResponse;
468 let input_wrapper =
469 match crate::operation::RestartOperationOperationInputWrapper::from_request(&mut req)
470 .await
471 {
472 Ok(v) => v,
473 Err(r) => {
474 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
475 let mut response = r.into_response();
476 response.extensions_mut().insert(error);
477 return response.map(aws_smithy_http_server::boxed);
478 }
479 };
480 let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
481 Ok(v) => v,
482 Err(r) => {
483 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
484 let mut response = r.into_response();
485 response.extensions_mut().insert(error);
486 return response.map(aws_smithy_http_server::boxed);
487 }
488 };
489 let input_inner = input_wrapper.into();
490 let output_inner = self(input_inner, state).await;
491 let output_wrapper: crate::operation::RestartOperationOperationOutputWrapper =
492 output_inner.into();
493 output_wrapper
494 .into_response()
495 .map(aws_smithy_http_server::boxed)
496 }
497}
498#[async_trait::async_trait]
499impl<B, Fun, Fut, S>
500 crate::server_operation_handler_trait::Handler<
501 B,
502 aws_smithy_http_server::Extension<S>,
503 crate::input::StartOperationInput,
504 > for Fun
505where
506 S: Send + Clone + Sync + 'static,
507 Fun: FnOnce(crate::input::StartOperationInput, aws_smithy_http_server::Extension<S>) -> Fut
508 + Clone
509 + Send
510 + 'static,
511 Fut: std::future::Future<
512 Output = Result<crate::output::StartOperationOutput, crate::error::StartOperationError>,
513 > + Send,
514 B: aws_smithy_http_server::HttpBody + Send + 'static,
515 B::Data: Send,
516 B::Error: Into<aws_smithy_http_server::BoxError>,
517 aws_smithy_http_server::rejection::SmithyRejection:
518 From<<B as aws_smithy_http_server::HttpBody>::Error>,
519{
520 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
521 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
522 let mut req = axum_core::extract::RequestParts::new(req);
523 use axum_core::extract::FromRequest;
524 use axum_core::response::IntoResponse;
525 let input_wrapper =
526 match crate::operation::StartOperationOperationInputWrapper::from_request(&mut req)
527 .await
528 {
529 Ok(v) => v,
530 Err(r) => {
531 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
532 let mut response = r.into_response();
533 response.extensions_mut().insert(error);
534 return response.map(aws_smithy_http_server::boxed);
535 }
536 };
537 let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
538 Ok(v) => v,
539 Err(r) => {
540 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
541 let mut response = r.into_response();
542 response.extensions_mut().insert(error);
543 return response.map(aws_smithy_http_server::boxed);
544 }
545 };
546 let input_inner = input_wrapper.into();
547 let output_inner = self(input_inner, state).await;
548 let output_wrapper: crate::operation::StartOperationOperationOutputWrapper =
549 output_inner.into();
550 output_wrapper
551 .into_response()
552 .map(aws_smithy_http_server::boxed)
553 }
554}
555#[async_trait::async_trait]
556impl<B, Fun, Fut, S>
557 crate::server_operation_handler_trait::Handler<
558 B,
559 aws_smithy_http_server::Extension<S>,
560 crate::input::StopOperationInput,
561 > for Fun
562where
563 S: Send + Clone + Sync + 'static,
564 Fun: FnOnce(crate::input::StopOperationInput, aws_smithy_http_server::Extension<S>) -> Fut
565 + Clone
566 + Send
567 + 'static,
568 Fut: std::future::Future<
569 Output = Result<crate::output::StopOperationOutput, crate::error::StopOperationError>,
570 > + Send,
571 B: aws_smithy_http_server::HttpBody + Send + 'static,
572 B::Data: Send,
573 B::Error: Into<aws_smithy_http_server::BoxError>,
574 aws_smithy_http_server::rejection::SmithyRejection:
575 From<<B as aws_smithy_http_server::HttpBody>::Error>,
576{
577 type Sealed = crate::server_operation_handler_trait::sealed::Hidden;
578 async fn call(self, req: http::Request<B>) -> http::Response<aws_smithy_http_server::BoxBody> {
579 let mut req = axum_core::extract::RequestParts::new(req);
580 use axum_core::extract::FromRequest;
581 use axum_core::response::IntoResponse;
582 let input_wrapper =
583 match crate::operation::StopOperationOperationInputWrapper::from_request(&mut req).await
584 {
585 Ok(v) => v,
586 Err(r) => {
587 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
588 let mut response = r.into_response();
589 response.extensions_mut().insert(error);
590 return response.map(aws_smithy_http_server::boxed);
591 }
592 };
593 let state = match aws_smithy_http_server::Extension::<S>::from_request(&mut req).await {
594 Ok(v) => v,
595 Err(r) => {
596 let error = aws_smithy_http_server::ExtensionRejection::new(r.to_string());
597 let mut response = r.into_response();
598 response.extensions_mut().insert(error);
599 return response.map(aws_smithy_http_server::boxed);
600 }
601 };
602 let input_inner = input_wrapper.into();
603 let output_inner = self(input_inner, state).await;
604 let output_wrapper: crate::operation::StopOperationOperationOutputWrapper =
605 output_inner.into();
606 output_wrapper
607 .into_response()
608 .map(aws_smithy_http_server::boxed)
609 }
610}