lsp

type AnnotatedTextEdit struct {
	TextEdit

	// The actual annotation identifier.
	AnnotationID ChangeAnnotationIdentifier `json:"annotationId"`
}

type ApplyWorkspaceEditParams struct {
	// An optional label of the workspace edit. This label is
	// presented in the user interface for example on an undo
	// stack to undo the workspace edit.
	Label *string `json:"label,omitempty"`

	// The edits to apply.
	Edit WorkspaceEdit `json:"edit"`
}

type ApplyWorkspaceEditResult struct {
	// Indicates whether the edit was applied or not.
	Applied bool `json:"applied"`

	// An optional textual description for why the edit was not applied.
	// This may be used by the server for diagnostic logging or to provide
	// a suitable error for a request that triggered the edit.
	FailureReason *string `json:"failureReason,omitempty"`

	// Depending on the client's failure handling strategy `failedChange`
	// might contain the index of the change that failed. This property is
	// only available if the client signals a `failureHandling` strategy
	// in its client capabilities.
	FailedChange *UInteger `json:"failedChange,omitempty"`
}

type BoolOrString struct {
	BoolVal *bool
	StrVal  *string
}

type CallHierarchyClientCapabilities struct {
	// Whether implementation supports dynamic registration. If this is set to
	// `true` the client supports the new `(TextDocumentRegistrationOptions &
	// StaticRegistrationOptions)` return value for the corresponding server
	// capability as well.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type CallHierarchyIncomingCall struct {
	// The item that makes the call.
	From CallHierarchyItem `json:"from"`

	// The range at which at which the calls appears. This is relative to the caller
	// denoted by [`this.from`](#CallHierarchyIncomingCall.from).
	FromRanges []Range `json:"fromRanges"`
}

type CallHierarchyIncomingCallsHandlerFunc func(
	ctx *common.LSPContext,
	params *CallHierarchyIncomingCallsParams,
) ([]CallHierarchyIncomingCall, error)

type CallHierarchyIncomingCallsParams struct {
	WorkDoneProgressParams
	PartialResultParams

	Item CallHierarchyItem `json:"item"`
}

type CallHierarchyItem struct {
	// The name of this item.
	Name string `json:"name"`

	// The kind of this item.
	Kind SymbolKind `json:"kind"`

	// Tags for this item.
	Tags []SymbolTag `json:"tags,omitempty"`

	// More detail for this item, e.g. the signature of a function.
	Detail *string `json:"detail,omitempty"`

	// The resource identifier of this item.
	URI DocumentURI `json:"uri"`

	// The range enclosing this symbol not including leading/trailing whitespace
	// but everything else, e.g. comments and code.
	Range Range `json:"range"`

	// The range that should be selected and revealed when this symbol is being
	// picked, e.g. the name of a function. Must be contained by the
	// [`range`](#CallHierarchyItem.range).
	SelectionRange Range `json:"selectionRange"`

	// A data entry field that is preserved between a call hierarchy prepare and
	// incoming calls or outgoing calls requests.
	Data any `json:"data,omitempty"`
}

type CallHierarchyOptions struct {
	WorkDoneProgressOptions
}

type CallHierarchyOutgoingCall struct {
	// The item that is called.
	To CallHierarchyItem `json:"to"`

	// The range at which this item is called. This is the range relative to
	// the caller, e.g the item passed to `callHierarchy/outgoingCalls` request.
	FromRanges []Range `json:"fromRanges"`
}

type CallHierarchyOutgoingCallsHandlerFunc func(
	ctx *common.LSPContext,
	params *CallHierarchyOutgoingCallsParams,
) ([]CallHierarchyOutgoingCall, error)

type CallHierarchyOutgoingCallsParams struct {
	WorkDoneProgressParams
	PartialResultParams

	Item CallHierarchyItem `json:"item"`
}

type CallHierarchyPrepareParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
}

type CallHierarchyRegistrationOptions struct {
	CallHierarchyOptions
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
}

type CancelParams struct {
	// ID of the request to cancel.
	ID *IntOrString `json:"id"`
}

type CancelRequestHandlerFunc func(ctx *common.LSPContext, params *CancelParams) error

type ChangeAnnotation struct {
	// A human-readable string describing the change.
	// This is rendered prominently in the user interface.
	Label string `json:"label"`

	// A flag which indicates that user confirmation is needed
	// before applying the change.
	NeedsConfirmation *bool `json:"needsConfirmation,omitempty"`

	// A human-readable string which is rendered less prominent
	// in the user interface.
	Description *string `json:"description,omitempty"`
}

type ChangeAnnotationIdentifier = string

type ChangeAnnotationSupport struct {
	// Whether the client groups edits with equal labels into tree nodes,
	// for instance all edits labelled with "Changes in Strings" would be
	// a tree node.
	GroupsOnLabel *bool `json:"groupsOnLabel,omitempty"`
}

type ClientCapabilities struct {
	// Workspace specific client capabilities.
	Workspace *ClientWorkspaceCapabilities `json:"workspace,omitempty"`

	// Text document specific client capabilities.
	TextDocument *TextDocumentClientCapabilities `json:"textDocument,omitempty"`

	// Capabilities specific to the notebook document support.
	//
	// @since 3.17.0
	NotebookDocument *NotebookDocumentClientCapabilities `json:"notebook,omitempty"`

	// Window specific client capabilities.
	Window *WindowClientCapabilities `json:"window,omitempty"`

	// General client capabilities.
	//
	// @since 3.16.0
	General *GeneralClientCapabilities `json:"general,omitempty"`

	// Experimenal client capabilities.
	Experimental LSPAny `json:"experimental,omitempty"`
}

type ClientWorkspaceCapabilities struct {
	// the cliet supports applying batch edits to the workspace
	// by supporting the request `workspace/applyEdit`.
	ApplyEdit *bool `json:"applyEdit,omitempty"`

	// Capabilities specific to `WorkspaceEdit`s
	WorkspaceEdit *WorkspaceEditClientCapabilities `json:"workspaceEdit,omitempty"`

	// Capabilities specific to the `workspace/didChangeConfiguration` notification.
	DidChangeConfiguration *DidChangeConfigurationClientCapabilities `json:"didChangeConfiguration,omitempty"`

	// Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
	DidChangeWatchedFiles *DidChangeWatchedFilesClientCapabilities `json:"didChangeWatchedFiles,omitempty"`

	// Capabilities specific to the `workspace/symbol` request.
	Symbol *WorkspaceSymbolClientCapabilities `json:"symbol,omitempty"`

	// Capabilities specific to the `workspace/executeCommand` request.
	ExecuteCommand *ExecuteCommandClientCapabilities `json:"executeCommand,omitempty"`

	// The client has support for workspace folders.
	//
	// @since 3.6.0
	WorkspaceFolders *bool `json:"workspaceFolders,omitempty"`

	// The client supports `workspace/configuration` requests.
	//
	// @since 3.6.0
	Configuration *bool `json:"configuration,omitempty"`

	// Capabilities specific to the semantic token requiests scoped to the
	// workspace.
	//
	// @since 3.16.0
	SemanticTokens *SemanticTokensWorkspaceClientCapabilities `json:"semanticTokens,omitempty"`

	// Capabilities specific to the code lens requests scoped to the workspace.
	//
	// @since 3.16.0
	CodeLens *CodeLensWorkspaceClientCapabilities `json:"codeLens,omitempty"`

	// The client has support for file requests/notifications.
	//
	// @since 3.16.0
	FileOperations *FileOperationClientCapabilities `json:"fileOperations,omitempty"`

	// Client workspace capabilities specific to inline values.
	//
	// @since 3.17.0
	InlineValue *InlineValueWorkspaceClientCapabilities `json:"inlineValue,omitempty"`

	// Client workspace capabilities specific to inlay hints.
	//
	// @since 3.17.0
	InlayHint *InlayHintWorkspaceClientCapabilities `json:"inlayHint,omitempty"`

	// Client workspace capabilities specific to diagnostics.
	//
	// @since 3.17.0
	Diagnostics *DiagnosticWorkspaceClientCapabilities `json:"diagnostics,omitempty"`
}

