Trait CocoonService 

pub trait CocoonService:
    Send
    + Sync
    + 'static {
    type OpenChannelFromMountainStream: Stream<Item = Result<Envelope, Status>> + Send + 'static;

    // Required methods
    fn process_mountain_request<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GenericRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GenericResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn send_mountain_notification<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GenericNotification>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn cancel_operation<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CancelOperationRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn open_channel_from_mountain<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Streaming<Envelope>>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Self::OpenChannelFromMountainStream>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn initial_handshake<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Empty>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn init_extension_host<'life0, 'async_trait>(
        &'life0 self,
        request: Request<InitExtensionHostRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_command<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterCommandRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn execute_contributed_command<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ExecuteCommandRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ExecuteCommandResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn unregister_command<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UnregisterCommandRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_hover_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_hover<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideHoverRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideHoverResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_completion_item_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_completion_items<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideCompletionItemsRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCompletionItemsResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_definition_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_definition<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideDefinitionRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDefinitionResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_reference_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_references<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideReferencesRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideReferencesResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_code_actions_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_code_actions<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideCodeActionsRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCodeActionsResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_document_highlight_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_document_highlights<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideDocumentHighlightsRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentHighlightsResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_document_symbol_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_document_symbols<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideDocumentSymbolsRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentSymbolsResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_workspace_symbol_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_workspace_symbols<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideWorkspaceSymbolsRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideWorkspaceSymbolsResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_rename_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_rename_edits<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideRenameEditsRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideRenameEditsResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_document_formatting_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_document_formatting<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideDocumentFormattingRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentFormattingResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_document_range_formatting_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_document_range_formatting<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideDocumentRangeFormattingRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentRangeFormattingResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_on_type_formatting_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterOnTypeFormattingProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_on_type_formatting<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideOnTypeFormattingRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideOnTypeFormattingResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_signature_help_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterSignatureHelpProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_signature_help<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideSignatureHelpRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideSignatureHelpResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_code_lens_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_code_lenses<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideCodeLensesRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCodeLensesResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_folding_range_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_folding_ranges<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideFoldingRangesRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideFoldingRangesResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_selection_range_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_selection_ranges<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideSelectionRangesRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideSelectionRangesResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_semantic_tokens_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterSemanticTokensProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_semantic_tokens_full<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideSemanticTokensRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideSemanticTokensResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_inlay_hints_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_inlay_hints<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideInlayHintsRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideInlayHintsResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_type_hierarchy_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_type_hierarchy_supertypes<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideTypeHierarchyRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideTypeHierarchyResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_type_hierarchy_subtypes<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideTypeHierarchyRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideTypeHierarchyResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_call_hierarchy_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_call_hierarchy_incoming_calls<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideCallHierarchyRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCallHierarchyResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_call_hierarchy_outgoing_calls<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideCallHierarchyRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCallHierarchyResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_linked_editing_range_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn provide_linked_editing_ranges<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ProvideLinkedEditingRangesRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideLinkedEditingRangesResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn show_quick_pick<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ShowQuickPickRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ShowQuickPickResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn show_input_box<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ShowInputBoxRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ShowInputBoxResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn show_progress<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ShowProgressRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ShowProgressResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn report_progress<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ReportProgressRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn post_webview_message<'life0, 'async_trait>(
        &'life0 self,
        request: Request<PostWebviewMessageRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn dispose_webview_panel<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DisposeWebviewPanelRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn open_external<'life0, 'async_trait>(
        &'life0 self,
        request: Request<OpenExternalRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn delete_file<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DeleteFileRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn rename_file<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RenameFileRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn copy_file<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CopyFileRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_directory<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CreateDirectoryRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_output_channel<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CreateOutputChannelRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<CreateOutputChannelResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn append_output<'life0, 'async_trait>(
        &'life0 self,
        request: Request<AppendOutputRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn clear_output<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ClearOutputRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn show_output<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ShowOutputRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn dispose_output<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DisposeOutputRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_task_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterTaskProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn execute_task<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ExecuteTaskRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ExecuteTaskResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn terminate_task<'life0, 'async_trait>(
        &'life0 self,
        request: Request<TerminateTaskRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_authentication_session<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetAuthenticationSessionRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetAuthenticationSessionResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_authentication_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterAuthenticationProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn stop_debugging<'life0, 'async_trait>(
        &'life0 self,
        request: Request<StopDebuggingRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_extension<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetExtensionRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetExtensionResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_all_extensions<'life0, 'async_trait>(
        &'life0 self,
        request: Request<Empty>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetAllExtensionsResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn resize_terminal<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ResizeTerminalRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_configuration<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetConfigurationRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetConfigurationResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn show_text_document<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ShowTextDocumentRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ShowTextDocumentResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn show_information_message<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ShowMessageRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ShowMessageResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn show_warning_message<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ShowMessageRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ShowMessageResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn show_error_message<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ShowMessageRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ShowMessageResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_status_bar_item<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CreateStatusBarItemRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<CreateStatusBarItemResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn set_status_bar_text<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SetStatusBarTextRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create_webview_panel<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CreateWebviewPanelRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<CreateWebviewPanelResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn set_webview_html<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SetWebviewHtmlRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn on_did_receive_message<'life0, 'async_trait>(
        &'life0 self,
        request: Request<OnDidReceiveMessageRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn read_file<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ReadFileRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ReadFileResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn write_file<'life0, 'async_trait>(
        &'life0 self,
        request: Request<WriteFileRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn stat<'life0, 'async_trait>(
        &'life0 self,
        request: Request<StatRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<StatResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn readdir<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ReaddirRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ReaddirResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn watch_file<'life0, 'async_trait>(
        &'life0 self,
        request: Request<WatchFileRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn find_files<'life0, 'async_trait>(
        &'life0 self,
        request: Request<FindFilesRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<FindFilesResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn find_text_in_files<'life0, 'async_trait>(
        &'life0 self,
        request: Request<FindTextInFilesRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<FindTextInFilesResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn open_document<'life0, 'async_trait>(
        &'life0 self,
        request: Request<OpenDocumentRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<OpenDocumentResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn save_all<'life0, 'async_trait>(
        &'life0 self,
        request: Request<SaveAllRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<SaveAllResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn apply_edit<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ApplyEditRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ApplyEditResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn update_configuration<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UpdateConfigurationRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn update_workspace_folders<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UpdateWorkspaceFoldersRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn open_terminal<'life0, 'async_trait>(
        &'life0 self,
        request: Request<OpenTerminalRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn terminal_input<'life0, 'async_trait>(
        &'life0 self,
        request: Request<TerminalInputRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn close_terminal<'life0, 'async_trait>(
        &'life0 self,
        request: Request<CloseTerminalRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn accept_terminal_opened<'life0, 'async_trait>(
        &'life0 self,
        request: Request<TerminalOpenedNotification>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn accept_terminal_closed<'life0, 'async_trait>(
        &'life0 self,
        request: Request<TerminalClosedNotification>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn accept_terminal_process_id<'life0, 'async_trait>(
        &'life0 self,
        request: Request<TerminalProcessIdNotification>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn accept_terminal_process_data<'life0, 'async_trait>(
        &'life0 self,
        request: Request<TerminalDataNotification>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_tree_view_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterTreeViewProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_tree_children<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetTreeChildrenRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetTreeChildrenResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_scm_provider<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterScmProviderRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn update_scm_group<'life0, 'async_trait>(
        &'life0 self,
        request: Request<UpdateScmGroupRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn git_exec<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GitExecRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GitExecResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn register_debug_adapter<'life0, 'async_trait>(
        &'life0 self,
        request: Request<RegisterDebugAdapterRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn start_debugging<'life0, 'async_trait>(
        &'life0 self,
        request: Request<StartDebuggingRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<StartDebuggingResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn participate_in_save<'life0, 'async_trait>(
        &'life0 self,
        request: Request<ParticipateInSaveRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<ParticipateInSaveResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_secret<'life0, 'async_trait>(
        &'life0 self,
        request: Request<GetSecretRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<GetSecretResponse>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn store_secret<'life0, 'async_trait>(
        &'life0 self,
        request: Request<StoreSecretRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn delete_secret<'life0, 'async_trait>(
        &'life0 self,
        request: Request<DeleteSecretRequest>,
    ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
}

Generated trait containing gRPC methods that should be implemented for use with CocoonServiceServer.

Required Associated Types

type OpenChannelFromMountainStream: Stream<Item = Result<Envelope, Status>> + Send + 'static

Server streaming response type for the OpenChannelFromMountain method.

Required Methods

fn process_mountain_request<'life0, 'async_trait>( &'life0 self, request: Request<GenericRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GenericResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

A generic request-response method for Mountain to call a function on Cocoon.

fn send_mountain_notification<'life0, 'async_trait>( &'life0 self, request: Request<GenericNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

A generic fire-and-forget method for Mountain to send a notification to Cocoon.

fn cancel_operation<'life0, 'async_trait>( &'life0 self, request: Request<CancelOperationRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

A method for Mountain to request that Cocoon cancel a long-running operation.

fn open_channel_from_mountain<'life0, 'async_trait>( &'life0 self, request: Request<Streaming<Envelope>>, ) -> Pin<Box<dyn Future<Output = Result<Response<Self::OpenChannelFromMountainStream>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

LAND-PATCH B7-S6 P2: bidirectional streaming channel (mirror of MountainService::OpenChannelFromCocoon). Mountain opens this stream once per Cocoon connection; all subsequent traffic multiplexes over it. Reverses the call direction so Mountain is the streaming initiator (which matches the typical “client opens stream, server replies” gRPC idiom).

fn initial_handshake<'life0, 'async_trait>( &'life0 self, request: Request<Empty>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Handshake - Called by Cocoon to signal readiness

fn init_extension_host<'life0, 'async_trait>( &'life0 self, request: Request<InitExtensionHostRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Initialize Extension Host - Mountain sends initialization data to Cocoon

fn register_command<'life0, 'async_trait>( &'life0 self, request: Request<RegisterCommandRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Command - Cocoon registers an extension command

fn execute_contributed_command<'life0, 'async_trait>( &'life0 self, request: Request<ExecuteCommandRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ExecuteCommandResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute Contributed Command - Mountain executes an extension command

fn unregister_command<'life0, 'async_trait>( &'life0 self, request: Request<UnregisterCommandRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Unregister Command - Unregister a previously registered command

fn register_hover_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Hover Provider - Register a hover provider

fn provide_hover<'life0, 'async_trait>( &'life0 self, request: Request<ProvideHoverRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideHoverResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Hover - Request hover information

fn register_completion_item_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Completion Item Provider - Register a completion provider

fn provide_completion_items<'life0, 'async_trait>( &'life0 self, request: Request<ProvideCompletionItemsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCompletionItemsResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Completion Items - Request completion items

fn register_definition_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Definition Provider - Register a definition provider

fn provide_definition<'life0, 'async_trait>( &'life0 self, request: Request<ProvideDefinitionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDefinitionResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Definition - Request definition location

fn register_reference_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Reference Provider - Register a reference provider

fn provide_references<'life0, 'async_trait>( &'life0 self, request: Request<ProvideReferencesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideReferencesResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide References - Request references

fn register_code_actions_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Code Actions Provider - Register code actions provider

fn provide_code_actions<'life0, 'async_trait>( &'life0 self, request: Request<ProvideCodeActionsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCodeActionsResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Code Actions - Request code actions

fn register_document_highlight_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Document Highlight Provider

fn provide_document_highlights<'life0, 'async_trait>( &'life0 self, request: Request<ProvideDocumentHighlightsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentHighlightsResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Document Highlights

fn register_document_symbol_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Document Symbol Provider

fn provide_document_symbols<'life0, 'async_trait>( &'life0 self, request: Request<ProvideDocumentSymbolsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentSymbolsResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Document Symbols

fn register_workspace_symbol_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Workspace Symbol Provider

fn provide_workspace_symbols<'life0, 'async_trait>( &'life0 self, request: Request<ProvideWorkspaceSymbolsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideWorkspaceSymbolsResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Workspace Symbols

fn register_rename_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Rename Provider

fn provide_rename_edits<'life0, 'async_trait>( &'life0 self, request: Request<ProvideRenameEditsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideRenameEditsResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Rename Edits

fn register_document_formatting_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Document Formatting Provider

fn provide_document_formatting<'life0, 'async_trait>( &'life0 self, request: Request<ProvideDocumentFormattingRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentFormattingResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Document Formatting

fn register_document_range_formatting_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Document Range Formatting Provider

fn provide_document_range_formatting<'life0, 'async_trait>( &'life0 self, request: Request<ProvideDocumentRangeFormattingRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideDocumentRangeFormattingResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Document Range Formatting

fn register_on_type_formatting_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterOnTypeFormattingProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register On Type Formatting Provider

fn provide_on_type_formatting<'life0, 'async_trait>( &'life0 self, request: Request<ProvideOnTypeFormattingRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideOnTypeFormattingResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide On Type Formatting

fn register_signature_help_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterSignatureHelpProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Signature Help Provider

fn provide_signature_help<'life0, 'async_trait>( &'life0 self, request: Request<ProvideSignatureHelpRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideSignatureHelpResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Signature Help

fn register_code_lens_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Code Lens Provider

fn provide_code_lenses<'life0, 'async_trait>( &'life0 self, request: Request<ProvideCodeLensesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCodeLensesResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Code Lenses

fn register_folding_range_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Folding Range Provider

fn provide_folding_ranges<'life0, 'async_trait>( &'life0 self, request: Request<ProvideFoldingRangesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideFoldingRangesResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Folding Ranges

fn register_selection_range_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Selection Range Provider

fn provide_selection_ranges<'life0, 'async_trait>( &'life0 self, request: Request<ProvideSelectionRangesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideSelectionRangesResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Selection Ranges

fn register_semantic_tokens_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterSemanticTokensProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Semantic Tokens Provider

fn provide_semantic_tokens_full<'life0, 'async_trait>( &'life0 self, request: Request<ProvideSemanticTokensRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideSemanticTokensResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Semantic Tokens Full

fn register_inlay_hints_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Inlay Hints Provider

fn provide_inlay_hints<'life0, 'async_trait>( &'life0 self, request: Request<ProvideInlayHintsRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideInlayHintsResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Inlay Hints

fn register_type_hierarchy_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Type Hierarchy Provider

fn provide_type_hierarchy_supertypes<'life0, 'async_trait>( &'life0 self, request: Request<ProvideTypeHierarchyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideTypeHierarchyResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Type Hierarchy Supertypes

fn provide_type_hierarchy_subtypes<'life0, 'async_trait>( &'life0 self, request: Request<ProvideTypeHierarchyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideTypeHierarchyResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Type Hierarchy Subtypes

fn register_call_hierarchy_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Call Hierarchy Provider

fn provide_call_hierarchy_incoming_calls<'life0, 'async_trait>( &'life0 self, request: Request<ProvideCallHierarchyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCallHierarchyResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Call Hierarchy Incoming Calls

fn provide_call_hierarchy_outgoing_calls<'life0, 'async_trait>( &'life0 self, request: Request<ProvideCallHierarchyRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideCallHierarchyResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Call Hierarchy Outgoing Calls

fn register_linked_editing_range_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Linked Editing Range Provider

fn provide_linked_editing_ranges<'life0, 'async_trait>( &'life0 self, request: Request<ProvideLinkedEditingRangesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ProvideLinkedEditingRangesResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Provide Linked Editing Ranges

fn show_quick_pick<'life0, 'async_trait>( &'life0 self, request: Request<ShowQuickPickRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowQuickPickResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Show Quick Pick

fn show_input_box<'life0, 'async_trait>( &'life0 self, request: Request<ShowInputBoxRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowInputBoxResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Show Input Box

fn show_progress<'life0, 'async_trait>( &'life0 self, request: Request<ShowProgressRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowProgressResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Show Progress

fn report_progress<'life0, 'async_trait>( &'life0 self, request: Request<ReportProgressRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Report Progress

fn post_webview_message<'life0, 'async_trait>( &'life0 self, request: Request<PostWebviewMessageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Post Message to Webview

fn dispose_webview_panel<'life0, 'async_trait>( &'life0 self, request: Request<DisposeWebviewPanelRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Dispose Webview Panel

fn open_external<'life0, 'async_trait>( &'life0 self, request: Request<OpenExternalRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Open External URI

fn delete_file<'life0, 'async_trait>( &'life0 self, request: Request<DeleteFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete File

fn rename_file<'life0, 'async_trait>( &'life0 self, request: Request<RenameFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Rename File

fn copy_file<'life0, 'async_trait>( &'life0 self, request: Request<CopyFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Copy File

fn create_directory<'life0, 'async_trait>( &'life0 self, request: Request<CreateDirectoryRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create Directory

fn create_output_channel<'life0, 'async_trait>( &'life0 self, request: Request<CreateOutputChannelRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CreateOutputChannelResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create Output Channel

fn append_output<'life0, 'async_trait>( &'life0 self, request: Request<AppendOutputRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Append to Output Channel

fn clear_output<'life0, 'async_trait>( &'life0 self, request: Request<ClearOutputRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Clear Output Channel

fn show_output<'life0, 'async_trait>( &'life0 self, request: Request<ShowOutputRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Show Output Channel

fn dispose_output<'life0, 'async_trait>( &'life0 self, request: Request<DisposeOutputRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Dispose Output Channel

fn register_task_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterTaskProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Task Provider

fn execute_task<'life0, 'async_trait>( &'life0 self, request: Request<ExecuteTaskRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ExecuteTaskResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute Task

fn terminate_task<'life0, 'async_trait>( &'life0 self, request: Request<TerminateTaskRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Terminate Task

fn get_authentication_session<'life0, 'async_trait>( &'life0 self, request: Request<GetAuthenticationSessionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetAuthenticationSessionResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get Authentication Session

fn register_authentication_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterAuthenticationProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Authentication Provider

fn stop_debugging<'life0, 'async_trait>( &'life0 self, request: Request<StopDebuggingRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stop Debugging

fn get_extension<'life0, 'async_trait>( &'life0 self, request: Request<GetExtensionRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetExtensionResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get Extension

fn get_all_extensions<'life0, 'async_trait>( &'life0 self, request: Request<Empty>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetAllExtensionsResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get All Extensions

fn resize_terminal<'life0, 'async_trait>( &'life0 self, request: Request<ResizeTerminalRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Resize Terminal

fn get_configuration<'life0, 'async_trait>( &'life0 self, request: Request<GetConfigurationRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetConfigurationResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get Configuration Value

fn show_text_document<'life0, 'async_trait>( &'life0 self, request: Request<ShowTextDocumentRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowTextDocumentResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Show Text Document - Open a text document

fn show_information_message<'life0, 'async_trait>( &'life0 self, request: Request<ShowMessageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowMessageResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Show Information Message - Display an info message

fn show_warning_message<'life0, 'async_trait>( &'life0 self, request: Request<ShowMessageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowMessageResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Show Warning Message - Display a warning message

fn show_error_message<'life0, 'async_trait>( &'life0 self, request: Request<ShowMessageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ShowMessageResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Show Error Message - Display an error message

fn create_status_bar_item<'life0, 'async_trait>( &'life0 self, request: Request<CreateStatusBarItemRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CreateStatusBarItemResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create Status Bar Item - Create a status bar item

fn set_status_bar_text<'life0, 'async_trait>( &'life0 self, request: Request<SetStatusBarTextRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set Status Bar Text - Set status bar text

fn create_webview_panel<'life0, 'async_trait>( &'life0 self, request: Request<CreateWebviewPanelRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<CreateWebviewPanelResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create Webview Panel - Create a new webview panel

fn set_webview_html<'life0, 'async_trait>( &'life0 self, request: Request<SetWebviewHtmlRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set Webview HTML - Update webview HTML content

fn on_did_receive_message<'life0, 'async_trait>( &'life0 self, request: Request<OnDidReceiveMessageRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

On Did Receive Message - Receive message from webview

fn read_file<'life0, 'async_trait>( &'life0 self, request: Request<ReadFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ReadFileResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read File - Read file contents

fn write_file<'life0, 'async_trait>( &'life0 self, request: Request<WriteFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Write File - Write file contents

fn stat<'life0, 'async_trait>( &'life0 self, request: Request<StatRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<StatResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Stat - Get file metadata

fn readdir<'life0, 'async_trait>( &'life0 self, request: Request<ReaddirRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ReaddirResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read Directory - List directory contents

fn watch_file<'life0, 'async_trait>( &'life0 self, request: Request<WatchFileRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Watch File - Watch file for changes

fn find_files<'life0, 'async_trait>( &'life0 self, request: Request<FindFilesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<FindFilesResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Find Files - Search for files

fn find_text_in_files<'life0, 'async_trait>( &'life0 self, request: Request<FindTextInFilesRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<FindTextInFilesResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Find Text in Files - Search for text across files

fn open_document<'life0, 'async_trait>( &'life0 self, request: Request<OpenDocumentRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<OpenDocumentResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Open Document - Open a document

fn save_all<'life0, 'async_trait>( &'life0 self, request: Request<SaveAllRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<SaveAllResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Save All - Save all open documents

fn apply_edit<'life0, 'async_trait>( &'life0 self, request: Request<ApplyEditRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ApplyEditResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Apply Edit - Apply a text edit to a document

fn update_configuration<'life0, 'async_trait>( &'life0 self, request: Request<UpdateConfigurationRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Update Configuration - Notify of configuration changes

fn update_workspace_folders<'life0, 'async_trait>( &'life0 self, request: Request<UpdateWorkspaceFoldersRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Update Workspace Folders - Update workspace folders

fn open_terminal<'life0, 'async_trait>( &'life0 self, request: Request<OpenTerminalRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Open Terminal - Open a new terminal

fn terminal_input<'life0, 'async_trait>( &'life0 self, request: Request<TerminalInputRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Terminal Input - Send input to terminal

fn close_terminal<'life0, 'async_trait>( &'life0 self, request: Request<CloseTerminalRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Close Terminal - Close a terminal

fn accept_terminal_opened<'life0, 'async_trait>( &'life0 self, request: Request<TerminalOpenedNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Accept Terminal Opened - Notification: Terminal opened

fn accept_terminal_closed<'life0, 'async_trait>( &'life0 self, request: Request<TerminalClosedNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Accept Terminal Closed - Notification: Terminal closed

fn accept_terminal_process_id<'life0, 'async_trait>( &'life0 self, request: Request<TerminalProcessIdNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Accept Terminal Process ID - Notification: Terminal process ID

fn accept_terminal_process_data<'life0, 'async_trait>( &'life0 self, request: Request<TerminalDataNotification>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Accept Terminal Process Data - Notification: Terminal output

fn register_tree_view_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterTreeViewProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Tree View Provider - Register a tree view provider

fn get_tree_children<'life0, 'async_trait>( &'life0 self, request: Request<GetTreeChildrenRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetTreeChildrenResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get Tree Children - Request tree view children

fn register_scm_provider<'life0, 'async_trait>( &'life0 self, request: Request<RegisterScmProviderRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register SCM Provider - Register source control provider

fn update_scm_group<'life0, 'async_trait>( &'life0 self, request: Request<UpdateScmGroupRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Update SCM Group - Update SCM group

fn git_exec<'life0, 'async_trait>( &'life0 self, request: Request<GitExecRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GitExecResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Execute Git - Execute git command

fn register_debug_adapter<'life0, 'async_trait>( &'life0 self, request: Request<RegisterDebugAdapterRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Register Debug Adapter - Register debug adapter

fn start_debugging<'life0, 'async_trait>( &'life0 self, request: Request<StartDebuggingRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<StartDebuggingResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Start Debugging - Start debug session

fn participate_in_save<'life0, 'async_trait>( &'life0 self, request: Request<ParticipateInSaveRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<ParticipateInSaveResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Participate in Save - Extension participates in save

fn get_secret<'life0, 'async_trait>( &'life0 self, request: Request<GetSecretRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<GetSecretResponse>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get Secret - Retrieve a secret from storage

fn store_secret<'life0, 'async_trait>( &'life0 self, request: Request<StoreSecretRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Store Secret - Store a secret in storage

fn delete_secret<'life0, 'async_trait>( &'life0 self, request: Request<DeleteSecretRequest>, ) -> Pin<Box<dyn Future<Output = Result<Response<Empty>, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Delete Secret - Delete a secret from storage

Implementors

impl CocoonService for CocoonServiceImpl

type OpenChannelFromMountainStream = Pin<Box<dyn Stream<Item = Result<Envelope, Status>> + Send>>