pethost 0.2.9

///Shorthand for `OwnedView<GetMachineRequestView<'static>>`.
pub type OwnedGetMachineRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetMachineRequestView<'static>,
>;
///Shorthand for `OwnedView<GetMachineResponseView<'static>>`.
pub type OwnedGetMachineResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetMachineResponseView<'static>,
>;
///Shorthand for `OwnedView<RunMachineActionRequestView<'static>>`.
pub type OwnedRunMachineActionRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::RunMachineActionRequestView<'static>,
>;
///Shorthand for `OwnedView<RunMachineActionResponseView<'static>>`.
pub type OwnedRunMachineActionResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::RunMachineActionResponseView<
        'static,
    >,
>;
///Shorthand for `OwnedView<GetProjectRequestView<'static>>`.
pub type OwnedGetProjectRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetProjectRequestView<'static>,
>;
///Shorthand for `OwnedView<GetProjectResponseView<'static>>`.
pub type OwnedGetProjectResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetProjectResponseView<'static>,
>;
///Shorthand for `OwnedView<CreateProjectRequestView<'static>>`.
pub type OwnedCreateProjectRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::CreateProjectRequestView<'static>,
>;
///Shorthand for `OwnedView<CreateProjectResponseView<'static>>`.
pub type OwnedCreateProjectResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::CreateProjectResponseView<'static>,
>;
///Shorthand for `OwnedView<DeployProjectRequestView<'static>>`.
pub type OwnedDeployProjectRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::DeployProjectRequestView<'static>,
>;
///Shorthand for `OwnedView<DeployProjectResponseView<'static>>`.
pub type OwnedDeployProjectResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::DeployProjectResponseView<'static>,
>;
///Shorthand for `OwnedView<ListCommitsRequestView<'static>>`.
pub type OwnedListCommitsRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::ListCommitsRequestView<'static>,
>;
///Shorthand for `OwnedView<ListCommitsResponseView<'static>>`.
pub type OwnedListCommitsResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::ListCommitsResponseView<'static>,
>;
///Shorthand for `OwnedView<RunProjectActionRequestView<'static>>`.
pub type OwnedRunProjectActionRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::RunProjectActionRequestView<'static>,
>;
///Shorthand for `OwnedView<RunProjectActionResponseView<'static>>`.
pub type OwnedRunProjectActionResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::RunProjectActionResponseView<
        'static,
    >,
>;
///Shorthand for `OwnedView<SetProjectAlertsRequestView<'static>>`.
pub type OwnedSetProjectAlertsRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::SetProjectAlertsRequestView<'static>,
>;
///Shorthand for `OwnedView<SetProjectAlertsResponseView<'static>>`.
pub type OwnedSetProjectAlertsResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::SetProjectAlertsResponseView<
        'static,
    >,
>;
///Shorthand for `OwnedView<GetIncidentRequestView<'static>>`.
pub type OwnedGetIncidentRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetIncidentRequestView<'static>,
>;
///Shorthand for `OwnedView<GetIncidentResponseView<'static>>`.
pub type OwnedGetIncidentResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetIncidentResponseView<'static>,
>;
///Shorthand for `OwnedView<GetOperationRequestView<'static>>`.
pub type OwnedGetOperationRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetOperationRequestView<'static>,
>;
///Shorthand for `OwnedView<GetOperationResponseView<'static>>`.
pub type OwnedGetOperationResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetOperationResponseView<'static>,
>;
///Shorthand for `OwnedView<QueryHttpTrafficRequestView<'static>>`.
pub type OwnedQueryHttpTrafficRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::QueryHttpTrafficRequestView<'static>,
>;
///Shorthand for `OwnedView<QueryHttpTrafficResponseView<'static>>`.
pub type OwnedQueryHttpTrafficResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::QueryHttpTrafficResponseView<
        'static,
    >,
>;
///Shorthand for `OwnedView<QueryContainerLogsRequestView<'static>>`.
pub type OwnedQueryContainerLogsRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::QueryContainerLogsRequestView<
        'static,
    >,
>;
///Shorthand for `OwnedView<QueryContainerLogsResponseView<'static>>`.
pub type OwnedQueryContainerLogsResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::QueryContainerLogsResponseView<
        'static,
    >,
>;
///Shorthand for `OwnedView<LinkDatabaseRequestView<'static>>`.
pub type OwnedLinkDatabaseRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::LinkDatabaseRequestView<'static>,
>;
///Shorthand for `OwnedView<LinkDatabaseResponseView<'static>>`.
pub type OwnedLinkDatabaseResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::LinkDatabaseResponseView<'static>,
>;
///Shorthand for `OwnedView<CreateDatabaseRequestView<'static>>`.
pub type OwnedCreateDatabaseRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::CreateDatabaseRequestView<'static>,
>;
///Shorthand for `OwnedView<CreateDatabaseResponseView<'static>>`.
pub type OwnedCreateDatabaseResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::CreateDatabaseResponseView<'static>,
>;
///Shorthand for `OwnedView<RunServiceCommandRequestView<'static>>`.
pub type OwnedRunServiceCommandRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::RunServiceCommandRequestView<
        'static,
    >,
>;
///Shorthand for `OwnedView<RunServiceCommandResponseView<'static>>`.
pub type OwnedRunServiceCommandResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::RunServiceCommandResponseView<
        'static,
    >,
>;
///Shorthand for `OwnedView<OpenTerminalRequestView<'static>>`.
pub type OwnedOpenTerminalRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::OpenTerminalRequestView<'static>,
>;
///Shorthand for `OwnedView<OpenTerminalResponseView<'static>>`.
pub type OwnedOpenTerminalResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::OpenTerminalResponseView<'static>,
>;
///Shorthand for `OwnedView<OpenDatabaseClientRequestView<'static>>`.
pub type OwnedOpenDatabaseClientRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::OpenDatabaseClientRequestView<
        'static,
    >,
>;
///Shorthand for `OwnedView<OpenDatabaseClientResponseView<'static>>`.
pub type OwnedOpenDatabaseClientResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::OpenDatabaseClientResponseView<
        'static,
    >,
>;
///Shorthand for `OwnedView<ReadPathRequestView<'static>>`.
pub type OwnedReadPathRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::ReadPathRequestView<'static>,
>;
///Shorthand for `OwnedView<ReadPathResponseView<'static>>`.
pub type OwnedReadPathResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::ReadPathResponseView<'static>,
>;
///Shorthand for `OwnedView<CreateTransferRequestView<'static>>`.
pub type OwnedCreateTransferRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::CreateTransferRequestView<'static>,
>;
///Shorthand for `OwnedView<CreateTransferResponseView<'static>>`.
pub type OwnedCreateTransferResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::CreateTransferResponseView<'static>,
>;
///Shorthand for `OwnedView<GetUploadRequestView<'static>>`.
pub type OwnedGetUploadRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetUploadRequestView<'static>,
>;
///Shorthand for `OwnedView<GetUploadResponseView<'static>>`.
pub type OwnedGetUploadResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetUploadResponseView<'static>,
>;
///Shorthand for `OwnedView<WatchOperationRequestView<'static>>`.
pub type OwnedWatchOperationRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::WatchOperationRequestView<'static>,
>;
///Shorthand for `OwnedView<WatchOperationResponseView<'static>>`.
pub type OwnedWatchOperationResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::WatchOperationResponseView<'static>,
>;
///Shorthand for `OwnedView<TailContainerLogsRequestView<'static>>`.
pub type OwnedTailContainerLogsRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::TailContainerLogsRequestView<
        'static,
    >,
>;
///Shorthand for `OwnedView<TailContainerLogsResponseView<'static>>`.
pub type OwnedTailContainerLogsResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::TailContainerLogsResponseView<
        'static,
    >,
>;
///Shorthand for `OwnedView<TailHttpTrafficRequestView<'static>>`.
pub type OwnedTailHttpTrafficRequestView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::TailHttpTrafficRequestView<'static>,
>;
///Shorthand for `OwnedView<TailHttpTrafficResponseView<'static>>`.
pub type OwnedTailHttpTrafficResponseView = ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::TailHttpTrafficResponseView<'static>,
>;
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::GetMachineResponse>
for crate::proto::pethost::panel::v1::__buffa::view::GetMachineResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::GetMachineResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetMachineResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::RunMachineActionResponse>
for crate::proto::pethost::panel::v1::__buffa::view::RunMachineActionResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::RunMachineActionResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::RunMachineActionResponseView<
        'static,
    >,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::GetProjectResponse>
for crate::proto::pethost::panel::v1::__buffa::view::GetProjectResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::GetProjectResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetProjectResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::CreateProjectResponse>
for crate::proto::pethost::panel::v1::__buffa::view::CreateProjectResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::CreateProjectResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::CreateProjectResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::DeployProjectResponse>
for crate::proto::pethost::panel::v1::__buffa::view::DeployProjectResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::DeployProjectResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::DeployProjectResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::ListCommitsResponse>
for crate::proto::pethost::panel::v1::__buffa::view::ListCommitsResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::ListCommitsResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::ListCommitsResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::RunProjectActionResponse>
for crate::proto::pethost::panel::v1::__buffa::view::RunProjectActionResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::RunProjectActionResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::RunProjectActionResponseView<
        'static,
    >,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::SetProjectAlertsResponse>
for crate::proto::pethost::panel::v1::__buffa::view::SetProjectAlertsResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::SetProjectAlertsResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::SetProjectAlertsResponseView<
        'static,
    >,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::GetIncidentResponse>