type CodeAction struct {
	// A short, human-readable, title for this code action.
	Title string `json:"title"`

	// The kind of the code action.
	//
	// Used to filter code actions.
	Kind *CodeActionKind `json:"kind,omitempty"`

	// The diagnostics that this code action resolves.
	Diagnostics []Diagnostic `json:"diagnostics,omitempty"`

	// Marks this as a preferred action. Preferred actions are used by the
	// `auto fix` command and can be targeted by keybindings.
	//
	// A quick fix should be marked preferred if it properly addresses the
	// underlying error. A refactoring should be marked preferred if it is the
	// most reasonable choice of actions to take.
	//
	// @since 3.15.0
	IsPreferred *bool `json:"isPreferred,omitempty"`

	// Marks that the code action cannot currently be applied.
	//
	// Clients should follow the following guidelines regarding disabled code
	// actions:
	//
	// - Disabled code actions are not shown in automatic lightbulbs code
	//   action menus.
	//
	// - Disabled actions are shown as faded out in the code action menu when
	//   the user request a more specific type of code action, such as
	//   refactorings.
	//
	// - If the user has a keybinding that auto applies a code action and only
	//   a disabled code actions are returned, the client should show the user
	//   an error message with `reason` in the editor.
	//
	// @since 3.16.0
	Disabled *CodeActionDisabledReason `json:"disabled,omitempty"`

	// The workspace edit this code action performs.
	Edit *WorkspaceEdit `json:"edit,omitempty"`

	// A command this code action executes. If a code action
	// provides an edit and a command, first the edit is
	// executed and then the command.
	Command *Command `json:"command,omitempty"`

	// A data entry field that is preserved on a code action between
	// a `textDocument/codeAction` and a `codeAction/resolve` request.
	//
	// @since 3.16.0
	Data LSPAny `json:"data,omitempty"`
}

type CodeActionClientCapabilities struct {
	// Whether code action supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// The client supports code action literals as a valid
	// response of the `textDocument/codeAction` request.
	//
	// @since 3.8.0
	CodeActionLiteralSupport *CodeActionLiteralSupport `json:"codeActionLiteralSupport,omitempty"`

	// Whether code action supports the `isPreferred` property.
	//
	// @since 3.15.0
	IsPreferredSupport *bool `json:"isPreferredSupport,omitempty"`

	// Whether code action supports the `disabled` property.
	//
	// @since 3.16.0
	DisabledSupport *bool `json:"disabledSupport,omitempty"`

	// Whether code action supports the `data` property which is
	// preserved between a `textDocument/codeAction` and a
	// `codeAction/resolve` request.
	//
	// @since 3.16.0
	DataSupport *bool `json:"dataSupport,omitempty"`

	// Whether the client supports resolving additional code action
	// properties via a separate `codeAction/resolve` request.
	//
	// @since 3.16.0
	ResolveSupport *CodeActionResolveSupport `json:"resolveSupport,omitempty"`

	// Whether the client honors the change annotations in
	// text edits and resource operations returned via the
	// `CodeAction#edit` property by for example presenting
	// the workspace edit in the user interface and asking
	// for confirmation.
	//
	// @since 3.16.0
	HonorsChangeAnnotations *bool `json:"honorsChangeAnnotations,omitempty"`
}

type CodeActionContext struct {
	// An array of diagnostics known on the client side overlapping the range
	// provided to the `textDocument/codeAction` request. They are provided so
	// that the server knows which errors are currently presented to the user
	// for the given range. There is no guarantee that these accurately reflect
	// the error state of the resource. The primary parameter
	// to compute code actions is the provided range.
	Diagnostics []Diagnostic `json:"diagnostics"`

	// Requested kind of actions to return.
	//
	// Actions not of this kind are filtered out by the client before being
	// shown. So servers can omit computing them.
	Only []CodeActionKind `json:"only,omitempty"`

	// The reason why code actions were requested.
	//
	// @since 3.17.0
	TriggerKind *CodeActionTriggerKind `json:"triggerKind,omitempty"`
}

type CodeActionDisabledReason struct {
	// Human readable description of why the code action is disabled.
	//
	// This is displayed in the code actions user interface.
	Reason string `json:"reason"`
}

type CodeActionHandlerFunc func(
	ctx *common.LSPContext,
	params *CodeActionParams,
) ([]*CodeActionOrCommand, error)

type CodeActionKind = string

type CodeActionKindCapabilities struct {
	// The code action kind values the client supports. When this
	// property exists the client also guarantees that it will
	// handle values outside its set gracefully and falls back
	// to a default value when unknown.
	ValueSet []CodeActionKind `json:"valueSet,omitempty"`
}

type CodeActionLiteralSupport struct {
	// The code action kind is supported with the following value
	// set.
	CodeActionKind *CodeActionKindCapabilities `json:"codeActionKind,omitempty"`
}

type CodeActionOptions struct {
	WorkDoneProgressOptions

	// CodeActionKinds that this server may return.
	//
	// The list of kinds may be generic, such as `CodeActionKind.Refactor`,
	// or the server may list out every specific kind they provide.
	CodeActionKinds []CodeActionKind `json:"codeActionKinds,omitempty"`

	// The server provides support to resolve additional
	// information for a code action.
	//
	// @since 3.16.0
	ResolveProvider *bool `json:"resolveProvider,omitempty"`
}

type CodeActionOrCommand struct {
	CodeAction *CodeAction `json:"codeAction,omitempty"`
	Command    *Command    `json:"command,omitempty"`
}

type CodeActionParams struct {
	// The document in which the command was invoked.
	TextDocument TextDocumentIdentifier `json:"textDocument"`

	// The range for which the command was invoked.
	Range Range `json:"range"`

	// Context carrying additional information.
	Context CodeActionContext `json:"context"`
}

type CodeActionResolveHandlerFunc func(
	ctx *common.LSPContext,
	params *CodeAction,
) (*CodeAction, error)

type CodeActionResolveSupport struct {
	// The properties that a client can resolve lazily.
	Properties []string `json:"properties"`
}

type CodeActionTriggerKind = Integer

type CodeDescription struct {
	// A URI to open with more information about the diagnostic error.
	Href URI `json:"href"`
}

type CodeLens struct {
	// The range in which this code lens is valid. Should only span a single line.
	Range Range `json:"range"`

	// The command this code lens represents.
	Command *Command `json:"command,omitempty"`

	// A data entry field that is preserved on a code lens item between
	// a code lens and a code lens resolve request.
	Data LSPAny `json:"data,omitempty"`
}

type CodeLensClientCapabilities struct {
	// Whether code lens supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type CodeLensHandlerFunc func(
	ctx *common.LSPContext,
	params *CodeLensParams,
) ([]CodeLens, error)

type CodeLensOptions struct {
	WorkDoneProgressOptions

	// Code lens has a resolve provider as well.
	ResolveProvider *bool `json:"resolveProvider,omitempty"`
}

type CodeLensParams struct {
	WorkDoneProgressParams
	PartialResultParams

	// The document to request code lens for.
	TextDocument TextDocumentIdentifier `json:"textDocument"`
}

type CodeLensResolveHandlerFunc func(
	ctx *common.LSPContext,
	params *CodeLens,
) (*CodeLens, error)

