lsproto

type AnnotatedTextEdit struct {
	// The range of the text document to be manipulated. To insert
	// text into a document create a range where start === end.
	Range Range `json:"range"`

	// The string to be inserted. For delete operations use an
	// empty string.
	NewText string `json:"newText"`

	// The actual identifier of the change annotation
	AnnotationId string `json:"annotationId"`
}

type ApplyKind uint32

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,omitzero"`

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

	// Additional data about the edit.
	//
	// Since: 3.18.0
	//
	// Proposed.
	Metadata *WorkspaceEditMetadata `json:"metadata,omitzero"`
}

type ApplyWorkspaceEditResponse = *ApplyWorkspaceEditResult

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,omitzero"`

	// 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 `failureHandlingStrategy` in its client capabilities.
	FailedChange *uint32 `json:"failedChange,omitzero"`
}

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

type BaseSymbolInformation struct {
	// The name of this symbol.
	Name string `json:"name"`

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

	// Tags for this symbol.
	//
	// Since: 3.16.0
	Tags *[]SymbolTag `json:"tags,omitzero"`

	// The name of the symbol containing this symbol. This information is for
	// user interface purposes (e.g. to render a qualifier in the user interface
	// if necessary). It can't be used to re-infer a hierarchy for the document
	// symbols.
	ContainerName *string `json:"containerName,omitzero"`
}

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

type BooleanOrCallHierarchyOptionsOrCallHierarchyRegistrationOptions struct {
	Boolean                          *bool
	CallHierarchyOptions             *CallHierarchyOptions
	CallHierarchyRegistrationOptions *CallHierarchyRegistrationOptions
}

type BooleanOrClientSemanticTokensRequestFullDelta struct {
	Boolean                              *bool
	ClientSemanticTokensRequestFullDelta *ClientSemanticTokensRequestFullDelta
}

type BooleanOrCodeActionOptions struct {
	Boolean           *bool
	CodeActionOptions *CodeActionOptions
}

type BooleanOrDeclarationOptionsOrDeclarationRegistrationOptions struct {
	Boolean                        *bool
	DeclarationOptions             *DeclarationOptions
	DeclarationRegistrationOptions *DeclarationRegistrationOptions
}

type BooleanOrDefinitionOptions struct {
	Boolean           *bool
	DefinitionOptions *DefinitionOptions
}

type BooleanOrDocumentColorOptionsOrDocumentColorRegistrationOptions struct {
	Boolean                          *bool
	DocumentColorOptions             *DocumentColorOptions
	DocumentColorRegistrationOptions *DocumentColorRegistrationOptions
}

type BooleanOrDocumentFormattingOptions struct {
	Boolean                   *bool
	DocumentFormattingOptions *DocumentFormattingOptions
}

type BooleanOrDocumentHighlightOptions struct {
	Boolean                  *bool
	DocumentHighlightOptions *DocumentHighlightOptions
}

type BooleanOrDocumentRangeFormattingOptions struct {
	Boolean                        *bool
	DocumentRangeFormattingOptions *DocumentRangeFormattingOptions
}

type BooleanOrDocumentSymbolOptions struct {
	Boolean               *bool
	DocumentSymbolOptions *DocumentSymbolOptions
}

type BooleanOrEmptyObject struct {
	Boolean     *bool
	EmptyObject *struct{}
}

type BooleanOrFoldingRangeOptionsOrFoldingRangeRegistrationOptions struct {
	Boolean                         *bool
	FoldingRangeOptions             *FoldingRangeOptions
	FoldingRangeRegistrationOptions *FoldingRangeRegistrationOptions
}

type BooleanOrHoverOptions struct {
	Boolean      *bool
	HoverOptions *HoverOptions
}

type BooleanOrImplementationOptionsOrImplementationRegistrationOptions struct {
	Boolean                           *bool
	ImplementationOptions             *ImplementationOptions
	ImplementationRegistrationOptions *ImplementationRegistrationOptions
}

type BooleanOrInlayHintOptionsOrInlayHintRegistrationOptions struct {
	Boolean                      *bool
	InlayHintOptions             *InlayHintOptions
	InlayHintRegistrationOptions *InlayHintRegistrationOptions
}

