Mountain/Vine/Generated/

vine.rs

// This file is @generated by prost-build.
/// Represents an empty message, typically used for RPCs that don't need to return data.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Empty {}
/// A generic request message containing a method name and serialized parameters.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GenericRequest {
    #[prost(uint64, tag = "1")]
    pub request_identifier: u64,
    #[prost(string, tag = "2")]
    pub method: ::prost::alloc::string::String,
    /// Parameters are expected to be a JSON-serialized byte array.
    #[prost(bytes = "vec", tag = "3")]
    pub parameter: ::prost::alloc::vec::Vec<u8>,
}
/// A generic response message containing the result or an error.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GenericResponse {
    #[prost(uint64, tag = "1")]
    pub request_identifier: u64,
    /// The successful result, JSON-serialized.
    #[prost(bytes = "vec", tag = "2")]
    pub result: ::prost::alloc::vec::Vec<u8>,
    #[prost(message, optional, tag = "3")]
    pub error: ::core::option::Option<RpcError>,
}
/// A generic notification message, which is fire-and-forget and does not have an ID.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GenericNotification {
    #[prost(string, tag = "1")]
    pub method: ::prost::alloc::string::String,
    /// Parameters are expected to be a JSON-serialized byte array.
    #[prost(bytes = "vec", tag = "2")]
    pub parameter: ::prost::alloc::vec::Vec<u8>,
}
/// A structured error payload, compliant with JSON-RPC error objects.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RpcError {
    #[prost(int32, tag = "1")]
    pub code: i32,
    #[prost(string, tag = "2")]
    pub message: ::prost::alloc::string::String,
    /// Optional, additional error data, JSON-serialized.
    #[prost(bytes = "vec", tag = "3")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
/// A message to cancel a specific, ongoing operation.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CancelOperationRequest {
    #[prost(uint64, tag = "1")]
    pub request_identifier_to_cancel: u64,
}
/// A generic data payload, currently unused but available for future extensions.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RpcDataPayload {
    #[prost(bytes = "vec", tag = "1")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
/// A position in a text document, expressed as zero-based line and character offset.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Position {
    #[prost(uint32, tag = "1")]
    pub line: u32,
    #[prost(uint32, tag = "2")]
    pub character: u32,
}
/// A range in a text document, expressed as start and end positions.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Range {
    #[prost(message, optional, tag = "1")]
    pub start: ::core::option::Option<Position>,
    #[prost(message, optional, tag = "2")]
    pub end: ::core::option::Option<Position>,
}
/// A Uniform Resource Identifier (URI).
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Uri {
    #[prost(string, tag = "1")]
    pub value: ::prost::alloc::string::String,
}
/// A command argument, which can be one of several types.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Argument {
    #[prost(oneof = "argument::Value", tags = "1, 2, 3, 4")]
    pub value: ::core::option::Option<argument::Value>,
}
/// Nested message and enum types in `Argument`.
pub mod argument {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Value {
        #[prost(string, tag = "1")]
        StringValue(::prost::alloc::string::String),
        #[prost(int32, tag = "2")]
        IntValue(i32),
        #[prost(bool, tag = "3")]
        BoolValue(bool),
        #[prost(bytes, tag = "4")]
        BytesValue(::prost::alloc::vec::Vec<u8>),
    }
}
/// A workspace folder.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WorkspaceFolder {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
}
/// Request to initialize the extension host.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct InitExtensionHostRequest {
    #[prost(message, repeated, tag = "1")]
    pub workspace_folders: ::prost::alloc::vec::Vec<WorkspaceFolder>,
    #[prost(map = "string, string", tag = "2")]
    pub configuration: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
    #[prost(string, tag = "3")]
    pub workspace_id: ::prost::alloc::string::String,
}
/// Request to register a command.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RegisterCommandRequest {
    #[prost(string, tag = "1")]
    pub command_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub extension_id: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub title: ::prost::alloc::string::String,
}
/// Request to execute a command.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ExecuteCommandRequest {
    #[prost(string, tag = "1")]
    pub command_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "2")]
    pub arguments: ::prost::alloc::vec::Vec<Argument>,
}
/// Response from command execution.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ExecuteCommandResponse {
    #[prost(oneof = "execute_command_response::Result", tags = "1, 2")]
    pub result: ::core::option::Option<execute_command_response::Result>,
}
/// Nested message and enum types in `ExecuteCommandResponse`.
pub mod execute_command_response {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Result {
        #[prost(bytes, tag = "1")]
        Value(::prost::alloc::vec::Vec<u8>),
        #[prost(message, tag = "2")]
        Error(super::RpcError),
    }
}
/// Request to unregister a command.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UnregisterCommandRequest {
    #[prost(string, tag = "1")]
    pub command_id: ::prost::alloc::string::String,
}
/// Request to register a provider.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RegisterProviderRequest {
    #[prost(string, tag = "1")]
    pub language_selector: ::prost::alloc::string::String,
    #[prost(uint32, tag = "2")]
    pub handle: u32,
    #[prost(string, tag = "3")]
    pub extension_id: ::prost::alloc::string::String,
}
/// Request for hover information.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProvideHoverRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(message, optional, tag = "2")]
    pub position: ::core::option::Option<Position>,
    #[prost(uint32, tag = "3")]
    pub provider_handle: u32,
}
/// Response with hover information.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProvideHoverResponse {
    #[prost(string, tag = "1")]
    pub markdown: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub range: ::core::option::Option<Range>,
}
/// Request for completion items.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProvideCompletionItemsRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(message, optional, tag = "2")]
    pub position: ::core::option::Option<Position>,
    #[prost(uint32, tag = "3")]
    pub provider_handle: u32,
    #[prost(string, tag = "4")]
    pub trigger_character: ::prost::alloc::string::String,
}
/// Response with completion items.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProvideCompletionItemsResponse {
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<CompletionItem>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CompletionItem {
    #[prost(string, tag = "1")]
    pub label: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub kind: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub detail: ::prost::alloc::string::String,
    #[prost(bytes = "vec", tag = "4")]
    pub documentation: ::prost::alloc::vec::Vec<u8>,
    #[prost(string, tag = "5")]
    pub insert_text: ::prost::alloc::string::String,
}
/// Request for definition location.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProvideDefinitionRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(message, optional, tag = "2")]
    pub position: ::core::option::Option<Position>,
    #[prost(uint32, tag = "3")]
    pub provider_handle: u32,
}
/// Response with definition location.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProvideDefinitionResponse {
    #[prost(message, repeated, tag = "1")]
    pub locations: ::prost::alloc::vec::Vec<Location>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct Location {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(message, optional, tag = "2")]
    pub range: ::core::option::Option<Range>,
}
/// Request for references.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProvideReferencesRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(message, optional, tag = "2")]
    pub position: ::core::option::Option<Position>,
    #[prost(uint32, tag = "3")]
    pub provider_handle: u32,
}
/// Response with references.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProvideReferencesResponse {
    #[prost(message, repeated, tag = "1")]
    pub locations: ::prost::alloc::vec::Vec<Location>,
}
/// Request for code actions.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ProvideCodeActionsRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(message, optional, tag = "2")]
    pub range: ::core::option::Option<Range>,
    #[prost(uint32, tag = "3")]
    pub provider_handle: u32,
}
/// Response with code actions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ProvideCodeActionsResponse {
    #[prost(message, repeated, tag = "1")]
    pub actions: ::prost::alloc::vec::Vec<CodeAction>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CodeAction {
    #[prost(string, tag = "1")]
    pub title: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub kind: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub is_preferred: bool,
}
/// Request to show a text document.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ShowTextDocumentRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(enumeration = "ViewColumn", tag = "2")]
    pub view_column: i32,
    #[prost(bool, tag = "3")]
    pub preserve_focus: bool,
}
/// Response for showing a text document.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ShowTextDocumentResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
/// Request to show a message.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ShowMessageRequest {
    #[prost(string, tag = "1")]
    pub message: ::prost::alloc::string::String,
}
/// Response for showing a message.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ShowMessageResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
/// Request to create a status bar item.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateStatusBarItemRequest {
    #[prost(string, tag = "1")]
    pub id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub text: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub tooltip: ::prost::alloc::string::String,
}
/// Response for creating a status bar item.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateStatusBarItemResponse {
    #[prost(string, tag = "1")]
    pub item_id: ::prost::alloc::string::String,
}
/// Request to set status bar text.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SetStatusBarTextRequest {
    #[prost(string, tag = "1")]
    pub item_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub text: ::prost::alloc::string::String,
}
/// Request to create a webview panel.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateWebviewPanelRequest {
    #[prost(string, tag = "1")]
    pub view_type: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub title: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub icon_path: ::prost::alloc::string::String,
    #[prost(enumeration = "ViewColumn", tag = "4")]
    pub view_column: i32,
    #[prost(bool, tag = "5")]
    pub preserve_focus: bool,
    #[prost(bool, tag = "6")]
    pub enable_find_widget: bool,
    #[prost(bool, tag = "7")]
    pub retain_context_when_hidden: bool,
    #[prost(string, repeated, tag = "8")]
    pub local_resource_roots: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Response for creating a webview panel.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CreateWebviewPanelResponse {
    #[prost(uint32, tag = "1")]
    pub handle: u32,
}
/// Request to set webview HTML.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SetWebviewHtmlRequest {
    #[prost(uint32, tag = "1")]
    pub handle: u32,
    #[prost(string, tag = "2")]
    pub html: ::prost::alloc::string::String,
}
/// Request for webview message.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OnDidReceiveMessageRequest {
    #[prost(uint32, tag = "1")]
    pub handle: u32,
    #[prost(oneof = "on_did_receive_message_request::Message", tags = "2, 3")]
    pub message: ::core::option::Option<on_did_receive_message_request::Message>,
}
/// Nested message and enum types in `OnDidReceiveMessageRequest`.
pub mod on_did_receive_message_request {
    #[derive(Clone, PartialEq, Eq, Hash, ::prost::Oneof)]
    pub enum Message {
        #[prost(string, tag = "2")]
        StringMessage(::prost::alloc::string::String),
        #[prost(bytes, tag = "3")]
        BytesMessage(::prost::alloc::vec::Vec<u8>),
    }
}
/// Request to read a file.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ReadFileRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
}
/// Response with file contents.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ReadFileResponse {
    #[prost(bytes = "vec", tag = "1")]
    pub content: ::prost::alloc::vec::Vec<u8>,
    #[prost(string, tag = "2")]
    pub encoding: ::prost::alloc::string::String,
}
/// Request to write a file.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WriteFileRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(bytes = "vec", tag = "2")]
    pub content: ::prost::alloc::vec::Vec<u8>,
    #[prost(string, tag = "3")]
    pub encoding: ::prost::alloc::string::String,
}
/// Request for file metadata.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StatRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
}
/// Response with file metadata.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StatResponse {
    #[prost(bool, tag = "1")]
    pub is_file: bool,
    #[prost(bool, tag = "2")]
    pub is_directory: bool,
    #[prost(uint64, tag = "3")]
    pub size: u64,
    #[prost(uint64, tag = "4")]
    pub mtime: u64,
}
/// Request to read directory contents.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ReaddirRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
}
/// Response with directory contents.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ReaddirResponse {
    #[prost(string, repeated, tag = "1")]
    pub entries: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request to watch a file.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct WatchFileRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
}
/// Request to find files.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FindFilesRequest {
    #[prost(string, tag = "1")]
    pub pattern: ::prost::alloc::string::String,
    #[prost(bool, tag = "2")]
    pub include: bool,
}
/// Response with found files.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FindFilesResponse {
    #[prost(string, repeated, tag = "1")]
    pub uris: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request to find text in files.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct FindTextInFilesRequest {
    #[prost(string, tag = "1")]
    pub pattern: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "2")]
    pub include: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, repeated, tag = "3")]
    pub exclude: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Response with text matches.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct FindTextInFilesResponse {
    #[prost(message, repeated, tag = "1")]
    pub matches: ::prost::alloc::vec::Vec<TextMatch>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TextMatch {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(message, optional, tag = "2")]
    pub range: ::core::option::Option<Range>,
    #[prost(string, tag = "3")]
    pub preview: ::prost::alloc::string::String,
}
/// Request to open a document.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OpenDocumentRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(enumeration = "ViewColumn", tag = "2")]
    pub view_column: i32,
}
/// Response for opening a document.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OpenDocumentResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
/// Request to save all documents.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SaveAllRequest {
    #[prost(bool, tag = "1")]
    pub include_untitled: bool,
}
/// Response for saving all documents.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SaveAllResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
/// Request to apply an edit.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ApplyEditRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(message, repeated, tag = "2")]
    pub edits: ::prost::alloc::vec::Vec<TextEdit>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TextEdit {
    #[prost(message, optional, tag = "1")]
    pub range: ::core::option::Option<Range>,
    #[prost(string, tag = "2")]
    pub new_text: ::prost::alloc::string::String,
}
/// Response for applying an edit.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ApplyEditResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
/// Request to update configuration.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct UpdateConfigurationRequest {
    #[prost(string, repeated, tag = "1")]
    pub changed_keys: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Request to update workspace folders.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateWorkspaceFoldersRequest {
    #[prost(message, repeated, tag = "1")]
    pub additions: ::prost::alloc::vec::Vec<WorkspaceFolder>,
    #[prost(message, repeated, tag = "2")]
    pub removals: ::prost::alloc::vec::Vec<WorkspaceFolder>,
}
/// Request to open a terminal.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct OpenTerminalRequest {
    #[prost(string, tag = "1")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub shell_path: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "3")]
    pub shell_args: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(string, tag = "4")]
    pub cwd: ::prost::alloc::string::String,
}
/// Request for terminal input.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TerminalInputRequest {
    #[prost(uint32, tag = "1")]
    pub terminal_id: u32,
    #[prost(bytes = "vec", tag = "2")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