type CodeLensWorkspaceClientCapabilities struct {
	// Whether the client implementation supports a refresh request sent from the
	// server to the client.
	//
	// Note that this event is global and will force the client to refresh all
	// code lenses currently shown. It should be used with absolute care and is
	// useful for situation where a server for example detect a project wide
	// change that requires such a calculation.
	RefreshSupport *bool `json:"refreshSupport,omitempty"`
}

type Color struct {
	// The red component of this color in the range [0-1]
	Red Decimal `json:"red"`

	// The green component of this color in the range [0-1].
	Green Decimal `json:"green"`

	// The blue component of this color in the range [0-1].
	Blue Decimal `json:"blue"`

	// The alpha component of this color in the range [0-1].
	Alpha Decimal `json:"alpha"`
}

type ColorInformation struct {
	// The range in the document where this color appears.
	Range Range `json:"range"`

	// The actual color value for this color range.
	Color Color `json:"color"`
}

type ColorPresentation struct {
	// The label of this color presentation. It will be shown on the color
	// picker header. By default this is also the text that is inserted when
	// selecting this color presentation.
	Label string `json:"label"`

	// An [edit](#TextEdit) which is applied to a document when selecting
	// this presentation for the color. When omitted the
	// [label](#ColorPresentation.label) is used.
	TextEdit *TextEdit `json:"textEdit,omitempty"`

	// An optional array of additional [text edits](#TextEdit) that are applied
	// when selecting this color presentation. Edits must not overlap with the
	// main [edit](#ColorPresentation.textEdit) nor with themselves.
	AdditionalTextEdits []TextEdit `json:"additionalTextEdits,omitempty"`
}

type ColorPresentationParams struct {
	WorkDoneProgressParams
	PartialResultParams

	// The text document.
	TextDocument TextDocumentIdentifier `json:"textDocument"`

	// The color information to request presentations for.
	Color Color `json:"color"`

	// The range where the color would be inserted. Serves as a context.
	Range Range `json:"range"`
}

type Command struct {
	// Title of the command, like `save`.
	Title string `json:"title"`

	// The identifier of the actual command handler.
	Command string `json:"command"`

	// Arguments that the command handler should be
	// invoked with.
	Arguments []LSPAny `json:"arguments,omitempty"`
}

type CompletionClientCapabilities struct {
	// Whether completion supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// The client supports the following `CompletionItem` specific capabilities.
	CompletionItem *CompletionItemCapabilities `json:"completionItem,omitempty"`

	// The completion item kind values the client support
	CompletionItemKind *CompletionItemKindCapabilities `json:"completionItemKind,omitempty"`

	// The client supports to send additional context information for a
	// `textDocument/completion` request.
	ContextSupport *bool `json:"contextSupport,omitempty"`

	// The client's default when the completion item doesn't provide a
	// `insertTextMode` property.
	//
	// @since 3.17.0
	InsertTextMode *CompletionItemInsertTextMode `json:"insertTextMode,omitempty"`

	// The client supports the following `CompletionList` specific
	// capabilities.
	//
	// @since 3.17.0
	CompletionList *CompletionListCapabilities `json:"completionList,omitempty"`
}

type CompletionContext struct {
	// How the completion was triggered.
	TriggerKind CompletionTriggerKind `json:"triggerKind"`

	// The trigger character (a single character) that has trigger code
	// complete. Is undefined if
	// `triggerKind !== CompletionTriggerKind.TriggerCharacter`
	TriggerCharacter *string `json:"triggerCharacter,omitempty"`
}

type CompletionHandlerFunc func(
	ctx *common.LSPContext,
	params *CompletionParams,
) (any, error)

type CompletionItem struct {
	// The label of this completion item.
	//
	// The label property is also by default the text that
	// is inserted when selecting this completion.
	//
	// If label details are provided the label itself should
	// be an unqualified name of the completion item.
	Label string `json:"label"`

	// Additional details for the label.
	//
	// @since 3.17.0
	LabelDetails *CompletionItemLabelDetails `json:"labelDetails,omitempty"`

	// The kind of this completion item. Based of the kind
	// an icon is chosen by the editor. The standardized set
	// of available values is defined in `CompletionItemKind`.
	Kind *CompletionItemKind `json:"kind,omitempty"`

	// Tags for this completion item.
	//
	// @since 3.15.0
	Tags []CompletionItemTag `json:"tags,omitempty"`

	// A human-readable string with additional information
	// about this item, like type or symbol information.
	Detail *string `json:"detail,omitempty"`

	// A human-readable string that represents a doc-comment.
	//
	// string | MarkupContent | nil
	Documentation any `json:"documentation,omitempty"`

	// Indicates if this item is deprecated.
	//
	// @deprecated Use `tags` instead if supported.
	Deprecated *bool `json:"deprecated,omitempty"`

	// Select this item when showing.
	//
	// *Note* that only one completion item can be selected and that the
	// tool / client decides which item that is. The rule is that the *first*
	// item of those that match best is selected.
	Preselect *bool `json:"preselect,omitempty"`

	// A string that should be used when comparing this item
	// with other items. When omitted the label is used
	// as the sort text for this item.
	SortText *string `json:"sortText,omitempty"`

	// A string that should be used when filtering a set of
	// completion items. When omitted the label is used as the
	// filter text for this item.
	FilterText *string `json:"filterText,omitempty"`

	// A string that should be inserted into a document when selecting
	// this completion. When omitted the label is used as the insert text
	// for this item.
	//
	// The `insertText` is subject to interpretation by the client side.
	// Some tools might not take the string literally. For example
	// VS Code when code complete is requested in this example
	// `con<cursor position>` and a completion item with an `insertText` of
	// `console` is provided it will only insert `sole`. Therefore it is
	// recommended to use `textEdit` instead since it avoids additional client
	// side interpretation.
	InsertText *string `json:"insertText,omitempty"`

	// The format of the insert text. The format applies to both the
	// `insertText` property and the `newText` property of a provided
	// `textEdit`. If omitted defaults to `InsertTextFormat.PlainText`.
	//
	// Please note that the insertTextFormat doesn't apply to
	// `additionalTextEdits`.
	InsertTextFormat *InsertTextFormat `json:"insertTextFormat,omitempty"`

	// How whitespace and indentation is handled during completion
	// item insertion. If not provided the client's default value depends on
	// the `textDocument.completion.insertTextMode` client capability.
	//
	// @since 3.16.0
	// @since 3.17.0 - support for `textDocument.completion.insertTextMode`
	InsertTextMode *InsertTextMode `json:"insertTextMode,omitempty"`

	// An edit which is applied to a document when selecting this completion.
	// When an edit is provided the value of `insertText` is ignored.
	//
	// *Note:* The range of the edit must be a single line range and it must
	// contain the position at which completion has been requested.
	//
	// Most editors support two different operations when accepting a completion
	// item. One is to insert a completion text and the other is to replace an
	// existing text with a completion text. Since this can usually not be
	// predetermined by a server it can report both ranges. Clients need to
	// signal support for `InsertReplaceEdit`s via the
	// `textDocument.completion.completionItem.insertReplaceSupport` client
	// capability property.
	//
	// *Note 1:* The text edit's range as well as both ranges from an insert
	// replace edit must be a [single line] and they must contain the position
	// at which completion has been requested.
	// *Note 2:* If an `InsertReplaceEdit` is returned the edit's insert range
	// must be a prefix of the edit's replace range, that means it must be
	// contained and starting at the same position.
	//
	// @since 3.16.0 additional type `InsertReplaceEdit`
	//
	// TextEdit | InsertReplaceEdit | nil
	TextEdit any `json:"textEdit,omitempty"`

	// The edit text used if the completion item is part of a CompletionList and
	// CompletionList defines an item default for the text edit range.
	//
	// Clients will only honor this property if they opt into completion list
	// item defaults using the capability `completionList.itemDefaults`.
	//
	// If not provided and a list's default range is provided the label
	// property is used as a text.
	//
	// @since 3.17.0
	TextEditText *string `json:"textEditText,omitempty"`

	// An optional array of additional text edits that are applied when
	// selecting this completion. Edits must not overlap (including the same
	// insert position) with the main edit nor with themselves.
	//
	// Additional text edits should be used to change text unrelated to the
	// current cursor position (for example adding an import statement at the
	// top of the file if the completion item will insert an unqualified type).
	AdditionalTextEdits []TextEdit `json:"additionalTextEdits,omitempty"`

	// An optional set of characters that when pressed while this completion is
	// active will accept it first and then type that character. Note that all
	// commit characters should have `length=1` and that superfluous characters
	// will be ignored.
	CommitCharacters []string `json:"commitCharacters,omitempty"`

	// An optional command that is executed *after* inserting this completion.
	// *Note* that additional modifications to the current document should be
	// described with the additionalTextEdits-property.
	Command *Command `json:"command,omitempty"`

	// A data entry field that is preserved on a completion item between
	// a completion and a completion resolve request.
	Data LSPAny `json:"data,omitempty"`
}