type BooleanOrInlineCompletionOptions struct {
	Boolean                 *bool
	InlineCompletionOptions *InlineCompletionOptions
}

type BooleanOrInlineValueOptionsOrInlineValueRegistrationOptions struct {
	Boolean                        *bool
	InlineValueOptions             *InlineValueOptions
	InlineValueRegistrationOptions *InlineValueRegistrationOptions
}

type BooleanOrLinkedEditingRangeOptionsOrLinkedEditingRangeRegistrationOptions struct {
	Boolean                               *bool
	LinkedEditingRangeOptions             *LinkedEditingRangeOptions
	LinkedEditingRangeRegistrationOptions *LinkedEditingRangeRegistrationOptions
}

type BooleanOrMonikerOptionsOrMonikerRegistrationOptions struct {
	Boolean                    *bool
	MonikerOptions             *MonikerOptions
	MonikerRegistrationOptions *MonikerRegistrationOptions
}

type BooleanOrReferenceOptions struct {
	Boolean          *bool
	ReferenceOptions *ReferenceOptions
}

type BooleanOrRenameOptions struct {
	Boolean       *bool
	RenameOptions *RenameOptions
}

type BooleanOrSaveOptions struct {
	Boolean     *bool
	SaveOptions *SaveOptions
}

type BooleanOrSelectionRangeOptionsOrSelectionRangeRegistrationOptions struct {
	Boolean                           *bool
	SelectionRangeOptions             *SelectionRangeOptions
	SelectionRangeRegistrationOptions *SelectionRangeRegistrationOptions
}

type BooleanOrSemanticTokensFullDelta struct {
	Boolean                 *bool
	SemanticTokensFullDelta *SemanticTokensFullDelta
}

type BooleanOrTypeDefinitionOptionsOrTypeDefinitionRegistrationOptions struct {
	Boolean                           *bool
	TypeDefinitionOptions             *TypeDefinitionOptions
	TypeDefinitionRegistrationOptions *TypeDefinitionRegistrationOptions
}

type BooleanOrTypeHierarchyOptionsOrTypeHierarchyRegistrationOptions struct {
	Boolean                          *bool
	TypeHierarchyOptions             *TypeHierarchyOptions
	TypeHierarchyRegistrationOptions *TypeHierarchyRegistrationOptions
}

type BooleanOrWorkspaceSymbolOptions struct {
	Boolean                *bool
	WorkspaceSymbolOptions *WorkspaceSymbolOptions
}

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,omitzero"`
}

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

	// The ranges at which the calls appear. This is relative to the caller
	// denoted by `this.from`.
	FromRanges []Range `json:"fromRanges"`
}

type CallHierarchyIncomingCallsOrNull struct {
	CallHierarchyIncomingCalls *[]*CallHierarchyIncomingCall
}

type CallHierarchyIncomingCallsParams struct {
	// An optional token that a server can use to report work done progress.
	WorkDoneToken *IntegerOrString `json:"workDoneToken,omitzero"`

	// An optional token that a server can use to report partial results (e.g. streaming) to
	// the client.
	PartialResultToken *IntegerOrString `json:"partialResultToken,omitzero"`

	Item *CallHierarchyItem `json:"item"`
}

type CallHierarchyIncomingCallsResponse = CallHierarchyIncomingCallsOrNull

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,omitzero"`

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

	// 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`.
	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,omitzero"`
}

type CallHierarchyItemsOrNull struct {
	CallHierarchyItems *[]*CallHierarchyItem
}

type CallHierarchyOptions struct {
	WorkDoneProgress *bool `json:"workDoneProgress,omitzero"`
}

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 `provideCallHierarchyOutgoingCalls`
	// and not `this.to`.
	FromRanges []Range `json:"fromRanges"`
}

type CallHierarchyOutgoingCallsOrNull struct {
	CallHierarchyOutgoingCalls *[]*CallHierarchyOutgoingCall
}

