1// Generated code. Do not edit
  2package lsp
  3
  4import (
  5	"context"
  6
  7	"github.com/opencode-ai/opencode/internal/lsp/protocol"
  8)
  9
 10// Implementation sends a textDocument/implementation request to the LSP server.
 11// A request to resolve the implementation locations of a symbol at a given text document position. The request's parameter is of type TextDocumentPositionParams the response is of type Definition or a Thenable that resolves to such.
 12func (c *Client) Implementation(ctx context.Context, params protocol.ImplementationParams) (protocol.Or_Result_textDocument_implementation, error) {
 13	var result protocol.Or_Result_textDocument_implementation
 14	err := c.Call(ctx, "textDocument/implementation", params, &result)
 15	return result, err
 16}
 17
 18// TypeDefinition sends a textDocument/typeDefinition request to the LSP server.
 19// A request to resolve the type definition locations of a symbol at a given text document position. The request's parameter is of type TextDocumentPositionParams the response is of type Definition or a Thenable that resolves to such.
 20func (c *Client) TypeDefinition(ctx context.Context, params protocol.TypeDefinitionParams) (protocol.Or_Result_textDocument_typeDefinition, error) {
 21	var result protocol.Or_Result_textDocument_typeDefinition
 22	err := c.Call(ctx, "textDocument/typeDefinition", params, &result)
 23	return result, err
 24}
 25
 26// DocumentColor sends a textDocument/documentColor request to the LSP server.
 27// A request to list all color symbols found in a given text document. The request's parameter is of type DocumentColorParams the response is of type ColorInformation ColorInformation[] or a Thenable that resolves to such.
 28func (c *Client) DocumentColor(ctx context.Context, params protocol.DocumentColorParams) ([]protocol.ColorInformation, error) {
 29	var result []protocol.ColorInformation
 30	err := c.Call(ctx, "textDocument/documentColor", params, &result)
 31	return result, err
 32}
 33
 34// ColorPresentation sends a textDocument/colorPresentation request to the LSP server.
 35// A request to list all presentation for a color. The request's parameter is of type ColorPresentationParams the response is of type ColorInformation ColorInformation[] or a Thenable that resolves to such.
 36func (c *Client) ColorPresentation(ctx context.Context, params protocol.ColorPresentationParams) ([]protocol.ColorPresentation, error) {
 37	var result []protocol.ColorPresentation
 38	err := c.Call(ctx, "textDocument/colorPresentation", params, &result)
 39	return result, err
 40}
 41
 42// FoldingRange sends a textDocument/foldingRange request to the LSP server.
 43// A request to provide folding ranges in a document. The request's parameter is of type FoldingRangeParams, the response is of type FoldingRangeList or a Thenable that resolves to such.
 44func (c *Client) FoldingRange(ctx context.Context, params protocol.FoldingRangeParams) ([]protocol.FoldingRange, error) {
 45	var result []protocol.FoldingRange
 46	err := c.Call(ctx, "textDocument/foldingRange", params, &result)
 47	return result, err
 48}
 49
 50// Declaration sends a textDocument/declaration request to the LSP server.
 51// A request to resolve the type definition locations of a symbol at a given text document position. The request's parameter is of type TextDocumentPositionParams the response is of type Declaration or a typed array of DeclarationLink or a Thenable that resolves to such.
 52func (c *Client) Declaration(ctx context.Context, params protocol.DeclarationParams) (protocol.Or_Result_textDocument_declaration, error) {
 53	var result protocol.Or_Result_textDocument_declaration
 54	err := c.Call(ctx, "textDocument/declaration", params, &result)
 55	return result, err
 56}
 57
 58// SelectionRange sends a textDocument/selectionRange request to the LSP server.
 59// A request to provide selection ranges in a document. The request's parameter is of type SelectionRangeParams, the response is of type SelectionRange SelectionRange[] or a Thenable that resolves to such.
 60func (c *Client) SelectionRange(ctx context.Context, params protocol.SelectionRangeParams) ([]protocol.SelectionRange, error) {
 61	var result []protocol.SelectionRange
 62	err := c.Call(ctx, "textDocument/selectionRange", params, &result)
 63	return result, err
 64}
 65
 66// PrepareCallHierarchy sends a textDocument/prepareCallHierarchy request to the LSP server.
 67// A request to result a CallHierarchyItem in a document at a given position. Can be used as an input to an incoming or outgoing call hierarchy. Since 3.16.0
 68func (c *Client) PrepareCallHierarchy(ctx context.Context, params protocol.CallHierarchyPrepareParams) ([]protocol.CallHierarchyItem, error) {
 69	var result []protocol.CallHierarchyItem
 70	err := c.Call(ctx, "textDocument/prepareCallHierarchy", params, &result)
 71	return result, err
 72}
 73
 74// IncomingCalls sends a callHierarchy/incomingCalls request to the LSP server.
 75// A request to resolve the incoming calls for a given CallHierarchyItem. Since 3.16.0
 76func (c *Client) IncomingCalls(ctx context.Context, params protocol.CallHierarchyIncomingCallsParams) ([]protocol.CallHierarchyIncomingCall, error) {
 77	var result []protocol.CallHierarchyIncomingCall
 78	err := c.Call(ctx, "callHierarchy/incomingCalls", params, &result)
 79	return result, err
 80}
 81
 82// OutgoingCalls sends a callHierarchy/outgoingCalls request to the LSP server.
 83// A request to resolve the outgoing calls for a given CallHierarchyItem. Since 3.16.0
 84func (c *Client) OutgoingCalls(ctx context.Context, params protocol.CallHierarchyOutgoingCallsParams) ([]protocol.CallHierarchyOutgoingCall, error) {
 85	var result []protocol.CallHierarchyOutgoingCall
 86	err := c.Call(ctx, "callHierarchy/outgoingCalls", params, &result)
 87	return result, err
 88}
 89
 90// SemanticTokensFull sends a textDocument/semanticTokens/full request to the LSP server.
 91// Since 3.16.0
 92func (c *Client) SemanticTokensFull(ctx context.Context, params protocol.SemanticTokensParams) (protocol.SemanticTokens, error) {
 93	var result protocol.SemanticTokens
 94	err := c.Call(ctx, "textDocument/semanticTokens/full", params, &result)
 95	return result, err
 96}
 97
 98// SemanticTokensFullDelta sends a textDocument/semanticTokens/full/delta request to the LSP server.
 99// Since 3.16.0