type CompletionItemCapabilities struct {
	// Client supports snippets as insert text.
	//
	// A snippet can define tab stops and placeholders with `$1`, `$2`
	// and `${3:foo}`. `$0` defines the final tab stop, it defaults to
	// the end of the snippet. Placeholders with equal identifiers are
	// linked, that is typing in one will update others too.
	SnippetSupport *bool `json:"snippetSupport,omitempty"`

	// Client supports commit characters on a completion item.
	CommitCharactersSupport *bool `json:"commitCharactersSupport,omitempty"`

	// Client supports the follow content formats for the documentation
	// property. The order describes the preferred format of the client.
	DocumentationFormat []MarkupKind `json:"documentationFormat,omitempty"`

	// Client supports the deprecated property on a completion item.
	DeprecatedSupport *bool `json:"deprecatedSupport,omitempty"`

	// Client supports the preselect property on a completion item.
	PreselectSupport *bool `json:"preselectSupport,omitempty"`

	// Client supports the tag property on a completion item. Clients
	// supporting tags have to handle unknown tags gracefully. Clients
	// especially need to preserve unknown tags when sending a completion
	// item back to the server in a resolve call.
	//
	// @since 3.15.0
	TagSupport *CompletionItemTagSupport `json:"tagSupport,omitempty"`

	// Client supports insert replace edit to control different behavior if
	// a completion item is inserted in the text or should replace text.
	//
	// @since 3.16.0
	InsertReplaceSupport *bool `json:"insertReplaceSupport,omitempty"`

	// Indicates which properties a client can resolve lazily on a
	// completion item. Before version 3.16.0 only the predefined properties
	// `documentation` and `detail` could be resolved lazily.
	//
	// @since 3.16.0
	ResolveSupport *CompletionItemResolveSupport `json:"resolveSupport,omitempty"`

	// The client supports the `insertTextMode` property on
	// a completion item to override the whitespace handling
	// mode as defined by the client (see `insertTextMode`).
	//
	// @since 3.16.0
	InsertTextModeSupport *CompletionItemInsertTextModeSupport `json:"insertTextModeSupport,omitempty"`

	// The client has support for completion item label
	// details (see also `CompletionItemLabelDetails`).
	//
	// @since 3.17.0
	LabelDetailsSupport *bool `json:"labelDetailsSupport,omitempty"`
}

type CompletionItemDefaults struct {
	// A default commit character set.
	//
	// @since 3.17.0
	CommitCharacters []string `json:"commitCharacters,omitempty"`

	// A default edit range.
	//
	// @since 3.17.0
	//
	// Range | InsertReplaceRange | nil
	EditRange any `json:"editRange,omitempty"`

	// A default insert text format.
	//
	// @since 3.17.0
	InsertTextFormat *InsertTextFormat `json:"insertTextFormat,omitempty"`

	// A default insert text mode.
	//
	// @since 3.17.0
	InsertTextMode *InsertTextMode `json:"insertTextMode,omitempty"`

	// A default data value.
	//
	// @since 3.17.0
	Data LSPAny `json:"data,omitempty"`
}

type CompletionItemInsertTextMode = Integer

type CompletionItemInsertTextModeSupport struct {
	ValueSet []CompletionItemInsertTextMode `json:"valueSet"`
}

type CompletionItemKind = Integer

type CompletionItemKindCapabilities struct {
	// The completion item kind values the client supports. When this
	// property exists the client also guarantees that it will
	// handle values outside its set gracefully and falls back
	// to a default value when unknown.
	//
	// If this property is not present the client only supports
	// the completion items kinds from `Text` to `Reference` as defined in
	// the initial version of the protocol.
	ValueSet []CompletionItemKind `json:"valueSet,omitempty"`
}

type CompletionItemLabelDetails struct {
	// An optional string which is rendered less prominently directly after
	// {@link CompletionItem.label label}, without any spacing. Should be
	// used for function signatures or type annotations.
	Detail *string `json:"detail,omitempty"`

	// An optional string which is rendered less prominently after
	// {@link CompletionItemLabelDetails.detail}. Should be used for fully qualified
	// names or file path.
	Description *string `json:"description,omitempty"`
}

type CompletionItemResolveHandlerFunc func(
	ctx *common.LSPContext,
	params *CompletionItem,
) (*CompletionItem, error)

type CompletionItemResolveSupport struct {
	// The properties that a client can resolve lazily.
	Properties []string `json:"properties"`
}

type CompletionItemTag = Integer

type CompletionItemTagSupport struct {
	// The tags supported by the client.
	ValueSet []CompletionItemTag `json:"valueSet"`
}

type CompletionList struct {
	// This list is not complete. Further typing should result in recomputing
	// this list.
	//
	// Recomputed lists have all their items replaced (not appended) in the
	// incomplete completion sessions.
	IsIncomplete bool `json:"isIncomplete"`

	// In many cases the items of an actual completion result share the same
	// value for properties like `commitCharacters` or the range of a text
	// edit. A completion list can therefore define item defaults which will
	// be used if a completion item itself doesn't specify the value.
	//
	// If a completion list specifies a default value and a completion item
	// also specifies a corresponding value the one from the item is used.
	//
	// Servers are only allowed to return default values if the client
	// signals support for this via the `completionList.itemDefaults`
	// capability.
	//
	// @since 3.17.0
	ItemDefaults *CompletionItemDefaults `json:"itemDefaults,omitempty"`

	// The completion items.
	Items []*CompletionItem `json:"items"`
}

type CompletionListCapabilities struct {
	// The client supports the following itemDefaults on
	// a completion list.
	//
	// The value lists the supported property names of the
	// `CompletionList.itemDefaults` object. If omitted
	// no properties are supported.
	//
	// @since 3.17.0
	ItemDefaults []string `json:"itemDefaults,omitempty"`
}

type CompletionOptions struct {
	WorkDoneProgressOptions

	// The additional characters, beyond the defaults provided by the client (typically
	// [a-zA-Z]), that should automatically trigger a completion request. For example
	// `.` in JavaScript represents the beginning of an object property or method and is
	// thus a good candidate for triggering a completion request.
	//
	// Most tools trigger a completion request automatically without explicitly
	// requesting it using a keyboard shortcut (e.g. Ctrl+Space). Typically they
	// do so when the user starts to type an identifier. For example if the user
	// types `c` in a JavaScript file code complete will automatically pop up
	// present `console` besides others as a completion item. Characters that
	// make up identifiers don't need to be listed here.
	TriggerCharacters []string `json:"triggerCharacters,omitempty"`

	// The list of all possible characters that commit a completion. This field
	// can be used if clients don't support individual commit characters per
	// completion item. See client capability
	// `completion.completionItem.commitCharactersSupport`.
	//
	// If a server provides both `allCommitCharacters` and commit characters on
	// an individual completion item the ones on the completion item win.
	//
	// @since 3.2.0
	AllCommitCharacters []string `json:"allCommitCharacters,omitempty"`

	// The server provides support to resolve additional
	// information for a completion item.
	ResolveProvider *bool `json:"resolveProvider,omitempty"`

	// The server supports the following `CompletionItem` specific
	// capabilities.
	//
	// @since 3.17.0
	CompletionItem *CompletionOptionsItem `json:"completionItem,omitempty"`
}