type CallHierarchyOutgoingCallsParams struct {
	// An optional token that a server can use to report work done progress.
	WorkDoneToken *IntegerOrString `json:"workDoneToken,omitzero"`

	// An optional token that a server can use to report partial results (e.g. streaming) to
	// the client.
	PartialResultToken *IntegerOrString `json:"partialResultToken,omitzero"`

	Item *CallHierarchyItem `json:"item"`
}

type CallHierarchyOutgoingCallsResponse = CallHierarchyOutgoingCallsOrNull

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

	// The position inside the text document.
	Position Position `json:"position"`

	// An optional token that a server can use to report work done progress.
	WorkDoneToken *IntegerOrString `json:"workDoneToken,omitzero"`
}

type CallHierarchyPrepareResponse = CallHierarchyItemsOrNull

type CallHierarchyRegistrationOptions struct {
	// A document selector to identify the scope of the registration. If set to null
	// the document selector provided on the client side will be used.
	DocumentSelector DocumentSelectorOrNull `json:"documentSelector"`

	WorkDoneProgress *bool `json:"workDoneProgress,omitzero"`

	// The id used to register the request. The id can be used to deregister
	// the request again. See also Registration#id.
	Id *string `json:"id,omitzero"`
}

type CancelParams struct {
	// The request id to cancel.
	Id IntegerOrString `json:"id"`
}

type ChangeAnnotation struct {
	// A human-readable string describing the actual change. The string
	// is rendered prominent 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,omitzero"`

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

type ChangeAnnotationsSupportOptions 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,omitzero"`
}

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

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

	// Capabilities specific to the notebook document support.
	//
	// Since: 3.17.0
	NotebookDocument *NotebookDocumentClientCapabilities `json:"notebookDocument,omitzero"`

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

	// General client capabilities.
	//
	// Since: 3.16.0
	General *GeneralClientCapabilities `json:"general,omitzero"`

	// Experimental client capabilities.
	Experimental *any `json:"experimental,omitzero"`
}

type ClientCodeActionKindOptions 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"`
}

type ClientCodeActionLiteralOptions struct {
	// The code action kind is support with the following value
	// set.
	CodeActionKind *ClientCodeActionKindOptions `json:"codeActionKind"`
}

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

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

type ClientCompletionItemInsertTextModeOptions struct {
	ValueSet []InsertTextMode `json:"valueSet"`
}

type ClientCompletionItemOptions 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,omitzero"`

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

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

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

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

	// 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 *CompletionItemTagOptions `json:"tagSupport,omitzero"`

	// Client support 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,omitzero"`

	// Indicates which properties a client can resolve lazily on a completion
	// item. Before version 3.16.0 only the predefined properties `documentation`
	// and `details` could be resolved lazily.
	//
	// Since: 3.16.0
	ResolveSupport *ClientCompletionItemResolveOptions `json:"resolveSupport,omitzero"`

	// 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 *ClientCompletionItemInsertTextModeOptions `json:"insertTextModeSupport,omitzero"`

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

type ClientCompletionItemOptionsKind 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,omitzero"`
}

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

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

type ClientFoldingRangeKindOptions 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,omitzero"`
}

type ClientFoldingRangeOptions 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,omitzero"`
}

type ClientInfo struct {
	// The name of the client as defined by the client.
	Name string `json:"name"`

	// The client's version as defined by the client.
	Version *string `json:"version,omitzero"`
}

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

type ClientSemanticTokensRequestFullDelta struct {
	// The client will send the `textDocument/semanticTokens/full/delta` request if
	// the server provides a corresponding handler.
	Delta *bool `json:"delta,omitzero"`
}

type ClientSemanticTokensRequestOptions struct {
	// The client will send the `textDocument/semanticTokens/range` request if
	// the server provides a corresponding handler.
	Range *BooleanOrEmptyObject `json:"range,omitzero"`

	// The client will send the `textDocument/semanticTokens/full` request if
	// the server provides a corresponding handler.
	Full *BooleanOrClientSemanticTokensRequestFullDelta `json:"full,omitzero"`
}