100func (c *Client) SemanticTokensFullDelta(ctx context.Context, params protocol.SemanticTokensDeltaParams) (protocol.Or_Result_textDocument_semanticTokens_full_delta, error) {
101	var result protocol.Or_Result_textDocument_semanticTokens_full_delta
102	err := c.Call(ctx, "textDocument/semanticTokens/full/delta", params, &result)
103	return result, err
104}
105
106// SemanticTokensRange sends a textDocument/semanticTokens/range request to the LSP server.
107// Since 3.16.0
108func (c *Client) SemanticTokensRange(ctx context.Context, params protocol.SemanticTokensRangeParams) (protocol.SemanticTokens, error) {
109	var result protocol.SemanticTokens
110	err := c.Call(ctx, "textDocument/semanticTokens/range", params, &result)
111	return result, err
112}
113
114// LinkedEditingRange sends a textDocument/linkedEditingRange request to the LSP server.
115// A request to provide ranges that can be edited together. Since 3.16.0
116func (c *Client) LinkedEditingRange(ctx context.Context, params protocol.LinkedEditingRangeParams) (protocol.LinkedEditingRanges, error) {
117	var result protocol.LinkedEditingRanges
118	err := c.Call(ctx, "textDocument/linkedEditingRange", params, &result)
119	return result, err
120}
121
122// WillCreateFiles sends a workspace/willCreateFiles request to the LSP server.
123// The will create files request is sent from the client to the server before files are actually created as long as the creation is triggered from within the client. The request can return a WorkspaceEdit which will be applied to workspace before the files are created. Hence the WorkspaceEdit can not manipulate the content of the file to be created. Since 3.16.0
124func (c *Client) WillCreateFiles(ctx context.Context, params protocol.CreateFilesParams) (protocol.WorkspaceEdit, error) {
125	var result protocol.WorkspaceEdit
126	err := c.Call(ctx, "workspace/willCreateFiles", params, &result)
127	return result, err
128}
129
130// WillRenameFiles sends a workspace/willRenameFiles request to the LSP server.
131// The will rename files request is sent from the client to the server before files are actually renamed as long as the rename is triggered from within the client. Since 3.16.0
132func (c *Client) WillRenameFiles(ctx context.Context, params protocol.RenameFilesParams) (protocol.WorkspaceEdit, error) {
133	var result protocol.WorkspaceEdit
134	err := c.Call(ctx, "workspace/willRenameFiles", params, &result)
135	return result, err
136}
137
138// WillDeleteFiles sends a workspace/willDeleteFiles request to the LSP server.
139// The did delete files notification is sent from the client to the server when files were deleted from within the client. Since 3.16.0
140func (c *Client) WillDeleteFiles(ctx context.Context, params protocol.DeleteFilesParams) (protocol.WorkspaceEdit, error) {
141	var result protocol.WorkspaceEdit
142	err := c.Call(ctx, "workspace/willDeleteFiles", params, &result)
143	return result, err
144}
145
146// Moniker sends a textDocument/moniker request to the LSP server.
147// A request to get the moniker of a symbol at a given text document position. The request parameter is of type TextDocumentPositionParams. The response is of type Moniker Moniker[] or null.
148func (c *Client) Moniker(ctx context.Context, params protocol.MonikerParams) ([]protocol.Moniker, error) {
149	var result []protocol.Moniker
150	err := c.Call(ctx, "textDocument/moniker", params, &result)
151	return result, err
152}
153
154// PrepareTypeHierarchy sends a textDocument/prepareTypeHierarchy request to the LSP server.
155// A request to result a TypeHierarchyItem in a document at a given position. Can be used as an input to a subtypes or supertypes type hierarchy. Since 3.17.0
156func (c *Client) PrepareTypeHierarchy(ctx context.Context, params protocol.TypeHierarchyPrepareParams) ([]protocol.TypeHierarchyItem, error) {
157	var result []protocol.TypeHierarchyItem
158	err := c.Call(ctx, "textDocument/prepareTypeHierarchy", params, &result)
159	return result, err
160}
161
162// Supertypes sends a typeHierarchy/supertypes request to the LSP server.
163// A request to resolve the supertypes for a given TypeHierarchyItem. Since 3.17.0
164func (c *Client) Supertypes(ctx context.Context, params protocol.TypeHierarchySupertypesParams) ([]protocol.TypeHierarchyItem, error) {
165	var result []protocol.TypeHierarchyItem
166	err := c.Call(ctx, "typeHierarchy/supertypes", params, &result)
167	return result, err
168}
169
170// Subtypes sends a typeHierarchy/subtypes request to the LSP server.
171// A request to resolve the subtypes for a given TypeHierarchyItem. Since 3.17.0
172func (c *Client) Subtypes(ctx context.Context, params protocol.TypeHierarchySubtypesParams) ([]protocol.TypeHierarchyItem, error) {
173	var result []protocol.TypeHierarchyItem
174	err := c.Call(ctx, "typeHierarchy/subtypes", params, &result)
175	return result, err
176}
177
178// InlineValue sends a textDocument/inlineValue request to the LSP server.
179// A request to provide inline values in a document. The request's parameter is of type InlineValueParams, the response is of type InlineValue InlineValue[] or a Thenable that resolves to such. Since 3.17.0
180func (c *Client) InlineValue(ctx context.Context, params protocol.InlineValueParams) ([]protocol.InlineValue, error) {
181	var result []protocol.InlineValue
182	err := c.Call(ctx, "textDocument/inlineValue", params, &result)
183	return result, err
184}
185
186// InlayHint sends a textDocument/inlayHint request to the LSP server.
187// A request to provide inlay hints in a document. The request's parameter is of type InlayHintsParams, the response is of type InlayHint InlayHint[] or a Thenable that resolves to such. Since 3.17.0
188func (c *Client) InlayHint(ctx context.Context, params protocol.InlayHintParams) ([]protocol.InlayHint, error) {
189	var result []protocol.InlayHint
190	err := c.Call(ctx, "textDocument/inlayHint", params, &result)
191	return result, err
192}
193
194// Resolve sends a inlayHint/resolve request to the LSP server.
195// A request to resolve additional properties for an inlay hint. The request's parameter is of type InlayHint, the response is of type InlayHint or a Thenable that resolves to such. Since 3.17.0
196func (c *Client) Resolve(ctx context.Context, params protocol.InlayHint) (protocol.InlayHint, error) {
197	var result protocol.InlayHint
198	err := c.Call(ctx, "inlayHint/resolve", params, &result)
199	return result, err
200}
201
202// Diagnostic sends a textDocument/diagnostic request to the LSP server.
203// The document diagnostic request definition. Since 3.17.0
204func (c *Client) Diagnostic(ctx context.Context, params protocol.DocumentDiagnosticParams) (protocol.DocumentDiagnosticReport, error) {
205	var result protocol.DocumentDiagnosticReport
206	err := c.Call(ctx, "textDocument/diagnostic", params, &result)
207	return result, err
208}
209
210// DiagnosticWorkspace sends a workspace/diagnostic request to the LSP server.
211// The workspace diagnostic request definition. Since 3.17.0
212func (c *Client) DiagnosticWorkspace(ctx context.Context, params protocol.WorkspaceDiagnosticParams) (protocol.WorkspaceDiagnosticReport, error) {
213	var result protocol.WorkspaceDiagnosticReport
214	err := c.Call(ctx, "workspace/diagnostic", params, &result)
215	return result, err
216}
217
218// InlineCompletion sends a textDocument/inlineCompletion request to the LSP server.
219// A request to provide inline completions in a document. The request's parameter is of type InlineCompletionParams, the response is of type InlineCompletion InlineCompletion[] or a Thenable that resolves to such. Since 3.18.0 PROPOSED
220func (c *Client) InlineCompletion(ctx context.Context, params protocol.InlineCompletionParams) (protocol.Or_Result_textDocument_inlineCompletion, error) {
221	var result protocol.Or_Result_textDocument_inlineCompletion
222	err := c.Call(ctx, "textDocument/inlineCompletion", params, &result)
223	return result, err
224}
225
226// TextDocumentContent sends a workspace/textDocumentContent request to the LSP server.
227// The workspace/textDocumentContent request is sent from the client to the server to request the content of a text document. Since 3.18.0 PROPOSED
228func (c *Client) TextDocumentContent(ctx context.Context, params protocol.TextDocumentContentParams) (string, error) {
229	var result string
230	err := c.Call(ctx, "workspace/textDocumentContent", params, &result)
231	return result, err
232}
233
234// Initialize sends a initialize request to the LSP server.
235// The initialize request is sent from the client to the server. It is sent once as the request after starting up the server. The requests parameter is of type InitializeParams the response if of type InitializeResult of a Thenable that resolves to such.
236func (c *Client) Initialize(ctx context.Context, params protocol.ParamInitialize) (protocol.InitializeResult, error) {
237	var result protocol.InitializeResult
238	err := c.Call(ctx, "initialize", params, &result)
239	return result, err
240}
241
242// Shutdown sends a shutdown request to the LSP server.
243// A shutdown request is sent from the client to the server. It is sent once when the client decides to shutdown the server. The only notification that is sent after a shutdown request is the exit event.
244func (c *Client) Shutdown(ctx context.Context) error {
245	return c.Call(ctx, "shutdown", nil, nil)
246}
247
248// WillSaveWaitUntil sends a textDocument/willSaveWaitUntil request to the LSP server.
249// A document will save request is sent from the client to the server before the document is actually saved. The request can return an array of TextEdits which will be applied to the text document before it is saved. Please note that clients might drop results if computing the text edits took too long or if a server constantly fails on this request. This is done to keep the save fast and reliable.
250func (c *Client) WillSaveWaitUntil(ctx context.Context, params protocol.WillSaveTextDocumentParams) ([]protocol.TextEdit, error) {
251	var result []protocol.TextEdit
252	err := c.Call(ctx, "textDocument/willSaveWaitUntil", params, &result)
253	return result, err
254}
255
256// Completion sends a textDocument/completion request to the LSP server.
257// Request to request completion at a given text document position. The request's parameter is of type TextDocumentPosition the response is of type CompletionItem CompletionItem[] or CompletionList or a Thenable that resolves to such. The request can delay the computation of the CompletionItem.detail detail and CompletionItem.documentation documentation properties to the completionItem/resolve request. However, properties that are needed for the initial sorting and filtering, like sortText, filterText, insertText, and textEdit, must not be changed during resolve.
258func (c *Client) Completion(ctx context.Context, params protocol.CompletionParams) (protocol.Or_Result_textDocument_completion, error) {
259	var result protocol.Or_Result_textDocument_completion
260	err := c.Call(ctx, "textDocument/completion", params, &result)
261	return result, err
262}
263
264// ResolveCompletionItem sends a completionItem/resolve request to the LSP server.
265// Request to resolve additional information for a given completion item.The request's parameter is of type CompletionItem the response is of type CompletionItem or a Thenable that resolves to such.
266func (c *Client) ResolveCompletionItem(ctx context.Context, params protocol.CompletionItem) (protocol.CompletionItem, error) {
267	var result protocol.CompletionItem
268	err := c.Call(ctx, "completionItem/resolve", params, &result)
269	return result, err
270}
271
272// Hover sends a textDocument/hover request to the LSP server.
273// Request to request hover information at a given text document position. The request's parameter is of type TextDocumentPosition the response is of type Hover or a Thenable that resolves to such.
274func (c *Client) Hover(ctx context.Context, params protocol.HoverParams) (protocol.Hover, error) {
275	var result protocol.Hover
276	err := c.Call(ctx, "textDocument/hover", params, &result)
277	return result, err
278}
279
280// SignatureHelp sends a textDocument/signatureHelp request to the LSP server.
281func (c *Client) SignatureHelp(ctx context.Context, params protocol.SignatureHelpParams) (protocol.SignatureHelp, error) {
282	var result protocol.SignatureHelp
283	err := c.Call(ctx, "textDocument/signatureHelp", params, &result)
284	return result, err
285}
286
287// Definition sends a textDocument/definition request to the LSP server.
288// A request to resolve the definition location of a symbol at a given text document position. The request's parameter is of type TextDocumentPosition the response is of either type Definition or a typed array of DefinitionLink or a Thenable that resolves to such.
289func (c *Client) Definition(ctx context.Context, params protocol.DefinitionParams) (protocol.Or_Result_textDocument_definition, error) {
290	var result protocol.Or_Result_textDocument_definition
291	err := c.Call(ctx, "textDocument/definition", params, &result)
292	return result, err
293}
294
295// References sends a textDocument/references request to the LSP server.
296// A request to resolve project-wide references for the symbol denoted by the given text document position. The request's parameter is of type ReferenceParams the response is of type Location Location[] or a Thenable that resolves to such.
297func (c *Client) References(ctx context.Context, params protocol.ReferenceParams) ([]protocol.Location, error) {
298	var result []protocol.Location
299	err := c.Call(ctx, "textDocument/references", params, &result)
300	return result, err
301}
302
303// DocumentHighlight sends a textDocument/documentHighlight request to the LSP server.
304// Request to resolve a DocumentHighlight for a given text document position. The request's parameter is of type TextDocumentPosition the request response is an array of type DocumentHighlight or a Thenable that resolves to such.
305func (c *Client) DocumentHighlight(ctx context.Context, params protocol.DocumentHighlightParams) ([]protocol.DocumentHighlight, error) {
306	var result []protocol.DocumentHighlight
307	err := c.Call(ctx, "textDocument/documentHighlight", params, &result)
308	return result, err
309}
310
311// DocumentSymbol sends a textDocument/documentSymbol request to the LSP server.
312// A request to list all symbols found in a given text document. The request's parameter is of type TextDocumentIdentifier the response is of type SymbolInformation SymbolInformation[] or a Thenable that resolves to such.
313func (c *Client) DocumentSymbol(ctx context.Context, params protocol.DocumentSymbolParams) (protocol.Or_Result_textDocument_documentSymbol, error) {
314	var result protocol.Or_Result_textDocument_documentSymbol
315	err := c.Call(ctx, "textDocument/documentSymbol", params, &result)
316	return result, err
317}
318
319// CodeAction sends a textDocument/codeAction request to the LSP server.
320// A request to provide commands for the given text document and range.
321func (c *Client) CodeAction(ctx context.Context, params protocol.CodeActionParams) ([]protocol.Or_Result_textDocument_codeAction_Item0_Elem, error) {
322	var result []protocol.Or_Result_textDocument_codeAction_Item0_Elem
323	err := c.Call(ctx, "textDocument/codeAction", params, &result)
324	return result, err
325}
326
327// ResolveCodeAction sends a codeAction/resolve request to the LSP server.
328// Request to resolve additional information for a given code action.The request's parameter is of type CodeAction the response is of type CodeAction or a Thenable that resolves to such.
329func (c *Client) ResolveCodeAction(ctx context.Context, params protocol.CodeAction) (protocol.CodeAction, error) {
330	var result protocol.CodeAction
331	err := c.Call(ctx, "codeAction/resolve", params, &result)
332	return result, err
333}
334
335// Symbol sends a workspace/symbol request to the LSP server.
336// A request to list project-wide symbols matching the query string given by the WorkspaceSymbolParams. The response is of type SymbolInformation SymbolInformation[] or a Thenable that resolves to such. Since 3.17.0 - support for WorkspaceSymbol in the returned data. Clients need to advertise support for WorkspaceSymbols via the client capability workspace.symbol.resolveSupport.
337func (c *Client) Symbol(ctx context.Context, params protocol.WorkspaceSymbolParams) (protocol.Or_Result_workspace_symbol, error) {
338	var result protocol.Or_Result_workspace_symbol
339	err := c.Call(ctx, "workspace/symbol", params, &result)
340	return result, err
341}
342
343// ResolveWorkspaceSymbol sends a workspaceSymbol/resolve request to the LSP server.
344// A request to resolve the range inside the workspace symbol's location. Since 3.17.0
345func (c *Client) ResolveWorkspaceSymbol(ctx context.Context, params protocol.WorkspaceSymbol) (protocol.WorkspaceSymbol, error) {
346	var result protocol.WorkspaceSymbol
347	err := c.Call(ctx, "workspaceSymbol/resolve", params, &result)
348	return result, err
349}
350
351// CodeLens sends a textDocument/codeLens request to the LSP server.
352// A request to provide code lens for the given text document.
353func (c *Client) CodeLens(ctx context.Context, params protocol.CodeLensParams) ([]protocol.CodeLens, error) {
354	var result []protocol.CodeLens
355	err := c.Call(ctx, "textDocument/codeLens", params, &result)
356	return result, err
357}
358
359// ResolveCodeLens sends a codeLens/resolve request to the LSP server.
360// A request to resolve a command for a given code lens.
361func (c *Client) ResolveCodeLens(ctx context.Context, params protocol.CodeLens) (protocol.CodeLens, error) {
362	var result protocol.CodeLens
363	err := c.Call(ctx, "codeLens/resolve", params, &result)
364	return result, err
365}
366
367// DocumentLink sends a textDocument/documentLink request to the LSP server.
368// A request to provide document links
369func (c *Client) DocumentLink(ctx context.Context, params protocol.DocumentLinkParams) ([]protocol.DocumentLink, error) {
370	var result []protocol.DocumentLink
371	err := c.Call(ctx, "textDocument/documentLink", params, &result)
372	return result, err
373}
374
375// ResolveDocumentLink sends a documentLink/resolve request to the LSP server.
376// Request to resolve additional information for a given document link. The request's parameter is of type DocumentLink the response is of type DocumentLink or a Thenable that resolves to such.
377func (c *Client) ResolveDocumentLink(ctx context.Context, params protocol.DocumentLink) (protocol.DocumentLink, error) {
378	var result protocol.DocumentLink
379	err := c.Call(ctx, "documentLink/resolve", params, &result)
380	return result, err
381}
382
383// Formatting sends a textDocument/formatting request to the LSP server.
384// A request to format a whole document.
385func (c *Client) Formatting(ctx context.Context, params protocol.DocumentFormattingParams) ([]protocol.TextEdit, error) {
386	var result []protocol.TextEdit
387	err := c.Call(ctx, "textDocument/formatting", params, &result)
388	return result, err
389}
390
391// RangeFormatting sends a textDocument/rangeFormatting request to the LSP server.
392// A request to format a range in a document.
393func (c *Client) RangeFormatting(ctx context.Context, params protocol.DocumentRangeFormattingParams) ([]protocol.TextEdit, error) {
394	var result []protocol.TextEdit
395	err := c.Call(ctx, "textDocument/rangeFormatting", params, &result)
396	return result, err
397}
398
399// RangesFormatting sends a textDocument/rangesFormatting request to the LSP server.
400// A request to format ranges in a document. Since 3.18.0 PROPOSED
401func (c *Client) RangesFormatting(ctx context.Context, params protocol.DocumentRangesFormattingParams) ([]protocol.TextEdit, error) {
402	var result []protocol.TextEdit
403	err := c.Call(ctx, "textDocument/rangesFormatting", params, &result)
404	return result, err
405}
406
407// OnTypeFormatting sends a textDocument/onTypeFormatting request to the LSP server.
408// A request to format a document on type.
409func (c *Client) OnTypeFormatting(ctx context.Context, params protocol.DocumentOnTypeFormattingParams) ([]protocol.TextEdit, error) {
410	var result []protocol.TextEdit
411	err := c.Call(ctx, "textDocument/onTypeFormatting", params, &result)
412	return result, err
413}
414
415// Rename sends a textDocument/rename request to the LSP server.
416// A request to rename a symbol.
417func (c *Client) Rename(ctx context.Context, params protocol.RenameParams) (protocol.WorkspaceEdit, error) {
418	var result protocol.WorkspaceEdit
419	err := c.Call(ctx, "textDocument/rename", params, &result)
420	return result, err
421}
422
423// PrepareRename sends a textDocument/prepareRename request to the LSP server.
424// A request to test and perform the setup necessary for a rename. Since 3.16 - support for default behavior
425func (c *Client) PrepareRename(ctx context.Context, params protocol.PrepareRenameParams) (protocol.PrepareRenameResult, error) {
426	var result protocol.PrepareRenameResult
427	err := c.Call(ctx, "textDocument/prepareRename", params, &result)
428	return result, err
429}
430
431// ExecuteCommand sends a workspace/executeCommand request to the LSP server.
432// A request send from the client to the server to execute a command. The request might return a workspace edit which the client will apply to the workspace.
433func (c *Client) ExecuteCommand(ctx context.Context, params protocol.ExecuteCommandParams) (any, error) {
434	var result any
435	err := c.Call(ctx, "workspace/executeCommand", params, &result)
436	return result, err
437}
438
439// DidChangeWorkspaceFolders sends a workspace/didChangeWorkspaceFolders notification to the LSP server.
440// The workspace/didChangeWorkspaceFolders notification is sent from the client to the server when the workspace folder configuration changes.
441func (c *Client) DidChangeWorkspaceFolders(ctx context.Context, params protocol.DidChangeWorkspaceFoldersParams) error {
442	return c.Notify(ctx, "workspace/didChangeWorkspaceFolders", params)
443}
444
445// WorkDoneProgressCancel sends a window/workDoneProgress/cancel notification to the LSP server.
446// The window/workDoneProgress/cancel notification is sent from  the client to the server to cancel a progress initiated on the server side.
447func (c *Client) WorkDoneProgressCancel(ctx context.Context, params protocol.WorkDoneProgressCancelParams) error {
448	return c.Notify(ctx, "window/workDoneProgress/cancel", params)
449}
450
451// DidCreateFiles sends a workspace/didCreateFiles notification to the LSP server.
452// The did create files notification is sent from the client to the server when files were created from within the client. Since 3.16.0
453func (c *Client) DidCreateFiles(ctx context.Context, params protocol.CreateFilesParams) error {
454	return c.Notify(ctx, "workspace/didCreateFiles", params)
455}
456
457// DidRenameFiles sends a workspace/didRenameFiles notification to the LSP server.
458// The did rename files notification is sent from the client to the server when files were renamed from within the client. Since 3.16.0
459func (c *Client) DidRenameFiles(ctx context.Context, params protocol.RenameFilesParams) error {
460	return c.Notify(ctx, "workspace/didRenameFiles", params)
461}
462
463// DidDeleteFiles sends a workspace/didDeleteFiles notification to the LSP server.
464// The will delete files request is sent from the client to the server before files are actually deleted as long as the deletion is triggered from within the client. Since 3.16.0
465func (c *Client) DidDeleteFiles(ctx context.Context, params protocol.DeleteFilesParams) error {
466	return c.Notify(ctx, "workspace/didDeleteFiles", params)
467}
468
469// DidOpenNotebookDocument sends a notebookDocument/didOpen notification to the LSP server.
470// A notification sent when a notebook opens. Since 3.17.0
471func (c *Client) DidOpenNotebookDocument(ctx context.Context, params protocol.DidOpenNotebookDocumentParams) error {
472	return c.Notify(ctx, "notebookDocument/didOpen", params)
473}
474
475// DidChangeNotebookDocument sends a notebookDocument/didChange notification to the LSP server.
476func (c *Client) DidChangeNotebookDocument(ctx context.Context, params protocol.DidChangeNotebookDocumentParams) error {
477	return c.Notify(ctx, "notebookDocument/didChange", params)
478}
479
480// DidSaveNotebookDocument sends a notebookDocument/didSave notification to the LSP server.
481// A notification sent when a notebook document is saved. Since 3.17.0
482func (c *Client) DidSaveNotebookDocument(ctx context.Context, params protocol.DidSaveNotebookDocumentParams) error {
483	return c.Notify(ctx, "notebookDocument/didSave", params)
484}
485
486// DidCloseNotebookDocument sends a notebookDocument/didClose notification to the LSP server.
487// A notification sent when a notebook closes. Since 3.17.0
488func (c *Client) DidCloseNotebookDocument(ctx context.Context, params protocol.DidCloseNotebookDocumentParams) error {
489	return c.Notify(ctx, "notebookDocument/didClose", params)
490}
491
492// Initialized sends a initialized notification to the LSP server.
493// The initialized notification is sent from the client to the server after the client is fully initialized and the server is allowed to send requests from the server to the client.
494func (c *Client) Initialized(ctx context.Context, params protocol.InitializedParams) error {
495	return c.Notify(ctx, "initialized", params)
496}
497
498// Exit sends a exit notification to the LSP server.
499// The exit event is sent from the client to the server to ask the server to exit its process.
500func (c *Client) Exit(ctx context.Context) error {
501	return c.Notify(ctx, "exit", nil)
502}
503
504// DidChangeConfiguration sends a workspace/didChangeConfiguration notification to the LSP server.
505// The configuration change notification is sent from the client to the server when the client's configuration has changed. The notification contains the changed configuration as defined by the language client.
506func (c *Client) DidChangeConfiguration(ctx context.Context, params protocol.DidChangeConfigurationParams) error {
507	return c.Notify(ctx, "workspace/didChangeConfiguration", params)
508}
509
510// DidOpen sends a textDocument/didOpen notification to the LSP server.
511// The document open notification is sent from the client to the server to signal newly opened text documents. The document's truth is now managed by the client and the server must not try to read the document's truth using the document's uri. Open in this sense means it is managed by the client. It doesn't necessarily mean that its content is presented in an editor. An open notification must not be sent more than once without a corresponding close notification send before. This means open and close notification must be balanced and the max open count is one.
512func (c *Client) DidOpen(ctx context.Context, params protocol.DidOpenTextDocumentParams) error {
513	return c.Notify(ctx, "textDocument/didOpen", params)
514}
515
516// DidChange sends a textDocument/didChange notification to the LSP server.
517// The document change notification is sent from the client to the server to signal changes to a text document.
518func (c *Client) DidChange(ctx context.Context, params protocol.DidChangeTextDocumentParams) error {
519	return c.Notify(ctx, "textDocument/didChange", params)
520}
521
522// DidClose sends a textDocument/didClose notification to the LSP server.
523// The document close notification is sent from the client to the server when the document got closed in the client. The document's truth now exists where the document's uri points to (e.g. if the document's uri is a file uri the truth now exists on disk). As with the open notification the close notification is about managing the document's content. Receiving a close notification doesn't mean that the document was open in an editor before. A close notification requires a previous open notification to be sent.
524func (c *Client) DidClose(ctx context.Context, params protocol.DidCloseTextDocumentParams) error {
525	return c.Notify(ctx, "textDocument/didClose", params)
526}
527
528// DidSave sends a textDocument/didSave notification to the LSP server.
529// The document save notification is sent from the client to the server when the document got saved in the client.
530func (c *Client) DidSave(ctx context.Context, params protocol.DidSaveTextDocumentParams) error {
531	return c.Notify(ctx, "textDocument/didSave", params)
532}
533
534// WillSave sends a textDocument/willSave notification to the LSP server.
535// A document will save notification is sent from the client to the server before the document is actually saved.
536func (c *Client) WillSave(ctx context.Context, params protocol.WillSaveTextDocumentParams) error {
537	return c.Notify(ctx, "textDocument/willSave", params)
538}
539
540// DidChangeWatchedFiles sends a workspace/didChangeWatchedFiles notification to the LSP server.
541// The watched files notification is sent from the client to the server when the client detects changes to file watched by the language client.
542func (c *Client) DidChangeWatchedFiles(ctx context.Context, params protocol.DidChangeWatchedFilesParams) error {
543	return c.Notify(ctx, "workspace/didChangeWatchedFiles", params)
544}
545
546// SetTrace sends a $/setTrace notification to the LSP server.
547func (c *Client) SetTrace(ctx context.Context, params protocol.SetTraceParams) error {
548	return c.Notify(ctx, "$/setTrace", params)
549}
550
551// Progress sends a $/progress notification to the LSP server.
552func (c *Client) Progress(ctx context.Context, params protocol.ProgressParams) error {
553	return c.Notify(ctx, "$/progress", params)
554}