type CompletionOptionsItem struct {
	// The server has support for completion item label
	// details (see also `CompletionItemLabelDetails`) when receiving
	// a completion item in a resolve call.
	//
	// @since 3.17.0
	LabelDetailsSupport *bool `json:"labelDetailsSupport,omitempty"`
}

type CompletionParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams

	// The completion context. This is only available if the client specifies
	// to send this using the client capability
	// `completion.contextSupport === true`
	Context *CompletionContext `json:"context,omitempty"`
}

type CompletionTriggerKind = Integer

type ConfigurationItem struct {
	// The scope to get the configuration section for.
	ScopeURI *URI `json:"scopeUri,omitempty"`

	// The configuration section asked for.
	Section *string `json:"section,omitempty"`
}

type ConfigurationParams struct {
	Items []ConfigurationItem `json:"items"`
}

type CreateFile struct {
	// A create operatoin
	Kind string `json:"kind"` // == "create"

	// The resource to create.
	URI DocumentURI `json:"uri"`

	// Additional options
	Options *CreateFileOptions `json:"options,omitempty"`

	// An optional annotation identifier describing the operation.
	//
	// @since 3.16.0
	AnnotationID *ChangeAnnotationIdentifier `json:"annotationId,omitempty"`
}

type CreateFileOptions struct {
	// Overwrite existing file. Overwrite wins over `ignoreIfExists`
	Overwrite *bool `json:"overwrite,omitempty"`

	// Ignore if exists.
	IgnoreIfExists *bool `json:"ignoreIfExists,omitempty"`
}

type CreateFilesParams struct {
	// An array of all files/folders created in this operation.
	Files []FileCreate `json:"files"`
}

type Decimal = float64

type DeclarationClientCapabilities struct {
	// Whether declaration supports dynamic registration. If this is set to
	// `true` the client supports the new `DeclarationRegistrationOptions`
	// return value for the corresponding server capability as well.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// The client supports additional metadata in the form of declaration links.
	LinkSupport *bool `json:"linkSupport,omitempty"`
}

type DeclarationOptions struct {
	WorkDoneProgressOptions
}

type DeclarationParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams
}

type DeclarationRegistrationOptions struct {
	DeclarationOptions
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
}

type DefinitionClientCapabilities struct {
	// Whether definition supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// The client supports additional metadata in the form of definition links.
	LinkSupport *bool `json:"linkSupport,omitempty"`
}

type DefinitionOptions struct {
	WorkDoneProgressOptions
}

type DefinitionParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams
}

type DeleteFile struct {
	// A delete operation.
	Kind string `json:"kind"` // == "delete"

	// The file to delete.
	URI DocumentURI `json:"uri"`

	// Delete options.
	Options *DeleteFileOptions `json:"options,omitempty"`

	// An optional annotation identifier describing the operation.
	//
	// @since 3.16.0
	AnnotationID *ChangeAnnotationIdentifier `json:"annotationId,omitempty"`
}

type DeleteFileOptions struct {
	// Delete the content recursively if a folder is denoted.
	Recursive *bool `json:"recursive,omitempty"`

	// Ignore the operation if the file doesn't exist.
	IgnoreIfNotExists *bool `json:"ignoreIfNotExists,omitempty"`
}

type DeleteFilesParams struct {
	// An array of all files/folders deleted in this operation.
	Files []FileDelete `json:"files"`
}

type Diagnostic struct {
	// The range at which the message applies.
	Range Range `json:"range"`

	// The diagnostic's severity. Can be omitted. If omitted it is up to the
	// client to interpret diagnostics as error, warning, info or hint.
	Severity *DiagnosticSeverity `json:"severity,omitempty"`

	// The diagnostic's code, which might appear in the user interface.
	Code *IntOrString `json:"code,omitempty"`

	// An optional property to describe the error code.
	// @since 3.16.0
	CodeDescription *CodeDescription `json:"codeDescription,omitempty"`

	// A human-readable string describing the source of this
	// diagnostic, e.g. 'typescript' or 'super lint'.
	Source *string `json:"source,omitempty"`

	// The diagnostic's message.
	Message string `json:"message"`

	// Additional metadata about the diagnostic.
	//
	// @since 3.15.0
	Tags []DiagnosticTag `json:"tags,omitempty"`

	// An array of related diagnostic information, e.g. when symbol-names within
	// a scope collide all definitions can be marked via this property.
	RelatedInformation []DiagnosticRelatedInformation `json:"relatedInformation,omitempty"`

	// A data entry field that is preserved between a `textDocument/publishDiagnostics`
	// notification and `textDocument/codeAction` request.
	//
	// @since 3.16.0
	Data any `json:"data,omitempty"`
}

type DiagnosticClientCapabilities struct {
	// Whether implementation supports dynamic registration. If this is set to
	// `true` the client supports the new
	// `(TextDocumentRegistrationOptions & StaticRegistrationOptions)`
	// return value for the corresponding server capability as well.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// Whether the clients support related documents for document diagnostic
	// pulls.
	RelatedDocumentSupport *bool `json:"relatedDocumentSupport,omitempty"`
}

type DiagnosticOptions struct {
	WorkDoneProgressOptions

	// An optional identifier under which the diagnostics are
	// managed by the client.
	Identifier *string `json:"identifier,omitempty"`

	// Whether the language has inter file dependencies meaning that
	// editing code in one file can result in a different diagnostic
	// set in another file. Inter file dependencies are common for
	// most programming languages and typically uncommon for linters.
	InterFileDependencies bool `json:"interFileDependencies"`

	// The server provides support for workspace diagnostics as well.
	WorkspaceDiagnostics bool `json:"workspaceDiagnostics"`
}

type DiagnosticRegistrationOptions struct {
	DiagnosticOptions
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
}

type DiagnosticRelatedInformation struct {
	// The location of this related diagnostic information.
	Location Location `json:"location"`

	// The message of this related diagnostic information.
	Message string `json:"message"`
}

type DiagnosticSeverity = UInteger

type DiagnosticTag = UInteger

type DiagnosticTagSupport struct {
	// The tags supported by the client.
	ValueSet []DiagnosticTag `json:"valueSet"`
}

type DiagnosticWorkspaceClientCapabilities struct {
	// Whether the client implementation supports a refresh request sent from
	// the server to the client.
	//
	// Note that this event is global and will force the client to refresh all
	// pulled diagnostics currently shown. It should be used with absolute care
	// and is useful for situation where a server for example detects a project
	// wide change that requires such a calculation.
	RefreshSupport *bool `json:"refreshSupport,omitempty"`
}

type DidChangeConfigurationClientCapabilities struct {
	// Did change configuration notification supports dynamic registration.
	//
	// @since 3.6.0 to support the new pull model.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type DidChangeConfigurationParams struct {
	// The actual changed settings.
	Settings LSPAny `json:"settings"`
}

type DidChangeNotebookDocumentParams struct {
	// The notebook document that changed.
	// The version number points to the version after
	// all provided changes have been applied.
	NotebookDocument VersionedNotebookDocumentIdentifier `json:"notebookDocument"`

	// The actual changes to the notebook document.
	//
	// The change describes single state change to the notebook document.
	// So it moves a notebook document, its cells and its cell text document
	// contents from state S to S'.
	//
	// To mirror the content of a notebook using change events use the
	// following approach:
	// - start with the same initial content
	// - apply the 'notebookDocument/didChange' notifications in the order
	//   you receive them.
	Change NotebookDocumentChangeEvent `json:"change"`
}