type ClientShowMessageActionItemOptions struct {
	// Whether the client supports additional attributes which
	// are preserved and send back to the server in the
	// request's response.
	AdditionalPropertiesSupport *bool `json:"additionalPropertiesSupport,omitzero"`
}

type ClientSignatureInformationOptions struct {
	// Client supports the following content formats for the documentation
	// property. The order describes the preferred format of the client.
	DocumentationFormat *[]MarkupKind `json:"documentationFormat,omitzero"`

	// Client capabilities specific to parameter information.
	ParameterInformation *ClientSignatureParameterInformationOptions `json:"parameterInformation,omitzero"`

	// The client supports the `activeParameter` property on `SignatureInformation`
	// literal.
	//
	// Since: 3.16.0
	ActiveParameterSupport *bool `json:"activeParameterSupport,omitzero"`

	// The client supports the `activeParameter` property on
	// `SignatureHelp`/`SignatureInformation` being set to `null` to
	// indicate that no parameter should be active.
	//
	// Since: 3.18.0
	//
	// Proposed.
	NoActiveParameterSupport *bool `json:"noActiveParameterSupport,omitzero"`
}

type ClientSignatureParameterInformationOptions struct {
	// The client supports processing label offsets instead of a
	// simple label string.
	//
	// Since: 3.14.0
	LabelOffsetSupport *bool `json:"labelOffsetSupport,omitzero"`
}

type ClientSymbolKindOptions struct {
	// The symbol 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 symbol kinds from `File` to `Array` as defined in
	// the initial version of the protocol.
	ValueSet *[]SymbolKind `json:"valueSet,omitzero"`
}

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

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

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,omitzero"`

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

	// 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,omitzero"`

	// 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](https://code.visualstudio.com/docs/editor/editingevolved#_code-action)
	//     code action menus.
	//
	//   - Disabled actions are shown as faded out in the code action menu when the user requests a more specific type
	//     of code action, such as refactorings.
	//
	//   - If the user has a [keybinding](https://code.visualstudio.com/docs/editor/refactoring#_keybindings-for-code-actions)
	//     that auto applies a code action and only disabled code actions are returned, the client should show the user an
	//     error message with `reason` in the editor.
	//
	// Since: 3.16.0
	Disabled *CodeActionDisabled `json:"disabled,omitzero"`

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

	// 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,omitzero"`

	// 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 *any `json:"data,omitzero"`

	// Tags for this code action.
	//
	// Since: 3.18.0 - proposed
	Tags *[]CodeActionTag `json:"tags,omitzero"`
}

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

	// The client support code action literals of type `CodeAction` as a valid
	// response of the `textDocument/codeAction` request. If the property is not
	// set the request can only return `Command` literals.
	//
	// Since: 3.8.0
	CodeActionLiteralSupport *ClientCodeActionLiteralOptions `json:"codeActionLiteralSupport,omitzero"`

	// Whether code action supports the `isPreferred` property.
	//
	// Since: 3.15.0
	IsPreferredSupport *bool `json:"isPreferredSupport,omitzero"`

	// Whether code action supports the `disabled` property.
	//
	// Since: 3.16.0
	DisabledSupport *bool `json:"disabledSupport,omitzero"`

	// 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,omitzero"`

	// Whether the client supports resolving additional code action
	// properties via a separate `codeAction/resolve` request.
	//
	// Since: 3.16.0
	ResolveSupport *ClientCodeActionResolveOptions `json:"resolveSupport,omitzero"`

	// 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,omitzero"`

	// Whether the client supports documentation for a class of
	// code actions.
	//
	// Since: 3.18.0
	//
	// Proposed.
	DocumentationSupport *bool `json:"documentationSupport,omitzero"`

	// Client supports the tag property on a code action. Clients
	// supporting tags have to handle unknown tags gracefully.
	//
	// Since: 3.18.0 - proposed
	TagSupport *CodeActionTagOptions `json:"tagSupport,omitzero"`
}

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,omitzero"`

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

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

type CodeActionKind string

