yoa-backtest-api-sdk 21.2.0

// @generated
/// Generated client implementations.
pub mod backtest_api_internal_service_client {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    #[derive(Debug, Clone)]
    pub struct BacktestApiInternalServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl BacktestApiInternalServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> BacktestApiInternalServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::BoxBody>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> BacktestApiInternalServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::BoxBody>,
            >>::Error: Into<StdError> + Send + Sync,
        {
            BacktestApiInternalServiceClient::new(
                InterceptedService::new(inner, interceptor),
            )
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        pub async fn health(
            &mut self,
            request: impl tonic::IntoRequest<super::HealthRequest>,
        ) -> std::result::Result<tonic::Response<super::HealthResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/Health",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "Health",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn submit_command(
            &mut self,
            request: impl tonic::IntoRequest<super::SubmitCommandRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SubmitCommandResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/SubmitCommand",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "SubmitCommand",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_status(
            &mut self,
            request: impl tonic::IntoRequest<super::GetStatusRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetStatusResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetStatus",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetStatus",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_result_readiness(
            &mut self,
            request: impl tonic::IntoRequest<super::GetResultReadinessRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetResultReadinessResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetResultReadiness",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetResultReadiness",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetConfigResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_result_overview(
            &mut self,
            request: impl tonic::IntoRequest<super::GetResultOverviewRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetResultOverviewResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetResultOverview",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetResultOverview",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_result_report(
            &mut self,
            request: impl tonic::IntoRequest<super::GetResultReportRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetResultReportResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetResultReport",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetResultReport",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_result_rolling_statistics(
            &mut self,
            request: impl tonic::IntoRequest<super::GetResultRollingStatisticsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetResultRollingStatisticsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetResultRollingStatistics",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetResultRollingStatistics",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_result_series(
            &mut self,
            request: impl tonic::IntoRequest<super::GetResultSeriesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetResultSeriesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetResultSeries",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetResultSeries",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_equity_viewport(
            &mut self,
            request: impl tonic::IntoRequest<super::GetEquityViewportRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetEquityViewportResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetEquityViewport",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetEquityViewport",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn stream_equity_timeline(
            &mut self,
            request: impl tonic::IntoRequest<super::StreamEquityTimelineRequest>,
        ) -> std::result::Result<
            tonic::Response<
                tonic::codec::Streaming<super::StreamEquityTimelineResponse>,
            >,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/StreamEquityTimeline",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "StreamEquityTimeline",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        pub async fn list_result_orders(
            &mut self,
            request: impl tonic::IntoRequest<super::ListResultOrdersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResultOrdersResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/ListResultOrders",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "ListResultOrders",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn list_result_trades(
            &mut self,
            request: impl tonic::IntoRequest<super::ListResultTradesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResultTradesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/ListResultTrades",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "ListResultTrades",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn list_result_trade_orders(
            &mut self,
            request: impl tonic::IntoRequest<super::ListResultTradeOrdersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResultTradeOrdersResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/ListResultTradeOrders",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "ListResultTradeOrders",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_portfolio_statistics(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPortfolioStatisticsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetPortfolioStatisticsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetPortfolioStatistics",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetPortfolioStatistics",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_trade_statistics(
            &mut self,
            request: impl tonic::IntoRequest<super::GetTradeStatisticsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetTradeStatisticsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetTradeStatistics",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetTradeStatistics",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_closed_trades(
            &mut self,
            request: impl tonic::IntoRequest<super::GetClosedTradesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetClosedTradesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetClosedTrades",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetClosedTrades",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_orders(
            &mut self,
            request: impl tonic::IntoRequest<super::GetOrdersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetOrdersResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetOrders",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetOrders",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_order_events(
            &mut self,
            request: impl tonic::IntoRequest<super::GetOrderEventsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetOrderEventsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetOrderEvents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetOrderEvents",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_charts(
            &mut self,
            request: impl tonic::IntoRequest<super::GetChartsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetChartsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetCharts",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetCharts",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_chart_series(
            &mut self,
            request: impl tonic::IntoRequest<super::GetChartSeriesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetChartSeriesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetChartSeries",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetChartSeries",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_series_points(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSeriesPointsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetSeriesPointsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetSeriesPoints",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetSeriesPoints",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_drawdown_curve(
            &mut self,
            request: impl tonic::IntoRequest<super::GetDrawdownCurveRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetDrawdownCurveResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetDrawdownCurve",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetDrawdownCurve",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_kv_stats(
            &mut self,
            request: impl tonic::IntoRequest<super::GetKvStatsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetKvStatsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetKvStats",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetKvStats",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_algorithm_config(
            &mut self,
            request: impl tonic::IntoRequest<super::GetAlgorithmConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetAlgorithmConfigResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetAlgorithmConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetAlgorithmConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_preview(
            &mut self,
            request: impl tonic::IntoRequest<super::GetPreviewRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetPreviewResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetPreview",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetPreview",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_summary_batch(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSummaryBatchRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetSummaryBatchResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetSummaryBatch",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetSummaryBatch",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_runner_logs(
            &mut self,
            request: impl tonic::IntoRequest<super::GetRunnerLogsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetRunnerLogsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetRunnerLogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetRunnerLogs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_trace(
            &mut self,
            request: impl tonic::IntoRequest<super::GetTraceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetTraceResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetTrace",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetTrace",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_replay_event(
            &mut self,
            request: impl tonic::IntoRequest<super::GetReplayEventRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetReplayEventResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetReplayEvent",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetReplayEvent",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_replay_run_state(
            &mut self,
            request: impl tonic::IntoRequest<super::GetReplayRunStateRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetReplayRunStateResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetReplayRunState",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetReplayRunState",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn list_replay_lifecycle_events(
            &mut self,
            request: impl tonic::IntoRequest<super::ListReplayLifecycleEventsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListReplayLifecycleEventsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/ListReplayLifecycleEvents",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "ListReplayLifecycleEvents",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn delete_backtest_result(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteBacktestResultRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteBacktestResultResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/DeleteBacktestResult",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "DeleteBacktestResult",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn list_configs(
            &mut self,
            request: impl tonic::IntoRequest<super::ListConfigsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListConfigsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/ListConfigs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "ListConfigs",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn get_config_detail(
            &mut self,
            request: impl tonic::IntoRequest<super::GetConfigDetailRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetConfigDetailResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetConfigDetail",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "GetConfigDetail",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn create_config(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateConfigResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/CreateConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "CreateConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn update_config(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::UpdateConfigResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/UpdateConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "UpdateConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn delete_config(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteConfigResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/DeleteConfig",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "DeleteConfig",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        pub async fn stream_progress(
            &mut self,
            request: impl tonic::IntoRequest<super::StreamProgressRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::StreamProgressResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/StreamProgress",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "StreamProgress",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
        pub async fn stream_runner_logs(
            &mut self,
            request: impl tonic::IntoRequest<super::StreamRunnerLogsRequest>,
        ) -> std::result::Result<
            tonic::Response<tonic::codec::Streaming<super::StreamRunnerLogsResponse>>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::new(
                        tonic::Code::Unknown,
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic::codec::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/StreamRunnerLogs",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "yoa.backtest.api.internal.v2.BacktestApiInternalService",
                        "StreamRunnerLogs",
                    ),
                );
            self.inner.server_streaming(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod backtest_api_internal_service_server {
    #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
    use tonic::codegen::*;
    /// Generated trait containing gRPC methods that should be implemented for use with BacktestApiInternalServiceServer.
    #[async_trait]
    pub trait BacktestApiInternalService: Send + Sync + 'static {
        async fn health(
            &self,
            request: tonic::Request<super::HealthRequest>,
        ) -> std::result::Result<tonic::Response<super::HealthResponse>, tonic::Status>;
        async fn submit_command(
            &self,
            request: tonic::Request<super::SubmitCommandRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SubmitCommandResponse>,
            tonic::Status,
        >;
        async fn get_status(
            &self,
            request: tonic::Request<super::GetStatusRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetStatusResponse>,
            tonic::Status,
        >;
        async fn get_result_readiness(
            &self,
            request: tonic::Request<super::GetResultReadinessRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetResultReadinessResponse>,
            tonic::Status,
        >;
        async fn get_config(
            &self,
            request: tonic::Request<super::GetConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetConfigResponse>,
            tonic::Status,
        >;
        async fn get_result_overview(
            &self,
            request: tonic::Request<super::GetResultOverviewRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetResultOverviewResponse>,
            tonic::Status,
        >;
        async fn get_result_report(
            &self,
            request: tonic::Request<super::GetResultReportRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetResultReportResponse>,
            tonic::Status,
        >;
        async fn get_result_rolling_statistics(
            &self,
            request: tonic::Request<super::GetResultRollingStatisticsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetResultRollingStatisticsResponse>,
            tonic::Status,
        >;
        async fn get_result_series(
            &self,
            request: tonic::Request<super::GetResultSeriesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetResultSeriesResponse>,
            tonic::Status,
        >;
        async fn get_equity_viewport(
            &self,
            request: tonic::Request<super::GetEquityViewportRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetEquityViewportResponse>,
            tonic::Status,
        >;
        /// Server streaming response type for the StreamEquityTimeline method.
        type StreamEquityTimelineStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<
                    super::StreamEquityTimelineResponse,
                    tonic::Status,
                >,
            >
            + Send
            + 'static;
        async fn stream_equity_timeline(
            &self,
            request: tonic::Request<super::StreamEquityTimelineRequest>,
        ) -> std::result::Result<
            tonic::Response<Self::StreamEquityTimelineStream>,
            tonic::Status,
        >;
        async fn list_result_orders(
            &self,
            request: tonic::Request<super::ListResultOrdersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResultOrdersResponse>,
            tonic::Status,
        >;
        async fn list_result_trades(
            &self,
            request: tonic::Request<super::ListResultTradesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResultTradesResponse>,
            tonic::Status,
        >;
        async fn list_result_trade_orders(
            &self,
            request: tonic::Request<super::ListResultTradeOrdersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListResultTradeOrdersResponse>,
            tonic::Status,
        >;
        async fn get_portfolio_statistics(
            &self,
            request: tonic::Request<super::GetPortfolioStatisticsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetPortfolioStatisticsResponse>,
            tonic::Status,
        >;
        async fn get_trade_statistics(
            &self,
            request: tonic::Request<super::GetTradeStatisticsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetTradeStatisticsResponse>,
            tonic::Status,
        >;
        async fn get_closed_trades(
            &self,
            request: tonic::Request<super::GetClosedTradesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetClosedTradesResponse>,
            tonic::Status,
        >;
        async fn get_orders(
            &self,
            request: tonic::Request<super::GetOrdersRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetOrdersResponse>,
            tonic::Status,
        >;
        async fn get_order_events(
            &self,
            request: tonic::Request<super::GetOrderEventsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetOrderEventsResponse>,
            tonic::Status,
        >;
        async fn get_charts(
            &self,
            request: tonic::Request<super::GetChartsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetChartsResponse>,
            tonic::Status,
        >;
        async fn get_chart_series(
            &self,
            request: tonic::Request<super::GetChartSeriesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetChartSeriesResponse>,
            tonic::Status,
        >;
        async fn get_series_points(
            &self,
            request: tonic::Request<super::GetSeriesPointsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetSeriesPointsResponse>,
            tonic::Status,
        >;
        async fn get_drawdown_curve(
            &self,
            request: tonic::Request<super::GetDrawdownCurveRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetDrawdownCurveResponse>,
            tonic::Status,
        >;
        async fn get_kv_stats(
            &self,
            request: tonic::Request<super::GetKvStatsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetKvStatsResponse>,
            tonic::Status,
        >;
        async fn get_algorithm_config(
            &self,
            request: tonic::Request<super::GetAlgorithmConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetAlgorithmConfigResponse>,
            tonic::Status,
        >;
        async fn get_preview(
            &self,
            request: tonic::Request<super::GetPreviewRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetPreviewResponse>,
            tonic::Status,
        >;
        async fn get_summary_batch(
            &self,
            request: tonic::Request<super::GetSummaryBatchRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetSummaryBatchResponse>,
            tonic::Status,
        >;
        async fn get_runner_logs(
            &self,
            request: tonic::Request<super::GetRunnerLogsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetRunnerLogsResponse>,
            tonic::Status,
        >;
        async fn get_trace(
            &self,
            request: tonic::Request<super::GetTraceRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetTraceResponse>,
            tonic::Status,
        >;
        async fn get_replay_event(
            &self,
            request: tonic::Request<super::GetReplayEventRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetReplayEventResponse>,
            tonic::Status,
        >;
        async fn get_replay_run_state(
            &self,
            request: tonic::Request<super::GetReplayRunStateRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetReplayRunStateResponse>,
            tonic::Status,
        >;
        async fn list_replay_lifecycle_events(
            &self,
            request: tonic::Request<super::ListReplayLifecycleEventsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListReplayLifecycleEventsResponse>,
            tonic::Status,
        >;
        async fn delete_backtest_result(
            &self,
            request: tonic::Request<super::DeleteBacktestResultRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteBacktestResultResponse>,
            tonic::Status,
        >;
        async fn list_configs(
            &self,
            request: tonic::Request<super::ListConfigsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ListConfigsResponse>,
            tonic::Status,
        >;
        async fn get_config_detail(
            &self,
            request: tonic::Request<super::GetConfigDetailRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetConfigDetailResponse>,
            tonic::Status,
        >;
        async fn create_config(
            &self,
            request: tonic::Request<super::CreateConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateConfigResponse>,
            tonic::Status,
        >;
        async fn update_config(
            &self,
            request: tonic::Request<super::UpdateConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::UpdateConfigResponse>,
            tonic::Status,
        >;
        async fn delete_config(
            &self,
            request: tonic::Request<super::DeleteConfigRequest>,
        ) -> std::result::Result<
            tonic::Response<super::DeleteConfigResponse>,
            tonic::Status,
        >;
        /// Server streaming response type for the StreamProgress method.
        type StreamProgressStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<super::StreamProgressResponse, tonic::Status>,
            >
            + Send
            + 'static;
        async fn stream_progress(
            &self,
            request: tonic::Request<super::StreamProgressRequest>,
        ) -> std::result::Result<
            tonic::Response<Self::StreamProgressStream>,
            tonic::Status,
        >;
        /// Server streaming response type for the StreamRunnerLogs method.
        type StreamRunnerLogsStream: tonic::codegen::tokio_stream::Stream<
                Item = std::result::Result<
                    super::StreamRunnerLogsResponse,
                    tonic::Status,
                >,
            >
            + Send
            + 'static;
        async fn stream_runner_logs(
            &self,
            request: tonic::Request<super::StreamRunnerLogsRequest>,
        ) -> std::result::Result<
            tonic::Response<Self::StreamRunnerLogsStream>,
            tonic::Status,
        >;
    }
    #[derive(Debug)]
    pub struct BacktestApiInternalServiceServer<T: BacktestApiInternalService> {
        inner: Arc<T>,
        accept_compression_encodings: EnabledCompressionEncodings,
        send_compression_encodings: EnabledCompressionEncodings,
        max_decoding_message_size: Option<usize>,
        max_encoding_message_size: Option<usize>,
    }
    impl<T: BacktestApiInternalService> BacktestApiInternalServiceServer<T> {
        pub fn new(inner: T) -> Self {
            Self::from_arc(Arc::new(inner))
        }
        pub fn from_arc(inner: Arc<T>) -> Self {
            Self {
                inner,
                accept_compression_encodings: Default::default(),
                send_compression_encodings: Default::default(),
                max_decoding_message_size: None,
                max_encoding_message_size: None,
            }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> InterceptedService<Self, F>
        where
            F: tonic::service::Interceptor,
        {
            InterceptedService::new(Self::new(inner), interceptor)
        }
        /// Enable decompressing requests with the given encoding.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.accept_compression_encodings.enable(encoding);
            self
        }
        /// Compress responses with the given encoding, if the client supports it.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.send_compression_encodings.enable(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.max_decoding_message_size = Some(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.max_encoding_message_size = Some(limit);
            self
        }
    }
    impl<T, B> tonic::codegen::Service<http::Request<B>>
    for BacktestApiInternalServiceServer<T>
    where
        T: BacktestApiInternalService,
        B: Body + Send + 'static,
        B::Error: Into<StdError> + Send + 'static,
    {
        type Response = http::Response<tonic::body::BoxBody>;
        type Error = std::convert::Infallible;
        type Future = BoxFuture<Self::Response, Self::Error>;
        fn poll_ready(
            &mut self,
            _cx: &mut Context<'_>,
        ) -> Poll<std::result::Result<(), Self::Error>> {
            Poll::Ready(Ok(()))
        }
        fn call(&mut self, req: http::Request<B>) -> Self::Future {
            match req.uri().path() {
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/Health" => {
                    #[allow(non_camel_case_types)]
                    struct HealthSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::HealthRequest>
                    for HealthSvc<T> {
                        type Response = super::HealthResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::HealthRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::health(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = HealthSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/SubmitCommand" => {
                    #[allow(non_camel_case_types)]
                    struct SubmitCommandSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::SubmitCommandRequest>
                    for SubmitCommandSvc<T> {
                        type Response = super::SubmitCommandResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SubmitCommandRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::submit_command(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SubmitCommandSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetStatus" => {
                    #[allow(non_camel_case_types)]
                    struct GetStatusSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetStatusRequest>
                    for GetStatusSvc<T> {
                        type Response = super::GetStatusResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetStatusRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_status(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetStatusSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetResultReadiness" => {
                    #[allow(non_camel_case_types)]
                    struct GetResultReadinessSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetResultReadinessRequest>
                    for GetResultReadinessSvc<T> {
                        type Response = super::GetResultReadinessResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetResultReadinessRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_result_readiness(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetResultReadinessSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetConfig" => {
                    #[allow(non_camel_case_types)]
                    struct GetConfigSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetConfigRequest>
                    for GetConfigSvc<T> {
                        type Response = super::GetConfigResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetConfigRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_config(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetConfigSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetResultOverview" => {
                    #[allow(non_camel_case_types)]
                    struct GetResultOverviewSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetResultOverviewRequest>
                    for GetResultOverviewSvc<T> {
                        type Response = super::GetResultOverviewResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetResultOverviewRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_result_overview(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetResultOverviewSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetResultReport" => {
                    #[allow(non_camel_case_types)]
                    struct GetResultReportSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetResultReportRequest>
                    for GetResultReportSvc<T> {
                        type Response = super::GetResultReportResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetResultReportRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_result_report(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetResultReportSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetResultRollingStatistics" => {
                    #[allow(non_camel_case_types)]
                    struct GetResultRollingStatisticsSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<
                        super::GetResultRollingStatisticsRequest,
                    > for GetResultRollingStatisticsSvc<T> {
                        type Response = super::GetResultRollingStatisticsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::GetResultRollingStatisticsRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_result_rolling_statistics(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetResultRollingStatisticsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetResultSeries" => {
                    #[allow(non_camel_case_types)]
                    struct GetResultSeriesSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetResultSeriesRequest>
                    for GetResultSeriesSvc<T> {
                        type Response = super::GetResultSeriesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetResultSeriesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_result_series(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetResultSeriesSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetEquityViewport" => {
                    #[allow(non_camel_case_types)]
                    struct GetEquityViewportSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetEquityViewportRequest>
                    for GetEquityViewportSvc<T> {
                        type Response = super::GetEquityViewportResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetEquityViewportRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_equity_viewport(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetEquityViewportSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/StreamEquityTimeline" => {
                    #[allow(non_camel_case_types)]
                    struct StreamEquityTimelineSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::ServerStreamingService<
                        super::StreamEquityTimelineRequest,
                    > for StreamEquityTimelineSvc<T> {
                        type Response = super::StreamEquityTimelineResponse;
                        type ResponseStream = T::StreamEquityTimelineStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::StreamEquityTimelineRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::stream_equity_timeline(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = StreamEquityTimelineSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/ListResultOrders" => {
                    #[allow(non_camel_case_types)]
                    struct ListResultOrdersSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::ListResultOrdersRequest>
                    for ListResultOrdersSvc<T> {
                        type Response = super::ListResultOrdersResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ListResultOrdersRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::list_result_orders(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ListResultOrdersSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/ListResultTrades" => {
                    #[allow(non_camel_case_types)]
                    struct ListResultTradesSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::ListResultTradesRequest>
                    for ListResultTradesSvc<T> {
                        type Response = super::ListResultTradesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ListResultTradesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::list_result_trades(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ListResultTradesSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/ListResultTradeOrders" => {
                    #[allow(non_camel_case_types)]
                    struct ListResultTradeOrdersSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::ListResultTradeOrdersRequest>
                    for ListResultTradeOrdersSvc<T> {
                        type Response = super::ListResultTradeOrdersResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ListResultTradeOrdersRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::list_result_trade_orders(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ListResultTradeOrdersSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetPortfolioStatistics" => {
                    #[allow(non_camel_case_types)]
                    struct GetPortfolioStatisticsSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetPortfolioStatisticsRequest>
                    for GetPortfolioStatisticsSvc<T> {
                        type Response = super::GetPortfolioStatisticsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetPortfolioStatisticsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_portfolio_statistics(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetPortfolioStatisticsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetTradeStatistics" => {
                    #[allow(non_camel_case_types)]
                    struct GetTradeStatisticsSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetTradeStatisticsRequest>
                    for GetTradeStatisticsSvc<T> {
                        type Response = super::GetTradeStatisticsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetTradeStatisticsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_trade_statistics(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetTradeStatisticsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetClosedTrades" => {
                    #[allow(non_camel_case_types)]
                    struct GetClosedTradesSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetClosedTradesRequest>
                    for GetClosedTradesSvc<T> {
                        type Response = super::GetClosedTradesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetClosedTradesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_closed_trades(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetClosedTradesSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetOrders" => {
                    #[allow(non_camel_case_types)]
                    struct GetOrdersSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetOrdersRequest>
                    for GetOrdersSvc<T> {
                        type Response = super::GetOrdersResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetOrdersRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_orders(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetOrdersSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetOrderEvents" => {
                    #[allow(non_camel_case_types)]
                    struct GetOrderEventsSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetOrderEventsRequest>
                    for GetOrderEventsSvc<T> {
                        type Response = super::GetOrderEventsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetOrderEventsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_order_events(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetOrderEventsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetCharts" => {
                    #[allow(non_camel_case_types)]
                    struct GetChartsSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetChartsRequest>
                    for GetChartsSvc<T> {
                        type Response = super::GetChartsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetChartsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_charts(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetChartsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetChartSeries" => {
                    #[allow(non_camel_case_types)]
                    struct GetChartSeriesSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetChartSeriesRequest>
                    for GetChartSeriesSvc<T> {
                        type Response = super::GetChartSeriesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetChartSeriesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_chart_series(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetChartSeriesSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetSeriesPoints" => {
                    #[allow(non_camel_case_types)]
                    struct GetSeriesPointsSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetSeriesPointsRequest>
                    for GetSeriesPointsSvc<T> {
                        type Response = super::GetSeriesPointsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetSeriesPointsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_series_points(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetSeriesPointsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetDrawdownCurve" => {
                    #[allow(non_camel_case_types)]
                    struct GetDrawdownCurveSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetDrawdownCurveRequest>
                    for GetDrawdownCurveSvc<T> {
                        type Response = super::GetDrawdownCurveResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetDrawdownCurveRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_drawdown_curve(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetDrawdownCurveSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetKvStats" => {
                    #[allow(non_camel_case_types)]
                    struct GetKvStatsSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetKvStatsRequest>
                    for GetKvStatsSvc<T> {
                        type Response = super::GetKvStatsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetKvStatsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_kv_stats(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetKvStatsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetAlgorithmConfig" => {
                    #[allow(non_camel_case_types)]
                    struct GetAlgorithmConfigSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetAlgorithmConfigRequest>
                    for GetAlgorithmConfigSvc<T> {
                        type Response = super::GetAlgorithmConfigResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetAlgorithmConfigRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_algorithm_config(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetAlgorithmConfigSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetPreview" => {
                    #[allow(non_camel_case_types)]
                    struct GetPreviewSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetPreviewRequest>
                    for GetPreviewSvc<T> {
                        type Response = super::GetPreviewResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetPreviewRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_preview(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetPreviewSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetSummaryBatch" => {
                    #[allow(non_camel_case_types)]
                    struct GetSummaryBatchSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetSummaryBatchRequest>
                    for GetSummaryBatchSvc<T> {
                        type Response = super::GetSummaryBatchResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetSummaryBatchRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_summary_batch(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetSummaryBatchSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetRunnerLogs" => {
                    #[allow(non_camel_case_types)]
                    struct GetRunnerLogsSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetRunnerLogsRequest>
                    for GetRunnerLogsSvc<T> {
                        type Response = super::GetRunnerLogsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetRunnerLogsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_runner_logs(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetRunnerLogsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetTrace" => {
                    #[allow(non_camel_case_types)]
                    struct GetTraceSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetTraceRequest>
                    for GetTraceSvc<T> {
                        type Response = super::GetTraceResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetTraceRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_trace(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetTraceSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetReplayEvent" => {
                    #[allow(non_camel_case_types)]
                    struct GetReplayEventSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetReplayEventRequest>
                    for GetReplayEventSvc<T> {
                        type Response = super::GetReplayEventResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetReplayEventRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_replay_event(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetReplayEventSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetReplayRunState" => {
                    #[allow(non_camel_case_types)]
                    struct GetReplayRunStateSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetReplayRunStateRequest>
                    for GetReplayRunStateSvc<T> {
                        type Response = super::GetReplayRunStateResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetReplayRunStateRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_replay_run_state(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetReplayRunStateSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/ListReplayLifecycleEvents" => {
                    #[allow(non_camel_case_types)]
                    struct ListReplayLifecycleEventsSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<
                        super::ListReplayLifecycleEventsRequest,
                    > for ListReplayLifecycleEventsSvc<T> {
                        type Response = super::ListReplayLifecycleEventsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::ListReplayLifecycleEventsRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::list_replay_lifecycle_events(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ListReplayLifecycleEventsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/DeleteBacktestResult" => {
                    #[allow(non_camel_case_types)]
                    struct DeleteBacktestResultSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::DeleteBacktestResultRequest>
                    for DeleteBacktestResultSvc<T> {
                        type Response = super::DeleteBacktestResultResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::DeleteBacktestResultRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::delete_backtest_result(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = DeleteBacktestResultSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/ListConfigs" => {
                    #[allow(non_camel_case_types)]
                    struct ListConfigsSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::ListConfigsRequest>
                    for ListConfigsSvc<T> {
                        type Response = super::ListConfigsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ListConfigsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::list_configs(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ListConfigsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/GetConfigDetail" => {
                    #[allow(non_camel_case_types)]
                    struct GetConfigDetailSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::GetConfigDetailRequest>
                    for GetConfigDetailSvc<T> {
                        type Response = super::GetConfigDetailResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetConfigDetailRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::get_config_detail(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = GetConfigDetailSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/CreateConfig" => {
                    #[allow(non_camel_case_types)]
                    struct CreateConfigSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::CreateConfigRequest>
                    for CreateConfigSvc<T> {
                        type Response = super::CreateConfigResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CreateConfigRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::create_config(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CreateConfigSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/UpdateConfig" => {
                    #[allow(non_camel_case_types)]
                    struct UpdateConfigSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::UpdateConfigRequest>
                    for UpdateConfigSvc<T> {
                        type Response = super::UpdateConfigResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::UpdateConfigRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::update_config(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = UpdateConfigSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/DeleteConfig" => {
                    #[allow(non_camel_case_types)]
                    struct DeleteConfigSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::UnaryService<super::DeleteConfigRequest>
                    for DeleteConfigSvc<T> {
                        type Response = super::DeleteConfigResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::DeleteConfigRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::delete_config(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = DeleteConfigSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/StreamProgress" => {
                    #[allow(non_camel_case_types)]
                    struct StreamProgressSvc<T: BacktestApiInternalService>(pub Arc<T>);
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::ServerStreamingService<super::StreamProgressRequest>
                    for StreamProgressSvc<T> {
                        type Response = super::StreamProgressResponse;
                        type ResponseStream = T::StreamProgressStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::StreamProgressRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::stream_progress(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = StreamProgressSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/yoa.backtest.api.internal.v2.BacktestApiInternalService/StreamRunnerLogs" => {
                    #[allow(non_camel_case_types)]
                    struct StreamRunnerLogsSvc<T: BacktestApiInternalService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: BacktestApiInternalService,
                    > tonic::server::ServerStreamingService<
                        super::StreamRunnerLogsRequest,
                    > for StreamRunnerLogsSvc<T> {
                        type Response = super::StreamRunnerLogsResponse;
                        type ResponseStream = T::StreamRunnerLogsStream;
                        type Future = BoxFuture<
                            tonic::Response<Self::ResponseStream>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::StreamRunnerLogsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as BacktestApiInternalService>::stream_runner_logs(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = StreamRunnerLogsSvc(inner);
                        let codec = tonic::codec::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.server_streaming(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                _ => {
                    Box::pin(async move {
                        Ok(
                            http::Response::builder()
                                .status(200)
                                .header("grpc-status", tonic::Code::Unimplemented as i32)
                                .header(
                                    http::header::CONTENT_TYPE,
                                    tonic::metadata::GRPC_CONTENT_TYPE,
                                )
                                .body(empty_body())
                                .unwrap(),
                        )
                    })
                }
            }
        }
    }
    impl<T: BacktestApiInternalService> Clone for BacktestApiInternalServiceServer<T> {
        fn clone(&self) -> Self {
            let inner = self.inner.clone();
            Self {
                inner,
                accept_compression_encodings: self.accept_compression_encodings,
                send_compression_encodings: self.send_compression_encodings,
                max_decoding_message_size: self.max_decoding_message_size,
                max_encoding_message_size: self.max_encoding_message_size,
            }
        }
    }
    impl<T: BacktestApiInternalService> tonic::server::NamedService
    for BacktestApiInternalServiceServer<T> {
        const NAME: &'static str = "yoa.backtest.api.internal.v2.BacktestApiInternalService";
    }
}