type DidChangeTextDocumentParams struct {
	// The document that did change. The version number points
	// to the version after all provided content changes have
	// been applied.
	TextDocument VersionedTextDocumentIdentifier `json:"textDocument"`

	// The actual content changes. The content changes describe single state
	// changes to the document. So if there are two content changes c1 (at
	// array index 0) and c2 (at array index 1) for a document in state S then
	// c1 moves the document from S to S' and c2 from S' to S”. So c1 is
	// computed on the state S and c2 is computed on the state S'.
	//
	// To mirror the content of a document using change events use the following
	// approach:
	// - start with the same initial content
	// - apply the 'textDocument/didChange' notifications in the order you
	//   receive them.
	// - apply the `TextDocumentContentChangeEvent`s in a single notification
	//   in the order you receive them.
	//
	// TextDocumentContentChangeEvent | TextDocumentContentChangeEventWhole
	ContentChanges []any `json:"contentChanges"`
}

type DidChangeWatchedFilesClientCapabilities struct {
	// Did change watched files notification supports dynamic registration.
	// Please note that the current protocol doesn't support static
	// configuration for file changes from the server side.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// Whether the client has support for relative patterns
	// or not.
	//
	// @since 3.17.0
	RelativePatternSupport *bool `json:"relativePatternSupport,omitempty"`
}

type DidChangeWatchedFilesParams struct {
	// The actual file events.
	Changes []FileEvent `json:"changes"`
}

type DidChangeWorkspaceFoldersParams struct {
	// The actual workspace folder change event.
	Event WorkspaceFoldersChangeEvent `json:"event"`
}

type DidCloseNotebookDocumentParams struct {
	// The notebook document that was closed.
	NotebookDocument NotebookDocumentIdentifier `json:"notebookDocument"`

	// The text documents that represent the content
	// of a notebook cell that was closed.
	CellTextDocuments []TextDocumentIdentifier `json:"cellTextDocuments"`
}

type DidCloseTextDocumentParams struct {
	// The document that was closed.
	TextDocument TextDocumentIdentifier `json:"textDocument"`
}

type DidOpenNotebookDocumentParams struct {
	// The document that was opened.
	Notebook NotebookDocument `json:"notebook"`

	// The text documents that represent the content
	// of a notebook cell.
	CellTextDocuments []TextDocumentItem `json:"cellTextDocuments"`
}

type DidOpenTextDocumentParams struct {
	// The document that was opened.
	TextDocument TextDocumentItem `json:"textDocument"`
}

type DidSaveNotebookDocumentParams struct {
	// The notebook document that was saved.
	NotebookDocument NotebookDocumentIdentifier `json:"notebookDocument"`
}

type DidSaveTextDocumentParams struct {
	// The document that was saved.
	TextDocument TextDocumentIdentifier `json:"textDocument"`

	// Optional, contains the content when saved.
	// Whether this is present or not depends on the includeText value
	// when the save notification was requested.
	Text *string `json:"text,omitempty"`
}

type Dispatcher struct {
	// contains filtered or unexported fields
}

type DocumentColorClientCapabilities struct {
	//  Whether document color supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type DocumentColorHandlerFunc func(
	ctx *common.LSPContext,
	params *DocumentColorParams,
) ([]ColorInformation, error)

type DocumentColorOptions struct {
	WorkDoneProgressOptions
}

type DocumentColorParams struct {
	WorkDoneProgressParams
	PartialResultParams

	// The text document.
	TextDocument TextDocumentIdentifier `json:"textDocument"`
}

type DocumentColorPresentationHandlerFunc func(
	ctx *common.LSPContext,
	params *ColorPresentationParams,
) ([]ColorPresentation, error)

type DocumentColorRegistrationOptions struct {
	DocumentColorOptions
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
}

type DocumentDiagnosticHandlerFunc func(
	ctx *common.LSPContext,
	params *DocumentDiagnosticParams,
) (any, error)

type DocumentDiagnosticParams struct {
	// The text document.
	TextDocument TextDocumentIdentifier `json:"textDocument"`

	// The additional identifier provided during registration.
	Identifier *string `json:"identifier,omitempty"`

	// The result id of a previous response if provided.
	PreviousResultID *string `json:"previousResultId,omitempty"`
}

type DocumentDiagnosticReportKind = string

type DocumentDiagnosticReportPartialResult struct {
	// map[string](FullDocumentDiagnosticReport | UnchangedDocumentDiagnosticReport)
	RelatedDocuments map[string]any `json:"relatedDocuments"`
}

type DocumentFilter struct {
	// A language id, like `typescript`.
	Language *string `json:"language,omitempty"`

	// A Uri [scheme](#Uri.scheme), like `file` or `untitled`.
	Scheme *string `json:"scheme,omitempty"`

	// A glob pattern, like `*.{ts,js}`.
	// - `*` to match one or more characters in a path segment
	// - `?` to match on one character in a path segment
	// - `**` to match any number of path segments, including none
	// - `{}` to group sub patterns into an OR expression. (e.g. `**​/*.{ts,js}`
	//   matches all TypeScript and JavaScript files)
	// - `[]` to declare a range of characters to match in a path segment
	//   (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
	// - `[!...]` to negate a range of characters to match in a path segment
	//   (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but
	//   not `example.0`)
	Pattern *string `json:"pattern,omitempty"`
}

type DocumentFormattingClientCapabilities struct {
	// Whether formatting supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type DocumentFormattingHandlerFunc func(
	ctx *common.LSPContext,
	params *DocumentFormattingParams,
) ([]TextEdit, error)

type DocumentFormattingOptions struct {
	WorkDoneProgressOptions
}

type DocumentFormattingParams struct {
	WorkDoneProgressParams

	// The document to format.
	TextDocument TextDocumentIdentifier `json:"textDocument"`

	// The format options.
	Options FormattingOptions `json:"options"`
}

type DocumentHighlight struct {
	// The range this highlight applies to.
	Range Range `json:"range"`

	// The highlight kind, default is DocumentHighlightKind.Text.
	Kind *DocumentHighlightKind `json:"kind,omitempty"`
}

type DocumentHighlightClientCapabilities struct {
	// Whether document highlight supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type DocumentHighlightHandlerFunc func(
	ctx *common.LSPContext,
	params *DocumentHighlightParams,
) ([]DocumentHighlight, error)

type DocumentHighlightKind = Integer

type DocumentHighlightOptions struct {
	WorkDoneProgressOptions
}

type DocumentHighlightParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams
}

type DocumentLink struct {
	// The range this link applies to.
	Range Range `json:"range"`

	// The uri this link points to. If missing a resolve request is sent later.
	Target *DocumentURI `json:"target,omitempty"`

	// The tooltip text when you hover over this link.
	//
	// If a tooltip is provided, is will be displayed in a string that includes
	// instructions on how to trigger the link, such as `{0} (ctrl + click)`.
	// The specific instructions vary depending on OS, user settings, and
	// localization.
	//
	// @since 3.15.0
	Tooltip *string `json:"tooltip,omitempty"`

	// A data entry field that is preserved on a document link between a
	// DocumentLinkRequest and a DocumentLinkResolveRequest.
	Data LSPAny `json:"data,omitempty"`
}

type DocumentLinkClientCapabilities struct {
	// Whether document link supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// Whether the client supports the `tooltip` property on `DocumentLink`.
	//
	// @since 3.15.0
	TooltipSupport *bool `json:"tooltipSupport,omitempty"`
}

