@lspeasy/core 1.0.1

package/dist/protocol/namespaces.d.ts

@@ -0,0 +1,1432 @@
+/**
+ * LSP Request and Notification namespaces
+ * Auto-generated from metaModel.json
+ *
+ * DO NOT EDIT MANUALLY
+ */
+import type * as LSP from './types.js';
+/** LSP Request type definitions organized by namespace */
+export type LSPRequest = {
+    CallHierarchy: {
+        IncomingCalls: {
+            Method: 'callHierarchy/incomingCalls';
+            Params: LSP.CallHierarchyIncomingCallsParams;
+            Result: LSP.CallHierarchyIncomingCall[] | null;
+            PartialResult: LSP.CallHierarchyIncomingCall[];
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        OutgoingCalls: {
+            Method: 'callHierarchy/outgoingCalls';
+            Params: LSP.CallHierarchyOutgoingCallsParams;
+            Result: LSP.CallHierarchyOutgoingCall[] | null;
+            PartialResult: LSP.CallHierarchyOutgoingCall[];
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+    };
+    Client: {
+        Registration: {
+            Method: 'client/registerCapability';
+            Params: LSP.RegistrationParams;
+            Result: null;
+            Direction: 'serverToClient';
+        };
+        Unregistration: {
+            Method: 'client/unregisterCapability';
+            Params: LSP.UnregistrationParams;
+            Result: null;
+            Direction: 'serverToClient';
+        };
+    };
+    CodeAction: {
+        Resolve: {
+            Method: 'codeAction/resolve';
+            Params: LSP.CodeAction;
+            Result: LSP.CodeAction;
+            ServerCapability: 'codeActionProvider.resolveProvider';
+            ClientCapability: 'textDocument.codeAction.resolveSupport';
+            Direction: 'clientToServer';
+        };
+    };
+    CodeLens: {
+        Resolve: {
+            Method: 'codeLens/resolve';
+            Params: LSP.CodeLens;
+            Result: LSP.CodeLens;
+            ServerCapability: 'codeLensProvider.resolveProvider';
+            ClientCapability: 'textDocument.codeLens.resolveSupport';
+            Direction: 'clientToServer';
+        };
+    };
+    CompletionItem: {
+        CompletionResolve: {
+            Method: 'completionItem/resolve';
+            Params: LSP.CompletionItem;
+            Result: LSP.CompletionItem;
+            ServerCapability: 'completionProvider.resolveProvider';
+            ClientCapability: 'textDocument.completion.completionItem.resolveSupport';
+            Direction: 'clientToServer';
+        };
+    };
+    DocumentLink: {
+        Resolve: {
+            Method: 'documentLink/resolve';
+            Params: LSP.DocumentLink;
+            Result: LSP.DocumentLink;
+            ServerCapability: 'documentLinkProvider.resolveProvider';
+            ClientCapability: 'textDocument.documentLink';
+            Direction: 'clientToServer';
+        };
+    };
+    InlayHint: {
+        Resolve: {
+            Method: 'inlayHint/resolve';
+            Params: LSP.InlayHint;
+            Result: LSP.InlayHint;
+            ServerCapability: 'inlayHintProvider.resolveProvider';
+            ClientCapability: 'textDocument.inlayHint.resolveSupport';
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+    };
+    Lifecycle: {
+        Initialize: {
+            Method: 'initialize';
+            Params: LSP.InitializeParams;
+            Result: LSP.InitializeResult;
+            ErrorData: LSP.InitializeError;
+            Direction: 'clientToServer';
+        };
+        Shutdown: {
+            Method: 'shutdown';
+            Params: undefined;
+            Result: null;
+            Direction: 'clientToServer';
+        };
+    };
+    TextDocument: {
+        Implementation: {
+            Method: 'textDocument/implementation';
+            Params: LSP.ImplementationParams;
+            Result: LSP.Definition | LSP.DefinitionLink[] | null;
+            PartialResult: LSP.Location[] | LSP.DefinitionLink[];
+            RegistrationOptions: LSP.ImplementationRegistrationOptions;
+            ServerCapability: 'implementationProvider';
+            ClientCapability: 'textDocument.implementation';
+            Direction: 'clientToServer';
+        };
+        TypeDefinition: {
+            Method: 'textDocument/typeDefinition';
+            Params: LSP.TypeDefinitionParams;
+            Result: LSP.Definition | LSP.DefinitionLink[] | null;
+            PartialResult: LSP.Location[] | LSP.DefinitionLink[];
+            RegistrationOptions: LSP.TypeDefinitionRegistrationOptions;
+            ServerCapability: 'typeDefinitionProvider';
+            ClientCapability: 'textDocument.typeDefinition';
+            Direction: 'clientToServer';
+        };
+        DocumentColor: {
+            Method: 'textDocument/documentColor';
+            Params: LSP.DocumentColorParams;
+            Result: LSP.ColorInformation[];
+            PartialResult: LSP.ColorInformation[];
+            RegistrationOptions: LSP.DocumentColorRegistrationOptions;
+            ServerCapability: 'colorProvider';
+            ClientCapability: 'textDocument.colorProvider';
+            Direction: 'clientToServer';
+        };
+        ColorPresentation: {
+            Method: 'textDocument/colorPresentation';
+            Params: LSP.ColorPresentationParams;
+            Result: LSP.ColorPresentation[];
+            PartialResult: LSP.ColorPresentation[];
+            RegistrationOptions: LSP.WorkDoneProgressOptions & LSP.TextDocumentRegistrationOptions;
+            ServerCapability: 'colorProvider';
+            ClientCapability: 'textDocument.colorProvider';
+            Direction: 'clientToServer';
+        };
+        FoldingRange: {
+            Method: 'textDocument/foldingRange';
+            Params: LSP.FoldingRangeParams;
+            Result: LSP.FoldingRange[] | null;
+            PartialResult: LSP.FoldingRange[];
+            RegistrationOptions: LSP.FoldingRangeRegistrationOptions;
+            ServerCapability: 'foldingRangeProvider';
+            ClientCapability: 'textDocument.foldingRange';
+            Direction: 'clientToServer';
+        };
+        Declaration: {
+            Method: 'textDocument/declaration';
+            Params: LSP.DeclarationParams;
+            Result: LSP.Declaration | LSP.DeclarationLink[] | null;
+            PartialResult: LSP.Location[] | LSP.DeclarationLink[];
+            RegistrationOptions: LSP.DeclarationRegistrationOptions;
+            ServerCapability: 'declarationProvider';
+            ClientCapability: 'textDocument.declaration';
+            Direction: 'clientToServer';
+        };
+        SelectionRange: {
+            Method: 'textDocument/selectionRange';
+            Params: LSP.SelectionRangeParams;
+            Result: LSP.SelectionRange[] | null;
+            PartialResult: LSP.SelectionRange[];
+            RegistrationOptions: LSP.SelectionRangeRegistrationOptions;
+            ServerCapability: 'selectionRangeProvider';
+            ClientCapability: 'textDocument.selectionRange';
+            Direction: 'clientToServer';
+        };
+        CallHierarchyPrepare: {
+            Method: 'textDocument/prepareCallHierarchy';
+            Params: LSP.CallHierarchyPrepareParams;
+            Result: LSP.CallHierarchyItem[] | null;
+            RegistrationOptions: LSP.CallHierarchyRegistrationOptions;
+            ServerCapability: 'callHierarchyProvider';
+            ClientCapability: 'textDocument.callHierarchy';
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        SemanticTokens: {
+            Method: 'textDocument/semanticTokens/full';
+            Params: LSP.SemanticTokensParams;
+            Result: LSP.SemanticTokens | null;
+            PartialResult: LSP.SemanticTokensPartialResult;
+            RegistrationOptions: LSP.SemanticTokensRegistrationOptions;
+            ServerCapability: 'semanticTokensProvider';
+            ClientCapability: 'textDocument.semanticTokens';
+            RegistrationMethod: 'textDocument/semanticTokens';
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        SemanticTokensDelta: {
+            Method: 'textDocument/semanticTokens/full/delta';
+            Params: LSP.SemanticTokensDeltaParams;
+            Result: LSP.SemanticTokens | LSP.SemanticTokensDelta | null;
+            PartialResult: LSP.SemanticTokensPartialResult | LSP.SemanticTokensDeltaPartialResult;
+            RegistrationOptions: LSP.SemanticTokensRegistrationOptions;
+            ServerCapability: 'semanticTokensProvider.full.delta';
+            ClientCapability: 'textDocument.semanticTokens.requests.full.delta';
+            RegistrationMethod: 'textDocument/semanticTokens';
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        SemanticTokensRange: {
+            Method: 'textDocument/semanticTokens/range';
+            Params: LSP.SemanticTokensRangeParams;
+            Result: LSP.SemanticTokens | null;
+            PartialResult: LSP.SemanticTokensPartialResult;
+            ServerCapability: 'semanticTokensProvider.range';
+            ClientCapability: 'textDocument.semanticTokens.requests.range';
+            RegistrationMethod: 'textDocument/semanticTokens';
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        LinkedEditingRange: {
+            Method: 'textDocument/linkedEditingRange';
+            Params: LSP.LinkedEditingRangeParams;
+            Result: LSP.LinkedEditingRanges | null;
+            RegistrationOptions: LSP.LinkedEditingRangeRegistrationOptions;
+            ServerCapability: 'linkedEditingRangeProvider';
+            ClientCapability: 'textDocument.linkedEditingRange';
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        Moniker: {
+            Method: 'textDocument/moniker';
+            Params: LSP.MonikerParams;
+            Result: LSP.Moniker[] | null;
+            PartialResult: LSP.Moniker[];
+            RegistrationOptions: LSP.MonikerRegistrationOptions;
+            ServerCapability: 'monikerProvider';
+            ClientCapability: 'textDocument.moniker';
+            Direction: 'clientToServer';
+        };
+        TypeHierarchyPrepare: {
+            Method: 'textDocument/prepareTypeHierarchy';
+            Params: LSP.TypeHierarchyPrepareParams;
+            Result: LSP.TypeHierarchyItem[] | null;
+            RegistrationOptions: LSP.TypeHierarchyRegistrationOptions;
+            ServerCapability: 'typeHierarchyProvider';
+            ClientCapability: 'textDocument.typeHierarchy';
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+        InlineValue: {
+            Method: 'textDocument/inlineValue';
+            Params: LSP.InlineValueParams;
+            Result: LSP.InlineValue[] | null;
+            PartialResult: LSP.InlineValue[];
+            RegistrationOptions: LSP.InlineValueRegistrationOptions;
+            ServerCapability: 'inlineValueProvider';
+            ClientCapability: 'textDocument.inlineValue';
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+        InlayHint: {
+            Method: 'textDocument/inlayHint';
+            Params: LSP.InlayHintParams;
+            Result: LSP.InlayHint[] | null;
+            PartialResult: LSP.InlayHint[];
+            RegistrationOptions: LSP.InlayHintRegistrationOptions;
+            ServerCapability: 'inlayHintProvider';
+            ClientCapability: 'textDocument.inlayHint';
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+        DocumentDiagnostic: {
+            Method: 'textDocument/diagnostic';
+            Params: LSP.DocumentDiagnosticParams;
+            Result: LSP.DocumentDiagnosticReport;
+            PartialResult: LSP.DocumentDiagnosticReportPartialResult;
+            RegistrationOptions: LSP.DiagnosticRegistrationOptions;
+            ErrorData: LSP.DiagnosticServerCancellationData;
+            ServerCapability: 'diagnosticProvider';
+            ClientCapability: 'textDocument.diagnostic';
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+        InlineCompletion: {
+            Method: 'textDocument/inlineCompletion';
+            Params: LSP.InlineCompletionParams;
+            Result: LSP.InlineCompletionList | LSP.InlineCompletionItem[] | null;
+            PartialResult: LSP.InlineCompletionItem[];
+            RegistrationOptions: LSP.InlineCompletionRegistrationOptions;
+            ServerCapability: 'inlineCompletionProvider';
+            ClientCapability: 'textDocument.inlineCompletion';
+            Since: '3.18.0';
+            Proposed: true;
+            Direction: 'clientToServer';
+        };
+        WillSaveTextDocumentWaitUntil: {
+            Method: 'textDocument/willSaveWaitUntil';
+            Params: LSP.WillSaveTextDocumentParams;
+            Result: LSP.TextEdit[] | null;
+            RegistrationOptions: LSP.TextDocumentRegistrationOptions;
+            ServerCapability: 'textDocumentSync.willSaveWaitUntil';
+            ClientCapability: 'textDocument.synchronization.willSaveWaitUntil';
+            Direction: 'clientToServer';
+        };
+        Completion: {
+            Method: 'textDocument/completion';
+            Params: LSP.CompletionParams;
+            Result: LSP.CompletionItem[] | LSP.CompletionList | null;
+            PartialResult: LSP.CompletionItem[];
+            RegistrationOptions: LSP.CompletionRegistrationOptions;
+            ServerCapability: 'completionProvider';
+            ClientCapability: 'textDocument.completion';
+            Direction: 'clientToServer';
+        };
+        Hover: {
+            Method: 'textDocument/hover';
+            Params: LSP.HoverParams;
+            Result: LSP.Hover | null;
+            RegistrationOptions: LSP.HoverRegistrationOptions;
+            ServerCapability: 'hoverProvider';
+            ClientCapability: 'textDocument.hover';
+            Direction: 'clientToServer';
+        };
+        SignatureHelp: {
+            Method: 'textDocument/signatureHelp';
+            Params: LSP.SignatureHelpParams;
+            Result: LSP.SignatureHelp | null;
+            RegistrationOptions: LSP.SignatureHelpRegistrationOptions;
+            ServerCapability: 'signatureHelpProvider';
+            ClientCapability: 'textDocument.signatureHelp';
+            Direction: 'clientToServer';
+        };
+        Definition: {
+            Method: 'textDocument/definition';
+            Params: LSP.DefinitionParams;
+            Result: LSP.Definition | LSP.DefinitionLink[] | null;
+            PartialResult: LSP.Location[] | LSP.DefinitionLink[];
+            RegistrationOptions: LSP.DefinitionRegistrationOptions;
+            ServerCapability: 'definitionProvider';
+            ClientCapability: 'textDocument.definition';
+            Direction: 'clientToServer';
+        };
+        References: {
+            Method: 'textDocument/references';
+            Params: LSP.ReferenceParams;
+            Result: LSP.Location[] | null;
+            PartialResult: LSP.Location[];
+            RegistrationOptions: LSP.ReferenceRegistrationOptions;
+            ServerCapability: 'referencesProvider';
+            ClientCapability: 'textDocument.references';
+            Direction: 'clientToServer';
+        };
+        DocumentHighlight: {
+            Method: 'textDocument/documentHighlight';
+            Params: LSP.DocumentHighlightParams;
+            Result: LSP.DocumentHighlight[] | null;
+            PartialResult: LSP.DocumentHighlight[];
+            RegistrationOptions: LSP.DocumentHighlightRegistrationOptions;
+            ServerCapability: 'documentHighlightProvider';
+            ClientCapability: 'textDocument.documentHighlight';
+            Direction: 'clientToServer';
+        };
+        DocumentSymbol: {
+            Method: 'textDocument/documentSymbol';
+            Params: LSP.DocumentSymbolParams;
+            Result: LSP.SymbolInformation[] | LSP.DocumentSymbol[] | null;
+            PartialResult: LSP.SymbolInformation[] | LSP.DocumentSymbol[];
+            RegistrationOptions: LSP.DocumentSymbolRegistrationOptions;
+            ServerCapability: 'documentSymbolProvider';
+            ClientCapability: 'textDocument.documentSymbol';
+            Direction: 'clientToServer';
+        };
+        CodeAction: {
+            Method: 'textDocument/codeAction';
+            Params: LSP.CodeActionParams;
+            Result: LSP.Command | LSP.CodeAction[] | null;
+            PartialResult: LSP.Command | LSP.CodeAction[];
+            RegistrationOptions: LSP.CodeActionRegistrationOptions;
+            ServerCapability: 'codeActionProvider';
+            ClientCapability: 'textDocument.codeAction';
+            Direction: 'clientToServer';
+        };
+        CodeLens: {
+            Method: 'textDocument/codeLens';
+            Params: LSP.CodeLensParams;
+            Result: LSP.CodeLens[] | null;
+            PartialResult: LSP.CodeLens[];
+            RegistrationOptions: LSP.CodeLensRegistrationOptions;
+            ServerCapability: 'codeLensProvider';
+            ClientCapability: 'textDocument.codeLens';
+            Direction: 'clientToServer';
+        };
+        DocumentLink: {
+            Method: 'textDocument/documentLink';
+            Params: LSP.DocumentLinkParams;
+            Result: LSP.DocumentLink[] | null;
+            PartialResult: LSP.DocumentLink[];
+            RegistrationOptions: LSP.DocumentLinkRegistrationOptions;
+            ServerCapability: 'documentLinkProvider';
+            ClientCapability: 'textDocument.documentLink';
+            Direction: 'clientToServer';
+        };
+        DocumentFormatting: {
+            Method: 'textDocument/formatting';
+            Params: LSP.DocumentFormattingParams;
+            Result: LSP.TextEdit[] | null;
+            RegistrationOptions: LSP.DocumentFormattingRegistrationOptions;
+            ServerCapability: 'documentFormattingProvider';
+            ClientCapability: 'textDocument.formatting';
+            Direction: 'clientToServer';
+        };
+        DocumentRangeFormatting: {
+            Method: 'textDocument/rangeFormatting';
+            Params: LSP.DocumentRangeFormattingParams;
+            Result: LSP.TextEdit[] | null;
+            RegistrationOptions: LSP.DocumentRangeFormattingRegistrationOptions;
+            ServerCapability: 'documentRangeFormattingProvider';
+            ClientCapability: 'textDocument.rangeFormatting';
+            Direction: 'clientToServer';
+        };
+        DocumentRangesFormatting: {
+            Method: 'textDocument/rangesFormatting';
+            Params: LSP.DocumentRangesFormattingParams;
+            Result: LSP.TextEdit[] | null;
+            RegistrationOptions: LSP.DocumentRangeFormattingRegistrationOptions;
+            ServerCapability: 'documentRangeFormattingProvider.rangesSupport';
+            ClientCapability: 'textDocument.rangeFormatting.rangesSupport';
+            Since: '3.18.0';
+            Proposed: true;
+            Direction: 'clientToServer';
+        };
+        DocumentOnTypeFormatting: {
+            Method: 'textDocument/onTypeFormatting';
+            Params: LSP.DocumentOnTypeFormattingParams;
+            Result: LSP.TextEdit[] | null;
+            RegistrationOptions: LSP.DocumentOnTypeFormattingRegistrationOptions;
+            ServerCapability: 'documentOnTypeFormattingProvider';
+            ClientCapability: 'textDocument.onTypeFormatting';
+            Direction: 'clientToServer';
+        };
+        Rename: {
+            Method: 'textDocument/rename';
+            Params: LSP.RenameParams;
+            Result: LSP.WorkspaceEdit | null;
+            RegistrationOptions: LSP.RenameRegistrationOptions;
+            ServerCapability: 'renameProvider';
+            ClientCapability: 'textDocument.rename';
+            Direction: 'clientToServer';
+        };
+        PrepareRename: {
+            Method: 'textDocument/prepareRename';
+            Params: LSP.PrepareRenameParams;
+            Result: LSP.PrepareRenameResult | null;
+            ServerCapability: 'renameProvider.prepareProvider';
+            ClientCapability: 'textDocument.rename.prepareSupport';
+            Since: '3.16';
+            Direction: 'clientToServer';
+        };
+    };
+    TypeHierarchy: {
+        Supertypes: {
+            Method: 'typeHierarchy/supertypes';
+            Params: LSP.TypeHierarchySupertypesParams;
+            Result: LSP.TypeHierarchyItem[] | null;
+            PartialResult: LSP.TypeHierarchyItem[];
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+        Subtypes: {
+            Method: 'typeHierarchy/subtypes';
+            Params: LSP.TypeHierarchySubtypesParams;
+            Result: LSP.TypeHierarchyItem[] | null;
+            PartialResult: LSP.TypeHierarchyItem[];
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+    };
+    Window: {
+        WorkDoneProgressCreate: {
+            Method: 'window/workDoneProgress/create';
+            Params: LSP.WorkDoneProgressCreateParams;
+            Result: null;
+            ClientCapability: 'window.workDoneProgress';
+            Direction: 'serverToClient';
+        };
+        ShowDocument: {
+            Method: 'window/showDocument';
+            Params: LSP.ShowDocumentParams;
+            Result: LSP.ShowDocumentResult;
+            ClientCapability: 'window.showDocument.support';
+            Since: '3.16.0';
+            Direction: 'serverToClient';
+        };
+        ShowMessage: {
+            Method: 'window/showMessageRequest';
+            Params: LSP.ShowMessageRequestParams;
+            Result: LSP.MessageActionItem | null;
+            ClientCapability: 'window.showMessage';
+            Direction: 'serverToClient';
+        };
+    };
+    Workspace: {
+        WillCreateFiles: {
+            Method: 'workspace/willCreateFiles';
+            Params: LSP.CreateFilesParams;
+            Result: LSP.WorkspaceEdit | null;
+            RegistrationOptions: LSP.FileOperationRegistrationOptions;
+            ServerCapability: 'workspace.fileOperations.willCreate';
+            ClientCapability: 'workspace.fileOperations.willCreate';
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        WillRenameFiles: {
+            Method: 'workspace/willRenameFiles';
+            Params: LSP.RenameFilesParams;
+            Result: LSP.WorkspaceEdit | null;
+            RegistrationOptions: LSP.FileOperationRegistrationOptions;
+            ServerCapability: 'workspace.fileOperations.willRename';
+            ClientCapability: 'workspace.fileOperations.willRename';
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        WillDeleteFiles: {
+            Method: 'workspace/willDeleteFiles';
+            Params: LSP.DeleteFilesParams;
+            Result: LSP.WorkspaceEdit | null;
+            RegistrationOptions: LSP.FileOperationRegistrationOptions;
+            ServerCapability: 'workspace.fileOperations.willDelete';
+            ClientCapability: 'workspace.fileOperations.willDelete';
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        Diagnostic: {
+            Method: 'workspace/diagnostic';
+            Params: LSP.WorkspaceDiagnosticParams;
+            Result: LSP.WorkspaceDiagnosticReport;
+            PartialResult: LSP.WorkspaceDiagnosticReportPartialResult;
+            ErrorData: LSP.DiagnosticServerCancellationData;
+            ServerCapability: 'diagnosticProvider.workspaceDiagnostics';
+            ClientCapability: 'workspace.diagnostics';
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+        TextDocumentContent: {
+            Method: 'workspace/textDocumentContent';
+            Params: LSP.TextDocumentContentParams;
+            Result: LSP.TextDocumentContentResult;
+            RegistrationOptions: LSP.TextDocumentContentRegistrationOptions;
+            ServerCapability: 'workspace.textDocumentContent';
+            ClientCapability: 'workspace.textDocumentContent';
+            Since: '3.18.0';
+            Proposed: true;
+            Direction: 'clientToServer';
+        };
+        Symbol: {
+            Method: 'workspace/symbol';
+            Params: LSP.WorkspaceSymbolParams;
+            Result: LSP.SymbolInformation[] | LSP.WorkspaceSymbol[] | null;
+            PartialResult: LSP.SymbolInformation[] | LSP.WorkspaceSymbol[];
+            RegistrationOptions: LSP.WorkspaceSymbolRegistrationOptions;
+            ServerCapability: 'workspaceSymbolProvider';
+            ClientCapability: 'workspace.symbol';
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+        ExecuteCommand: {
+            Method: 'workspace/executeCommand';
+            Params: LSP.ExecuteCommandParams;
+            Result: LSP.LSPAny | null;
+            RegistrationOptions: LSP.ExecuteCommandRegistrationOptions;
+            ServerCapability: 'executeCommandProvider';
+            ClientCapability: 'workspace.executeCommand';
+            Direction: 'clientToServer';
+        };
+        Folders: {
+            Method: 'workspace/workspaceFolders';
+            Params: undefined;
+            Result: LSP.WorkspaceFolder[] | null;
+            ServerCapability: 'workspace.workspaceFolders';
+            ClientCapability: 'workspace.workspaceFolders';
+            Direction: 'serverToClient';
+        };
+        Configuration: {
+            Method: 'workspace/configuration';
+            Params: LSP.ConfigurationParams;
+            Result: LSP.LSPAny[];
+            ClientCapability: 'workspace.configuration';
+            Direction: 'serverToClient';
+        };
+        FoldingRangeRefresh: {
+            Method: 'workspace/foldingRange/refresh';
+            Params: undefined;
+            Result: null;
+            ClientCapability: 'workspace.foldingRange.refreshSupport';
+            Since: '3.18.0';
+            Proposed: true;
+            Direction: 'serverToClient';
+        };
+        SemanticTokensRefresh: {
+            Method: 'workspace/semanticTokens/refresh';
+            Params: undefined;
+            Result: null;
+            ClientCapability: 'workspace.semanticTokens.refreshSupport';
+            Since: '3.16.0';
+            Direction: 'serverToClient';
+        };
+        InlineValueRefresh: {
+            Method: 'workspace/inlineValue/refresh';
+            Params: undefined;
+            Result: null;
+            ClientCapability: 'workspace.inlineValue.refreshSupport';
+            Since: '3.17.0';
+            Direction: 'serverToClient';
+        };
+        InlayHintRefresh: {
+            Method: 'workspace/inlayHint/refresh';
+            Params: undefined;
+            Result: null;
+            ClientCapability: 'workspace.inlayHint.refreshSupport';
+            Since: '3.17.0';
+            Direction: 'serverToClient';
+        };
+        DiagnosticRefresh: {
+            Method: 'workspace/diagnostic/refresh';
+            Params: undefined;
+            Result: null;
+            ClientCapability: 'workspace.diagnostics.refreshSupport';
+            Since: '3.17.0';
+            Direction: 'serverToClient';
+        };
+        TextDocumentContentRefresh: {
+            Method: 'workspace/textDocumentContent/refresh';
+            Params: LSP.TextDocumentContentRefreshParams;
+            Result: null;
+            Since: '3.18.0';
+            Proposed: true;
+            Direction: 'serverToClient';
+        };
+        CodeLensRefresh: {
+            Method: 'workspace/codeLens/refresh';
+            Params: undefined;
+            Result: null;
+            ClientCapability: 'workspace.codeLens';
+            Since: '3.16.0';
+            Direction: 'serverToClient';
+        };
+        ApplyWorkspaceEdit: {
+            Method: 'workspace/applyEdit';
+            Params: LSP.ApplyWorkspaceEditParams;
+            Result: LSP.ApplyWorkspaceEditResult;
+            ClientCapability: 'workspace.applyEdit';
+            Direction: 'serverToClient';
+        };
+    };
+    WorkspaceSymbol: {
+        Resolve: {
+            Method: 'workspaceSymbol/resolve';
+            Params: LSP.WorkspaceSymbol;
+            Result: LSP.WorkspaceSymbol;
+            ServerCapability: 'workspaceSymbolProvider.resolveProvider';
+            ClientCapability: 'workspace.symbol.resolveSupport';
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+    };
+};
+/** LSP Notification type definitions organized by namespace */
+export type LSPNotification = {
+    General: {
+        Cancel: {
+            Method: '$/cancelRequest';
+            Params: LSP.CancelParams;
+            Direction: 'both';
+        };
+        Progress: {
+            Method: '$/progress';
+            Params: LSP.ProgressParams;
+            Direction: 'both';
+        };
+        SetTrace: {
+            Method: '$/setTrace';
+            Params: LSP.SetTraceParams;
+            Direction: 'clientToServer';
+        };
+        LogTrace: {
+            Method: '$/logTrace';
+            Params: LSP.LogTraceParams;
+            Direction: 'serverToClient';
+        };
+    };
+    Lifecycle: {
+        Initialized: {
+            Method: 'initialized';
+            Params: LSP.InitializedParams;
+            Direction: 'clientToServer';
+        };
+        Exit: {
+            Method: 'exit';
+            Params: undefined;
+            Direction: 'clientToServer';
+        };
+    };
+    NotebookDocument: {
+        DidOpenNotebookDocument: {
+            Method: 'notebookDocument/didOpen';
+            Params: LSP.DidOpenNotebookDocumentParams;
+            RegistrationMethod: 'notebookDocument/sync';
+            RegistrationOptions: LSP.NotebookDocumentSyncRegistrationOptions;
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+        DidChangeNotebookDocument: {
+            Method: 'notebookDocument/didChange';
+            Params: LSP.DidChangeNotebookDocumentParams;
+            RegistrationMethod: 'notebookDocument/sync';
+            RegistrationOptions: LSP.NotebookDocumentSyncRegistrationOptions;
+            Direction: 'clientToServer';
+        };
+        DidSaveNotebookDocument: {
+            Method: 'notebookDocument/didSave';
+            Params: LSP.DidSaveNotebookDocumentParams;
+            RegistrationMethod: 'notebookDocument/sync';
+            RegistrationOptions: LSP.NotebookDocumentSyncRegistrationOptions;
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+        DidCloseNotebookDocument: {
+            Method: 'notebookDocument/didClose';
+            Params: LSP.DidCloseNotebookDocumentParams;
+            RegistrationMethod: 'notebookDocument/sync';
+            RegistrationOptions: LSP.NotebookDocumentSyncRegistrationOptions;
+            Since: '3.17.0';
+            Direction: 'clientToServer';
+        };
+    };
+    Telemetry: {
+        Event: {
+            Method: 'telemetry/event';
+            Params: LSP.LSPAny;
+            Direction: 'serverToClient';
+        };
+    };
+    TextDocument: {
+        DidOpenTextDocument: {
+            Method: 'textDocument/didOpen';
+            Params: LSP.DidOpenTextDocumentParams;
+            ClientCapability: 'textDocument.synchronization';
+            ServerCapability: 'textDocumentSync.openClose';
+            RegistrationOptions: LSP.TextDocumentRegistrationOptions;
+            Direction: 'clientToServer';
+        };
+        DidChangeTextDocument: {
+            Method: 'textDocument/didChange';
+            Params: LSP.DidChangeTextDocumentParams;
+            ClientCapability: 'textDocument.synchronization';
+            ServerCapability: 'textDocumentSync';
+            RegistrationOptions: LSP.TextDocumentChangeRegistrationOptions;
+            Direction: 'clientToServer';
+        };
+        DidCloseTextDocument: {
+            Method: 'textDocument/didClose';
+            Params: LSP.DidCloseTextDocumentParams;
+            ClientCapability: 'textDocument.synchronization';
+            ServerCapability: 'textDocumentSync.openClose';
+            RegistrationOptions: LSP.TextDocumentRegistrationOptions;
+            Direction: 'clientToServer';
+        };
+        DidSaveTextDocument: {
+            Method: 'textDocument/didSave';
+            Params: LSP.DidSaveTextDocumentParams;
+            ClientCapability: 'textDocument.synchronization.didSave';
+            ServerCapability: 'textDocumentSync.save';
+            RegistrationOptions: LSP.TextDocumentSaveRegistrationOptions;
+            Direction: 'clientToServer';
+        };
+        WillSaveTextDocument: {
+            Method: 'textDocument/willSave';
+            Params: LSP.WillSaveTextDocumentParams;
+            ClientCapability: 'textDocument.synchronization.willSave';
+            ServerCapability: 'textDocumentSync.willSave';
+            RegistrationOptions: LSP.TextDocumentRegistrationOptions;
+            Direction: 'clientToServer';
+        };
+        PublishDiagnostics: {
+            Method: 'textDocument/publishDiagnostics';
+            Params: LSP.PublishDiagnosticsParams;
+            ClientCapability: 'textDocument.publishDiagnostics';
+            Direction: 'serverToClient';
+        };
+    };
+    Window: {
+        WorkDoneProgressCancel: {
+            Method: 'window/workDoneProgress/cancel';
+            Params: LSP.WorkDoneProgressCancelParams;
+            Direction: 'clientToServer';
+        };
+        ShowMessage: {
+            Method: 'window/showMessage';
+            Params: LSP.ShowMessageParams;
+            ClientCapability: 'window.showMessage';
+            Direction: 'serverToClient';
+        };
+        LogMessage: {
+            Method: 'window/logMessage';
+            Params: LSP.LogMessageParams;
+            Direction: 'serverToClient';
+        };
+    };
+    Workspace: {
+        DidChangeWorkspaceFolders: {
+            Method: 'workspace/didChangeWorkspaceFolders';
+            Params: LSP.DidChangeWorkspaceFoldersParams;
+            ServerCapability: 'workspace.workspaceFolders.changeNotifications';
+            Direction: 'clientToServer';
+        };
+        DidCreateFiles: {
+            Method: 'workspace/didCreateFiles';
+            Params: LSP.CreateFilesParams;
+            ClientCapability: 'workspace.fileOperations.didCreate';
+            ServerCapability: 'workspace.fileOperations.didCreate';
+            RegistrationOptions: LSP.FileOperationRegistrationOptions;
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        DidRenameFiles: {
+            Method: 'workspace/didRenameFiles';
+            Params: LSP.RenameFilesParams;
+            ClientCapability: 'workspace.fileOperations.didRename';
+            ServerCapability: 'workspace.fileOperations.didRename';
+            RegistrationOptions: LSP.FileOperationRegistrationOptions;
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        DidDeleteFiles: {
+            Method: 'workspace/didDeleteFiles';
+            Params: LSP.DeleteFilesParams;
+            ClientCapability: 'workspace.fileOperations.didDelete';
+            ServerCapability: 'workspace.fileOperations.didDelete';
+            RegistrationOptions: LSP.FileOperationRegistrationOptions;
+            Since: '3.16.0';
+            Direction: 'clientToServer';
+        };
+        DidChangeConfiguration: {
+            Method: 'workspace/didChangeConfiguration';
+            Params: LSP.DidChangeConfigurationParams;
+            ClientCapability: 'workspace.didChangeConfiguration';
+            RegistrationOptions: LSP.DidChangeConfigurationRegistrationOptions;
+            Direction: 'clientToServer';
+        };
+        DidChangeWatchedFiles: {
+            Method: 'workspace/didChangeWatchedFiles';
+            Params: LSP.DidChangeWatchedFilesParams;
+            ClientCapability: 'workspace.didChangeWatchedFiles';
+            RegistrationOptions: LSP.DidChangeWatchedFilesRegistrationOptions;
+            Direction: 'clientToServer';
+        };
+    };
+};
+/**
+ * LSP Request methods organized by namespace
+ * @deprecated Use individual namespace exports instead
+ */
+export declare const LSPRequest: {
+    readonly CallHierarchy: {
+        readonly IncomingCalls: {
+            readonly Method: "callHierarchy/incomingCalls";
+            readonly Direction: "clientToServer";
+        };
+        readonly OutgoingCalls: {
+            readonly Method: "callHierarchy/outgoingCalls";
+            readonly Direction: "clientToServer";
+        };
+    };
+    readonly Client: {
+        readonly Registration: {
+            readonly Method: "client/registerCapability";
+            readonly Direction: "serverToClient";
+        };
+        readonly Unregistration: {
+            readonly Method: "client/unregisterCapability";
+            readonly Direction: "serverToClient";
+        };
+    };
+    readonly CodeAction: {
+        readonly Resolve: {
+            readonly Method: "codeAction/resolve";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "codeActionProvider.resolveProvider";
+            readonly ClientCapability: "textDocument.codeAction.resolveSupport";
+        };
+    };
+    readonly CodeLens: {
+        readonly Resolve: {
+            readonly Method: "codeLens/resolve";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "codeLensProvider.resolveProvider";
+            readonly ClientCapability: "textDocument.codeLens.resolveSupport";
+        };
+    };
+    readonly CompletionItem: {
+        readonly CompletionResolve: {
+            readonly Method: "completionItem/resolve";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "completionProvider.resolveProvider";
+            readonly ClientCapability: "textDocument.completion.completionItem.resolveSupport";
+        };
+    };
+    readonly DocumentLink: {
+        readonly Resolve: {
+            readonly Method: "documentLink/resolve";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "documentLinkProvider.resolveProvider";
+            readonly ClientCapability: "textDocument.documentLink";
+        };
+    };
+    readonly InlayHint: {
+        readonly Resolve: {
+            readonly Method: "inlayHint/resolve";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "inlayHintProvider.resolveProvider";
+            readonly ClientCapability: "textDocument.inlayHint.resolveSupport";
+        };
+    };
+    readonly Lifecycle: {
+        readonly Initialize: {
+            readonly Method: "initialize";
+            readonly Direction: "clientToServer";
+        };
+        readonly Shutdown: {
+            readonly Method: "shutdown";
+            readonly Direction: "clientToServer";
+        };
+    };
+    readonly TextDocument: {
+        readonly Implementation: {
+            readonly Method: "textDocument/implementation";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "implementationProvider";
+            readonly ClientCapability: "textDocument.implementation";
+        };
+        readonly TypeDefinition: {
+            readonly Method: "textDocument/typeDefinition";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "typeDefinitionProvider";
+            readonly ClientCapability: "textDocument.typeDefinition";
+        };
+        readonly DocumentColor: {
+            readonly Method: "textDocument/documentColor";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "colorProvider";
+            readonly ClientCapability: "textDocument.colorProvider";
+        };
+        readonly ColorPresentation: {
+            readonly Method: "textDocument/colorPresentation";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "colorProvider";
+            readonly ClientCapability: "textDocument.colorProvider";
+        };
+        readonly FoldingRange: {
+            readonly Method: "textDocument/foldingRange";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "foldingRangeProvider";
+            readonly ClientCapability: "textDocument.foldingRange";
+        };
+        readonly Declaration: {
+            readonly Method: "textDocument/declaration";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "declarationProvider";
+            readonly ClientCapability: "textDocument.declaration";
+        };
+        readonly SelectionRange: {
+            readonly Method: "textDocument/selectionRange";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "selectionRangeProvider";
+            readonly ClientCapability: "textDocument.selectionRange";
+        };
+        readonly CallHierarchyPrepare: {
+            readonly Method: "textDocument/prepareCallHierarchy";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "callHierarchyProvider";
+            readonly ClientCapability: "textDocument.callHierarchy";
+        };
+        readonly SemanticTokens: {
+            readonly Method: "textDocument/semanticTokens/full";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "semanticTokensProvider";
+            readonly ClientCapability: "textDocument.semanticTokens";
+            readonly RegistrationMethod: "textDocument/semanticTokens";
+        };
+        readonly SemanticTokensDelta: {
+            readonly Method: "textDocument/semanticTokens/full/delta";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "semanticTokensProvider.full.delta";
+            readonly ClientCapability: "textDocument.semanticTokens.requests.full.delta";
+            readonly RegistrationMethod: "textDocument/semanticTokens";
+        };
+        readonly SemanticTokensRange: {
+            readonly Method: "textDocument/semanticTokens/range";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "semanticTokensProvider.range";
+            readonly ClientCapability: "textDocument.semanticTokens.requests.range";
+            readonly RegistrationMethod: "textDocument/semanticTokens";
+        };
+        readonly LinkedEditingRange: {
+            readonly Method: "textDocument/linkedEditingRange";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "linkedEditingRangeProvider";
+            readonly ClientCapability: "textDocument.linkedEditingRange";
+        };
+        readonly Moniker: {
+            readonly Method: "textDocument/moniker";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "monikerProvider";
+            readonly ClientCapability: "textDocument.moniker";
+        };
+        readonly TypeHierarchyPrepare: {
+            readonly Method: "textDocument/prepareTypeHierarchy";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "typeHierarchyProvider";
+            readonly ClientCapability: "textDocument.typeHierarchy";
+        };
+        readonly InlineValue: {
+            readonly Method: "textDocument/inlineValue";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "inlineValueProvider";
+            readonly ClientCapability: "textDocument.inlineValue";
+        };
+        readonly InlayHint: {
+            readonly Method: "textDocument/inlayHint";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "inlayHintProvider";
+            readonly ClientCapability: "textDocument.inlayHint";
+        };
+        readonly DocumentDiagnostic: {
+            readonly Method: "textDocument/diagnostic";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "diagnosticProvider";
+            readonly ClientCapability: "textDocument.diagnostic";
+        };
+        readonly InlineCompletion: {
+            readonly Method: "textDocument/inlineCompletion";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "inlineCompletionProvider";
+            readonly ClientCapability: "textDocument.inlineCompletion";
+        };
+        readonly WillSaveTextDocumentWaitUntil: {
+            readonly Method: "textDocument/willSaveWaitUntil";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "textDocumentSync.willSaveWaitUntil";
+            readonly ClientCapability: "textDocument.synchronization.willSaveWaitUntil";
+        };
+        readonly Completion: {
+            readonly Method: "textDocument/completion";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "completionProvider";
+            readonly ClientCapability: "textDocument.completion";
+        };
+        readonly Hover: {
+            readonly Method: "textDocument/hover";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "hoverProvider";
+            readonly ClientCapability: "textDocument.hover";
+        };
+        readonly SignatureHelp: {
+            readonly Method: "textDocument/signatureHelp";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "signatureHelpProvider";
+            readonly ClientCapability: "textDocument.signatureHelp";
+        };
+        readonly Definition: {
+            readonly Method: "textDocument/definition";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "definitionProvider";
+            readonly ClientCapability: "textDocument.definition";
+        };
+        readonly References: {
+            readonly Method: "textDocument/references";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "referencesProvider";
+            readonly ClientCapability: "textDocument.references";
+        };
+        readonly DocumentHighlight: {
+            readonly Method: "textDocument/documentHighlight";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "documentHighlightProvider";
+            readonly ClientCapability: "textDocument.documentHighlight";
+        };
+        readonly DocumentSymbol: {
+            readonly Method: "textDocument/documentSymbol";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "documentSymbolProvider";
+            readonly ClientCapability: "textDocument.documentSymbol";
+        };
+        readonly CodeAction: {
+            readonly Method: "textDocument/codeAction";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "codeActionProvider";
+            readonly ClientCapability: "textDocument.codeAction";
+        };
+        readonly CodeLens: {
+            readonly Method: "textDocument/codeLens";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "codeLensProvider";
+            readonly ClientCapability: "textDocument.codeLens";
+        };
+        readonly DocumentLink: {
+            readonly Method: "textDocument/documentLink";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "documentLinkProvider";
+            readonly ClientCapability: "textDocument.documentLink";
+        };
+        readonly DocumentFormatting: {
+            readonly Method: "textDocument/formatting";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "documentFormattingProvider";
+            readonly ClientCapability: "textDocument.formatting";
+        };
+        readonly DocumentRangeFormatting: {
+            readonly Method: "textDocument/rangeFormatting";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "documentRangeFormattingProvider";
+            readonly ClientCapability: "textDocument.rangeFormatting";
+        };
+        readonly DocumentRangesFormatting: {
+            readonly Method: "textDocument/rangesFormatting";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "documentRangeFormattingProvider.rangesSupport";
+            readonly ClientCapability: "textDocument.rangeFormatting.rangesSupport";
+        };
+        readonly DocumentOnTypeFormatting: {
+            readonly Method: "textDocument/onTypeFormatting";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "documentOnTypeFormattingProvider";
+            readonly ClientCapability: "textDocument.onTypeFormatting";
+        };
+        readonly Rename: {
+            readonly Method: "textDocument/rename";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "renameProvider";
+            readonly ClientCapability: "textDocument.rename";
+        };
+        readonly PrepareRename: {
+            readonly Method: "textDocument/prepareRename";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "renameProvider.prepareProvider";
+            readonly ClientCapability: "textDocument.rename.prepareSupport";
+        };
+    };
+    readonly TypeHierarchy: {
+        readonly Supertypes: {
+            readonly Method: "typeHierarchy/supertypes";
+            readonly Direction: "clientToServer";
+        };
+        readonly Subtypes: {
+            readonly Method: "typeHierarchy/subtypes";
+            readonly Direction: "clientToServer";
+        };
+    };
+    readonly Window: {
+        readonly WorkDoneProgressCreate: {
+            readonly Method: "window/workDoneProgress/create";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "window.workDoneProgress";
+        };
+        readonly ShowDocument: {
+            readonly Method: "window/showDocument";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "window.showDocument.support";
+        };
+        readonly ShowMessage: {
+            readonly Method: "window/showMessageRequest";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "window.showMessage";
+        };
+    };
+    readonly Workspace: {
+        readonly WillCreateFiles: {
+            readonly Method: "workspace/willCreateFiles";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "workspace.fileOperations.willCreate";
+            readonly ClientCapability: "workspace.fileOperations.willCreate";
+        };
+        readonly WillRenameFiles: {
+            readonly Method: "workspace/willRenameFiles";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "workspace.fileOperations.willRename";
+            readonly ClientCapability: "workspace.fileOperations.willRename";
+        };
+        readonly WillDeleteFiles: {
+            readonly Method: "workspace/willDeleteFiles";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "workspace.fileOperations.willDelete";
+            readonly ClientCapability: "workspace.fileOperations.willDelete";
+        };
+        readonly Diagnostic: {
+            readonly Method: "workspace/diagnostic";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "diagnosticProvider.workspaceDiagnostics";
+            readonly ClientCapability: "workspace.diagnostics";
+        };
+        readonly TextDocumentContent: {
+            readonly Method: "workspace/textDocumentContent";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "workspace.textDocumentContent";
+            readonly ClientCapability: "workspace.textDocumentContent";
+        };
+        readonly Symbol: {
+            readonly Method: "workspace/symbol";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "workspaceSymbolProvider";
+            readonly ClientCapability: "workspace.symbol";
+        };
+        readonly ExecuteCommand: {
+            readonly Method: "workspace/executeCommand";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "executeCommandProvider";
+            readonly ClientCapability: "workspace.executeCommand";
+        };
+        readonly Folders: {
+            readonly Method: "workspace/workspaceFolders";
+            readonly Direction: "serverToClient";
+            readonly ServerCapability: "workspace.workspaceFolders";
+            readonly ClientCapability: "workspace.workspaceFolders";
+        };
+        readonly Configuration: {
+            readonly Method: "workspace/configuration";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "workspace.configuration";
+        };
+        readonly FoldingRangeRefresh: {
+            readonly Method: "workspace/foldingRange/refresh";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "workspace.foldingRange.refreshSupport";
+        };
+        readonly SemanticTokensRefresh: {
+            readonly Method: "workspace/semanticTokens/refresh";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "workspace.semanticTokens.refreshSupport";
+        };
+        readonly InlineValueRefresh: {
+            readonly Method: "workspace/inlineValue/refresh";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "workspace.inlineValue.refreshSupport";
+        };
+        readonly InlayHintRefresh: {
+            readonly Method: "workspace/inlayHint/refresh";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "workspace.inlayHint.refreshSupport";
+        };
+        readonly DiagnosticRefresh: {
+            readonly Method: "workspace/diagnostic/refresh";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "workspace.diagnostics.refreshSupport";
+        };
+        readonly TextDocumentContentRefresh: {
+            readonly Method: "workspace/textDocumentContent/refresh";
+            readonly Direction: "serverToClient";
+        };
+        readonly CodeLensRefresh: {
+            readonly Method: "workspace/codeLens/refresh";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "workspace.codeLens";
+        };
+        readonly ApplyWorkspaceEdit: {
+            readonly Method: "workspace/applyEdit";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "workspace.applyEdit";
+        };
+    };
+    readonly WorkspaceSymbol: {
+        readonly Resolve: {
+            readonly Method: "workspaceSymbol/resolve";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "workspaceSymbolProvider.resolveProvider";
+            readonly ClientCapability: "workspace.symbol.resolveSupport";
+        };
+    };
+};
+/**
+ * LSP Notification methods organized by namespace
+ * @deprecated Use individual namespace exports instead
+ */
+export declare const LSPNotification: {
+    readonly General: {
+        readonly Cancel: {
+            readonly Method: "$/cancelRequest";
+            readonly Direction: "both";
+        };
+        readonly Progress: {
+            readonly Method: "$/progress";
+            readonly Direction: "both";
+        };
+        readonly SetTrace: {
+            readonly Method: "$/setTrace";
+            readonly Direction: "clientToServer";
+        };
+        readonly LogTrace: {
+            readonly Method: "$/logTrace";
+            readonly Direction: "serverToClient";
+        };
+    };
+    readonly Lifecycle: {
+        readonly Initialized: {
+            readonly Method: "initialized";
+            readonly Direction: "clientToServer";
+        };
+        readonly Exit: {
+            readonly Method: "exit";
+            readonly Direction: "clientToServer";
+        };
+    };
+    readonly NotebookDocument: {
+        readonly DidOpenNotebookDocument: {
+            readonly Method: "notebookDocument/didOpen";
+            readonly Direction: "clientToServer";
+            readonly RegistrationMethod: "notebookDocument/sync";
+        };
+        readonly DidChangeNotebookDocument: {
+            readonly Method: "notebookDocument/didChange";
+            readonly Direction: "clientToServer";
+            readonly RegistrationMethod: "notebookDocument/sync";
+        };
+        readonly DidSaveNotebookDocument: {
+            readonly Method: "notebookDocument/didSave";
+            readonly Direction: "clientToServer";
+            readonly RegistrationMethod: "notebookDocument/sync";
+        };
+        readonly DidCloseNotebookDocument: {
+            readonly Method: "notebookDocument/didClose";
+            readonly Direction: "clientToServer";
+            readonly RegistrationMethod: "notebookDocument/sync";
+        };
+    };
+    readonly Telemetry: {
+        readonly Event: {
+            readonly Method: "telemetry/event";
+            readonly Direction: "serverToClient";
+        };
+    };
+    readonly TextDocument: {
+        readonly DidOpenTextDocument: {
+            readonly Method: "textDocument/didOpen";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "textDocumentSync.openClose";
+            readonly ClientCapability: "textDocument.synchronization";
+        };
+        readonly DidChangeTextDocument: {
+            readonly Method: "textDocument/didChange";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "textDocumentSync";
+            readonly ClientCapability: "textDocument.synchronization";
+        };
+        readonly DidCloseTextDocument: {
+            readonly Method: "textDocument/didClose";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "textDocumentSync.openClose";
+            readonly ClientCapability: "textDocument.synchronization";
+        };
+        readonly DidSaveTextDocument: {
+            readonly Method: "textDocument/didSave";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "textDocumentSync.save";
+            readonly ClientCapability: "textDocument.synchronization.didSave";
+        };
+        readonly WillSaveTextDocument: {
+            readonly Method: "textDocument/willSave";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "textDocumentSync.willSave";
+            readonly ClientCapability: "textDocument.synchronization.willSave";
+        };
+        readonly PublishDiagnostics: {
+            readonly Method: "textDocument/publishDiagnostics";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "textDocument.publishDiagnostics";
+        };
+    };
+    readonly Window: {
+        readonly WorkDoneProgressCancel: {
+            readonly Method: "window/workDoneProgress/cancel";
+            readonly Direction: "clientToServer";
+        };
+        readonly ShowMessage: {
+            readonly Method: "window/showMessage";
+            readonly Direction: "serverToClient";
+            readonly ClientCapability: "window.showMessage";
+        };
+        readonly LogMessage: {
+            readonly Method: "window/logMessage";
+            readonly Direction: "serverToClient";
+        };
+    };
+    readonly Workspace: {
+        readonly DidChangeWorkspaceFolders: {
+            readonly Method: "workspace/didChangeWorkspaceFolders";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "workspace.workspaceFolders.changeNotifications";
+        };
+        readonly DidCreateFiles: {
+            readonly Method: "workspace/didCreateFiles";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "workspace.fileOperations.didCreate";
+            readonly ClientCapability: "workspace.fileOperations.didCreate";
+        };
+        readonly DidRenameFiles: {
+            readonly Method: "workspace/didRenameFiles";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "workspace.fileOperations.didRename";
+            readonly ClientCapability: "workspace.fileOperations.didRename";
+        };
+        readonly DidDeleteFiles: {
+            readonly Method: "workspace/didDeleteFiles";
+            readonly Direction: "clientToServer";
+            readonly ServerCapability: "workspace.fileOperations.didDelete";
+            readonly ClientCapability: "workspace.fileOperations.didDelete";
+        };
+        readonly DidChangeConfiguration: {
+            readonly Method: "workspace/didChangeConfiguration";
+            readonly Direction: "clientToServer";
+            readonly ClientCapability: "workspace.didChangeConfiguration";
+        };
+        readonly DidChangeWatchedFiles: {
+            readonly Method: "workspace/didChangeWatchedFiles";
+            readonly Direction: "clientToServer";
+            readonly ClientCapability: "workspace.didChangeWatchedFiles";
+        };
+    };
+};
+//# sourceMappingURL=namespaces.d.ts.map