for crate::proto::pethost::panel::v1::__buffa::view::GetIncidentResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::GetIncidentResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetIncidentResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::GetOperationResponse>
for crate::proto::pethost::panel::v1::__buffa::view::GetOperationResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::GetOperationResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetOperationResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::QueryHttpTrafficResponse>
for crate::proto::pethost::panel::v1::__buffa::view::QueryHttpTrafficResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::QueryHttpTrafficResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::QueryHttpTrafficResponseView<
        'static,
    >,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<
    crate::proto::pethost::panel::v1::QueryContainerLogsResponse,
>
for crate::proto::pethost::panel::v1::__buffa::view::QueryContainerLogsResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<
    crate::proto::pethost::panel::v1::QueryContainerLogsResponse,
>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::QueryContainerLogsResponseView<
        'static,
    >,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::LinkDatabaseResponse>
for crate::proto::pethost::panel::v1::__buffa::view::LinkDatabaseResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::LinkDatabaseResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::LinkDatabaseResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::CreateDatabaseResponse>
for crate::proto::pethost::panel::v1::__buffa::view::CreateDatabaseResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::CreateDatabaseResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::CreateDatabaseResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::RunServiceCommandResponse>
for crate::proto::pethost::panel::v1::__buffa::view::RunServiceCommandResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::RunServiceCommandResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::RunServiceCommandResponseView<
        'static,
    >,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::OpenTerminalResponse>
for crate::proto::pethost::panel::v1::__buffa::view::OpenTerminalResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::OpenTerminalResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::OpenTerminalResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<
    crate::proto::pethost::panel::v1::OpenDatabaseClientResponse,
>
for crate::proto::pethost::panel::v1::__buffa::view::OpenDatabaseClientResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<
    crate::proto::pethost::panel::v1::OpenDatabaseClientResponse,
>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::OpenDatabaseClientResponseView<
        'static,
    >,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::ReadPathResponse>
for crate::proto::pethost::panel::v1::__buffa::view::ReadPathResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::ReadPathResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::ReadPathResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::CreateTransferResponse>
for crate::proto::pethost::panel::v1::__buffa::view::CreateTransferResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::CreateTransferResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::CreateTransferResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::GetUploadResponse>
for crate::proto::pethost::panel::v1::__buffa::view::GetUploadResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::GetUploadResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::GetUploadResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::WatchOperationResponse>
for crate::proto::pethost::panel::v1::__buffa::view::WatchOperationResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::WatchOperationResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::WatchOperationResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::TailContainerLogsResponse>
for crate::proto::pethost::panel::v1::__buffa::view::TailContainerLogsResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::TailContainerLogsResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::TailContainerLogsResponseView<
        'static,
    >,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::TailHttpTrafficResponse>
for crate::proto::pethost::panel::v1::__buffa::view::TailHttpTrafficResponseView<'_> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self, codec)
    }
}
impl ::connectrpc::Encodable<crate::proto::pethost::panel::v1::TailHttpTrafficResponse>
for ::buffa::view::OwnedView<
    crate::proto::pethost::panel::v1::__buffa::view::TailHttpTrafficResponseView<'static>,
> {
    fn encode(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::buffa::bytes::Bytes, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body(self.reborrow(), codec)
    }
    /// An `OwnedView` still holds the buffer it was decoded from, so
    /// its large fields can be handed to the response body by
    /// reference count instead of copied. The bare view impl above
    /// cannot do this: it has borrows but no buffer to name.
    fn encode_segments(
        &self,
        codec: ::connectrpc::CodecFormat,
    ) -> ::std::result::Result<::connectrpc::EncodedBody, ::connectrpc::ConnectError> {
        ::connectrpc::__codegen::encode_view_body_segments(
            self.reborrow(),
            self.bytes(),
            codec,
        )
    }
}
/// Full service name for this service.
pub const PANEL_SERVICE_SERVICE_NAME: &str = "pethost.panel.v1.PanelService";
/// Static [`Spec`](::connectrpc::Spec) for the `GetMachine` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_GET_MACHINE_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/GetMachine",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::NoSideEffects);
/// Static [`Spec`](::connectrpc::Spec) for the `RunMachineAction` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_RUN_MACHINE_ACTION_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/RunMachineAction",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Static [`Spec`](::connectrpc::Spec) for the `GetProject` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_GET_PROJECT_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/GetProject",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::NoSideEffects);
/// Static [`Spec`](::connectrpc::Spec) for the `CreateProject` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_CREATE_PROJECT_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/CreateProject",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Static [`Spec`](::connectrpc::Spec) for the `DeployProject` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_DEPLOY_PROJECT_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/DeployProject",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Static [`Spec`](::connectrpc::Spec) for the `ListCommits` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_LIST_COMMITS_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/ListCommits",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::NoSideEffects);
/// Static [`Spec`](::connectrpc::Spec) for the `RunProjectAction` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_RUN_PROJECT_ACTION_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/RunProjectAction",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Static [`Spec`](::connectrpc::Spec) for the `SetProjectAlerts` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_SET_PROJECT_ALERTS_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/SetProjectAlerts",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Idempotent);
/// Static [`Spec`](::connectrpc::Spec) for the `GetIncident` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_GET_INCIDENT_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/GetIncident",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::NoSideEffects);
/// Static [`Spec`](::connectrpc::Spec) for the `GetOperation` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_GET_OPERATION_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/GetOperation",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::NoSideEffects);
/// Static [`Spec`](::connectrpc::Spec) for the `QueryHttpTraffic` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_QUERY_HTTP_TRAFFIC_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/QueryHttpTraffic",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::NoSideEffects);
/// Static [`Spec`](::connectrpc::Spec) for the `QueryContainerLogs` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_QUERY_CONTAINER_LOGS_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/QueryContainerLogs",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::NoSideEffects);
/// Static [`Spec`](::connectrpc::Spec) for the `LinkDatabase` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_LINK_DATABASE_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/LinkDatabase",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Idempotent);
/// Static [`Spec`](::connectrpc::Spec) for the `CreateDatabase` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_CREATE_DATABASE_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/CreateDatabase",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Static [`Spec`](::connectrpc::Spec) for the `RunServiceCommand` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_RUN_SERVICE_COMMAND_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/RunServiceCommand",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Static [`Spec`](::connectrpc::Spec) for the `OpenTerminal` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_OPEN_TERMINAL_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/OpenTerminal",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Static [`Spec`](::connectrpc::Spec) for the `OpenDatabaseClient` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_OPEN_DATABASE_CLIENT_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/OpenDatabaseClient",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Static [`Spec`](::connectrpc::Spec) for the `ReadPath` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_READ_PATH_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/ReadPath",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::NoSideEffects);
/// Static [`Spec`](::connectrpc::Spec) for the `CreateTransfer` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_CREATE_TRANSFER_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/CreateTransfer",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Static [`Spec`](::connectrpc::Spec) for the `GetUpload` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_GET_UPLOAD_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/GetUpload",
        ::connectrpc::StreamType::Unary,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::NoSideEffects);
/// Static [`Spec`](::connectrpc::Spec) for the `WatchOperation` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_WATCH_OPERATION_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/WatchOperation",
        ::connectrpc::StreamType::ServerStream,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Static [`Spec`](::connectrpc::Spec) for the `TailContainerLogs` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_TAIL_CONTAINER_LOGS_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/TailContainerLogs",
        ::connectrpc::StreamType::ServerStream,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// Static [`Spec`](::connectrpc::Spec) for the `TailHttpTraffic` RPC, as seen by the server; the generated client passes it with [`origin`](::connectrpc::Spec::origin) `Client` (compare across sides with [`Spec::same_method`](::connectrpc::Spec::same_method)).
pub const PANEL_SERVICE_TAIL_HTTP_TRAFFIC_SPEC: ::connectrpc::Spec = ::connectrpc::Spec::server(
        "/pethost.panel.v1.PanelService/TailHttpTraffic",
        ::connectrpc::StreamType::ServerStream,
    )
    .with_idempotency_level(::connectrpc::IdempotencyLevel::Unknown);