type DocumentLinkHandlerFunc func(
	ctx *common.LSPContext,
	params *DocumentLinkParams,
) ([]DocumentLink, error)

type DocumentLinkOptions struct {
	WorkDoneProgressOptions

	// Code lens has a resolve provider as well.
	ResolveProvider *bool `json:"resolveProvider,omitempty"`
}

type DocumentLinkParams struct {
	WorkDoneProgressParams
	PartialResultParams

	// The document to provide document links for.
	TextDocument TextDocumentIdentifier `json:"textDocument"`
}

type DocumentLinkResolveHandlerFunc func(
	ctx *common.LSPContext,
	params *DocumentLink,
) (*DocumentLink, error)

type DocumentLinkedEditingRangeHandlerFunc func(
	ctx *common.LSPContext,
	params *LinkedEditingRangeParams,
) (*LinkedEditingRanges, error)

type DocumentOnTypeFormattingClientCapabilities struct {
	// Whether on type formatting supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type DocumentOnTypeFormattingHandlerFunc func(
	ctx *common.LSPContext,
	params *DocumentOnTypeFormattingParams,
) ([]TextEdit, error)

type DocumentOnTypeFormattingOptions struct {
	// A character on which formatting should be triggered, like `}`.
	FirstTriggerCharacter string `json:"firstTriggerCharacter"`

	// More trigger characters.
	MoreTriggerCharacter []string `json:"moreTriggerCharacter,omitempty"`
}

type DocumentOnTypeFormattingParams struct {
	// The document to format.
	TextDocument TextDocumentIdentifier `json:"textDocument"`

	// The position around which the on type formatting should happen.
	// This is not necessarily the exact position where the character denoted
	// by the property `ch` got typed.
	Position Position `json:"position"`

	// The character that has been typed that triggered the formatting
	// on type request. That is not necessarily the last character that
	// got inserted into the document since the client could auto insert
	// characters as well (e.g. like automatic brace completion).
	Ch string `json:"ch"`

	// The formatting options.
	Options FormattingOptions `json:"options"`
}

type DocumentPrepareRenameHandlerFunc func(
	ctx *common.LSPContext,
	params *PrepareRenameParams,
) (any, error)

type DocumentRangeFormattingClientCapabilities struct {
	// Whether formatting supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type DocumentRangeFormattingHandlerFunc func(
	ctx *common.LSPContext,
	params *DocumentRangeFormattingParams,
) ([]TextEdit, error)

type DocumentRangeFormattingOptions struct {
	WorkDoneProgressOptions
}

type DocumentRangeFormattingParams struct {
	WorkDoneProgressParams

	// The document to format.
	TextDocument TextDocumentIdentifier `json:"textDocument"`

	// The range to format.
	Range Range `json:"Range"`

	// The format options.
	Options FormattingOptions `json:"options"`
}

type DocumentRenameHandlerFunc func(
	ctx *common.LSPContext,
	params *RenameParams,
) (*WorkspaceEdit, error)

type DocumentSelector = []DocumentFilter

type DocumentSymbol struct {
	// The name of this symbol. Will be displayed in the user interface and
	// therefore must not be an empty string or a string only consisting of
	// white spaces.
	Name string `json:"name"`

	// More detail for this symbol, e.g the signature of a function.
	Detail *string `json:"detail,omitempty"`

	// The kind of this symbol.
	Kind SymbolKind `json:"kind"`

	// Tags for this symbol.
	//
	// @since 3.16.0
	Tags []SymbolTag `json:"tags,omitempty"`

	// Indicates if this symbol is deprecated.
	//
	// @deprecated Use tags instead.
	Deprecated *bool `json:"deprecated,omitempty"`

	// The range enclosing this symbol not including leading/trailing whitespace
	// but everything else like comments. This information is typically used to
	// determine if the clients cursor is inside the symbol to reveal in the
	// symbol in the UI.
	Range Range `json:"range"`

	// The range that should be selected and revealed when this symbol is being
	// picked, e.g. the name of a function. Must be contained by the `range`.
	SelectionRange Range `json:"selectionRange"`

	// Children of this symbol, e.g. properties of a class.
	Children []DocumentSymbol `json:"children,omitempty"`
}

type DocumentSymbolClientCapabilities struct {
	// Whether document symbol supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// Specific capabilities for the `SymbolKind` in the
	// `textDocument/documentSymbol` request.
	SymbolKind *SymbolKindCapabilities `json:"symbolKind,omitempty"`

	// The client supports hierarchical document symbols.
	HierarchicalDocumentSymbolSupport *bool `json:"hierarchicalDocumentSymbolSupport,omitempty"`

	// The client supports tags on `SymbolInformation`. Tags are supported on
	// `DocumentSymbol` if `hierarchicalDocumentSymbolSupport` is set to true.
	// Clients supporting tags have to handle unknown tags gracefully.
	//
	// @since 3.16.0
	TagSupport *SymbolTagSupport `json:"tagSupport,omitempty"`

	// The client supports an additional label presented in the UI when
	// registering a document symbol provider.
	//
	// @since 3.16.0
	LabelSupport *bool `json:"labelSupport,omitempty"`
}

type DocumentSymbolHandlerFunc func(
	ctx *common.LSPContext,
	params *DocumentSymbolParams,
) (any, error)

type DocumentSymbolOptions struct {
	WorkDoneProgressOptions

	// A human-readable string that is shown when multiple outline trees
	// are shown for the same document.
	//
	// @since 3.16.0
	Label *string `json:"label,omitempty"`
}

type DocumentSymbolParams struct {
	WorkDoneProgressParams
	PartialResultParams

	// The text document.
	TextDocument TextDocumentIdentifier `json:"textDocument"`
}

type DocumentURI = string

type DocumentURIObject struct {
	URI DocumentURI `json:"uri"`
}

type ErrorWithData struct {
	// The error code (e.g. diagnostic error code)
	Code *IntOrString
	// The data to send with the error.
	Data any
}

type ExecuteCommandClientCapabilities struct {
	// Execute command supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type ExecuteCommandOptions struct {
	WorkDoneProgressOptions

	// The commands to be executed on the server.
	Commands []string `json:"commands"`
}

type ExecuteCommandParams struct {
	WorkDoneProgressParams

	// The identifier of the actual command handler.
	Command string `json:"command"`

	// Arguments that the command should be invoked with.
	Arguments []LSPAny `json:"arguments,omitempty"`
}

type ExitHandlerFunc func(ctx *common.LSPContext) error

type FailureHandlingKind = string

type FileChangeType = Integer

type FileCreate struct {
	// A file:// URI for the location of the file/folder being created.
	URI string `json:"uri"`
}

type FileDelete struct {
	// A file:// URI for the location of the file/folder being deleted.
	URI string `json:"uri"`
}

type FileEvent struct {
	// The file's URI.
	URI DocumentURI `json:"uri"`

	// The change type.
	Type FileChangeType `json:"type"`
}

type FileOperationClientCapabilities struct {

	// Whether the client supports dynamic regristration for file requests/notifications.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// The client has support for sending didCreateFiles notifications.
	DidCreate *bool `json:"didCreate,omitempty"`

	// The client has support for sending willCreateFiles requests.
	WillCreate *bool `json:"willCreate,omitempty"`

	// The client has support for sending didRenameFiles notifications.
	DidRename *bool `json:"didRename,omitempty"`

	// The client has support for sending willRenameFiles requests.
	WillRename *bool `json:"willRename,omitempty"`

	// The client has support for sending didDeleteFiles notifications.
	DidDelete *bool `json:"didDelete,omitempty"`

	// The client has support for sending willDeleteFiles requests.
	WillDelete *bool `json:"willDelete,omitempty"`
}

type FileOperationFilter struct {
	// A Uri like `file` or `untitled`.
	Scheme *string `json:"scheme,omitempty"`

	// The actual file operation pattern.
	Pattern FileOperationPattern `json:"pattern"`
}