type CodeActionKindDocumentation struct {
	// The kind of the code action being documented.
	//
	// If the kind is generic, such as `CodeActionKind.Refactor`, the documentation will be shown whenever any
	// refactorings are returned. If the kind if more specific, such as `CodeActionKind.RefactorExtract`, the
	// documentation will only be shown when extract refactoring code actions are returned.
	Kind CodeActionKind `json:"kind"`

	// Command that is ued to display the documentation to the user.
	//
	// The title of this documentation code action is taken from Command.title
	Command *Command `json:"command"`
}

type CodeActionOptions struct {
	WorkDoneProgress *bool `json:"workDoneProgress,omitzero"`

	// 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,omitzero"`

	// Static documentation for a class of code actions.
	//
	// Documentation from the provider should be shown in the code actions menu if either:
	//
	// - Code actions of `kind` are requested by the editor. In this case, the editor will show the documentation that
	//   most closely matches the requested code action kind. For example, if a provider has documentation for
	//   both `Refactor` and `RefactorExtract`, when the user requests code actions for `RefactorExtract`,
	//   the editor will use the documentation for `RefactorExtract` instead of the documentation for `Refactor`.
	//
	// - Any code actions of `kind` are returned by the provider.
	//
	// At most one documentation entry should be shown per provider.
	//
	// Since: 3.18.0
	//
	// Proposed.
	Documentation *[]*CodeActionKindDocumentation `json:"documentation,omitzero"`

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

type CodeActionParams struct {
	// An optional token that a server can use to report work done progress.
	WorkDoneToken *IntegerOrString `json:"workDoneToken,omitzero"`

	// An optional token that a server can use to report partial results (e.g. streaming) to
	// the client.
	PartialResultToken *IntegerOrString `json:"partialResultToken,omitzero"`

	// 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 CodeActionRegistrationOptions struct {
	// A document selector to identify the scope of the registration. If set to null
	// the document selector provided on the client side will be used.
	DocumentSelector DocumentSelectorOrNull `json:"documentSelector"`

	WorkDoneProgress *bool `json:"workDoneProgress,omitzero"`

	// 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,omitzero"`

	// Static documentation for a class of code actions.
	//
	// Documentation from the provider should be shown in the code actions menu if either:
	//
	// - Code actions of `kind` are requested by the editor. In this case, the editor will show the documentation that
	//   most closely matches the requested code action kind. For example, if a provider has documentation for
	//   both `Refactor` and `RefactorExtract`, when the user requests code actions for `RefactorExtract`,
	//   the editor will use the documentation for `RefactorExtract` instead of the documentation for `Refactor`.
	//
	// - Any code actions of `kind` are returned by the provider.
	//
	// At most one documentation entry should be shown per provider.
	//
	// Since: 3.18.0
	//
	// Proposed.
	Documentation *[]*CodeActionKindDocumentation `json:"documentation,omitzero"`

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

type CodeActionResolveResponse = *CodeAction

type CodeActionResponse = CommandOrCodeActionArrayOrNull

type CodeActionTag uint32

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

type CodeActionTriggerKind uint32

type CodeDescription struct {
	// An 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,omitzero"`

	// A data entry field that is preserved on a code lens item between
	// a CodeLensRequest and a CodeLensResolveRequest
	Data *any `json:"data,omitzero"`
}

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

	// Whether the client supports resolving additional code lens
	// properties via a separate `codeLens/resolve` request.
	//
	// Since: 3.18.0
	ResolveSupport *ClientCodeLensResolveOptions `json:"resolveSupport,omitzero"`
}

type CodeLensOptions struct {
	WorkDoneProgress *bool `json:"workDoneProgress,omitzero"`

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

type CodeLensParams struct {
	// An optional token that a server can use to report work done progress.
	WorkDoneToken *IntegerOrString `json:"workDoneToken,omitzero"`

	// An optional token that a server can use to report partial results (e.g. streaming) to
	// the client.
	PartialResultToken *IntegerOrString `json:"partialResultToken,omitzero"`

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

type CodeLensRefreshResponse = Null

type CodeLensRegistrationOptions struct {
	// A document selector to identify the scope of the registration. If set to null
	// the document selector provided on the client side will be used.
	DocumentSelector DocumentSelectorOrNull `json:"documentSelector"`

	WorkDoneProgress *bool `json:"workDoneProgress,omitzero"`

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

type CodeLensResolveResponse = *CodeLens

type CodeLensResponse = CodeLenssOrNull

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,omitzero"`
}

type CodeLenssOrNull struct {
	CodeLenss *[]*CodeLens
}

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

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

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

	// The alpha component of this color in the range [0-1].
	Alpha float64 `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 which is applied to a document when selecting
	// this presentation for the color.  When `falsy` the label
	// is used.
	TextEdit *TextEdit `json:"textEdit,omitzero"`

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

type ColorPresentationParams struct {
	// An optional token that a server can use to report work done progress.
	WorkDoneToken *IntegerOrString `json:"workDoneToken,omitzero"`

	// An optional token that a server can use to report partial results (e.g. streaming) to
	// the client.
	PartialResultToken *IntegerOrString `json:"partialResultToken,omitzero"`

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

	// The color 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 ColorPresentationResponse = []*ColorPresentation

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

	// An optional tooltip.
	//
	// Since: 3.18.0
	//
	// Proposed.
	Tooltip *string `json:"tooltip,omitzero"`

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

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

type CommandOrCodeAction struct {
	Command    *Command
	CodeAction *CodeAction
}

type CommandOrCodeActionArrayOrNull struct {
	CommandOrCodeActionArray *[]CommandOrCodeAction
}

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

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

	CompletionItemKind *ClientCompletionItemOptionsKind `json:"completionItemKind,omitzero"`

	// Defines how the client handles whitespace and indentation
	// when accepting a completion item that uses multi line
	// text in either `insertText` or `textEdit`.
	//
	// Since: 3.17.0
	InsertTextMode *InsertTextMode `json:"insertTextMode,omitzero"`

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

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

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,omitzero"`
}

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,omitzero"`

	// The kind of this completion item. Based of the kind
	// an icon is chosen by the editor.
	Kind *CompletionItemKind `json:"kind,omitzero"`

	// Tags for this completion item.
	//
	// Since: 3.15.0
	Tags *[]CompletionItemTag `json:"tags,omitzero"`

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

	// A human-readable string that represents a doc-comment.
	Documentation *StringOrMarkupContent `json:"documentation,omitzero"`

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

	// 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,omitzero"`

	// A string that should be used when comparing this item
	// with other items. When `falsy` the label
	// is used.
	SortText *string `json:"sortText,omitzero"`

	// A string that should be used when filtering a set of
	// completion items. When `falsy` the label
	// is used.
	FilterText *string `json:"filterText,omitzero"`

	// A string that should be inserted into a document when selecting
	// this completion. When `falsy` the label
	// is used.
	//
	// 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,omitzero"`

	// 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,omitzero"`

	// How whitespace and indentation is handled during completion
	// item insertion. If not provided the clients default value depends on
	// the `textDocument.completion.insertTextMode` client capability.
	//
	// Since: 3.16.0
	InsertTextMode *InsertTextMode `json:"insertTextMode,omitzero"`

	// An edit which is applied to a document when selecting
	// this completion. When an edit is provided the value of
	// insertText is ignored.
	//
	// 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 `InsertReplaceEdits` via the
	// `textDocument.completion.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 *TextEditOrInsertReplaceEdit `json:"textEdit,omitzero"`

	// 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,omitzero"`

	// An optional array of additional 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,omitzero"`

	// 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,omitzero"`

	// 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,omitzero"`

	// A data entry field that is preserved on a completion item between a
	// CompletionRequest and a CompletionResolveRequest.
	Data *any `json:"data,omitzero"`
}

type CompletionItemApplyKinds struct {
	// Specifies whether commitCharacters on a completion will replace or be
	// merged with those in `completionList.itemDefaults.commitCharacters`.
	//
	// If ApplyKind.Replace, the commit characters from the completion item will
	// always be used unless not provided, in which case those from
	// `completionList.itemDefaults.commitCharacters` will be used. An
	// empty list can be used if a completion item does not have any commit
	// characters and also should not use those from
	// `completionList.itemDefaults.commitCharacters`.
	//
	// If ApplyKind.Merge the commitCharacters for the completion will be the
	// union of all values in both `completionList.itemDefaults.commitCharacters`
	// and the completion's own `commitCharacters`.
	//
	// Since: 3.18.0
	CommitCharacters *ApplyKind `json:"commitCharacters,omitzero"`

	// Specifies whether the `data` field on a completion will replace or
	// be merged with data from `completionList.itemDefaults.data`.
	//
	// If ApplyKind.Replace, the data from the completion item will be used if
	// provided (and not `null`), otherwise
	// `completionList.itemDefaults.data` will be used. An empty object can
	// be used if a completion item does not have any data but also should
	// not use the value from `completionList.itemDefaults.data`.
	//
	// If ApplyKind.Merge, a shallow merge will be performed between
	// `completionList.itemDefaults.data` and the completion's own data
	// using the following rules:
	//
	// - If a completion's `data` field is not provided (or `null`), the
	//   entire `data` field from `completionList.itemDefaults.data` will be
	//   used as-is.
	// - If a completion's `data` field is provided, each field will
	//   overwrite the field of the same name in
	//   `completionList.itemDefaults.data` but no merging of nested fields
	//   within that value will occur.
	//
	// Since: 3.18.0
	Data *ApplyKind `json:"data,omitzero"`
}

type CompletionItemDefaults struct {
	// A default commit character set.
	//
	// Since: 3.17.0
	CommitCharacters *[]string `json:"commitCharacters,omitzero"`

	// A default edit range.
	//
	// Since: 3.17.0
	EditRange *RangeOrEditRangeWithInsertReplace `json:"editRange,omitzero"`

	// A default insert text format.
	//
	// Since: 3.17.0
	InsertTextFormat *InsertTextFormat `json:"insertTextFormat,omitzero"`

	// A default insert text mode.
	//
	// Since: 3.17.0
	InsertTextMode *InsertTextMode `json:"insertTextMode,omitzero"`

	// A default data value.
	//
	// Since: 3.17.0
	Data *any `json:"data,omitzero"`
}

type CompletionItemKind uint32

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

	// An optional string which is rendered less prominently after CompletionItem.detail. Should be used
	// for fully qualified names and file paths.
	Description *string `json:"description,omitzero"`
}