/// ── Machine ──────────────────────────────────────────────────────────────
///
/// # Implementing handlers
///
/// Implement methods with plain `async fn`; the returned future satisfies
/// the `Send` bound automatically.
///
/// **Unary and server-streaming requests** arrive as
/// [`ServiceRequest<'_, Req>`](::connectrpc::ServiceRequest): a zero-copy
/// view of the request plus its body, valid for the duration of the call.
/// Fields are read directly (`request.name` is a `&str` into the decoded
/// buffer) and the borrow may be held across `.await` points. Anything
/// that must outlive the call — `tokio::spawn`, channels, server state,
/// or data captured by a returned response stream — takes owned data:
/// call `request.to_owned_message()` (or copy the specific fields)
/// first.
///
/// **Client-streaming and bidi requests** arrive as
/// [`InboundStream<Req>`](::connectrpc::InboundStream) — a
/// `ServiceStream` of [`StreamMessage`](::connectrpc::StreamMessage)s.
/// Each item owns its decoded buffer and is `Send + 'static`, so items
/// can be buffered or moved into spawned tasks; read fields zero-copy
/// through the generated accessor methods (`item.name()`) or `.view()`,
/// convert with `.to_owned_message()`, or yield an item back unchanged —
/// `StreamMessage<M>` implements `Encodable<M>`.
///
/// Request types resolved through `extern_path` (e.g. well-known types
/// from another crate) use the same wrappers; the crate that owns the
/// type must be generated with buffa ≥ 0.9.0 and views enabled so the
/// backing `HasMessageView` impl exists.
///
/// The `impl Encodable<Out>` return bound accepts the owned `Out`, the
/// generated `OutView<'_>` / `OwnedOutView`,
/// [`MaybeBorrowed`](::connectrpc::MaybeBorrowed), or
/// [`PreEncoded`](::connectrpc::PreEncoded) for handlers that encode a
/// non-`'static` view internally and pass the bytes across the handler
/// boundary. View bodies are not emitted for output types mapped via
/// `extern_path` (the impl would be an orphan); return owned for
/// WKT/extern outputs.
///
/// Server-streaming and bidi-streaming methods return
/// `ServiceStream<impl Encodable<Out> + Send + use<Self>>`. The
/// `use<Self>` precise-capturing clause excludes `&self`'s lifetime and
/// the request's lifetime (unary methods use `use<'a, Self>` and may
/// borrow from `&self`), so stream items must be `'static` and cannot
/// borrow from the request. To stream view-encoded data, encode each
/// item inside the stream body and yield
/// [`PreEncoded`](::connectrpc::PreEncoded) — see its `# Streaming
/// example` doc.
#[allow(clippy::type_complexity)]
pub trait PanelService: Send + Sync + 'static {
    /// Start here: the machine (resources, the person's domain, backups, SSH), every project with
    /// its problems and URL, deleted projects with snapshots, GitHub repositories to create projects
    /// from. Figures are the latest sample; disk sizes and the day's traffic lag a few minutes.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn get_machine<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::GetMachineRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::GetMachineResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// One machine action: add or remove the person's SSH public key (for SSH and SFTP to their
    /// projects' containers: Service.ssh_command), end a session, schedule or cancel a restart.
    /// Returns the machine.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn run_machine_action<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::RunMachineActionRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::RunMachineActionResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// One project in full: services (state, health, image, the ports it listens on, volumes,
    /// environment, the SSH command), volumes, routes, hosts with certificates, recent operations,
    /// snapshots, the last day's HTTP traffic. Env-file values and a database's password
    /// (Project.database.connection) only with include_secret_values. Its files: ReadPath.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn get_project<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::GetProjectRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::GetProjectResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// Creates a project from its files and deploys it. Waits for the deploy (wait_seconds) and
    /// answers with the operation and, once it ended, the project: its URL, its services' states,
    /// its problems. `violations` instead = nothing was created: change what each says, call again.
    /// SUCCEEDED says the containers run and listen, not what a page answers: open the URL once
    /// (401 = its password page).
    ///
    /// Files, one of: the directory as it is on your disk, as an archive (CreateTransfer, then
    /// `upload_id`): nothing is retyped; `files`, text you send yourself, when there is no directory
    /// or no shell (never a file you have not read); `source.github`. /.env holds the secrets
    /// (`env_file: .env`). The compose file is the root's pethost.compose.yaml (so the repository's
    /// compose.yaml stays for development), else compose.yaml, compose.yml, docker-compose.yml or
    /// docker-compose.yaml; it becomes /compose.yaml, other compose and override files are dropped.
    /// Without one, a Dockerfile yields service `app` (reading /.env if any, its EXPOSE ports, a
    /// named volume per VOLUME of its last stage).
    ///
    /// A database (Postgres or Valkey): `database`, no files, and a project_id without "_", not a
    /// number (only digits, or 0x and hex digits) and no name of every container's /etc/hosts
    /// (localhost, ip6-localhost, ip6-loopback, ...): it is the host name apps use. The machine
    /// writes its compose.yaml and /.env and deploys it at its default size, with no address; then
    /// LinkDatabase the apps that use it.
    ///
    /// compose.yaml rules. Data lives in named volumes; all else a container writes is lost when it
    /// is recreated. Project files are bind-mounted read-only. HTTP comes through the proxy, to a
    /// host of a route in `x-pethost`, the one extension read, in the file or as `x_pethost`:
    ///
    ///   x-pethost:
    /// ```text
    /// metadata: {name: Recipe Box, emoji: "🥗", description: One line, notes: Free text}
    /// routes:
    ///   - {host: recipes.sam.pethost.app, service: web, port: 3000}
    ///   - {host: recipes.sam.pethost.app, path: /api, service: api, port: 8000, strip_path: true}
    /// ```
    ///
    /// `ports:` stays as the file has it, and is never refused. A TCP port it publishes that
    /// answers HTTP gets its route by itself and is not opened on the machine: at
    /// `<project>.<Machine.apps_domain>`, or `<project>-<service>.<apps_domain>` each when the
    /// project has several; `Project.url` has it when the call answers. Any other published port
    /// opens on the machine as written, at `<Machine.hostname>:<port>`, and one that is taken there
    /// fails the deploy; so does a web port once its route is removed. Never opened: a port bound
    /// to 127.0.0.1 (`ssh_command` tunnels to it), a machine port of the machine's own (80, 443,
    /// 22), and one nothing listens on within a minute of its start, until a later deploy finds it
    /// listening (`Service.published_ports` lists what is open). With `x_pethost.routes` the routes
    /// are yours and the machine names none. A project that publishes no port gets
    /// `<project>.<apps_domain>` in its first deploy, for the one port it listens on.
    /// A service with neither is private: the project's services reach it at `<service>:<port>`.
    /// A password for visitors goes only as `x_pethost.password`, never into the file: every route
    /// then answers 401 with a password page, over HTTPS only; nothing returns it
    /// (`Project.password_protected` says it is set); and `files` that write /compose.yaml keep the
    /// `password_hash` line the machine put in its `x-pethost`.
    /// All of compose.yaml is interpolated: $$ for $.
    ///
    /// The file runs as written, or is refused: the machine corrects nothing in it, in any version.
    /// Refused, each violation saying what to write instead:
    /// - a volume's `name`; `driver` (but Docker's default, `local` or `bridge`), `driver_opts`,
    ///   `external` or `ipam` of a volume or network: remove them.
    /// - a writable bind mount of the whole project (`.:/app`): add `:ro`.
    /// - a volume with no name (`- /data`): name it. Below a bind mount it is allowed, as scratch
    ///   space (`/app/node_modules`).
    /// - `env_file` naming a file the files lack: write it, empty if it sets nothing, or give the
    ///   entry `required: false`.
    /// - `privileged`, `cap_add`, `security_opt` (but `no-new-privileges`), `devices`, host
    ///   namespaces, the Docker socket, a path outside the directory; more than one replica;
    ///   `include` or `extends` from a URL; a git URL as a build context.
    /// Not refused, and read the machine's way: a `container_name` and a network's `name` name
    /// nothing on the machine, so two projects may write the same (the project's services still
    /// reach the container by it); a service with `profiles` runs only while `COMPOSE_PROFILES`
    /// in /.env names one of them, and is no service of the project until then; a bind mount of a
    /// folder without `:ro` (`./data:/data`) mounts the project's volume named after the path
    /// (`data`), which deploys keep and backups hold, with none of the version's files in it, so
    /// project files take `:ro`, and data is plainer in a named volume (`data:/data`, with `data:`
    /// under `volumes:`); a bind mount of a file without `:ro` mounts it read-only.
    /// An image's VOLUME that no mount covers fails the deploy (UNCOVERED_IMAGE_VOLUME): mount a
    /// named volume or a tmpfs there.
    ///
    /// ALREADY_EXISTS = the id is taken (a retry with its operation_id returns that operation).
    /// FAILED_PRECONDITION = the GitHub App cannot read the repository (see GetMachine.github), or no
    /// such branch or directory; + MachineUpdatePending = `database`, on a machine whose software
    /// predates databases. A deleted project's id inherits its snapshots.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn create_project<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::CreateProjectRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::CreateProjectResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// Deploys a new version of a project and answers as CreateProject does: `files` written over
    /// its own (/.env, /compose.yaml, a source file), `x_pethost` (name, routes, password),
    /// `mount_volume`, a new archive (`upload_id`), a commit, or an earlier deploy's files again
    /// (`rollback_deploy_id`). compose.yaml rules: CreateProject's.
    ///
    /// It builds `build:` images, pulls missing ones, runs `compose up` on the whole project and waits
    /// until each service runs (healthy, if it has a healthcheck) or each job exits 0, and until each
    /// routed service listens on its route's port (up to 15 s: one that does not is the project's
    /// SERVICE_PORT_CLOSED problem, its route answering 502, not a failed deploy). So it also starts
    /// stopped services, reruns jobs, recreates changed services and those bind-mounting project
    /// files, and fails on an unhealthy service. While Project.x_pethost_applies_at_once, a version
    /// differing only in `x-pethost` (or not at all) applies at once, restarting nothing but a
    /// service whose published port a route takes or leaves. Any other
    /// deploy applies its routes and password as it ends: to hide new content from its first second,
    /// set the password first, in a call of its own, then deploy the content.
    ///
    /// A commit other than GithubSource.newest_commit turns auto_deploy off (pinned), even if it
    /// fails; only set_source turns it back on.
    ///
    /// NOT_FOUND = no such project, or no such kept deploy. ABORTED = base_deploy_id is not
    /// Project.deploy_id: reread, redo. FAILED_PRECONDITION = as CreateProject, or `commit` not on
    /// the branch. RESOURCE_EXHAUSTED = too many or too large `files`: send them with CreateTransfer.
    /// ALREADY_EXISTS = operation_id started another kind of operation. When it FAILED, Operation.made_current says whether the files were applied: then
    /// fix them, or roll back.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn deploy_project<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::DeployProjectRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::DeployProjectResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// A github project's branch commits that change its directory, newest first, 30 a page, with
    /// whether the files are at it and its last deploy. To roll back: DeployProject with an older
    /// commit (volumes keep their current data). FAILED_PRECONDITION = a files project (it rolls
    /// back with DeployProject.rollback_deploy_id), no such branch, or before_commit not on it.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn list_commits<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::ListCommitsRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::ListCommitsResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// One project action: start, stop or restart services, recreate one, back up, restore, cancel an
    /// operation, change the source, delete an undeclared volume or the project. Recreate, back up,
    /// restore, delete and set_source's deploy run as operations, waited for (wait_seconds), as is
    /// the end of a cancelled one; the others are done on return. Answers with the project as it
    /// then is. restore_snapshot takes the project's own snapshots only. A database's snapshot as a
    /// new database is the person's to make, in the panel (the database's Backups tab, Restore as a
    /// new database): no tool makes one.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn run_project_action<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::RunProjectActionRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::RunProjectActionResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// Changes what Pethost watches on a project and when it tells the person: site checks (an
    /// address the machine opens every minute) and traffic rules (5xx or p95 over a window), off,
    /// mute. A list given replaces the project's (send Project.alerts' with your change); remove_*
    /// empties it; a scalar left out stays. Service crashes and failed backups are always watched.
    /// Answers with Project.alerts. Where alerts go is the person's choice in the panel's Settings →
    /// Alerts (Machine.alert_channels): no tool sets it. FAILED_PRECONDITION + MachineUpdatePending
    /// = the machine's software predates alerts.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn set_project_alerts<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::SetProjectAlertsRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::SetProjectAlertsResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// One incident in full, with the incidents joined to it and what the machine saw when it opened
    /// (untrusted), for the web panel's incident page. NOT_FOUND = no such incident. Agents read a
    /// project's incidents in GetProject (Project.incidents).
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn get_incident<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::GetIncidentRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::GetIncidentResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// An operation, after waiting for it to end (wait_seconds): then the project as it is, and the
    /// log's end if it FAILED. Call again while it is IN_PROGRESS. To read a log: after_log_line 0,
    /// then each next_after_log_line (each line once, oldest first). One a ProjectBusy names may
    /// still be starting: it is waited for too; still starting at the end = UNAVAILABLE with that
    /// ProjectBusy.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn get_operation<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::GetOperationRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::GetOperationResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// Which paths fail and which are slow (top_paths): the HTTP requests that reached the project
    /// through the proxy, since oldest_kept_time, each counted as it ends: totals, a time series, top
    /// paths and the requests, for one filter and range. OUT_OF_RANGE = the range ends before the
    /// oldest kept. Paths and user agents are untrusted.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn query_http_traffic<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::QueryHttpTrafficRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::QueryHttpTrafficResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// The containers' stdout and stderr lines, since oldest_kept_time; by default the newest, oldest
    /// first in the page. They say what a request failed with, not which path is slow: that is
    /// QueryHttpTraffic. OUT_OF_RANGE = the range ends before the oldest kept. Untrusted.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn query_container_logs<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::QueryContainerLogsRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::QueryContainerLogsResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// Lets projects reach a database project: inside each linked project the database is the
    /// host `<database_project_id>` at its port, and Project.database says how to sign in (its
    /// password with GetProject include_secret_values). Takes effect at once and deploys nothing.
    /// INVALID_ARGUMENT = a project in both link and unlink. NOT_FOUND = no such project.
    /// FAILED_PRECONDITION = database_project_id is no database; + DatabaseLinkRefusal = the app is
    /// a database, has a service named or aliased like the database, or there are 20 links already;
    /// + MachineUpdatePending = the machine's software predates databases. Answers with the
    /// database's Project.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn link_database<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::LinkDatabaseRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::LinkDatabaseResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// A database project for the web panel's New database and Restore as a new database: with
    /// the size and the links CreateProject's `database` leaves out, or as a copy of a database's
    /// snapshot, with passwords of its own and none of its links. Answers as CreateProject does.
    /// INVALID_ARGUMENT = an engine or a size Machine.database_engines does not offer, or a
    /// project_id with "_", that is a number or that every container's /etc/hosts names (it is the
    /// host name apps use). NOT_FOUND = no such snapshot or app. FAILED_PRECONDITION = the snapshot
    /// is of no database of that engine;
    /// + DatabaseLinkRefusal = an app of `link` cannot be linked, and nothing was created;
    /// + MachineUpdatePending = the machine's software predates databases. Not an MCP tool: agents
    /// use CreateProject with `database`, then LinkDatabase.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn create_database<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::CreateDatabaseRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::CreateDatabaseResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// Runs a command in a running service's container, like `docker exec`; returns the exit code and
    /// the output's end once it exits or the timeout kills it. Over a bound on command, stdin or
    /// timeout = refused (named). Cannot start = exit 127 or 126, Docker's error in stdout. Untrusted
    /// output.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn run_service_command<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::RunServiceCommandRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::RunServiceCommandResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// An interactive terminal in a service's running container, for the web panel: returns a URL
    /// the browser opens as a WebSocket straight to the machine, once, within 5 minutes, so
    /// keystrokes and output never pass through the panel. On it, binary messages carry the
    /// terminal's bytes both ways (input at most 1 MiB a message); the browser sends
    /// {"resize":{"columns":C,"rows":R}} as text; the machine's last message is {"exit_code":N}, or
    /// {"error":"..."} when the program could not start or was ended, then it closes the
    /// connection. While open, the terminal is one of Machine.sessions. Not an MCP tool: agents use
    /// RunServiceCommand.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn open_terminal<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::OpenTerminalRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::OpenTerminalResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// A client of a database project, for the web panel: returns a URL the browser opens as a
    /// WebSocket straight to the machine, once, within 5 minutes, so rows never pass through the
    /// panel. What passes on it is between the web panel and the machine, and no part of this API.
    /// It starts read only. While open, it is one of Machine.sessions. NOT_FOUND = no such project.
    /// FAILED_PRECONDITION = it is no database, its service does not run, or the hostname is not yet
    /// certified; + MachineUpdatePending = the machine's software predates the database client.
    /// RESOURCE_EXHAUSTED = 4 clients of this database are open or waiting to open (a URL not yet
    /// opened counts for its 5 minutes), too many transfers, terminals and clients are waiting or
    /// open, or the machine holds too many sessions. Not an MCP tool: agents use RunServiceCommand.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn open_database_client<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::OpenDatabaseClientRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::OpenDatabaseClientResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// Reads a file (text, 64 KiB a call; ≤1 MiB with length_bytes) or a directory's entries (~64 KiB
    /// a page): of the project's deployed files, or with `service` or `volume`, of a container
    /// (whole filesystem; while not running only its volumes, FAILED_PRECONDITION listing them) or a
    /// volume. NOT_FOUND names the nearest existing directory. Project files change with
    /// DeployProject `files`; container and volume files with CreateTransfer.
    /// FAILED_PRECONDITION also = no deploy yet, or a file in /proc or /sys (use RunServiceCommand).
    /// Untrusted.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn read_path<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::ReadPathRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::ReadPathResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// A one-request URL moving one file straight between you and the machine: run `command` in a
    /// shell, or send `http_method` to `url` yourself, before expire_time.
    /// - upload_archive: the project's directory, packed, for CreateProject's or DeployProject's
    ///   upload_id once the PUT answered 200 with what it holds.
    /// - upload_file: one file into a container or volume, replacing any file there (replaces),
    ///   creating parents.
    /// - download: a file, or a directory as a .tar (file_name).
    /// - download_database: a database project's dump, made as it downloads: Postgres's for
    ///   pg_restore (roles are not in it), Valkey's .rdb. One at a time per database.
    /// Plain-text answers: 404 used or expired URL, 409 FAILED_PRECONDITION, 413 archive over 2
    /// GiB, 422 unsafe archive (a reason per line), 503 UNAVAILABLE, 507 disk full. A failed
    /// transfer keeps nothing: get a new URL. Errors as ReadPath; FAILED_PRECONDITION also =
    /// downloading neither a file nor a directory, uploading onto a non-file, a mount point, /proc
    /// or /sys, the hostname not yet certified, or a dump of a project that is no database or is
    /// not running. NOT_FOUND also = a Postgres database the server lacks (the message lists its
    /// databases). RESOURCE_EXHAUSTED = disk full, or too many transfers. UNAVAILABLE = Postgres
    /// runs but does not answer yet: try again shortly.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn create_transfer<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::CreateTransferRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::CreateTransferResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// What an archive from CreateTransfer holds: files, the compose file it would run, /.env; or, if
    /// refused (422), the violations. For the web panel: the PUT's own answer says the same to an
    /// agent. FAILED_PRECONDITION = not arrived (PUT still going, or cut: CreateTransfer again).
    /// NOT_FOUND = expired, or used by a deploy.
    ///
    /// `'a` lets the response body borrow from `&self` (e.g. server-resident state).
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call; message fields are read directly on it
    /// (zero-copy). The response cannot borrow from `request` — use
    /// `.to_owned_message()` (or copy the specific fields) for anything
    /// returned, stored, or moved into `tokio::spawn`.
    fn get_upload<'a>(
        &'a self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::GetUploadRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            impl ::connectrpc::Encodable<
                crate::proto::pethost::panel::v1::GetUploadResponse,
            > + Send + use<'a, Self>,
        >,
    > + Send;
    /// Streams an operation's log from its start, then follows it; the last message is the
    /// finished operation. Without a stream: GetOperation.
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call (until the response stream is returned);
    /// message fields are read directly on it (zero-copy). Data the
    /// returned stream needs must be copied out or converted via
    /// `.to_owned_message()`.
    fn watch_operation(
        &self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::WatchOperationRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            ::connectrpc::ServiceStream<
                impl ::connectrpc::Encodable<
                    crate::proto::pethost::panel::v1::WatchOperationResponse,
                > + Send + use<Self>,
            >,
        >,
    > + Send;
    /// Streams container output after a cursor, then new lines as they are written. OUT_OF_RANGE =
    /// the machine no longer keeps the cursor's line, so lines after it may be gone too: start over
    /// with QueryContainerLogs and tail after its tail_cursor. Without a stream: QueryContainerLogs.
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call (until the response stream is returned);
    /// message fields are read directly on it (zero-copy). Data the
    /// returned stream needs must be copied out or converted via
    /// `.to_owned_message()`.
    fn tail_container_logs(
        &self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::TailContainerLogsRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            ::connectrpc::ServiceStream<
                impl ::connectrpc::Encodable<
                    crate::proto::pethost::panel::v1::TailContainerLogsResponse,
                > + Send + use<Self>,
            >,
        >,
    > + Send;
    /// Streams HTTP requests after a sequence number, then new ones as they finish. Without a
    /// stream: QueryHttpTraffic.
    ///
    /// `request` is borrowed from the request body and is valid for the
    /// duration of the call (until the response stream is returned);
    /// message fields are read directly on it (zero-copy). Data the
    /// returned stream needs must be copied out or converted via
    /// `.to_owned_message()`.
    fn tail_http_traffic(
        &self,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::ServiceRequest<
            '_,
            crate::proto::pethost::panel::v1::TailHttpTrafficRequest,
        >,
    ) -> impl ::std::future::Future<
        Output = ::connectrpc::ServiceResult<
            ::connectrpc::ServiceStream<
                impl ::connectrpc::Encodable<
                    crate::proto::pethost::panel::v1::TailHttpTrafficResponse,
                > + Send + use<Self>,
            >,
        >,
    > + Send;
}
/// Extension trait for registering a service implementation with a Router.
///
/// This trait is automatically implemented for all types that implement the service trait.
/// Prefer [`Router::add_service`](::connectrpc::Router::add_service) for
/// top-down registration; `register` remains available for compatibility
/// and cases where the service-first call shape is more convenient.
///
/// # Example
///
/// ```rust,ignore
/// use std::sync::Arc;
///
/// let service = Arc::new(MyServiceImpl);
/// let router = service.register(Router::new());
/// ```
pub trait PanelServiceExt: PanelService {
    /// Register this service implementation with a Router.
    ///
    /// Takes ownership of the `Arc<Self>` and returns a new Router with
    /// this service's methods registered.
    fn register(
        self: ::std::sync::Arc<Self>,
        router: ::connectrpc::Router,
    ) -> ::connectrpc::Router;
}
impl<S: PanelService> PanelServiceExt for S {
    fn register(
        self: ::std::sync::Arc<Self>,
        router: ::connectrpc::Router,
    ) -> ::connectrpc::Router {
        router
            .route_view_idempotent(
                PANEL_SERVICE_SERVICE_NAME,
                "GetMachine",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::GetMachineRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::GetMachineRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.get_machine(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::GetMachineResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_GET_MACHINE_SPEC)
            .route_view(
                PANEL_SERVICE_SERVICE_NAME,
                "RunMachineAction",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::RunMachineActionRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::RunMachineActionRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.run_machine_action(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::RunMachineActionResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_RUN_MACHINE_ACTION_SPEC)
            .route_view_idempotent(
                PANEL_SERVICE_SERVICE_NAME,
                "GetProject",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::GetProjectRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::GetProjectRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.get_project(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::GetProjectResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_GET_PROJECT_SPEC)
            .route_view(
                PANEL_SERVICE_SERVICE_NAME,
                "CreateProject",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::CreateProjectRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::CreateProjectRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.create_project(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::CreateProjectResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_CREATE_PROJECT_SPEC)
            .route_view(
                PANEL_SERVICE_SERVICE_NAME,
                "DeployProject",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::DeployProjectRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::DeployProjectRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.deploy_project(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::DeployProjectResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_DEPLOY_PROJECT_SPEC)
            .route_view_idempotent(
                PANEL_SERVICE_SERVICE_NAME,
                "ListCommits",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::ListCommitsRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::ListCommitsRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.list_commits(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::ListCommitsResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_LIST_COMMITS_SPEC)
            .route_view(
                PANEL_SERVICE_SERVICE_NAME,
                "RunProjectAction",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::RunProjectActionRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::RunProjectActionRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.run_project_action(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::RunProjectActionResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_RUN_PROJECT_ACTION_SPEC)
            .route_view(
                PANEL_SERVICE_SERVICE_NAME,
                "SetProjectAlerts",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::SetProjectAlertsRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::SetProjectAlertsRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.set_project_alerts(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::SetProjectAlertsResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_SET_PROJECT_ALERTS_SPEC)
            .route_view_idempotent(
                PANEL_SERVICE_SERVICE_NAME,
                "GetIncident",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::GetIncidentRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::GetIncidentRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.get_incident(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::GetIncidentResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_GET_INCIDENT_SPEC)
            .route_view_idempotent(
                PANEL_SERVICE_SERVICE_NAME,
                "GetOperation",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::GetOperationRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::GetOperationRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.get_operation(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::GetOperationResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_GET_OPERATION_SPEC)
            .route_view_idempotent(
                PANEL_SERVICE_SERVICE_NAME,
                "QueryHttpTraffic",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::QueryHttpTrafficRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::QueryHttpTrafficRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.query_http_traffic(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::QueryHttpTrafficResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_QUERY_HTTP_TRAFFIC_SPEC)
            .route_view_idempotent(
                PANEL_SERVICE_SERVICE_NAME,
                "QueryContainerLogs",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::QueryContainerLogsRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::QueryContainerLogsRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.query_container_logs(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::QueryContainerLogsResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_QUERY_CONTAINER_LOGS_SPEC)
            .route_view(
                PANEL_SERVICE_SERVICE_NAME,
                "LinkDatabase",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::LinkDatabaseRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::LinkDatabaseRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.link_database(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::LinkDatabaseResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_LINK_DATABASE_SPEC)
            .route_view(
                PANEL_SERVICE_SERVICE_NAME,
                "CreateDatabase",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::CreateDatabaseRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::CreateDatabaseRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.create_database(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::CreateDatabaseResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_CREATE_DATABASE_SPEC)
            .route_view(
                PANEL_SERVICE_SERVICE_NAME,
                "RunServiceCommand",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::RunServiceCommandRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::RunServiceCommandRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.run_service_command(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::RunServiceCommandResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_RUN_SERVICE_COMMAND_SPEC)
            .route_view(
                PANEL_SERVICE_SERVICE_NAME,
                "OpenTerminal",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::OpenTerminalRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::OpenTerminalRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.open_terminal(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::OpenTerminalResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_OPEN_TERMINAL_SPEC)
            .route_view(
                PANEL_SERVICE_SERVICE_NAME,
                "OpenDatabaseClient",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::OpenDatabaseClientRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::OpenDatabaseClientRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.open_database_client(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::OpenDatabaseClientResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_OPEN_DATABASE_CLIENT_SPEC)
            .route_view_idempotent(
                PANEL_SERVICE_SERVICE_NAME,
                "ReadPath",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::ReadPathRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::ReadPathRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.read_path(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::ReadPathResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_READ_PATH_SPEC)
            .route_view(
                PANEL_SERVICE_SERVICE_NAME,
                "CreateTransfer",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::CreateTransferRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::CreateTransferRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.create_transfer(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::CreateTransferResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_CREATE_TRANSFER_SPEC)
            .route_view_idempotent(
                PANEL_SERVICE_SERVICE_NAME,
                "GetUpload",
                {
                    let svc = ::std::sync::Arc::clone(&self);
                    ::connectrpc::view_handler_fn(move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::GetUploadRequestView<
                                'static,
                            >,
                        >,
                        format|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::GetUploadRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.get_upload(ctx, sreq)
                                .await?
                                .encode::<
                                    crate::proto::pethost::panel::v1::GetUploadResponse,
                                >(format)
                        }
                    })
                },
            )
            .with_spec(PANEL_SERVICE_GET_UPLOAD_SPEC)
            .route_view_server_stream::<
                _,
                _,
                crate::proto::pethost::panel::v1::WatchOperationResponse,
            >(
                PANEL_SERVICE_SERVICE_NAME,
                "WatchOperation",
                ::connectrpc::view_streaming_handler_fn({
                    let svc = ::std::sync::Arc::clone(&self);
                    move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::WatchOperationRequestView<
                                'static,
                            >,
                        >|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::WatchOperationRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.watch_operation(ctx, sreq).await
                        }
                    }
                }),
            )
            .with_spec(PANEL_SERVICE_WATCH_OPERATION_SPEC)
            .route_view_server_stream::<
                _,
                _,
                crate::proto::pethost::panel::v1::TailContainerLogsResponse,
            >(
                PANEL_SERVICE_SERVICE_NAME,
                "TailContainerLogs",
                ::connectrpc::view_streaming_handler_fn({
                    let svc = ::std::sync::Arc::clone(&self);
                    move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::TailContainerLogsRequestView<
                                'static,
                            >,
                        >|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::TailContainerLogsRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.tail_container_logs(ctx, sreq).await
                        }
                    }
                }),
            )
            .with_spec(PANEL_SERVICE_TAIL_CONTAINER_LOGS_SPEC)
            .route_view_server_stream::<
                _,
                _,
                crate::proto::pethost::panel::v1::TailHttpTrafficResponse,
            >(
                PANEL_SERVICE_SERVICE_NAME,
                "TailHttpTraffic",
                ::connectrpc::view_streaming_handler_fn({
                    let svc = ::std::sync::Arc::clone(&self);
                    move |
                        ctx,
                        req: ::buffa::view::OwnedView<
                            crate::proto::pethost::panel::v1::__buffa::view::TailHttpTrafficRequestView<
                                'static,
                            >,
                        >|
                    {
                        let svc = ::std::sync::Arc::clone(&svc);
                        async move {
                            let sreq = ::connectrpc::ServiceRequest::<
                                crate::proto::pethost::panel::v1::TailHttpTrafficRequest,
                            >::from_parts(req.reborrow(), req.bytes());
                            svc.tail_http_traffic(ctx, sreq).await
                        }
                    }
                }),
            )
            .with_spec(PANEL_SERVICE_TAIL_HTTP_TRAFFIC_SPEC)
    }
}
/// Type-inference marker used by [`Router::add_service`](::connectrpc::Router::add_service).
#[doc(hidden)]
pub struct PanelServiceRegisterMarker;
impl<S: PanelService> ::connectrpc::ServiceRegister<PanelServiceRegisterMarker>
for ::std::sync::Arc<S> {
    fn register_service(self, router: ::connectrpc::Router) -> ::connectrpc::Router {
        <S as PanelServiceExt>::register(self, router)
    }
}
/// Monomorphic dispatcher for `PanelService`.
///
/// Unlike `.register(Router)` which type-erases each method into an `Arc<dyn ErasedHandler>` stored in a `HashMap`, this struct dispatches via a compile-time `match` on method name: no vtable, no hash lookup.
///
/// # Example
///
/// ```rust,ignore
/// use connectrpc::ConnectRpcService;
///
/// let server = PanelServiceServer::new(MyImpl);
/// let service = ConnectRpcService::new(server);
/// // hand `service` to axum/hyper as a fallback_service
/// ```
pub struct PanelServiceServer<T> {
    inner: ::std::sync::Arc<T>,
}
impl<T: PanelService> PanelServiceServer<T> {
    /// Wrap a service implementation in a monomorphic dispatcher.
    pub fn new(service: T) -> Self {
        Self {
            inner: ::std::sync::Arc::new(service),
        }
    }
    /// Wrap an already-`Arc`'d service implementation.
    pub fn from_arc(inner: ::std::sync::Arc<T>) -> Self {
        Self { inner }
    }
}
impl<T> Clone for PanelServiceServer<T> {
    fn clone(&self) -> Self {
        Self {
            inner: ::std::sync::Arc::clone(&self.inner),
        }
    }
}
impl<T: PanelService> ::connectrpc::Dispatcher for PanelServiceServer<T> {
    #[inline]
    fn lookup(
        &self,
        path: &str,
    ) -> Option<::connectrpc::dispatcher::codegen::MethodDescriptor> {
        let method = path.strip_prefix("pethost.panel.v1.PanelService/")?;
        match method {
            "GetMachine" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(true)
                        .with_spec(PANEL_SERVICE_GET_MACHINE_SPEC),
                )
            }
            "RunMachineAction" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(PANEL_SERVICE_RUN_MACHINE_ACTION_SPEC),
                )
            }
            "GetProject" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(true)
                        .with_spec(PANEL_SERVICE_GET_PROJECT_SPEC),
                )
            }
            "CreateProject" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(PANEL_SERVICE_CREATE_PROJECT_SPEC),
                )
            }
            "DeployProject" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(PANEL_SERVICE_DEPLOY_PROJECT_SPEC),
                )
            }
            "ListCommits" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(true)
                        .with_spec(PANEL_SERVICE_LIST_COMMITS_SPEC),
                )
            }
            "RunProjectAction" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(PANEL_SERVICE_RUN_PROJECT_ACTION_SPEC),
                )
            }
            "SetProjectAlerts" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(PANEL_SERVICE_SET_PROJECT_ALERTS_SPEC),
                )
            }
            "GetIncident" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(true)
                        .with_spec(PANEL_SERVICE_GET_INCIDENT_SPEC),
                )
            }
            "GetOperation" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(true)
                        .with_spec(PANEL_SERVICE_GET_OPERATION_SPEC),
                )
            }
            "QueryHttpTraffic" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(true)
                        .with_spec(PANEL_SERVICE_QUERY_HTTP_TRAFFIC_SPEC),
                )
            }
            "QueryContainerLogs" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(true)
                        .with_spec(PANEL_SERVICE_QUERY_CONTAINER_LOGS_SPEC),
                )
            }
            "LinkDatabase" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(PANEL_SERVICE_LINK_DATABASE_SPEC),
                )
            }
            "CreateDatabase" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(PANEL_SERVICE_CREATE_DATABASE_SPEC),
                )
            }
            "RunServiceCommand" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(PANEL_SERVICE_RUN_SERVICE_COMMAND_SPEC),
                )
            }
            "OpenTerminal" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(PANEL_SERVICE_OPEN_TERMINAL_SPEC),
                )
            }
            "OpenDatabaseClient" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(PANEL_SERVICE_OPEN_DATABASE_CLIENT_SPEC),
                )
            }
            "ReadPath" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(true)
                        .with_spec(PANEL_SERVICE_READ_PATH_SPEC),
                )
            }
            "CreateTransfer" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(false)
                        .with_spec(PANEL_SERVICE_CREATE_TRANSFER_SPEC),
                )
            }
            "GetUpload" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::unary(true)
                        .with_spec(PANEL_SERVICE_GET_UPLOAD_SPEC),
                )
            }
            "WatchOperation" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::server_streaming()
                        .with_spec(PANEL_SERVICE_WATCH_OPERATION_SPEC),
                )
            }
            "TailContainerLogs" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::server_streaming()
                        .with_spec(PANEL_SERVICE_TAIL_CONTAINER_LOGS_SPEC),
                )
            }
            "TailHttpTraffic" => {
                Some(
                    ::connectrpc::dispatcher::codegen::MethodDescriptor::server_streaming()
                        .with_spec(PANEL_SERVICE_TAIL_HTTP_TRAFFIC_SPEC),
                )
            }
            _ => None,
        }
    }
    fn call_unary(
        &self,
        path: &str,
        ctx: ::connectrpc::RequestContext,
        request: ::connectrpc::Payload,
        format: ::connectrpc::CodecFormat,
    ) -> ::connectrpc::dispatcher::codegen::UnaryResult {
        let Some(method) = path.strip_prefix("pethost.panel.v1.PanelService/") else {
            return ::connectrpc::dispatcher::codegen::unimplemented_unary(path);
        };
        let _ = (&ctx, &request, &format);
        match method {
            "GetMachine" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::GetMachineRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::GetMachineRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::GetMachineRequest,
                    >::from_parts(&req, &body);
                    svc.get_machine(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::GetMachineResponse,
                        >(format)
                })
            }
            "RunMachineAction" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::RunMachineActionRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::RunMachineActionRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::RunMachineActionRequest,
                    >::from_parts(&req, &body);
                    svc.run_machine_action(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::RunMachineActionResponse,
                        >(format)
                })
            }
            "GetProject" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::GetProjectRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::GetProjectRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::GetProjectRequest,
                    >::from_parts(&req, &body);
                    svc.get_project(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::GetProjectResponse,
                        >(format)
                })
            }
            "CreateProject" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::CreateProjectRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::CreateProjectRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::CreateProjectRequest,
                    >::from_parts(&req, &body);
                    svc.create_project(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::CreateProjectResponse,
                        >(format)
                })
            }
            "DeployProject" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::DeployProjectRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::DeployProjectRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::DeployProjectRequest,
                    >::from_parts(&req, &body);
                    svc.deploy_project(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::DeployProjectResponse,
                        >(format)
                })
            }
            "ListCommits" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::ListCommitsRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::ListCommitsRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::ListCommitsRequest,
                    >::from_parts(&req, &body);
                    svc.list_commits(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::ListCommitsResponse,
                        >(format)
                })
            }
            "RunProjectAction" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::RunProjectActionRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::RunProjectActionRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::RunProjectActionRequest,
                    >::from_parts(&req, &body);
                    svc.run_project_action(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::RunProjectActionResponse,
                        >(format)
                })
            }
            "SetProjectAlerts" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::SetProjectAlertsRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::SetProjectAlertsRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::SetProjectAlertsRequest,
                    >::from_parts(&req, &body);
                    svc.set_project_alerts(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::SetProjectAlertsResponse,
                        >(format)
                })
            }
            "GetIncident" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::GetIncidentRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::GetIncidentRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::GetIncidentRequest,
                    >::from_parts(&req, &body);
                    svc.get_incident(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::GetIncidentResponse,
                        >(format)
                })
            }
            "GetOperation" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::GetOperationRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::GetOperationRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::GetOperationRequest,
                    >::from_parts(&req, &body);
                    svc.get_operation(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::GetOperationResponse,
                        >(format)
                })
            }
            "QueryHttpTraffic" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::QueryHttpTrafficRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::QueryHttpTrafficRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::QueryHttpTrafficRequest,
                    >::from_parts(&req, &body);
                    svc.query_http_traffic(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::QueryHttpTrafficResponse,
                        >(format)
                })
            }
            "QueryContainerLogs" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::QueryContainerLogsRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::QueryContainerLogsRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::QueryContainerLogsRequest,
                    >::from_parts(&req, &body);
                    svc.query_container_logs(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::QueryContainerLogsResponse,
                        >(format)
                })
            }
            "LinkDatabase" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::LinkDatabaseRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::LinkDatabaseRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::LinkDatabaseRequest,
                    >::from_parts(&req, &body);
                    svc.link_database(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::LinkDatabaseResponse,
                        >(format)
                })
            }
            "CreateDatabase" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::CreateDatabaseRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::CreateDatabaseRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::CreateDatabaseRequest,
                    >::from_parts(&req, &body);
                    svc.create_database(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::CreateDatabaseResponse,
                        >(format)
                })
            }
            "RunServiceCommand" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::RunServiceCommandRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::RunServiceCommandRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::RunServiceCommandRequest,
                    >::from_parts(&req, &body);
                    svc.run_service_command(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::RunServiceCommandResponse,
                        >(format)
                })
            }
            "OpenTerminal" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::OpenTerminalRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::OpenTerminalRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::OpenTerminalRequest,
                    >::from_parts(&req, &body);
                    svc.open_terminal(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::OpenTerminalResponse,
                        >(format)
                })
            }
            "OpenDatabaseClient" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::OpenDatabaseClientRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::OpenDatabaseClientRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::OpenDatabaseClientRequest,
                    >::from_parts(&req, &body);
                    svc.open_database_client(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::OpenDatabaseClientResponse,
                        >(format)
                })
            }
            "ReadPath" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::ReadPathRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::ReadPathRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::ReadPathRequest,
                    >::from_parts(&req, &body);
                    svc.read_path(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::ReadPathResponse,
                        >(format)
                })
            }
            "CreateTransfer" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::CreateTransferRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::CreateTransferRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::CreateTransferRequest,
                    >::from_parts(&req, &body);
                    svc.create_transfer(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::CreateTransferResponse,
                        >(format)
                })
            }
            "GetUpload" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::GetUploadRequest,
                    >(request.encoded()?, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::GetUploadRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::GetUploadRequest,
                    >::from_parts(&req, &body);
                    svc.get_upload(ctx, req)
                        .await?
                        .encode::<
                            crate::proto::pethost::panel::v1::GetUploadResponse,
                        >(format)
                })
            }
            _ => ::connectrpc::dispatcher::codegen::unimplemented_unary(path),
        }
    }
    fn call_server_streaming(
        &self,
        path: &str,
        ctx: ::connectrpc::RequestContext,
        request: ::buffa::bytes::Bytes,
        format: ::connectrpc::CodecFormat,
    ) -> ::connectrpc::dispatcher::codegen::StreamingResult {
        let Some(method) = path.strip_prefix("pethost.panel.v1.PanelService/") else {
            return ::connectrpc::dispatcher::codegen::unimplemented_streaming(path);
        };
        let _ = (&ctx, &request, &format);
        match method {
            "WatchOperation" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::WatchOperationRequest,
                    >(request, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::WatchOperationRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::WatchOperationRequest,
                    >::from_parts(&req, &body);
                    let resp = svc.watch_operation(ctx, req).await?;
                    Ok(
                        resp
                            .map_body(|s| ::connectrpc::dispatcher::codegen::encode_response_stream::<
                                crate::proto::pethost::panel::v1::WatchOperationResponse,
                                _,
                                _,
                            >(s, format)),
                    )
                })
            }
            "TailContainerLogs" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::TailContainerLogsRequest,
                    >(request, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::TailContainerLogsRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::TailContainerLogsRequest,
                    >::from_parts(&req, &body);
                    let resp = svc.tail_container_logs(ctx, req).await?;
                    Ok(
                        resp
                            .map_body(|s| ::connectrpc::dispatcher::codegen::encode_response_stream::<
                                crate::proto::pethost::panel::v1::TailContainerLogsResponse,
                                _,
                                _,
                            >(s, format)),
                    )
                })
            }
            "TailHttpTraffic" => {
                let svc = ::std::sync::Arc::clone(&self.inner);
                Box::pin(async move {
                    let body = ::connectrpc::dispatcher::codegen::request_proto_bytes::<
                        crate::proto::pethost::panel::v1::TailHttpTrafficRequest,
                    >(request, format)?;
                    let req: crate::proto::pethost::panel::v1::__buffa::view::TailHttpTrafficRequestView<
                        '_,
                    > = ::connectrpc::dispatcher::codegen::decode_borrowed_request_view(
                        &body,
                        ctx.decode_options(),
                    )?;
                    let req = ::connectrpc::ServiceRequest::<
                        crate::proto::pethost::panel::v1::TailHttpTrafficRequest,
                    >::from_parts(&req, &body);
                    let resp = svc.tail_http_traffic(ctx, req).await?;
                    Ok(
                        resp
                            .map_body(|s| ::connectrpc::dispatcher::codegen::encode_response_stream::<
                                crate::proto::pethost::panel::v1::TailHttpTrafficResponse,
                                _,
                                _,
                            >(s, format)),
                    )
                })
            }
            _ => ::connectrpc::dispatcher::codegen::unimplemented_streaming(path),
        }
    }
    fn call_client_streaming(
        &self,
        path: &str,
        ctx: ::connectrpc::RequestContext,
        requests: ::connectrpc::dispatcher::codegen::RequestStream,
        format: ::connectrpc::CodecFormat,
    ) -> ::connectrpc::dispatcher::codegen::UnaryResult {
        let Some(method) = path.strip_prefix("pethost.panel.v1.PanelService/") else {
            return ::connectrpc::dispatcher::codegen::unimplemented_unary(path);
        };
        let _ = (&ctx, &requests, &format);
        match method {
            _ => ::connectrpc::dispatcher::codegen::unimplemented_unary(path),
        }
    }
    fn call_bidi_streaming(
        &self,
        path: &str,
        ctx: ::connectrpc::RequestContext,
        requests: ::connectrpc::dispatcher::codegen::RequestStream,
        format: ::connectrpc::CodecFormat,
    ) -> ::connectrpc::dispatcher::codegen::StreamingResult {
        let Some(method) = path.strip_prefix("pethost.panel.v1.PanelService/") else {
            return ::connectrpc::dispatcher::codegen::unimplemented_streaming(path);
        };
        let _ = (&ctx, &requests, &format);
        match method {
            _ => ::connectrpc::dispatcher::codegen::unimplemented_streaming(path),
        }
    }
}
/// Client for this service.
///
/// Generic over `T: ClientTransport`. For **gRPC** (HTTP/2), use
/// `Http2Connection` — it has honest `poll_ready` and composes with
/// `tower::balance` for multi-connection load balancing. For **Connect
/// over HTTP/1.1** (or unknown protocol), use `HttpClient`.
///
/// # Example (gRPC / HTTP/2)
///
/// ```rust,ignore
/// use connectrpc::client::{Http2Connection, ClientConfig};
/// use connectrpc::Protocol;
///
/// let uri: http::Uri = "http://localhost:8080".parse()?;
/// let conn = Http2Connection::connect_plaintext(uri.clone()).await?.shared(1024);
/// let config = ClientConfig::new(uri).with_protocol(Protocol::Grpc);
///
/// let client = PanelServiceClient::new(conn, config);
/// let response = client.get_machine(request).await?;
/// ```
///
/// # Example (Connect / HTTP/1.1 or ALPN)
///
/// ```rust,ignore
/// use connectrpc::client::{HttpClient, ClientConfig};
///
/// let http = HttpClient::plaintext();  // cleartext http:// only
/// let config = ClientConfig::new("http://localhost:8080".parse()?);
///
/// let client = PanelServiceClient::new(http, config);
/// let response = client.get_machine(request).await?;
/// ```
///
/// # Working with the response
///
/// Unary calls return [`UnaryResponse<OwnedView<FooView>>`](::connectrpc::client::UnaryResponse).
/// [`view()`](::connectrpc::client::UnaryResponse::view) borrows the response
/// message, so field access is zero-copy:
///
/// ```rust,ignore
/// let resp = client.get_machine(request).await?;
/// let name: &str = resp.view().name;  // borrow into the response buffer
/// ```
///
/// If you need the owned struct (e.g. to store or pass by value), use
/// [`into_owned()`](::connectrpc::client::UnaryResponse::into_owned):
///
/// ```rust,ignore
/// let owned = client.get_machine(request).await?.into_owned();
/// ```
///
/// [`into_view()`](::connectrpc::client::UnaryResponse::into_view) keeps the
/// zero-copy decoded body (an `OwnedView`) without copying; field access on it
/// goes through `.reborrow()`. Streaming responses yield one
/// [`StreamMessage`](::connectrpc::StreamMessage) per received message from
/// `.message().await` — read fields zero-copy through the generated accessor
/// methods (`msg.name()`) or `.view()`, or convert with `.to_owned_message()`.
#[derive(Clone)]
pub struct PanelServiceClient<T> {
    transport: T,
    config: ::connectrpc::client::ClientConfig,
}
impl<T> PanelServiceClient<T>
where
    T: ::connectrpc::client::ClientTransport,
    <T::ResponseBody as ::connectrpc::http_body::Body>::Error: ::std::fmt::Display,
{
    /// Create a new client with the given transport and configuration.
    pub fn new(transport: T, config: ::connectrpc::client::ClientConfig) -> Self {
        Self { transport, config }
    }
    /// Get the client configuration.
    pub fn config(&self) -> &::connectrpc::client::ClientConfig {
        &self.config
    }
    /// Get a mutable reference to the client configuration.
    pub fn config_mut(&mut self) -> &mut ::connectrpc::client::ClientConfig {
        &mut self.config
    }
    /// Call the GetMachine RPC. Sends a request to /pethost.panel.v1.PanelService/GetMachine.
    pub async fn get_machine(
        &self,
        request: crate::proto::pethost::panel::v1::GetMachineRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::GetMachineResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.get_machine_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the GetMachine RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn get_machine_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::GetMachineRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::GetMachineResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_GET_MACHINE_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the RunMachineAction RPC. Sends a request to /pethost.panel.v1.PanelService/RunMachineAction.
    pub async fn run_machine_action(
        &self,
        request: crate::proto::pethost::panel::v1::RunMachineActionRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::RunMachineActionResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.run_machine_action_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the RunMachineAction RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn run_machine_action_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::RunMachineActionRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::RunMachineActionResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_RUN_MACHINE_ACTION_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the GetProject RPC. Sends a request to /pethost.panel.v1.PanelService/GetProject.
    pub async fn get_project(
        &self,
        request: crate::proto::pethost::panel::v1::GetProjectRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::GetProjectResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.get_project_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the GetProject RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn get_project_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::GetProjectRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::GetProjectResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_GET_PROJECT_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the CreateProject RPC. Sends a request to /pethost.panel.v1.PanelService/CreateProject.
    pub async fn create_project(
        &self,
        request: crate::proto::pethost::panel::v1::CreateProjectRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::CreateProjectResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.create_project_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the CreateProject RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn create_project_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::CreateProjectRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::CreateProjectResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_CREATE_PROJECT_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the DeployProject RPC. Sends a request to /pethost.panel.v1.PanelService/DeployProject.
    pub async fn deploy_project(
        &self,
        request: crate::proto::pethost::panel::v1::DeployProjectRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::DeployProjectResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.deploy_project_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the DeployProject RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn deploy_project_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::DeployProjectRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::DeployProjectResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_DEPLOY_PROJECT_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the ListCommits RPC. Sends a request to /pethost.panel.v1.PanelService/ListCommits.
    pub async fn list_commits(
        &self,
        request: crate::proto::pethost::panel::v1::ListCommitsRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::ListCommitsResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.list_commits_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the ListCommits RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn list_commits_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::ListCommitsRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::ListCommitsResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_LIST_COMMITS_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the RunProjectAction RPC. Sends a request to /pethost.panel.v1.PanelService/RunProjectAction.
    pub async fn run_project_action(
        &self,
        request: crate::proto::pethost::panel::v1::RunProjectActionRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::RunProjectActionResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.run_project_action_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the RunProjectAction RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn run_project_action_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::RunProjectActionRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::RunProjectActionResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_RUN_PROJECT_ACTION_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the SetProjectAlerts RPC. Sends a request to /pethost.panel.v1.PanelService/SetProjectAlerts.
    pub async fn set_project_alerts(
        &self,
        request: crate::proto::pethost::panel::v1::SetProjectAlertsRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::SetProjectAlertsResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.set_project_alerts_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the SetProjectAlerts RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn set_project_alerts_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::SetProjectAlertsRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::SetProjectAlertsResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_SET_PROJECT_ALERTS_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the GetIncident RPC. Sends a request to /pethost.panel.v1.PanelService/GetIncident.
    pub async fn get_incident(
        &self,
        request: crate::proto::pethost::panel::v1::GetIncidentRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::GetIncidentResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.get_incident_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the GetIncident RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn get_incident_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::GetIncidentRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::GetIncidentResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_GET_INCIDENT_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the GetOperation RPC. Sends a request to /pethost.panel.v1.PanelService/GetOperation.
    pub async fn get_operation(
        &self,
        request: crate::proto::pethost::panel::v1::GetOperationRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::GetOperationResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.get_operation_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the GetOperation RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn get_operation_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::GetOperationRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::GetOperationResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_GET_OPERATION_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the QueryHttpTraffic RPC. Sends a request to /pethost.panel.v1.PanelService/QueryHttpTraffic.
    pub async fn query_http_traffic(
        &self,
        request: crate::proto::pethost::panel::v1::QueryHttpTrafficRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::QueryHttpTrafficResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.query_http_traffic_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the QueryHttpTraffic RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn query_http_traffic_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::QueryHttpTrafficRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::QueryHttpTrafficResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_QUERY_HTTP_TRAFFIC_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the QueryContainerLogs RPC. Sends a request to /pethost.panel.v1.PanelService/QueryContainerLogs.
    pub async fn query_container_logs(
        &self,
        request: crate::proto::pethost::panel::v1::QueryContainerLogsRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::QueryContainerLogsResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.query_container_logs_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the QueryContainerLogs RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn query_container_logs_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::QueryContainerLogsRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::QueryContainerLogsResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_QUERY_CONTAINER_LOGS_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the LinkDatabase RPC. Sends a request to /pethost.panel.v1.PanelService/LinkDatabase.
    pub async fn link_database(
        &self,
        request: crate::proto::pethost::panel::v1::LinkDatabaseRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::LinkDatabaseResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.link_database_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the LinkDatabase RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn link_database_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::LinkDatabaseRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::LinkDatabaseResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_LINK_DATABASE_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the CreateDatabase RPC. Sends a request to /pethost.panel.v1.PanelService/CreateDatabase.
    pub async fn create_database(
        &self,
        request: crate::proto::pethost::panel::v1::CreateDatabaseRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::CreateDatabaseResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.create_database_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the CreateDatabase RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn create_database_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::CreateDatabaseRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::CreateDatabaseResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_CREATE_DATABASE_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the RunServiceCommand RPC. Sends a request to /pethost.panel.v1.PanelService/RunServiceCommand.
    pub async fn run_service_command(
        &self,
        request: crate::proto::pethost::panel::v1::RunServiceCommandRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::RunServiceCommandResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.run_service_command_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the RunServiceCommand RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn run_service_command_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::RunServiceCommandRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::RunServiceCommandResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_RUN_SERVICE_COMMAND_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the OpenTerminal RPC. Sends a request to /pethost.panel.v1.PanelService/OpenTerminal.
    pub async fn open_terminal(
        &self,
        request: crate::proto::pethost::panel::v1::OpenTerminalRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::OpenTerminalResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.open_terminal_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the OpenTerminal RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn open_terminal_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::OpenTerminalRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::OpenTerminalResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_OPEN_TERMINAL_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the OpenDatabaseClient RPC. Sends a request to /pethost.panel.v1.PanelService/OpenDatabaseClient.
    pub async fn open_database_client(
        &self,
        request: crate::proto::pethost::panel::v1::OpenDatabaseClientRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::OpenDatabaseClientResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.open_database_client_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the OpenDatabaseClient RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn open_database_client_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::OpenDatabaseClientRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::OpenDatabaseClientResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_OPEN_DATABASE_CLIENT_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the ReadPath RPC. Sends a request to /pethost.panel.v1.PanelService/ReadPath.
    pub async fn read_path(
        &self,
        request: crate::proto::pethost::panel::v1::ReadPathRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::ReadPathResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.read_path_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the ReadPath RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn read_path_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::ReadPathRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::ReadPathResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_READ_PATH_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the CreateTransfer RPC. Sends a request to /pethost.panel.v1.PanelService/CreateTransfer.
    pub async fn create_transfer(
        &self,
        request: crate::proto::pethost::panel::v1::CreateTransferRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::CreateTransferResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.create_transfer_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the CreateTransfer RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn create_transfer_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::CreateTransferRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::CreateTransferResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_CREATE_TRANSFER_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the GetUpload RPC. Sends a request to /pethost.panel.v1.PanelService/GetUpload.
    pub async fn get_upload(
        &self,
        request: crate::proto::pethost::panel::v1::GetUploadRequest,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::GetUploadResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.get_upload_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the GetUpload RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn get_upload_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::GetUploadRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::UnaryResponse<
            ::buffa::view::OwnedView<
                crate::proto::pethost::panel::v1::__buffa::view::GetUploadResponseView<
                    'static,
                >,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_unary(
                &self.transport,
                &self.config,
                PANEL_SERVICE_GET_UPLOAD_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the WatchOperation RPC. Sends a request to /pethost.panel.v1.PanelService/WatchOperation.
    pub async fn watch_operation(
        &self,
        request: crate::proto::pethost::panel::v1::WatchOperationRequest,
    ) -> Result<
        ::connectrpc::client::ServerStream<
            T::ResponseBody,
            crate::proto::pethost::panel::v1::__buffa::view::WatchOperationResponseView<
                'static,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.watch_operation_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the WatchOperation RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn watch_operation_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::WatchOperationRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::ServerStream<
            T::ResponseBody,
            crate::proto::pethost::panel::v1::__buffa::view::WatchOperationResponseView<
                'static,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_server_stream(
                &self.transport,
                &self.config,
                PANEL_SERVICE_WATCH_OPERATION_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the TailContainerLogs RPC. Sends a request to /pethost.panel.v1.PanelService/TailContainerLogs.
    pub async fn tail_container_logs(
        &self,
        request: crate::proto::pethost::panel::v1::TailContainerLogsRequest,
    ) -> Result<
        ::connectrpc::client::ServerStream<
            T::ResponseBody,
            crate::proto::pethost::panel::v1::__buffa::view::TailContainerLogsResponseView<
                'static,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.tail_container_logs_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the TailContainerLogs RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn tail_container_logs_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::TailContainerLogsRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::ServerStream<
            T::ResponseBody,
            crate::proto::pethost::panel::v1::__buffa::view::TailContainerLogsResponseView<
                'static,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_server_stream(
                &self.transport,
                &self.config,
                PANEL_SERVICE_TAIL_CONTAINER_LOGS_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
    /// Call the TailHttpTraffic RPC. Sends a request to /pethost.panel.v1.PanelService/TailHttpTraffic.
    pub async fn tail_http_traffic(
        &self,
        request: crate::proto::pethost::panel::v1::TailHttpTrafficRequest,
    ) -> Result<
        ::connectrpc::client::ServerStream<
            T::ResponseBody,
            crate::proto::pethost::panel::v1::__buffa::view::TailHttpTrafficResponseView<
                'static,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        self.tail_http_traffic_with_options(
                request,
                ::connectrpc::client::CallOptions::default(),
            )
            .await
    }
    /// Call the TailHttpTraffic RPC with explicit per-call options. Options override [`ClientConfig`](::connectrpc::client::ClientConfig) defaults.
    pub async fn tail_http_traffic_with_options(
        &self,
        request: crate::proto::pethost::panel::v1::TailHttpTrafficRequest,
        options: ::connectrpc::client::CallOptions,
    ) -> Result<
        ::connectrpc::client::ServerStream<
            T::ResponseBody,
            crate::proto::pethost::panel::v1::__buffa::view::TailHttpTrafficResponseView<
                'static,
            >,
        >,
        ::connectrpc::ConnectError,
    > {
        ::connectrpc::client::call_server_stream(
                &self.transport,
                &self.config,
                PANEL_SERVICE_TAIL_HTTP_TRAFFIC_SPEC
                    .with_origin(::connectrpc::SpecOrigin::Client),
                request,
                options,
            )
            .await
    }
}