type FileOperationPattern struct {
	// The glob pattern to match. Glob patterns can have the following syntax:
	// - `*` to match one or more characters in a path segment
	// - `?` to match on one character in a path segment
	// - `**` to match any number of path segments, including none
	// - `{}` to group sub patterns into an OR expression. (e.g. `**​/*.{ts,js}`
	//   matches all TypeScript and JavaScript files)
	// - `[]` to declare a range of characters to match in a path segment
	//   (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
	// - `[!...]` to negate a range of characters to match in a path segment
	//   (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but
	//   not `example.0`)
	Glob string `json:"glob"`

	// Whether to match files or folders with this pattern.
	//
	// Matches both if undefined.
	Matches *FileOperationPatternKind `json:"matches,omitempty"`

	// Additional options used during matching.
	Options *FileOperationPatternOptions `json:"options,omitempty"`
}

type FileOperationPatternKind = string

type FileOperationPatternOptions struct {
	// The pattern should be matched ignoring casing.
	IgnoreCase *bool `json:"ignoreCase,omitempty"`
}

type FileOperationRegistrationOptions struct {
	// The actual filters.
	Filters []FileOperationFilter `json:"filters"`
}

type FileRename struct {
	// A file:// URI for the location of the file/folder being renamed.
	OldURI string `json:"oldUri"`

	// A file:// URI for the new location of the file/folder being renamed.
	NewURI string `json:"newUri"`
}

type FindReferencesHandlerFunc func(ctx *common.LSPContext, params *ReferencesParams) ([]Location, error)

type FoldingRange struct {
	// The zero-based start line of the range to fold. The folded area starts
	// after the line's last character. To be valid, the end must be zero or
	// larger and smaller than the number of lines in the document.
	StartLine UInteger `json:"startLine"`

	// The zero-based character offset from where the folded range starts. If
	// not defined, defaults to the length of the start line.
	StartCharacter *UInteger `json:"startCharacter,omitempty"`

	// The zero-based end line of the range to fold. The folded area ends with
	// the line's last character. To be valid, the end must be zero or larger
	// and smaller than the number of lines in the document.
	EndLine UInteger `json:"endLine"`

	// The zero-based character offset before the folded range ends. If not
	// defined, defaults to the length of the end line.
	EndCharacter *UInteger `json:"endCharacter,omitempty"`

	// Describes the kind of the folding range such as `comment` or `region`.
	// The kind is used to categorize folding ranges and used by commands like
	// 'Fold all comments'. See [FoldingRangeKind](#FoldingRangeKind) for an
	// enumeration of standardized kinds.
	Kind *FoldingRangeKind `json:"kind,omitempty"`

	// The text that the client should show when the specified range is
	// collapsed. If not defined or not supported by the client, a default
	// will be chosen by the client.
	//
	// @since 3.17.0 - proposed
	CollapsedText *string `json:"collapsedText,omitempty"`
}

type FoldingRangeCapabilities struct {
	// If set, the client signals that it supports setting collapsedText on
	// folding ranges to display custom labels instead of the default text.
	//
	// @since 3.17.0
	CollapsedText *bool `json:"collapsedText,omitempty"`
}

type FoldingRangeClientCapabilities struct {
	// Whether implementation supports dynamic registration for folding range
	// providers. If this is set to `true` the client supports the new
	// `FoldingRangeRegistrationOptions` return value for the corresponding
	// server capability as well.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// The maximum number of folding ranges that the client prefers to receive
	// per document. The value serves as a hint, servers are free to follow the
	// limit.
	RangeLimit *UInteger `json:"rangeLimit,omitempty"`

	// If set, the client signals that it only supports folding complete lines.
	// If set, client will ignore specified `startCharacter` and `endCharacter`
	// properties in a FoldingRange.
	LineFoldingOnly *bool `json:"lineFoldingOnly,omitempty"`

	// Specific options for the folding range kind.
	//
	// @since 3.17.0
	FoldingRangeKind *FoldingRangeKindCapabilities `json:"foldingRangeKind,omitempty"`

	// Specific options for the folding range.
	// @since 3.17.0
	FoldingRange *FoldingRangeCapabilities `json:"foldingRange,omitempty"`
}

type FoldingRangeHandlerFunc func(
	ctx *common.LSPContext,
	params *FoldingRangeParams,
) ([]FoldingRange, error)

type FoldingRangeKind = string

type FoldingRangeKindCapabilities struct {
	// The folding range kind values the client supports. When this
	// property exists the client also guarantees that it will
	// handle values outside its set gracefully and falls back
	// to a default value when unknown.
	ValueSet []FoldingRangeKind `json:"valueSet,omitempty"`
}

type FoldingRangeOptions struct {
	WorkDoneProgressOptions
}

type FoldingRangeParams struct {
	WorkDoneProgressParams
	PartialResultParams

	// The text document.
	TextDocument TextDocumentIdentifier `json:"textDocument"`
}

type FoldingRangeRegistrationOptions struct {
	FoldingRangeOptions
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
}

type FormattingOptions map[string]any

type FullDocumentDiagnosticReport struct {
	// A full document diagnostic report.
	// Expected to be DocumentDiagnosticReportKindFull.
	Kind DocumentDiagnosticReportKind `json:"kind"`

	// An optional result id. If provided, it will be sent on the next
	// diagnostic request for the same document.
	ResultID *string `json:"resultId,omitempty"`

	// The actual items.
	Items []Diagnostic `json:"items"`
}

type GeneralClientCapabilities struct {
	// Client capability that signals how the client handles stale requests
	// (e.g. a request for which the client will not process the response anymor
	// since teh information is outdated).
	//
	// @since 3.17.0
	StaleRequestSupport *StaleRequestSupport `json:"staleRequestSupport,omitempty"`

	// Client capabilities specific to regular expressions.
	//
	// @since 3.16.0
	RegularExpressions *RegularExpressionsClientCapabilities `json:"regularExpressions,omitempty"`

	// Client capabilities specific to the client's markdown parser.
	//
	// @since 3.16.0
	Markdown *MarkdownClientCapabilities `json:"markdown,omitempty"`

	// The position encodings supported by the client. Client and server
	// have to agree on the same position encoding to ensure that offsets
	// (e.g. character position in a line) are interpreted the same on both
	// side.
	//
	// To keep the protocol backwards compatible the following applies: if
	// the value 'utf-16' is missing from the array of position encodings
	// servers can assume that the client supports UTF-16. UTF-16 is
	// therefore a mandatory encoding.
	//
	// If omitted it defaults to ['utf-16'].
	//
	// Implementation considerations: since the conversion from one encoding
	// into another requires the content of the file / line the conversion
	// is best done where the file is read which is usually on the server
	// side.
	//
	// @since 3.17.0
	PositionEncodings []PositionEncodingKind `json:"positionEncodings,omitempty"`
}

type GotoDeclarationHandlerFunc func(ctx *common.LSPContext, params *DeclarationParams) (any, error)

type GotoDefinitionHandlerFunc func(ctx *common.LSPContext, params *DefinitionParams) (any, error)

type GotoImplementationHandlerFunc func(ctx *common.LSPContext, params *ImplementationParams) (any, error)

type GotoTypeDefinitionHandlerFunc func(ctx *common.LSPContext, params *TypeDefinitionParams) (any, error)

type Handler struct {
	// contains filtered or unexported fields
}

type HandlerOption func(*Handler)

type Hover struct {
	// The hover's content.
	//
	// MarkedString | []MarkedString | MarkupContent
	Contents any `json:"contents"`

	// An optional range is a range inside a text document
	// that is used to visualize a hover, e.g. by changing
	// the background color.
	Range *Range `json:"range,omitempty"`
}