tsiry-sandratraina.com / tunein-cli
Browse and listen to thousands of radio stations across the globe right from your terminal 🌎 📻 🎵✨
radio rust tokio web-radio command-line-tool tui
6
fork

Configure Feed

Select the types of activity you want to include in your feed.

run cargo fmt

tsiry-sandratraina.com fa8249bd ef0ae159

fmt.yml
+125 -235
+125 -235
src/api/tunein.v1alpha1.rs
··· 39 39 #[derive(Clone, PartialEq, ::prost::Message)] 40 40 pub struct GetStationDetailsResponse { 41 41 #[prost(message, optional, tag = "1")] 42 - pub station_link_details: ::core::option::Option< 43 - super::super::objects::v1alpha1::StationLinkDetails, 44 - >, 42 + pub station_link_details: 43 + ::core::option::Option<super::super::objects::v1alpha1::StationLinkDetails>, 45 44 } 46 45 #[derive(Clone, PartialEq, ::prost::Message)] 47 46 pub struct SearchRequest { ··· 62 61 dead_code, 63 62 missing_docs, 64 63 clippy::wildcard_imports, 65 - clippy::let_unit_value, 64 + clippy::let_unit_value 66 65 )] 67 - use tonic::codegen::*; 68 66 use tonic::codegen::http::Uri; 67 + use tonic::codegen::*; 69 68 #[derive(Debug, Clone)] 70 69 pub struct BrowseServiceClient<T> { 71 70 inner: tonic::client::Grpc<T>, ··· 109 108 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 110 109 >, 111 110 >, 112 - <T as tonic::codegen::Service< 113 - http::Request<tonic::body::BoxBody>, 114 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 111 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 112 + Into<StdError> + std::marker::Send + std::marker::Sync, 115 113 { 116 114 BrowseServiceClient::new(InterceptedService::new(inner, interceptor)) 117 115 } ··· 149 147 pub async fn get_categories( 150 148 &mut self, 151 149 request: impl tonic::IntoRequest<super::GetCategoriesRequest>, 152 - ) -> std::result::Result< 153 - tonic::Response<super::GetCategoriesResponse>, 154 - tonic::Status, 155 - > { 156 - self.inner 157 - .ready() 158 - .await 159 - .map_err(|e| { 160 - tonic::Status::unknown( 161 - format!("Service was not ready: {}", e.into()), 162 - ) 163 - })?; 150 + ) -> std::result::Result<tonic::Response<super::GetCategoriesResponse>, tonic::Status> 151 + { 152 + self.inner.ready().await.map_err(|e| { 153 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 154 + })?; 164 155 let codec = tonic::codec::ProstCodec::default(); 165 156 let path = http::uri::PathAndQuery::from_static( 166 157 "/tunein.v1alpha1.BrowseService/GetCategories", 167 158 ); 168 159 let mut req = request.into_request(); 169 - req.extensions_mut() 170 - .insert( 171 - GrpcMethod::new("tunein.v1alpha1.BrowseService", "GetCategories"), 172 - ); 160 + req.extensions_mut().insert(GrpcMethod::new( 161 + "tunein.v1alpha1.BrowseService", 162 + "GetCategories", 163 + )); 173 164 self.inner.unary(req, path, codec).await 174 165 } 175 166 pub async fn browse_category( 176 167 &mut self, 177 168 request: impl tonic::IntoRequest<super::BrowseCategoryRequest>, 178 - ) -> std::result::Result< 179 - tonic::Response<super::BrowseCategoryResponse>, 180 - tonic::Status, 181 - > { 182 - self.inner 183 - .ready() 184 - .await 185 - .map_err(|e| { 186 - tonic::Status::unknown( 187 - format!("Service was not ready: {}", e.into()), 188 - ) 189 - })?; 169 + ) -> std::result::Result<tonic::Response<super::BrowseCategoryResponse>, tonic::Status> 170 + { 171 + self.inner.ready().await.map_err(|e| { 172 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 173 + })?; 190 174 let codec = tonic::codec::ProstCodec::default(); 191 175 let path = http::uri::PathAndQuery::from_static( 192 176 "/tunein.v1alpha1.BrowseService/BrowseCategory", 193 177 ); 194 178 let mut req = request.into_request(); 195 - req.extensions_mut() 196 - .insert( 197 - GrpcMethod::new("tunein.v1alpha1.BrowseService", "BrowseCategory"), 198 - ); 179 + req.extensions_mut().insert(GrpcMethod::new( 180 + "tunein.v1alpha1.BrowseService", 181 + "BrowseCategory", 182 + )); 199 183 self.inner.unary(req, path, codec).await 200 184 } 201 185 pub async fn get_station_details( 202 186 &mut self, 203 187 request: impl tonic::IntoRequest<super::GetStationDetailsRequest>, 204 - ) -> std::result::Result< 205 - tonic::Response<super::GetStationDetailsResponse>, 206 - tonic::Status, 207 - > { 208 - self.inner 209 - .ready() 210 - .await 211 - .map_err(|e| { 212 - tonic::Status::unknown( 213 - format!("Service was not ready: {}", e.into()), 214 - ) 215 - })?; 188 + ) -> std::result::Result<tonic::Response<super::GetStationDetailsResponse>, tonic::Status> 189 + { 190 + self.inner.ready().await.map_err(|e| { 191 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 192 + })?; 216 193 let codec = tonic::codec::ProstCodec::default(); 217 194 let path = http::uri::PathAndQuery::from_static( 218 195 "/tunein.v1alpha1.BrowseService/GetStationDetails", 219 196 ); 220 197 let mut req = request.into_request(); 221 - req.extensions_mut() 222 - .insert( 223 - GrpcMethod::new("tunein.v1alpha1.BrowseService", "GetStationDetails"), 224 - ); 198 + req.extensions_mut().insert(GrpcMethod::new( 199 + "tunein.v1alpha1.BrowseService", 200 + "GetStationDetails", 201 + )); 225 202 self.inner.unary(req, path, codec).await 226 203 } 227 204 pub async fn search( 228 205 &mut self, 229 206 request: impl tonic::IntoRequest<super::SearchRequest>, 230 207 ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status> { 231 - self.inner 232 - .ready() 233 - .await 234 - .map_err(|e| { 235 - tonic::Status::unknown( 236 - format!("Service was not ready: {}", e.into()), 237 - ) 238 - })?; 208 + self.inner.ready().await.map_err(|e| { 209 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 210 + })?; 239 211 let codec = tonic::codec::ProstCodec::default(); 240 - let path = http::uri::PathAndQuery::from_static( 241 - "/tunein.v1alpha1.BrowseService/Search", 242 - ); 212 + let path = 213 + http::uri::PathAndQuery::from_static("/tunein.v1alpha1.BrowseService/Search"); 243 214 let mut req = request.into_request(); 244 215 req.extensions_mut() 245 216 .insert(GrpcMethod::new("tunein.v1alpha1.BrowseService", "Search")); ··· 254 225 dead_code, 255 226 missing_docs, 256 227 clippy::wildcard_imports, 257 - clippy::let_unit_value, 228 + clippy::let_unit_value 258 229 )] 259 230 use tonic::codegen::*; 260 231 /// Generated trait containing gRPC methods that should be implemented for use with BrowseServiceServer. ··· 263 234 async fn get_categories( 264 235 &self, 265 236 request: tonic::Request<super::GetCategoriesRequest>, 266 - ) -> std::result::Result< 267 - tonic::Response<super::GetCategoriesResponse>, 268 - tonic::Status, 269 - >; 237 + ) -> std::result::Result<tonic::Response<super::GetCategoriesResponse>, tonic::Status>; 270 238 async fn browse_category( 271 239 &self, 272 240 request: tonic::Request<super::BrowseCategoryRequest>, 273 - ) -> std::result::Result< 274 - tonic::Response<super::BrowseCategoryResponse>, 275 - tonic::Status, 276 - >; 241 + ) -> std::result::Result<tonic::Response<super::BrowseCategoryResponse>, tonic::Status>; 277 242 async fn get_station_details( 278 243 &self, 279 244 request: tonic::Request<super::GetStationDetailsRequest>, 280 - ) -> std::result::Result< 281 - tonic::Response<super::GetStationDetailsResponse>, 282 - tonic::Status, 283 - >; 245 + ) -> std::result::Result<tonic::Response<super::GetStationDetailsResponse>, tonic::Status>; 284 246 async fn search( 285 247 &self, 286 248 request: tonic::Request<super::SearchRequest>, ··· 307 269 max_encoding_message_size: None, 308 270 } 309 271 } 310 - pub fn with_interceptor<F>( 311 - inner: T, 312 - interceptor: F, 313 - ) -> InterceptedService<Self, F> 272 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 314 273 where 315 274 F: tonic::service::Interceptor, 316 275 { ··· 365 324 "/tunein.v1alpha1.BrowseService/GetCategories" => { 366 325 #[allow(non_camel_case_types)] 367 326 struct GetCategoriesSvc<T: BrowseService>(pub Arc<T>); 368 - impl< 369 - T: BrowseService, 370 - > tonic::server::UnaryService<super::GetCategoriesRequest> 371 - for GetCategoriesSvc<T> { 327 + impl<T: BrowseService> tonic::server::UnaryService<super::GetCategoriesRequest> 328 + for GetCategoriesSvc<T> 329 + { 372 330 type Response = super::GetCategoriesResponse; 373 - type Future = BoxFuture< 374 - tonic::Response<Self::Response>, 375 - tonic::Status, 376 - >; 331 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 377 332 fn call( 378 333 &mut self, 379 334 request: tonic::Request<super::GetCategoriesRequest>, ··· 410 365 "/tunein.v1alpha1.BrowseService/BrowseCategory" => { 411 366 #[allow(non_camel_case_types)] 412 367 struct BrowseCategorySvc<T: BrowseService>(pub Arc<T>); 413 - impl< 414 - T: BrowseService, 415 - > tonic::server::UnaryService<super::BrowseCategoryRequest> 416 - for BrowseCategorySvc<T> { 368 + impl<T: BrowseService> tonic::server::UnaryService<super::BrowseCategoryRequest> 369 + for BrowseCategorySvc<T> 370 + { 417 371 type Response = super::BrowseCategoryResponse; 418 - type Future = BoxFuture< 419 - tonic::Response<Self::Response>, 420 - tonic::Status, 421 - >; 372 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 422 373 fn call( 423 374 &mut self, 424 375 request: tonic::Request<super::BrowseCategoryRequest>, ··· 455 406 "/tunein.v1alpha1.BrowseService/GetStationDetails" => { 456 407 #[allow(non_camel_case_types)] 457 408 struct GetStationDetailsSvc<T: BrowseService>(pub Arc<T>); 458 - impl< 459 - T: BrowseService, 460 - > tonic::server::UnaryService<super::GetStationDetailsRequest> 461 - for GetStationDetailsSvc<T> { 409 + impl<T: BrowseService> 410 + tonic::server::UnaryService<super::GetStationDetailsRequest> 411 + for GetStationDetailsSvc<T> 412 + { 462 413 type Response = super::GetStationDetailsResponse; 463 - type Future = BoxFuture< 464 - tonic::Response<Self::Response>, 465 - tonic::Status, 466 - >; 414 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 467 415 fn call( 468 416 &mut self, 469 417 request: tonic::Request<super::GetStationDetailsRequest>, 470 418 ) -> Self::Future { 471 419 let inner = Arc::clone(&self.0); 472 420 let fut = async move { 473 - <T as BrowseService>::get_station_details(&inner, request) 474 - .await 421 + <T as BrowseService>::get_station_details(&inner, request).await 475 422 }; 476 423 Box::pin(fut) 477 424 } ··· 501 448 "/tunein.v1alpha1.BrowseService/Search" => { 502 449 #[allow(non_camel_case_types)] 503 450 struct SearchSvc<T: BrowseService>(pub Arc<T>); 504 - impl< 505 - T: BrowseService, 506 - > tonic::server::UnaryService<super::SearchRequest> 507 - for SearchSvc<T> { 451 + impl<T: BrowseService> tonic::server::UnaryService<super::SearchRequest> for SearchSvc<T> { 508 452 type Response = super::SearchResponse; 509 - type Future = BoxFuture< 510 - tonic::Response<Self::Response>, 511 - tonic::Status, 512 - >; 453 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 513 454 fn call( 514 455 &mut self, 515 456 request: tonic::Request<super::SearchRequest>, 516 457 ) -> Self::Future { 517 458 let inner = Arc::clone(&self.0); 518 - let fut = async move { 519 - <T as BrowseService>::search(&inner, request).await 520 - }; 459 + let fut = 460 + async move { <T as BrowseService>::search(&inner, request).await }; 521 461 Box::pin(fut) 522 462 } 523 463 } ··· 543 483 }; 544 484 Box::pin(fut) 545 485 } 546 - _ => { 547 - Box::pin(async move { 548 - let mut response = http::Response::new(empty_body()); 549 - let headers = response.headers_mut(); 550 - headers 551 - .insert( 552 - tonic::Status::GRPC_STATUS, 553 - (tonic::Code::Unimplemented as i32).into(), 554 - ); 555 - headers 556 - .insert( 557 - http::header::CONTENT_TYPE, 558 - tonic::metadata::GRPC_CONTENT_TYPE, 559 - ); 560 - Ok(response) 561 - }) 562 - } 486 + _ => Box::pin(async move { 487 + let mut response = http::Response::new(empty_body()); 488 + let headers = response.headers_mut(); 489 + headers.insert( 490 + tonic::Status::GRPC_STATUS, 491 + (tonic::Code::Unimplemented as i32).into(), 492 + ); 493 + headers.insert( 494 + http::header::CONTENT_TYPE, 495 + tonic::metadata::GRPC_CONTENT_TYPE, 496 + ); 497 + Ok(response) 498 + }), 563 499 } 564 500 } 565 501 } ··· 605 541 dead_code, 606 542 missing_docs, 607 543 clippy::wildcard_imports, 608 - clippy::let_unit_value, 544 + clippy::let_unit_value 609 545 )] 610 - use tonic::codegen::*; 611 546 use tonic::codegen::http::Uri; 547 + use tonic::codegen::*; 612 548 #[derive(Debug, Clone)] 613 549 pub struct PlaybackServiceClient<T> { 614 550 inner: tonic::client::Grpc<T>, ··· 652 588 <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody, 653 589 >, 654 590 >, 655 - <T as tonic::codegen::Service< 656 - http::Request<tonic::body::BoxBody>, 657 - >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync, 591 + <T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error: 592 + Into<StdError> + std::marker::Send + std::marker::Sync, 658 593 { 659 594 PlaybackServiceClient::new(InterceptedService::new(inner, interceptor)) 660 595 } ··· 693 628 &mut self, 694 629 request: impl tonic::IntoRequest<super::PlayRequest>, 695 630 ) -> std::result::Result<tonic::Response<super::PlayResponse>, tonic::Status> { 696 - self.inner 697 - .ready() 698 - .await 699 - .map_err(|e| { 700 - tonic::Status::unknown( 701 - format!("Service was not ready: {}", e.into()), 702 - ) 703 - })?; 631 + self.inner.ready().await.map_err(|e| { 632 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 633 + })?; 704 634 let codec = tonic::codec::ProstCodec::default(); 705 - let path = http::uri::PathAndQuery::from_static( 706 - "/tunein.v1alpha1.PlaybackService/Play", 707 - ); 635 + let path = 636 + http::uri::PathAndQuery::from_static("/tunein.v1alpha1.PlaybackService/Play"); 708 637 let mut req = request.into_request(); 709 638 req.extensions_mut() 710 639 .insert(GrpcMethod::new("tunein.v1alpha1.PlaybackService", "Play")); ··· 714 643 &mut self, 715 644 request: impl tonic::IntoRequest<super::StopRequest>, 716 645 ) -> std::result::Result<tonic::Response<super::StopResponse>, tonic::Status> { 717 - self.inner 718 - .ready() 719 - .await 720 - .map_err(|e| { 721 - tonic::Status::unknown( 722 - format!("Service was not ready: {}", e.into()), 723 - ) 724 - })?; 646 + self.inner.ready().await.map_err(|e| { 647 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 648 + })?; 725 649 let codec = tonic::codec::ProstCodec::default(); 726 - let path = http::uri::PathAndQuery::from_static( 727 - "/tunein.v1alpha1.PlaybackService/Stop", 728 - ); 650 + let path = 651 + http::uri::PathAndQuery::from_static("/tunein.v1alpha1.PlaybackService/Stop"); 729 652 let mut req = request.into_request(); 730 653 req.extensions_mut() 731 654 .insert(GrpcMethod::new("tunein.v1alpha1.PlaybackService", "Stop")); ··· 734 657 pub async fn play_or_pause( 735 658 &mut self, 736 659 request: impl tonic::IntoRequest<super::PlayOrPauseRequest>, 737 - ) -> std::result::Result< 738 - tonic::Response<super::PlayOrPauseResponse>, 739 - tonic::Status, 740 - > { 741 - self.inner 742 - .ready() 743 - .await 744 - .map_err(|e| { 745 - tonic::Status::unknown( 746 - format!("Service was not ready: {}", e.into()), 747 - ) 748 - })?; 660 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status> 661 + { 662 + self.inner.ready().await.map_err(|e| { 663 + tonic::Status::unknown(format!("Service was not ready: {}", e.into())) 664 + })?; 749 665 let codec = tonic::codec::ProstCodec::default(); 750 666 let path = http::uri::PathAndQuery::from_static( 751 667 "/tunein.v1alpha1.PlaybackService/PlayOrPause", 752 668 ); 753 669 let mut req = request.into_request(); 754 - req.extensions_mut() 755 - .insert( 756 - GrpcMethod::new("tunein.v1alpha1.PlaybackService", "PlayOrPause"), 757 - ); 670 + req.extensions_mut().insert(GrpcMethod::new( 671 + "tunein.v1alpha1.PlaybackService", 672 + "PlayOrPause", 673 + )); 758 674 self.inner.unary(req, path, codec).await 759 675 } 760 676 } ··· 766 682 dead_code, 767 683 missing_docs, 768 684 clippy::wildcard_imports, 769 - clippy::let_unit_value, 685 + clippy::let_unit_value 770 686 )] 771 687 use tonic::codegen::*; 772 688 /// Generated trait containing gRPC methods that should be implemented for use with PlaybackServiceServer. ··· 783 699 async fn play_or_pause( 784 700 &self, 785 701 request: tonic::Request<super::PlayOrPauseRequest>, 786 - ) -> std::result::Result< 787 - tonic::Response<super::PlayOrPauseResponse>, 788 - tonic::Status, 789 - >; 702 + ) -> std::result::Result<tonic::Response<super::PlayOrPauseResponse>, tonic::Status>; 790 703 } 791 704 #[derive(Debug)] 792 705 pub struct PlaybackServiceServer<T> { ··· 809 722 max_encoding_message_size: None, 810 723 } 811 724 } 812 - pub fn with_interceptor<F>( 813 - inner: T, 814 - interceptor: F, 815 - ) -> InterceptedService<Self, F> 725 + pub fn with_interceptor<F>(inner: T, interceptor: F) -> InterceptedService<Self, F> 816 726 where 817 727 F: tonic::service::Interceptor, 818 728 { ··· 867 777 "/tunein.v1alpha1.PlaybackService/Play" => { 868 778 #[allow(non_camel_case_types)] 869 779 struct PlaySvc<T: PlaybackService>(pub Arc<T>); 870 - impl< 871 - T: PlaybackService, 872 - > tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 780 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayRequest> for PlaySvc<T> { 873 781 type Response = super::PlayResponse; 874 - type Future = BoxFuture< 875 - tonic::Response<Self::Response>, 876 - tonic::Status, 877 - >; 782 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 878 783 fn call( 879 784 &mut self, 880 785 request: tonic::Request<super::PlayRequest>, 881 786 ) -> Self::Future { 882 787 let inner = Arc::clone(&self.0); 883 - let fut = async move { 884 - <T as PlaybackService>::play(&inner, request).await 885 - }; 788 + let fut = 789 + async move { <T as PlaybackService>::play(&inner, request).await }; 886 790 Box::pin(fut) 887 791 } 888 792 } ··· 911 815 "/tunein.v1alpha1.PlaybackService/Stop" => { 912 816 #[allow(non_camel_case_types)] 913 817 struct StopSvc<T: PlaybackService>(pub Arc<T>); 914 - impl< 915 - T: PlaybackService, 916 - > tonic::server::UnaryService<super::StopRequest> for StopSvc<T> { 818 + impl<T: PlaybackService> tonic::server::UnaryService<super::StopRequest> for StopSvc<T> { 917 819 type Response = super::StopResponse; 918 - type Future = BoxFuture< 919 - tonic::Response<Self::Response>, 920 - tonic::Status, 921 - >; 820 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 922 821 fn call( 923 822 &mut self, 924 823 request: tonic::Request<super::StopRequest>, 925 824 ) -> Self::Future { 926 825 let inner = Arc::clone(&self.0); 927 - let fut = async move { 928 - <T as PlaybackService>::stop(&inner, request).await 929 - }; 826 + let fut = 827 + async move { <T as PlaybackService>::stop(&inner, request).await }; 930 828 Box::pin(fut) 931 829 } 932 830 } ··· 955 853 "/tunein.v1alpha1.PlaybackService/PlayOrPause" => { 956 854 #[allow(non_camel_case_types)] 957 855 struct PlayOrPauseSvc<T: PlaybackService>(pub Arc<T>); 958 - impl< 959 - T: PlaybackService, 960 - > tonic::server::UnaryService<super::PlayOrPauseRequest> 961 - for PlayOrPauseSvc<T> { 856 + impl<T: PlaybackService> tonic::server::UnaryService<super::PlayOrPauseRequest> 857 + for PlayOrPauseSvc<T> 858 + { 962 859 type Response = super::PlayOrPauseResponse; 963 - type Future = BoxFuture< 964 - tonic::Response<Self::Response>, 965 - tonic::Status, 966 - >; 860 + type Future = BoxFuture<tonic::Response<Self::Response>, tonic::Status>; 967 861 fn call( 968 862 &mut self, 969 863 request: tonic::Request<super::PlayOrPauseRequest>, ··· 997 891 }; 998 892 Box::pin(fut) 999 893 } 1000 - _ => { 1001 - Box::pin(async move { 1002 - let mut response = http::Response::new(empty_body()); 1003 - let headers = response.headers_mut(); 1004 - headers 1005 - .insert( 1006 - tonic::Status::GRPC_STATUS, 1007 - (tonic::Code::Unimplemented as i32).into(), 1008 - ); 1009 - headers 1010 - .insert( 1011 - http::header::CONTENT_TYPE, 1012 - tonic::metadata::GRPC_CONTENT_TYPE, 1013 - ); 1014 - Ok(response) 1015 - }) 1016 - } 894 + _ => Box::pin(async move { 895 + let mut response = http::Response::new(empty_body()); 896 + let headers = response.headers_mut(); 897 + headers.insert( 898 + tonic::Status::GRPC_STATUS, 899 + (tonic::Code::Unimplemented as i32).into(), 900 + ); 901 + headers.insert( 902 + http::header::CONTENT_TYPE, 903 + tonic::metadata::GRPC_CONTENT_TYPE, 904 + ); 905 + Ok(response) 906 + }), 1017 907 } 1018 908 } 1019 909 }