/// Request to close a terminal.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct CloseTerminalRequest {
    #[prost(uint32, tag = "1")]
    pub terminal_id: u32,
}
/// Notification that a terminal was opened.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TerminalOpenedNotification {
    #[prost(uint32, tag = "1")]
    pub terminal_id: u32,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
}
/// Notification that a terminal was closed.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TerminalClosedNotification {
    #[prost(uint32, tag = "1")]
    pub terminal_id: u32,
}
/// Notification of terminal process ID.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TerminalProcessIdNotification {
    #[prost(uint32, tag = "1")]
    pub terminal_id: u32,
    #[prost(uint32, tag = "2")]
    pub process_id: u32,
}
/// Notification of terminal output.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TerminalDataNotification {
    #[prost(uint32, tag = "1")]
    pub terminal_id: u32,
    #[prost(bytes = "vec", tag = "2")]
    pub data: ::prost::alloc::vec::Vec<u8>,
}
/// Request to register a tree view provider.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RegisterTreeViewProviderRequest {
    #[prost(string, tag = "1")]
    pub view_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub extension_id: ::prost::alloc::string::String,
}
/// Request for tree children.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetTreeChildrenRequest {
    #[prost(string, tag = "1")]
    pub view_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub tree_item_handle: ::prost::alloc::string::String,
}
/// Response with tree children.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GetTreeChildrenResponse {
    #[prost(message, repeated, tag = "1")]
    pub items: ::prost::alloc::vec::Vec<TreeItem>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct TreeItem {
    #[prost(string, tag = "1")]
    pub handle: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub label: ::prost::alloc::string::String,
    #[prost(bool, tag = "3")]
    pub is_collapsed: bool,
    #[prost(string, tag = "4")]
    pub icon: ::prost::alloc::string::String,
}
/// Request to register an SCM provider.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RegisterScmProviderRequest {
    #[prost(string, tag = "1")]
    pub scm_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub extension_id: ::prost::alloc::string::String,
}
/// Request to update SCM group.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct UpdateScmGroupRequest {
    #[prost(string, tag = "1")]
    pub provider_id: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub group_id: ::prost::alloc::string::String,
    #[prost(message, repeated, tag = "3")]
    pub resource_states: ::prost::alloc::vec::Vec<SourceControlResourceState>,
}
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct SourceControlResourceState {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(string, tag = "2")]
    pub state: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub decorations: ::prost::alloc::string::String,
}
/// Request to execute a git command.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GitExecRequest {
    #[prost(string, tag = "1")]
    pub repository_path: ::prost::alloc::string::String,
    #[prost(string, repeated, tag = "2")]
    pub args: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// Response from git execution.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GitExecResponse {
    #[prost(string, repeated, tag = "1")]
    pub output: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
    #[prost(int32, tag = "2")]
    pub exit_code: i32,
}
/// Request to register a debug adapter.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct RegisterDebugAdapterRequest {
    #[prost(string, tag = "1")]
    pub debug_type: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub extension_id: ::prost::alloc::string::String,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct DebugConfiguration {
    #[prost(string, tag = "1")]
    pub r#type: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub name: ::prost::alloc::string::String,
    #[prost(string, tag = "3")]
    pub request: ::prost::alloc::string::String,
    #[prost(map = "string, string", tag = "4")]
    pub options: ::std::collections::HashMap<
        ::prost::alloc::string::String,
        ::prost::alloc::string::String,
    >,
}
/// Request to start debugging.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct StartDebuggingRequest {
    #[prost(string, tag = "1")]
    pub debug_type: ::prost::alloc::string::String,
    #[prost(message, optional, tag = "2")]
    pub configuration: ::core::option::Option<DebugConfiguration>,
}
/// Response for starting debugging.
#[derive(Clone, Copy, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StartDebuggingResponse {
    #[prost(bool, tag = "1")]
    pub success: bool,
}
/// Request to participate in save.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct ParticipateInSaveRequest {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(enumeration = "TextDocumentSaveReason", tag = "2")]
    pub reason: i32,
}
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TextEditForSave {
    #[prost(message, optional, tag = "1")]
    pub uri: ::core::option::Option<Uri>,
    #[prost(message, repeated, tag = "2")]
    pub edits: ::prost::alloc::vec::Vec<TextEdit>,
}
/// Response for participating in save.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ParticipateInSaveResponse {
    #[prost(message, repeated, tag = "1")]
    pub edits: ::prost::alloc::vec::Vec<TextEditForSave>,
}
/// Request to get a secret.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSecretRequest {
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
}
/// Response with secret value.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct GetSecretResponse {
    #[prost(string, tag = "1")]
    pub value: ::prost::alloc::string::String,
}
/// Request to store a secret.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct StoreSecretRequest {
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
    #[prost(string, tag = "2")]
    pub value: ::prost::alloc::string::String,
}
/// Request to delete a secret.
#[derive(Clone, PartialEq, Eq, Hash, ::prost::Message)]
pub struct DeleteSecretRequest {
    #[prost(string, tag = "1")]
    pub key: ::prost::alloc::string::String,
}
/// A view column (editor location).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ViewColumn {
    Undefined = 0,
    Active = 1,
    One = 2,
    Two = 3,
    Three = 4,
    Four = 5,
    Five = 6,
    Six = 7,
    Seven = 8,
    Eight = 9,
    Nine = 10,
}
impl ViewColumn {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::Undefined => "VIEW_COLUMN_UNDEFINED",
            Self::Active => "VIEW_COLUMN_ACTIVE",
            Self::One => "VIEW_COLUMN_ONE",
            Self::Two => "VIEW_COLUMN_TWO",
            Self::Three => "VIEW_COLUMN_THREE",
            Self::Four => "VIEW_COLUMN_FOUR",
            Self::Five => "VIEW_COLUMN_FIVE",
            Self::Six => "VIEW_COLUMN_SIX",
            Self::Seven => "VIEW_COLUMN_SEVEN",
            Self::Eight => "VIEW_COLUMN_EIGHT",
            Self::Nine => "VIEW_COLUMN_NINE",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "VIEW_COLUMN_UNDEFINED" => Some(Self::Undefined),
            "VIEW_COLUMN_ACTIVE" => Some(Self::Active),
            "VIEW_COLUMN_ONE" => Some(Self::One),
            "VIEW_COLUMN_TWO" => Some(Self::Two),
            "VIEW_COLUMN_THREE" => Some(Self::Three),
            "VIEW_COLUMN_FOUR" => Some(Self::Four),
            "VIEW_COLUMN_FIVE" => Some(Self::Five),
            "VIEW_COLUMN_SIX" => Some(Self::Six),
            "VIEW_COLUMN_SEVEN" => Some(Self::Seven),
            "VIEW_COLUMN_EIGHT" => Some(Self::Eight),
            "VIEW_COLUMN_NINE" => Some(Self::Nine),
            _ => None,
        }
    }
}
/// Text document save reason.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum TextDocumentSaveReason {
    SaveReasonManual = 0,
    SaveReasonAfterDelay = 1,
    SaveReasonFocusOut = 2,
}
impl TextDocumentSaveReason {
    /// String value of the enum field names used in the ProtoBuf definition.
    ///
    /// The values are not transformed in any way and thus are considered stable
    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
    pub fn as_str_name(&self) -> &'static str {
        match self {
            Self::SaveReasonManual => "SAVE_REASON_MANUAL",
            Self::SaveReasonAfterDelay => "SAVE_REASON_AFTER_DELAY",
            Self::SaveReasonFocusOut => "SAVE_REASON_FOCUS_OUT",
        }
    }
    /// Creates an enum from field names used in the ProtoBuf definition.
    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
        match value {
            "SAVE_REASON_MANUAL" => Some(Self::SaveReasonManual),
            "SAVE_REASON_AFTER_DELAY" => Some(Self::SaveReasonAfterDelay),
            "SAVE_REASON_FOCUS_OUT" => Some(Self::SaveReasonFocusOut),
            _ => None,
        }
    }
}
/// Generated client implementations.
pub mod mountain_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service running on the Mountain host, listening for requests from Cocoon.
    #[derive(Debug, Clone)]
    pub struct MountainServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl MountainServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> MountainServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> MountainServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            MountainServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// A generic request-response method for Cocoon to call a function on Mountain.
        pub async fn process_cocoon_request(
            &mut self,
            request: impl tonic::IntoRequest<super::GenericRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenericResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.MountainService/ProcessCocoonRequest",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.MountainService", "ProcessCocoonRequest"));
            self.inner.unary(req, path, codec).await
        }
        /// A generic fire-and-forget method for Cocoon to send a notification to Mountain.
        pub async fn send_cocoon_notification(
            &mut self,
            request: impl tonic::IntoRequest<super::GenericNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.MountainService/SendCocoonNotification",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.MountainService", "SendCocoonNotification"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// A method for Cocoon to request that Mountain cancel a long-running operation.
        pub async fn cancel_operation(
            &mut self,
            request: impl tonic::IntoRequest<super::CancelOperationRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.MountainService/CancelOperation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.MountainService", "CancelOperation"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod mountain_service_server {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    /// Generated trait containing gRPC methods that should be implemented for use with MountainServiceServer.
    #[async_trait]
    pub trait MountainService: std::marker::Send + std::marker::Sync + 'static {
        /// A generic request-response method for Cocoon to call a function on Mountain.
        async fn process_cocoon_request(
            &self,
            request: tonic::Request<super::GenericRequest>,
        ) -> std::result::Result<tonic::Response<super::GenericResponse>, tonic::Status>;
        /// A generic fire-and-forget method for Cocoon to send a notification to Mountain.
        async fn send_cocoon_notification(
            &self,
            request: tonic::Request<super::GenericNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// A method for Cocoon to request that Mountain cancel a long-running operation.
        async fn cancel_operation(
            &self,
            request: tonic::Request<super::CancelOperationRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
    }
    /// Service running on the Mountain host, listening for requests from Cocoon.
    #[derive(Debug)]
    pub struct MountainServiceServer<T> {
        inner: Arc<T>,
        accept_compression_encodings: EnabledCompressionEncodings,
        send_compression_encodings: EnabledCompressionEncodings,
        max_decoding_message_size: Option<usize>,
        max_encoding_message_size: Option<usize>,
    }
    impl<T> MountainServiceServer<T> {
        pub fn new(inner: T) -> Self {
            Self::from_arc(Arc::new(inner))
        }
        pub fn from_arc(inner: Arc<T>) -> Self {
            Self {
                inner,
                accept_compression_encodings: Default::default(),
                send_compression_encodings: Default::default(),
                max_decoding_message_size: None,
                max_encoding_message_size: None,
            }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> InterceptedService<Self, F>
        where
            F: tonic::service::Interceptor,
        {
            InterceptedService::new(Self::new(inner), interceptor)
        }
        /// Enable decompressing requests with the given encoding.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.accept_compression_encodings.enable(encoding);
            self
        }
        /// Compress responses with the given encoding, if the client supports it.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.send_compression_encodings.enable(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.max_decoding_message_size = Some(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.max_encoding_message_size = Some(limit);
            self
        }
    }
    impl<T, B> tonic::codegen::Service<http::Request<B>> for MountainServiceServer<T>
    where
        T: MountainService,
        B: Body + std::marker::Send + 'static,
        B::Error: Into<StdError> + std::marker::Send + 'static,
    {
        type Response = http::Response<tonic::body::Body>;
        type Error = std::convert::Infallible;
        type Future = BoxFuture<Self::Response, Self::Error>;
        fn poll_ready(
            &mut self,
            _cx: &mut Context<'_>,
        ) -> Poll<std::result::Result<(), Self::Error>> {
            Poll::Ready(Ok(()))
        }
        fn call(&mut self, req: http::Request<B>) -> Self::Future {
            match req.uri().path() {
                "/Vine.MountainService/ProcessCocoonRequest" => {
                    #[allow(non_camel_case_types)]
                    struct ProcessCocoonRequestSvc<T: MountainService>(pub Arc<T>);
                    impl<
                        T: MountainService,
                    > tonic::server::UnaryService<super::GenericRequest>
                    for ProcessCocoonRequestSvc<T> {
                        type Response = super::GenericResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GenericRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MountainService>::process_cocoon_request(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ProcessCocoonRequestSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.MountainService/SendCocoonNotification" => {
                    #[allow(non_camel_case_types)]
                    struct SendCocoonNotificationSvc<T: MountainService>(pub Arc<T>);
                    impl<
                        T: MountainService,
                    > tonic::server::UnaryService<super::GenericNotification>
                    for SendCocoonNotificationSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GenericNotification>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MountainService>::send_cocoon_notification(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SendCocoonNotificationSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.MountainService/CancelOperation" => {
                    #[allow(non_camel_case_types)]
                    struct CancelOperationSvc<T: MountainService>(pub Arc<T>);
                    impl<
                        T: MountainService,
                    > tonic::server::UnaryService<super::CancelOperationRequest>
                    for CancelOperationSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CancelOperationRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as MountainService>::cancel_operation(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CancelOperationSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                _ => {
                    Box::pin(async move {
                        let mut response = http::Response::new(
                            tonic::body::Body::default(),
                        );
                        let headers = response.headers_mut();
                        headers
                            .insert(
                                tonic::Status::GRPC_STATUS,
                                (tonic::Code::Unimplemented as i32).into(),
                            );
                        headers
                            .insert(
                                http::header::CONTENT_TYPE,
                                tonic::metadata::GRPC_CONTENT_TYPE,
                            );
                        Ok(response)
                    })
                }
            }
        }
    }
    impl<T> Clone for MountainServiceServer<T> {
        fn clone(&self) -> Self {
            let inner = self.inner.clone();
            Self {
                inner,
                accept_compression_encodings: self.accept_compression_encodings,
                send_compression_encodings: self.send_compression_encodings,
                max_decoding_message_size: self.max_decoding_message_size,
                max_encoding_message_size: self.max_encoding_message_size,
            }
        }
    }
    /// Generated gRPC service name
    pub const SERVICE_NAME: &str = "Vine.MountainService";
    impl<T> tonic::server::NamedService for MountainServiceServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}
/// Generated client implementations.
pub mod cocoon_service_client {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    use tonic::codegen::http::Uri;
    /// Service running on the Cocoon sidecar, listening for requests from Mountain.
    #[derive(Debug, Clone)]
    pub struct CocoonServiceClient<T> {
        inner: tonic::client::Grpc<T>,
    }
    impl CocoonServiceClient<tonic::transport::Channel> {
        /// Attempt to create a new client by connecting to a given endpoint.
        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
        where
            D: TryInto<tonic::transport::Endpoint>,
            D::Error: Into<StdError>,
        {
            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
            Ok(Self::new(conn))
        }
    }
    impl<T> CocoonServiceClient<T>
    where
        T: tonic::client::GrpcService<tonic::body::Body>,
        T::Error: Into<StdError>,
        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
        <T::ResponseBody as Body>::Error: Into<StdError> + std::marker::Send,
    {
        pub fn new(inner: T) -> Self {
            let inner = tonic::client::Grpc::new(inner);
            Self { inner }
        }
        pub fn with_origin(inner: T, origin: Uri) -> Self {
            let inner = tonic::client::Grpc::with_origin(inner, origin);
            Self { inner }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> CocoonServiceClient<InterceptedService<T, F>>
        where
            F: tonic::service::Interceptor,
            T::ResponseBody: Default,
            T: tonic::codegen::Service<
                http::Request<tonic::body::Body>,
                Response = http::Response<
                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
                >,
            >,
            <T as tonic::codegen::Service<
                http::Request<tonic::body::Body>,
            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
        {
            CocoonServiceClient::new(InterceptedService::new(inner, interceptor))
        }
        /// Compress requests with the given encoding.
        ///
        /// This requires the server to support it otherwise it might respond with an
        /// error.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.send_compressed(encoding);
            self
        }
        /// Enable decompressing responses.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.inner = self.inner.accept_compressed(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_decoding_message_size(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.inner = self.inner.max_encoding_message_size(limit);
            self
        }
        /// A generic request-response method for Mountain to call a function on Cocoon.
        pub async fn process_mountain_request(
            &mut self,
            request: impl tonic::IntoRequest<super::GenericRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GenericResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/ProcessMountainRequest",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "ProcessMountainRequest"));
            self.inner.unary(req, path, codec).await
        }
        /// A generic fire-and-forget method for Mountain to send a notification to Cocoon.
        pub async fn send_mountain_notification(
            &mut self,
            request: impl tonic::IntoRequest<super::GenericNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/SendMountainNotification",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.CocoonService", "SendMountainNotification"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// A method for Mountain to request that Cocoon cancel a long-running operation.
        pub async fn cancel_operation(
            &mut self,
            request: impl tonic::IntoRequest<super::CancelOperationRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/CancelOperation",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "CancelOperation"));
            self.inner.unary(req, path, codec).await
        }
        /// Handshake - Called by Cocoon to signal readiness
        pub async fn initial_handshake(
            &mut self,
            request: impl tonic::IntoRequest<super::Empty>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/initial_handshake",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "initial_handshake"));
            self.inner.unary(req, path, codec).await
        }
        /// Initialize Extension Host - Mountain sends initialization data to Cocoon
        pub async fn init_extension_host(
            &mut self,
            request: impl tonic::IntoRequest<super::InitExtensionHostRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/init_extension_host",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "init_extension_host"));
            self.inner.unary(req, path, codec).await
        }
        /// Register Command - Cocoon registers an extension command
        pub async fn register_command(
            &mut self,
            request: impl tonic::IntoRequest<super::RegisterCommandRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/register_command",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "register_command"));
            self.inner.unary(req, path, codec).await
        }
        /// Execute Contributed Command - Mountain executes an extension command
        pub async fn execute_contributed_command(
            &mut self,
            request: impl tonic::IntoRequest<super::ExecuteCommandRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ExecuteCommandResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/execute_contributed_command",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.CocoonService", "execute_contributed_command"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Unregister Command - Unregister a previously registered command
        pub async fn unregister_command(
            &mut self,
            request: impl tonic::IntoRequest<super::UnregisterCommandRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/unregister_command",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "unregister_command"));
            self.inner.unary(req, path, codec).await
        }
        /// Register Hover Provider - Register a hover provider
        pub async fn register_hover_provider(
            &mut self,
            request: impl tonic::IntoRequest<super::RegisterProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/register_hover_provider",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.CocoonService", "register_hover_provider"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Provide Hover - Request hover information
        pub async fn provide_hover(
            &mut self,
            request: impl tonic::IntoRequest<super::ProvideHoverRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProvideHoverResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/provide_hover",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "provide_hover"));
            self.inner.unary(req, path, codec).await
        }
        /// Register Completion Item Provider - Register a completion provider
        pub async fn register_completion_item_provider(
            &mut self,
            request: impl tonic::IntoRequest<super::RegisterProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/register_completion_item_provider",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "Vine.CocoonService",
                        "register_completion_item_provider",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Provide Completion Items - Request completion items
        pub async fn provide_completion_items(
            &mut self,
            request: impl tonic::IntoRequest<super::ProvideCompletionItemsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProvideCompletionItemsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/provide_completion_items",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.CocoonService", "provide_completion_items"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Register Definition Provider - Register a definition provider
        pub async fn register_definition_provider(
            &mut self,
            request: impl tonic::IntoRequest<super::RegisterProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/register_definition_provider",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.CocoonService", "register_definition_provider"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Provide Definition - Request definition location
        pub async fn provide_definition(
            &mut self,
            request: impl tonic::IntoRequest<super::ProvideDefinitionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProvideDefinitionResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/provide_definition",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "provide_definition"));
            self.inner.unary(req, path, codec).await
        }
        /// Register Reference Provider - Register a reference provider
        pub async fn register_reference_provider(
            &mut self,
            request: impl tonic::IntoRequest<super::RegisterProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/register_reference_provider",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.CocoonService", "register_reference_provider"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Provide References - Request references
        pub async fn provide_references(
            &mut self,
            request: impl tonic::IntoRequest<super::ProvideReferencesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProvideReferencesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/provide_references",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "provide_references"));
            self.inner.unary(req, path, codec).await
        }
        /// Register Code Actions Provider - Register code actions provider
        pub async fn register_code_actions_provider(
            &mut self,
            request: impl tonic::IntoRequest<super::RegisterProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/register_code_actions_provider",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new(
                        "Vine.CocoonService",
                        "register_code_actions_provider",
                    ),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Provide Code Actions - Request code actions
        pub async fn provide_code_actions(
            &mut self,
            request: impl tonic::IntoRequest<super::ProvideCodeActionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProvideCodeActionsResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/provide_code_actions",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "provide_code_actions"));
            self.inner.unary(req, path, codec).await
        }
        /// Show Text Document - Open a text document
        pub async fn show_text_document(
            &mut self,
            request: impl tonic::IntoRequest<super::ShowTextDocumentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ShowTextDocumentResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/show_text_document",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "show_text_document"));
            self.inner.unary(req, path, codec).await
        }
        /// Show Information Message - Display an info message
        pub async fn show_information_message(
            &mut self,
            request: impl tonic::IntoRequest<super::ShowMessageRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ShowMessageResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/show_information_message",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.CocoonService", "show_information_message"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Show Warning Message - Display a warning message
        pub async fn show_warning_message(
            &mut self,
            request: impl tonic::IntoRequest<super::ShowMessageRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ShowMessageResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/show_warning_message",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "show_warning_message"));
            self.inner.unary(req, path, codec).await
        }
        /// Show Error Message - Display an error message
        pub async fn show_error_message(
            &mut self,
            request: impl tonic::IntoRequest<super::ShowMessageRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ShowMessageResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/show_error_message",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "show_error_message"));
            self.inner.unary(req, path, codec).await
        }
        /// Create Status Bar Item - Create a status bar item
        pub async fn create_status_bar_item(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateStatusBarItemRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateStatusBarItemResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/create_status_bar_item",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "create_status_bar_item"));
            self.inner.unary(req, path, codec).await
        }
        /// Set Status Bar Text - Set status bar text
        pub async fn set_status_bar_text(
            &mut self,
            request: impl tonic::IntoRequest<super::SetStatusBarTextRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/set_status_bar_text",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "set_status_bar_text"));
            self.inner.unary(req, path, codec).await
        }
        /// Create Webview Panel - Create a new webview panel
        pub async fn create_webview_panel(
            &mut self,
            request: impl tonic::IntoRequest<super::CreateWebviewPanelRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateWebviewPanelResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/create_webview_panel",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "create_webview_panel"));
            self.inner.unary(req, path, codec).await
        }
        /// Set Webview HTML - Update webview HTML content
        pub async fn set_webview_html(
            &mut self,
            request: impl tonic::IntoRequest<super::SetWebviewHtmlRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/set_webview_html",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "set_webview_html"));
            self.inner.unary(req, path, codec).await
        }
        /// On Did Receive Message - Receive message from webview
        pub async fn on_did_receive_message(
            &mut self,
            request: impl tonic::IntoRequest<super::OnDidReceiveMessageRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/on_did_receive_message",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "on_did_receive_message"));
            self.inner.unary(req, path, codec).await
        }
        /// Read File - Read file contents
        pub async fn read_file(
            &mut self,
            request: impl tonic::IntoRequest<super::ReadFileRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ReadFileResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/read_file",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "read_file"));
            self.inner.unary(req, path, codec).await
        }
        /// Write File - Write file contents
        pub async fn write_file(
            &mut self,
            request: impl tonic::IntoRequest<super::WriteFileRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/write_file",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "write_file"));
            self.inner.unary(req, path, codec).await
        }
        /// Stat - Get file metadata
        pub async fn stat(
            &mut self,
            request: impl tonic::IntoRequest<super::StatRequest>,
        ) -> std::result::Result<tonic::Response<super::StatResponse>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static("/Vine.CocoonService/stat");
            let mut req = request.into_request();
            req.extensions_mut().insert(GrpcMethod::new("Vine.CocoonService", "stat"));
            self.inner.unary(req, path, codec).await
        }
        /// Read Directory - List directory contents
        pub async fn readdir(
            &mut self,
            request: impl tonic::IntoRequest<super::ReaddirRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ReaddirResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/readdir",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "readdir"));
            self.inner.unary(req, path, codec).await
        }
        /// Watch File - Watch file for changes
        pub async fn watch_file(
            &mut self,
            request: impl tonic::IntoRequest<super::WatchFileRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/watch_file",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "watch_file"));
            self.inner.unary(req, path, codec).await
        }
        /// Find Files - Search for files
        pub async fn find_files(
            &mut self,
            request: impl tonic::IntoRequest<super::FindFilesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::FindFilesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/find_files",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "find_files"));
            self.inner.unary(req, path, codec).await
        }
        /// Find Text in Files - Search for text across files
        pub async fn find_text_in_files(
            &mut self,
            request: impl tonic::IntoRequest<super::FindTextInFilesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::FindTextInFilesResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/find_text_in_files",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "find_text_in_files"));
            self.inner.unary(req, path, codec).await
        }
        /// Open Document - Open a document
        pub async fn open_document(
            &mut self,
            request: impl tonic::IntoRequest<super::OpenDocumentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::OpenDocumentResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/open_document",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "open_document"));
            self.inner.unary(req, path, codec).await
        }
        /// Save All - Save all open documents
        pub async fn save_all(
            &mut self,
            request: impl tonic::IntoRequest<super::SaveAllRequest>,
        ) -> std::result::Result<
            tonic::Response<super::SaveAllResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/save_all",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "save_all"));
            self.inner.unary(req, path, codec).await
        }
        /// Apply Edit - Apply a text edit to a document
        pub async fn apply_edit(
            &mut self,
            request: impl tonic::IntoRequest<super::ApplyEditRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ApplyEditResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/apply_edit",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "apply_edit"));
            self.inner.unary(req, path, codec).await
        }
        /// Update Configuration - Notify of configuration changes
        pub async fn update_configuration(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateConfigurationRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/update_configuration",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "update_configuration"));
            self.inner.unary(req, path, codec).await
        }
        /// Update Workspace Folders - Update workspace folders
        pub async fn update_workspace_folders(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateWorkspaceFoldersRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/update_workspace_folders",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.CocoonService", "update_workspace_folders"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Open Terminal - Open a new terminal
        pub async fn open_terminal(
            &mut self,
            request: impl tonic::IntoRequest<super::OpenTerminalRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/open_terminal",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "open_terminal"));
            self.inner.unary(req, path, codec).await
        }
        /// Terminal Input - Send input to terminal
        pub async fn terminal_input(
            &mut self,
            request: impl tonic::IntoRequest<super::TerminalInputRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/terminal_input",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "terminal_input"));
            self.inner.unary(req, path, codec).await
        }
        /// Close Terminal - Close a terminal
        pub async fn close_terminal(
            &mut self,
            request: impl tonic::IntoRequest<super::CloseTerminalRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/close_terminal",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "close_terminal"));
            self.inner.unary(req, path, codec).await
        }
        /// Accept Terminal Opened - Notification: Terminal opened
        pub async fn accept_terminal_opened(
            &mut self,
            request: impl tonic::IntoRequest<super::TerminalOpenedNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/accept_terminal_opened",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "accept_terminal_opened"));
            self.inner.unary(req, path, codec).await
        }
        /// Accept Terminal Closed - Notification: Terminal closed
        pub async fn accept_terminal_closed(
            &mut self,
            request: impl tonic::IntoRequest<super::TerminalClosedNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/accept_terminal_closed",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "accept_terminal_closed"));
            self.inner.unary(req, path, codec).await
        }
        /// Accept Terminal Process ID - Notification: Terminal process ID
        pub async fn accept_terminal_process_id(
            &mut self,
            request: impl tonic::IntoRequest<super::TerminalProcessIdNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/accept_terminal_process_id",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.CocoonService", "accept_terminal_process_id"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Accept Terminal Process Data - Notification: Terminal output
        pub async fn accept_terminal_process_data(
            &mut self,
            request: impl tonic::IntoRequest<super::TerminalDataNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/accept_terminal_process_data",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.CocoonService", "accept_terminal_process_data"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Register Tree View Provider - Register a tree view provider
        pub async fn register_tree_view_provider(
            &mut self,
            request: impl tonic::IntoRequest<super::RegisterTreeViewProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/register_tree_view_provider",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(
                    GrpcMethod::new("Vine.CocoonService", "register_tree_view_provider"),
                );
            self.inner.unary(req, path, codec).await
        }
        /// Get Tree Children - Request tree view children
        pub async fn get_tree_children(
            &mut self,
            request: impl tonic::IntoRequest<super::GetTreeChildrenRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetTreeChildrenResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/get_tree_children",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "get_tree_children"));
            self.inner.unary(req, path, codec).await
        }
        /// Register SCM Provider - Register source control provider
        pub async fn register_scm_provider(
            &mut self,
            request: impl tonic::IntoRequest<super::RegisterScmProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/register_scm_provider",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "register_scm_provider"));
            self.inner.unary(req, path, codec).await
        }
        /// Update SCM Group - Update SCM group
        pub async fn update_scm_group(
            &mut self,
            request: impl tonic::IntoRequest<super::UpdateScmGroupRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/update_scm_group",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "update_scm_group"));
            self.inner.unary(req, path, codec).await
        }
        /// Execute Git - Execute git command
        pub async fn git_exec(
            &mut self,
            request: impl tonic::IntoRequest<super::GitExecRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GitExecResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/git_exec",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "git_exec"));
            self.inner.unary(req, path, codec).await
        }
        /// Register Debug Adapter - Register debug adapter
        pub async fn register_debug_adapter(
            &mut self,
            request: impl tonic::IntoRequest<super::RegisterDebugAdapterRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/register_debug_adapter",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "register_debug_adapter"));
            self.inner.unary(req, path, codec).await
        }
        /// Start Debugging - Start debug session
        pub async fn start_debugging(
            &mut self,
            request: impl tonic::IntoRequest<super::StartDebuggingRequest>,
        ) -> std::result::Result<
            tonic::Response<super::StartDebuggingResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/start_debugging",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "start_debugging"));
            self.inner.unary(req, path, codec).await
        }
        /// Participate in Save - Extension participates in save
        pub async fn participate_in_save(
            &mut self,
            request: impl tonic::IntoRequest<super::ParticipateInSaveRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ParticipateInSaveResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/participate_in_save",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "participate_in_save"));
            self.inner.unary(req, path, codec).await
        }
        /// Get Secret - Retrieve a secret from storage
        pub async fn get_secret(
            &mut self,
            request: impl tonic::IntoRequest<super::GetSecretRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetSecretResponse>,
            tonic::Status,
        > {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/get_secret",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "get_secret"));
            self.inner.unary(req, path, codec).await
        }
        /// Store Secret - Store a secret in storage
        pub async fn store_secret(
            &mut self,
            request: impl tonic::IntoRequest<super::StoreSecretRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/store_secret",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "store_secret"));
            self.inner.unary(req, path, codec).await
        }
        /// Delete Secret - Delete a secret from storage
        pub async fn delete_secret(
            &mut self,
            request: impl tonic::IntoRequest<super::DeleteSecretRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status> {
            self.inner
                .ready()
                .await
                .map_err(|e| {
                    tonic::Status::unknown(
                        format!("Service was not ready: {}", e.into()),
                    )
                })?;
            let codec = tonic_prost::ProstCodec::default();
            let path = http::uri::PathAndQuery::from_static(
                "/Vine.CocoonService/delete_secret",
            );
            let mut req = request.into_request();
            req.extensions_mut()
                .insert(GrpcMethod::new("Vine.CocoonService", "delete_secret"));
            self.inner.unary(req, path, codec).await
        }
    }
}
/// Generated server implementations.
pub mod cocoon_service_server {
    #![allow(
        unused_variables,
        dead_code,
        missing_docs,
        clippy::wildcard_imports,
        clippy::let_unit_value,
    )]
    use tonic::codegen::*;
    /// Generated trait containing gRPC methods that should be implemented for use with CocoonServiceServer.
    #[async_trait]
    pub trait CocoonService: std::marker::Send + std::marker::Sync + 'static {
        /// A generic request-response method for Mountain to call a function on Cocoon.
        async fn process_mountain_request(
            &self,
            request: tonic::Request<super::GenericRequest>,
        ) -> std::result::Result<tonic::Response<super::GenericResponse>, tonic::Status>;
        /// A generic fire-and-forget method for Mountain to send a notification to Cocoon.
        async fn send_mountain_notification(
            &self,
            request: tonic::Request<super::GenericNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// A method for Mountain to request that Cocoon cancel a long-running operation.
        async fn cancel_operation(
            &self,
            request: tonic::Request<super::CancelOperationRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Handshake - Called by Cocoon to signal readiness
        async fn initial_handshake(
            &self,
            request: tonic::Request<super::Empty>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Initialize Extension Host - Mountain sends initialization data to Cocoon
        async fn init_extension_host(
            &self,
            request: tonic::Request<super::InitExtensionHostRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Register Command - Cocoon registers an extension command
        async fn register_command(
            &self,
            request: tonic::Request<super::RegisterCommandRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Execute Contributed Command - Mountain executes an extension command
        async fn execute_contributed_command(
            &self,
            request: tonic::Request<super::ExecuteCommandRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ExecuteCommandResponse>,
            tonic::Status,
        >;
        /// Unregister Command - Unregister a previously registered command
        async fn unregister_command(
            &self,
            request: tonic::Request<super::UnregisterCommandRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Register Hover Provider - Register a hover provider
        async fn register_hover_provider(
            &self,
            request: tonic::Request<super::RegisterProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Provide Hover - Request hover information
        async fn provide_hover(
            &self,
            request: tonic::Request<super::ProvideHoverRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProvideHoverResponse>,
            tonic::Status,
        >;
        /// Register Completion Item Provider - Register a completion provider
        async fn register_completion_item_provider(
            &self,
            request: tonic::Request<super::RegisterProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Provide Completion Items - Request completion items
        async fn provide_completion_items(
            &self,
            request: tonic::Request<super::ProvideCompletionItemsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProvideCompletionItemsResponse>,
            tonic::Status,
        >;
        /// Register Definition Provider - Register a definition provider
        async fn register_definition_provider(
            &self,
            request: tonic::Request<super::RegisterProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Provide Definition - Request definition location
        async fn provide_definition(
            &self,
            request: tonic::Request<super::ProvideDefinitionRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProvideDefinitionResponse>,
            tonic::Status,
        >;
        /// Register Reference Provider - Register a reference provider
        async fn register_reference_provider(
            &self,
            request: tonic::Request<super::RegisterProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Provide References - Request references
        async fn provide_references(
            &self,
            request: tonic::Request<super::ProvideReferencesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProvideReferencesResponse>,
            tonic::Status,
        >;
        /// Register Code Actions Provider - Register code actions provider
        async fn register_code_actions_provider(
            &self,
            request: tonic::Request<super::RegisterProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Provide Code Actions - Request code actions
        async fn provide_code_actions(
            &self,
            request: tonic::Request<super::ProvideCodeActionsRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ProvideCodeActionsResponse>,
            tonic::Status,
        >;
        /// Show Text Document - Open a text document
        async fn show_text_document(
            &self,
            request: tonic::Request<super::ShowTextDocumentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ShowTextDocumentResponse>,
            tonic::Status,
        >;
        /// Show Information Message - Display an info message
        async fn show_information_message(
            &self,
            request: tonic::Request<super::ShowMessageRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ShowMessageResponse>,
            tonic::Status,
        >;
        /// Show Warning Message - Display a warning message
        async fn show_warning_message(
            &self,
            request: tonic::Request<super::ShowMessageRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ShowMessageResponse>,
            tonic::Status,
        >;
        /// Show Error Message - Display an error message
        async fn show_error_message(
            &self,
            request: tonic::Request<super::ShowMessageRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ShowMessageResponse>,
            tonic::Status,
        >;
        /// Create Status Bar Item - Create a status bar item
        async fn create_status_bar_item(
            &self,
            request: tonic::Request<super::CreateStatusBarItemRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateStatusBarItemResponse>,
            tonic::Status,
        >;
        /// Set Status Bar Text - Set status bar text
        async fn set_status_bar_text(
            &self,
            request: tonic::Request<super::SetStatusBarTextRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Create Webview Panel - Create a new webview panel
        async fn create_webview_panel(
            &self,
            request: tonic::Request<super::CreateWebviewPanelRequest>,
        ) -> std::result::Result<
            tonic::Response<super::CreateWebviewPanelResponse>,
            tonic::Status,
        >;
        /// Set Webview HTML - Update webview HTML content
        async fn set_webview_html(
            &self,
            request: tonic::Request<super::SetWebviewHtmlRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// On Did Receive Message - Receive message from webview
        async fn on_did_receive_message(
            &self,
            request: tonic::Request<super::OnDidReceiveMessageRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Read File - Read file contents
        async fn read_file(
            &self,
            request: tonic::Request<super::ReadFileRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ReadFileResponse>,
            tonic::Status,
        >;
        /// Write File - Write file contents
        async fn write_file(
            &self,
            request: tonic::Request<super::WriteFileRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Stat - Get file metadata
        async fn stat(
            &self,
            request: tonic::Request<super::StatRequest>,
        ) -> std::result::Result<tonic::Response<super::StatResponse>, tonic::Status>;
        /// Read Directory - List directory contents
        async fn readdir(
            &self,
            request: tonic::Request<super::ReaddirRequest>,
        ) -> std::result::Result<tonic::Response<super::ReaddirResponse>, tonic::Status>;
        /// Watch File - Watch file for changes
        async fn watch_file(
            &self,
            request: tonic::Request<super::WatchFileRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Find Files - Search for files
        async fn find_files(
            &self,
            request: tonic::Request<super::FindFilesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::FindFilesResponse>,
            tonic::Status,
        >;
        /// Find Text in Files - Search for text across files
        async fn find_text_in_files(
            &self,
            request: tonic::Request<super::FindTextInFilesRequest>,
        ) -> std::result::Result<
            tonic::Response<super::FindTextInFilesResponse>,
            tonic::Status,
        >;
        /// Open Document - Open a document
        async fn open_document(
            &self,
            request: tonic::Request<super::OpenDocumentRequest>,
        ) -> std::result::Result<
            tonic::Response<super::OpenDocumentResponse>,
            tonic::Status,
        >;
        /// Save All - Save all open documents
        async fn save_all(
            &self,
            request: tonic::Request<super::SaveAllRequest>,
        ) -> std::result::Result<tonic::Response<super::SaveAllResponse>, tonic::Status>;
        /// Apply Edit - Apply a text edit to a document
        async fn apply_edit(
            &self,
            request: tonic::Request<super::ApplyEditRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ApplyEditResponse>,
            tonic::Status,
        >;
        /// Update Configuration - Notify of configuration changes
        async fn update_configuration(
            &self,
            request: tonic::Request<super::UpdateConfigurationRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Update Workspace Folders - Update workspace folders
        async fn update_workspace_folders(
            &self,
            request: tonic::Request<super::UpdateWorkspaceFoldersRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Open Terminal - Open a new terminal
        async fn open_terminal(
            &self,
            request: tonic::Request<super::OpenTerminalRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Terminal Input - Send input to terminal
        async fn terminal_input(
            &self,
            request: tonic::Request<super::TerminalInputRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Close Terminal - Close a terminal
        async fn close_terminal(
            &self,
            request: tonic::Request<super::CloseTerminalRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Accept Terminal Opened - Notification: Terminal opened
        async fn accept_terminal_opened(
            &self,
            request: tonic::Request<super::TerminalOpenedNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Accept Terminal Closed - Notification: Terminal closed
        async fn accept_terminal_closed(
            &self,
            request: tonic::Request<super::TerminalClosedNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Accept Terminal Process ID - Notification: Terminal process ID
        async fn accept_terminal_process_id(
            &self,
            request: tonic::Request<super::TerminalProcessIdNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Accept Terminal Process Data - Notification: Terminal output
        async fn accept_terminal_process_data(
            &self,
            request: tonic::Request<super::TerminalDataNotification>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Register Tree View Provider - Register a tree view provider
        async fn register_tree_view_provider(
            &self,
            request: tonic::Request<super::RegisterTreeViewProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Get Tree Children - Request tree view children
        async fn get_tree_children(
            &self,
            request: tonic::Request<super::GetTreeChildrenRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetTreeChildrenResponse>,
            tonic::Status,
        >;
        /// Register SCM Provider - Register source control provider
        async fn register_scm_provider(
            &self,
            request: tonic::Request<super::RegisterScmProviderRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Update SCM Group - Update SCM group
        async fn update_scm_group(
            &self,
            request: tonic::Request<super::UpdateScmGroupRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Execute Git - Execute git command
        async fn git_exec(
            &self,
            request: tonic::Request<super::GitExecRequest>,
        ) -> std::result::Result<tonic::Response<super::GitExecResponse>, tonic::Status>;
        /// Register Debug Adapter - Register debug adapter
        async fn register_debug_adapter(
            &self,
            request: tonic::Request<super::RegisterDebugAdapterRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Start Debugging - Start debug session
        async fn start_debugging(
            &self,
            request: tonic::Request<super::StartDebuggingRequest>,
        ) -> std::result::Result<
            tonic::Response<super::StartDebuggingResponse>,
            tonic::Status,
        >;
        /// Participate in Save - Extension participates in save
        async fn participate_in_save(
            &self,
            request: tonic::Request<super::ParticipateInSaveRequest>,
        ) -> std::result::Result<
            tonic::Response<super::ParticipateInSaveResponse>,
            tonic::Status,
        >;
        /// Get Secret - Retrieve a secret from storage
        async fn get_secret(
            &self,
            request: tonic::Request<super::GetSecretRequest>,
        ) -> std::result::Result<
            tonic::Response<super::GetSecretResponse>,
            tonic::Status,
        >;
        /// Store Secret - Store a secret in storage
        async fn store_secret(
            &self,
            request: tonic::Request<super::StoreSecretRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
        /// Delete Secret - Delete a secret from storage
        async fn delete_secret(
            &self,
            request: tonic::Request<super::DeleteSecretRequest>,
        ) -> std::result::Result<tonic::Response<super::Empty>, tonic::Status>;
    }
    /// Service running on the Cocoon sidecar, listening for requests from Mountain.
    #[derive(Debug)]
    pub struct CocoonServiceServer<T> {
        inner: Arc<T>,
        accept_compression_encodings: EnabledCompressionEncodings,
        send_compression_encodings: EnabledCompressionEncodings,
        max_decoding_message_size: Option<usize>,
        max_encoding_message_size: Option<usize>,
    }
    impl<T> CocoonServiceServer<T> {
        pub fn new(inner: T) -> Self {
            Self::from_arc(Arc::new(inner))
        }
        pub fn from_arc(inner: Arc<T>) -> Self {
            Self {
                inner,
                accept_compression_encodings: Default::default(),
                send_compression_encodings: Default::default(),
                max_decoding_message_size: None,
                max_encoding_message_size: None,
            }
        }
        pub fn with_interceptor<F>(
            inner: T,
            interceptor: F,
        ) -> InterceptedService<Self, F>
        where
            F: tonic::service::Interceptor,
        {
            InterceptedService::new(Self::new(inner), interceptor)
        }
        /// Enable decompressing requests with the given encoding.
        #[must_use]
        pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.accept_compression_encodings.enable(encoding);
            self
        }
        /// Compress responses with the given encoding, if the client supports it.
        #[must_use]
        pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self {
            self.send_compression_encodings.enable(encoding);
            self
        }
        /// Limits the maximum size of a decoded message.
        ///
        /// Default: `4MB`
        #[must_use]
        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
            self.max_decoding_message_size = Some(limit);
            self
        }
        /// Limits the maximum size of an encoded message.
        ///
        /// Default: `usize::MAX`
        #[must_use]
        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
            self.max_encoding_message_size = Some(limit);
            self
        }
    }
    impl<T, B> tonic::codegen::Service<http::Request<B>> for CocoonServiceServer<T>
    where
        T: CocoonService,
        B: Body + std::marker::Send + 'static,
        B::Error: Into<StdError> + std::marker::Send + 'static,
    {
        type Response = http::Response<tonic::body::Body>;
        type Error = std::convert::Infallible;
        type Future = BoxFuture<Self::Response, Self::Error>;
        fn poll_ready(
            &mut self,
            _cx: &mut Context<'_>,
        ) -> Poll<std::result::Result<(), Self::Error>> {
            Poll::Ready(Ok(()))
        }
        fn call(&mut self, req: http::Request<B>) -> Self::Future {
            match req.uri().path() {
                "/Vine.CocoonService/ProcessMountainRequest" => {
                    #[allow(non_camel_case_types)]
                    struct ProcessMountainRequestSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::GenericRequest>
                    for ProcessMountainRequestSvc<T> {
                        type Response = super::GenericResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GenericRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::process_mountain_request(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = ProcessMountainRequestSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/SendMountainNotification" => {
                    #[allow(non_camel_case_types)]
                    struct SendMountainNotificationSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::GenericNotification>
                    for SendMountainNotificationSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GenericNotification>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::send_mountain_notification(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = SendMountainNotificationSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/CancelOperation" => {
                    #[allow(non_camel_case_types)]
                    struct CancelOperationSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::CancelOperationRequest>
                    for CancelOperationSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CancelOperationRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::cancel_operation(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = CancelOperationSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/initial_handshake" => {
                    #[allow(non_camel_case_types)]
                    struct initial_handshakeSvc<T: CocoonService>(pub Arc<T>);
                    impl<T: CocoonService> tonic::server::UnaryService<super::Empty>
                    for initial_handshakeSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::Empty>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::initial_handshake(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = initial_handshakeSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/init_extension_host" => {
                    #[allow(non_camel_case_types)]
                    struct init_extension_hostSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::InitExtensionHostRequest>
                    for init_extension_hostSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::InitExtensionHostRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::init_extension_host(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = init_extension_hostSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/register_command" => {
                    #[allow(non_camel_case_types)]
                    struct register_commandSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::RegisterCommandRequest>
                    for register_commandSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RegisterCommandRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::register_command(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = register_commandSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/execute_contributed_command" => {
                    #[allow(non_camel_case_types)]
                    struct execute_contributed_commandSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ExecuteCommandRequest>
                    for execute_contributed_commandSvc<T> {
                        type Response = super::ExecuteCommandResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ExecuteCommandRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::execute_contributed_command(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = execute_contributed_commandSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/unregister_command" => {
                    #[allow(non_camel_case_types)]
                    struct unregister_commandSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::UnregisterCommandRequest>
                    for unregister_commandSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::UnregisterCommandRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::unregister_command(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = unregister_commandSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/register_hover_provider" => {
                    #[allow(non_camel_case_types)]
                    struct register_hover_providerSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::RegisterProviderRequest>
                    for register_hover_providerSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RegisterProviderRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::register_hover_provider(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = register_hover_providerSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/provide_hover" => {
                    #[allow(non_camel_case_types)]
                    struct provide_hoverSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ProvideHoverRequest>
                    for provide_hoverSvc<T> {
                        type Response = super::ProvideHoverResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ProvideHoverRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::provide_hover(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = provide_hoverSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/register_completion_item_provider" => {
                    #[allow(non_camel_case_types)]
                    struct register_completion_item_providerSvc<T: CocoonService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::RegisterProviderRequest>
                    for register_completion_item_providerSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RegisterProviderRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::register_completion_item_provider(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = register_completion_item_providerSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/provide_completion_items" => {
                    #[allow(non_camel_case_types)]
                    struct provide_completion_itemsSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ProvideCompletionItemsRequest>
                    for provide_completion_itemsSvc<T> {
                        type Response = super::ProvideCompletionItemsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ProvideCompletionItemsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::provide_completion_items(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = provide_completion_itemsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/register_definition_provider" => {
                    #[allow(non_camel_case_types)]
                    struct register_definition_providerSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::RegisterProviderRequest>
                    for register_definition_providerSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RegisterProviderRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::register_definition_provider(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = register_definition_providerSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/provide_definition" => {
                    #[allow(non_camel_case_types)]
                    struct provide_definitionSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ProvideDefinitionRequest>
                    for provide_definitionSvc<T> {
                        type Response = super::ProvideDefinitionResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ProvideDefinitionRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::provide_definition(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = provide_definitionSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/register_reference_provider" => {
                    #[allow(non_camel_case_types)]
                    struct register_reference_providerSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::RegisterProviderRequest>
                    for register_reference_providerSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RegisterProviderRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::register_reference_provider(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = register_reference_providerSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/provide_references" => {
                    #[allow(non_camel_case_types)]
                    struct provide_referencesSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ProvideReferencesRequest>
                    for provide_referencesSvc<T> {
                        type Response = super::ProvideReferencesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ProvideReferencesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::provide_references(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = provide_referencesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/register_code_actions_provider" => {
                    #[allow(non_camel_case_types)]
                    struct register_code_actions_providerSvc<T: CocoonService>(
                        pub Arc<T>,
                    );
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::RegisterProviderRequest>
                    for register_code_actions_providerSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RegisterProviderRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::register_code_actions_provider(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = register_code_actions_providerSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/provide_code_actions" => {
                    #[allow(non_camel_case_types)]
                    struct provide_code_actionsSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ProvideCodeActionsRequest>
                    for provide_code_actionsSvc<T> {
                        type Response = super::ProvideCodeActionsResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ProvideCodeActionsRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::provide_code_actions(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = provide_code_actionsSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/show_text_document" => {
                    #[allow(non_camel_case_types)]
                    struct show_text_documentSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ShowTextDocumentRequest>
                    for show_text_documentSvc<T> {
                        type Response = super::ShowTextDocumentResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ShowTextDocumentRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::show_text_document(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = show_text_documentSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/show_information_message" => {
                    #[allow(non_camel_case_types)]
                    struct show_information_messageSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ShowMessageRequest>
                    for show_information_messageSvc<T> {
                        type Response = super::ShowMessageResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ShowMessageRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::show_information_message(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = show_information_messageSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/show_warning_message" => {
                    #[allow(non_camel_case_types)]
                    struct show_warning_messageSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ShowMessageRequest>
                    for show_warning_messageSvc<T> {
                        type Response = super::ShowMessageResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ShowMessageRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::show_warning_message(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = show_warning_messageSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/show_error_message" => {
                    #[allow(non_camel_case_types)]
                    struct show_error_messageSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ShowMessageRequest>
                    for show_error_messageSvc<T> {
                        type Response = super::ShowMessageResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ShowMessageRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::show_error_message(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = show_error_messageSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/create_status_bar_item" => {
                    #[allow(non_camel_case_types)]
                    struct create_status_bar_itemSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::CreateStatusBarItemRequest>
                    for create_status_bar_itemSvc<T> {
                        type Response = super::CreateStatusBarItemResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CreateStatusBarItemRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::create_status_bar_item(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = create_status_bar_itemSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/set_status_bar_text" => {
                    #[allow(non_camel_case_types)]
                    struct set_status_bar_textSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::SetStatusBarTextRequest>
                    for set_status_bar_textSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SetStatusBarTextRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::set_status_bar_text(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = set_status_bar_textSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/create_webview_panel" => {
                    #[allow(non_camel_case_types)]
                    struct create_webview_panelSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::CreateWebviewPanelRequest>
                    for create_webview_panelSvc<T> {
                        type Response = super::CreateWebviewPanelResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CreateWebviewPanelRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::create_webview_panel(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = create_webview_panelSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/set_webview_html" => {
                    #[allow(non_camel_case_types)]
                    struct set_webview_htmlSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::SetWebviewHtmlRequest>
                    for set_webview_htmlSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SetWebviewHtmlRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::set_webview_html(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = set_webview_htmlSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/on_did_receive_message" => {
                    #[allow(non_camel_case_types)]
                    struct on_did_receive_messageSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::OnDidReceiveMessageRequest>
                    for on_did_receive_messageSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::OnDidReceiveMessageRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::on_did_receive_message(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = on_did_receive_messageSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/read_file" => {
                    #[allow(non_camel_case_types)]
                    struct read_fileSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ReadFileRequest>
                    for read_fileSvc<T> {
                        type Response = super::ReadFileResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ReadFileRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::read_file(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = read_fileSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/write_file" => {
                    #[allow(non_camel_case_types)]
                    struct write_fileSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::WriteFileRequest>
                    for write_fileSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::WriteFileRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::write_file(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = write_fileSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/stat" => {
                    #[allow(non_camel_case_types)]
                    struct statSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::StatRequest> for statSvc<T> {
                        type Response = super::StatResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::StatRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::stat(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = statSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/readdir" => {
                    #[allow(non_camel_case_types)]
                    struct readdirSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ReaddirRequest>
                    for readdirSvc<T> {
                        type Response = super::ReaddirResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ReaddirRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::readdir(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = readdirSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/watch_file" => {
                    #[allow(non_camel_case_types)]
                    struct watch_fileSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::WatchFileRequest>
                    for watch_fileSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::WatchFileRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::watch_file(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = watch_fileSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/find_files" => {
                    #[allow(non_camel_case_types)]
                    struct find_filesSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::FindFilesRequest>
                    for find_filesSvc<T> {
                        type Response = super::FindFilesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::FindFilesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::find_files(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = find_filesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/find_text_in_files" => {
                    #[allow(non_camel_case_types)]
                    struct find_text_in_filesSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::FindTextInFilesRequest>
                    for find_text_in_filesSvc<T> {
                        type Response = super::FindTextInFilesResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::FindTextInFilesRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::find_text_in_files(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = find_text_in_filesSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/open_document" => {
                    #[allow(non_camel_case_types)]
                    struct open_documentSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::OpenDocumentRequest>
                    for open_documentSvc<T> {
                        type Response = super::OpenDocumentResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::OpenDocumentRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::open_document(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = open_documentSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/save_all" => {
                    #[allow(non_camel_case_types)]
                    struct save_allSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::SaveAllRequest>
                    for save_allSvc<T> {
                        type Response = super::SaveAllResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::SaveAllRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::save_all(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = save_allSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/apply_edit" => {
                    #[allow(non_camel_case_types)]
                    struct apply_editSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ApplyEditRequest>
                    for apply_editSvc<T> {
                        type Response = super::ApplyEditResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ApplyEditRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::apply_edit(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = apply_editSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/update_configuration" => {
                    #[allow(non_camel_case_types)]
                    struct update_configurationSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::UpdateConfigurationRequest>
                    for update_configurationSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::UpdateConfigurationRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::update_configuration(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = update_configurationSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/update_workspace_folders" => {
                    #[allow(non_camel_case_types)]
                    struct update_workspace_foldersSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::UpdateWorkspaceFoldersRequest>
                    for update_workspace_foldersSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::UpdateWorkspaceFoldersRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::update_workspace_folders(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = update_workspace_foldersSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/open_terminal" => {
                    #[allow(non_camel_case_types)]
                    struct open_terminalSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::OpenTerminalRequest>
                    for open_terminalSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::OpenTerminalRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::open_terminal(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = open_terminalSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/terminal_input" => {
                    #[allow(non_camel_case_types)]
                    struct terminal_inputSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::TerminalInputRequest>
                    for terminal_inputSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::TerminalInputRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::terminal_input(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = terminal_inputSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/close_terminal" => {
                    #[allow(non_camel_case_types)]
                    struct close_terminalSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::CloseTerminalRequest>
                    for close_terminalSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::CloseTerminalRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::close_terminal(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = close_terminalSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/accept_terminal_opened" => {
                    #[allow(non_camel_case_types)]
                    struct accept_terminal_openedSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::TerminalOpenedNotification>
                    for accept_terminal_openedSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::TerminalOpenedNotification>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::accept_terminal_opened(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = accept_terminal_openedSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/accept_terminal_closed" => {
                    #[allow(non_camel_case_types)]
                    struct accept_terminal_closedSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::TerminalClosedNotification>
                    for accept_terminal_closedSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::TerminalClosedNotification>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::accept_terminal_closed(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = accept_terminal_closedSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/accept_terminal_process_id" => {
                    #[allow(non_camel_case_types)]
                    struct accept_terminal_process_idSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::TerminalProcessIdNotification>
                    for accept_terminal_process_idSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::TerminalProcessIdNotification>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::accept_terminal_process_id(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = accept_terminal_process_idSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/accept_terminal_process_data" => {
                    #[allow(non_camel_case_types)]
                    struct accept_terminal_process_dataSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::TerminalDataNotification>
                    for accept_terminal_process_dataSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::TerminalDataNotification>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::accept_terminal_process_data(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = accept_terminal_process_dataSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/register_tree_view_provider" => {
                    #[allow(non_camel_case_types)]
                    struct register_tree_view_providerSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::RegisterTreeViewProviderRequest>
                    for register_tree_view_providerSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<
                                super::RegisterTreeViewProviderRequest,
                            >,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::register_tree_view_provider(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = register_tree_view_providerSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/get_tree_children" => {
                    #[allow(non_camel_case_types)]
                    struct get_tree_childrenSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::GetTreeChildrenRequest>
                    for get_tree_childrenSvc<T> {
                        type Response = super::GetTreeChildrenResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetTreeChildrenRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::get_tree_children(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = get_tree_childrenSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/register_scm_provider" => {
                    #[allow(non_camel_case_types)]
                    struct register_scm_providerSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::RegisterScmProviderRequest>
                    for register_scm_providerSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RegisterScmProviderRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::register_scm_provider(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = register_scm_providerSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/update_scm_group" => {
                    #[allow(non_camel_case_types)]
                    struct update_scm_groupSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::UpdateScmGroupRequest>
                    for update_scm_groupSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::UpdateScmGroupRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::update_scm_group(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = update_scm_groupSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/git_exec" => {
                    #[allow(non_camel_case_types)]
                    struct git_execSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::GitExecRequest>
                    for git_execSvc<T> {
                        type Response = super::GitExecResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GitExecRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::git_exec(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = git_execSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/register_debug_adapter" => {
                    #[allow(non_camel_case_types)]
                    struct register_debug_adapterSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::RegisterDebugAdapterRequest>
                    for register_debug_adapterSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::RegisterDebugAdapterRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::register_debug_adapter(
                                        &inner,
                                        request,
                                    )
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = register_debug_adapterSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/start_debugging" => {
                    #[allow(non_camel_case_types)]
                    struct start_debuggingSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::StartDebuggingRequest>
                    for start_debuggingSvc<T> {
                        type Response = super::StartDebuggingResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::StartDebuggingRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::start_debugging(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = start_debuggingSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/participate_in_save" => {
                    #[allow(non_camel_case_types)]
                    struct participate_in_saveSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::ParticipateInSaveRequest>
                    for participate_in_saveSvc<T> {
                        type Response = super::ParticipateInSaveResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::ParticipateInSaveRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::participate_in_save(&inner, request)
                                    .await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = participate_in_saveSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/get_secret" => {
                    #[allow(non_camel_case_types)]
                    struct get_secretSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::GetSecretRequest>
                    for get_secretSvc<T> {
                        type Response = super::GetSecretResponse;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::GetSecretRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::get_secret(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = get_secretSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/store_secret" => {
                    #[allow(non_camel_case_types)]
                    struct store_secretSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::StoreSecretRequest>
                    for store_secretSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::StoreSecretRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::store_secret(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = store_secretSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                "/Vine.CocoonService/delete_secret" => {
                    #[allow(non_camel_case_types)]
                    struct delete_secretSvc<T: CocoonService>(pub Arc<T>);
                    impl<
                        T: CocoonService,
                    > tonic::server::UnaryService<super::DeleteSecretRequest>
                    for delete_secretSvc<T> {
                        type Response = super::Empty;
                        type Future = BoxFuture<
                            tonic::Response<Self::Response>,
                            tonic::Status,
                        >;
                        fn call(
                            &mut self,
                            request: tonic::Request<super::DeleteSecretRequest>,
                        ) -> Self::Future {
                            let inner = Arc::clone(&self.0);
                            let fut = async move {
                                <T as CocoonService>::delete_secret(&inner, request).await
                            };
                            Box::pin(fut)
                        }
                    }
                    let accept_compression_encodings = self.accept_compression_encodings;
                    let send_compression_encodings = self.send_compression_encodings;
                    let max_decoding_message_size = self.max_decoding_message_size;
                    let max_encoding_message_size = self.max_encoding_message_size;
                    let inner = self.inner.clone();
                    let fut = async move {
                        let method = delete_secretSvc(inner);
                        let codec = tonic_prost::ProstCodec::default();
                        let mut grpc = tonic::server::Grpc::new(codec)
                            .apply_compression_config(
                                accept_compression_encodings,
                                send_compression_encodings,
                            )
                            .apply_max_message_size_config(
                                max_decoding_message_size,
                                max_encoding_message_size,
                            );
                        let res = grpc.unary(method, req).await;
                        Ok(res)
                    };
                    Box::pin(fut)
                }
                _ => {
                    Box::pin(async move {
                        let mut response = http::Response::new(
                            tonic::body::Body::default(),
                        );
                        let headers = response.headers_mut();
                        headers
                            .insert(
                                tonic::Status::GRPC_STATUS,
                                (tonic::Code::Unimplemented as i32).into(),
                            );
                        headers
                            .insert(
                                http::header::CONTENT_TYPE,
                                tonic::metadata::GRPC_CONTENT_TYPE,
                            );
                        Ok(response)
                    })
                }
            }
        }
    }
    impl<T> Clone for CocoonServiceServer<T> {
        fn clone(&self) -> Self {
            let inner = self.inner.clone();
            Self {
                inner,
                accept_compression_encodings: self.accept_compression_encodings,
                send_compression_encodings: self.send_compression_encodings,
                max_decoding_message_size: self.max_decoding_message_size,
                max_encoding_message_size: self.max_encoding_message_size,
            }
        }
    }
    /// Generated gRPC service name
    pub const SERVICE_NAME: &str = "Vine.CocoonService";
    impl<T> tonic::server::NamedService for CocoonServiceServer<T> {
        const NAME: &'static str = SERVICE_NAME;
    }
}