type CompletionItemTag uint32

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

type CompletionItemsOrListOrNull struct {
	Items *[]*CompletionItem
	List  *CompletionList
}

type CompletionList struct {
	// This list it not complete. Further typing results 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 rules for combining these are
	// defined by `applyKinds` (if the client supports it), defaulting to
	// ApplyKind.Replace.
	//
	// 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,omitzero"`

	// Specifies how fields from a completion item should be combined with those
	// from `completionList.itemDefaults`.
	//
	// If unspecified, all fields will be treated as ApplyKind.Replace.
	//
	// If a field's value is ApplyKind.Replace, the value from a completion item
	// (if provided and not `null`) will always be used instead of the value
	// from `completionItem.itemDefaults`.
	//
	// If a field's value is ApplyKind.Merge, the values will be merged using
	// the rules defined against each field below.
	//
	// Servers are only allowed to return `applyKind` if the client
	// signals support for this via the `completionList.applyKindSupport`
	// capability.
	//
	// Since: 3.18.0
	ApplyKind *CompletionItemApplyKinds `json:"applyKind,omitzero"`

	// 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,omitzero"`

	// Specifies whether the client supports `CompletionList.applyKind` to
	// indicate how supported values from `completionList.itemDefaults`
	// and `completion` will be combined.
	//
	// If a client supports `applyKind` it must support it for all fields
	// that it supports that are listed in `CompletionList.applyKind`. This
	// means when clients add support for new/future fields in completion
	// items the MUST also support merge for them if those fields are
	// defined in `CompletionList.applyKind`.
	//
	// Since: 3.18.0
	ApplyKindSupport *bool `json:"applyKindSupport,omitzero"`
}