lsproto

type AnnotatedTextEdit struct {
	TextEdit

	// The actual identifier of the change annotation
	AnnotationId ChangeAnnotationIdentifier `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,omitempty"`

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

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

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

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

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

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

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 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`.
	SelectionRange Range `json:"selectionRange"`

	// A data entry field that is preserved between a call hierarchy prepare and
	// incoming calls or outgoing calls requests.
	Data *LSPAny `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 `provideCallHierarchyOutgoingCalls`
	// and not `this.to`.
	FromRanges []Range `json:"fromRanges"`
}

type CallHierarchyOutgoingCallsParams struct {
	WorkDoneProgressParams
	PartialResultParams

	Item CallHierarchyItem `json:"item"`
}

type CallHierarchyPrepareParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
}

type CallHierarchyRegistrationOptions struct {
	TextDocumentRegistrationOptions
	CallHierarchyOptions
	StaticRegistrationOptions
}

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

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

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

type ChangeAnnotationIdentifier = string

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

type ClientCapabilities struct {
	// Workspace specific client capabilities.
	Workspace *WorkspaceClientCapabilities `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:"notebookDocument,omitempty"`

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

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

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

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

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

	// Client supports the following 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 *CompletionItemTagOptions `json:"tagSupport,omitempty"`

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

	// 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,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 *ClientCompletionItemInsertTextModeOptions `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 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,omitempty"`
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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,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](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,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"`

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

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

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

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

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

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

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

type CodeActionParams struct {
	WorkDoneProgressParams
	PartialResultParams

	// 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 {
	TextDocumentRegistrationOptions
	CodeActionOptions
}

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

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

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

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

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 CodeLensRegistrationOptions struct {
	TextDocumentRegistrationOptions
	CodeLensOptions
}

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

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

type ColorPresentationParams struct {
	WorkDoneProgressParams
	PartialResultParams

	// 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 Command struct {
	// Title of the command, like `save`.
	Title string `json:"title"`

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

	// 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 *ClientCompletionItemOptions `json:"completionItem,omitempty"`

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

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

	// The client supports to send additional context information for a
	// `textDocument/completion` request.
	ContextSupport *bool `json:"contextSupport,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 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.
	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.
	Documentation *StringOrMarkupContent `json:"documentation,omitempty"`

	// Indicates if this item is deprecated.
	//
	// Deprecated: Use `tags` instead.
	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 `falsy` the label
	// is used.
	SortText *string `json:"sortText,omitempty"`

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

	// 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,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 clients default value depends on
	// the `textDocument.completion.insertTextMode` client capability.
	//
	// Since: 3.16.0
	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.
	//
	// 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,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 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
	// CompletionRequest and a CompletionResolveRequest.
	Data *LSPAny `json:"data,omitempty"`
}

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

	// 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,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
	EditRange *RangeOrEditRangeWithInsertReplace `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 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,omitempty"`

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

type CompletionItemTag uint32

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

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

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

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

type CompletionOptions struct {
	WorkDoneProgressOptions

	// Most tools trigger 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.
	//
	// If code complete should automatically be trigger on characters not being valid inside
	// an identifier (for example `.` in JavaScript) list them in `triggerCharacters`.
	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
	// `ClientCapabilities.textDocument.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 *ServerCompletionItemOptions `json:"completionItem,omitempty"`
}

type CompletionParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams

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

type CompletionRegistrationOptions struct {
	TextDocumentRegistrationOptions
	CompletionOptions
}

type CompletionTriggerKind uint32

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 {
	ResourceOperation

	// A create
	Kind StringLiteralCreate `json:"kind"`

	// The resource to create.
	Uri DocumentUri `json:"uri"`

	// Additional options
	Options *CreateFileOptions `json:"options,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 Declaration = LocationOrLocations

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 DeclarationLink = LocationLink

type DeclarationOptions struct {
	WorkDoneProgressOptions
}

type DeclarationParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams
}

type DeclarationRegistrationOptions struct {
	DeclarationOptions
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
}

type Definition = LocationOrLocations

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

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

type DefinitionLink = LocationLink

type DefinitionOptions struct {
	WorkDoneProgressOptions
}

type DefinitionParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams
}

type DefinitionRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DefinitionOptions
}

type DeleteFile struct {
	ResourceOperation

	// A delete
	Kind StringLiteralDelete `json:"kind"`

	// The file to delete.
	Uri DocumentUri `json:"uri"`

	// Delete options.
	Options *DeleteFileOptions `json:"options,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. To avoid interpretation mismatches when a
	// server is used with different clients it is highly recommended that servers
	// always provide a severity value.
	Severity *DiagnosticSeverity `json:"severity,omitempty"`

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

	// An optional property to describe the error code.
	// Requires the code field (above) to be present/not null.
	//
	// 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'. It usually
	// appears in the user interface.
	Source *string `json:"source,omitempty"`

	// The diagnostic's message. It usually appears in the user interface
	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 *LSPAny `json:"data,omitempty"`
}

type DiagnosticClientCapabilities struct {
	DiagnosticsCapabilities

	// 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 supports 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 DiagnosticOptionsOrDiagnosticRegistrationOptions struct {
	DiagnosticOptions             *DiagnosticOptions
	DiagnosticRegistrationOptions *DiagnosticRegistrationOptions
}

type DiagnosticRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DiagnosticOptions
	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 DiagnosticServerCancellationData struct {
	RetriggerRequest bool `json:"retriggerRequest"`
}

type DiagnosticSeverity uint32

type DiagnosticTag uint32

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 DiagnosticsCapabilities struct {
	// Whether the clients accepts diagnostics with related information.
	RelatedInformation *bool `json:"relatedInformation,omitempty"`

	// Client supports the tag property to provide meta data about a diagnostic.
	// Clients supporting tags have to handle unknown tags gracefully.
	//
	// Since: 3.15.0
	TagSupport *ClientDiagnosticsTagOptions `json:"tagSupport,omitempty"`

	// Client supports a codeDescription property
	//
	// Since: 3.16.0
	CodeDescriptionSupport *bool `json:"codeDescriptionSupport,omitempty"`

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

type DidChangeConfigurationClientCapabilities struct {
	// Did change configuration notification supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

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

type DidChangeConfigurationRegistrationOptions struct {
	Section *StringOrStrings `json:"section,omitempty"`
}

type DidChangeNotebookDocumentParams struct {
	// The notebook document that did change. The version number points
	// to the version after all provided changes have been applied. If
	// only the text document content of a cell changes the notebook version
	// doesn't necessarily have to change.
	NotebookDocument VersionedNotebookDocumentIdentifier `json:"notebookDocument"`

	// The actual changes to the notebook document.
	//
	// The changes describe single state changes to the notebook document.
	// So if there are two changes c1 (at array index 0) and c2 (at array
	// index 1) for a notebook in state S then c1 moves the notebook 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 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.
	//   - apply the `NotebookChangeEvent`s in a single notification 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.
	ContentChanges []TextDocumentContentChangeEvent `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 pattern
	// or not.
	//
	// Since: 3.17.0
	RelativePatternSupport *bool `json:"relativePatternSupport,omitempty"`
}

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

type DidChangeWatchedFilesRegistrationOptions struct {
	// The watchers to register.
	Watchers []FileSystemWatcher `json:"watchers"`
}

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

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

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

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

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

	// 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 got saved.
	NotebookDocument NotebookDocumentIdentifier `json:"notebookDocument"`
}

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

	// Optional the content when saved. Depends on the includeText value
	// when the save notification was requested.
	Text *string `json:"text,omitempty"`
}

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

type DocumentColorOptions struct {
	WorkDoneProgressOptions
}

type DocumentColorParams struct {
	WorkDoneProgressParams
	PartialResultParams

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

type DocumentColorRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentColorOptions
	StaticRegistrationOptions
}

type DocumentDiagnosticParams struct {
	WorkDoneProgressParams
	PartialResultParams

	// 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 DocumentDiagnosticReport = RelatedFullDocumentDiagnosticReportOrRelatedUnchangedDocumentDiagnosticReport

type DocumentDiagnosticReportKind string

type DocumentDiagnosticReportPartialResult struct {
	RelatedDocuments map[DocumentUri]FullDocumentDiagnosticReportOrUnchangedDocumentDiagnosticReport `json:"relatedDocuments"`
}

type DocumentFilter = TextDocumentFilterOrNotebookCellTextDocumentFilter

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

type DocumentFormattingOptions struct {
	WorkDoneProgressOptions
}

type DocumentFormattingParams struct {
	WorkDoneProgressParams

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

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

type DocumentFormattingRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentFormattingOptions
}

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

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

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

type DocumentHighlightKind uint32

type DocumentHighlightOptions struct {
	WorkDoneProgressOptions
}

type DocumentHighlightParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams
}

type DocumentHighlightRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentHighlightOptions
}

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 *URI `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 DocumentLinkOptions struct {
	WorkDoneProgressOptions

	// Document links have 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 DocumentLinkRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentLinkOptions
}

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

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 DocumentOnTypeFormattingRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentOnTypeFormattingOptions
}

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

	// Whether the client supports formatting multiple ranges at once.
	//
	// Since: 3.18.0
	//
	// Proposed.
	RangesSupport *bool `json:"rangesSupport,omitempty"`
}

type DocumentRangeFormattingOptions struct {
	WorkDoneProgressOptions

	// Whether the server supports formatting multiple ranges at once.
	//
	// Since: 3.18.0
	//
	// Proposed.
	RangesSupport *bool `json:"rangesSupport,omitempty"`
}

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 DocumentRangeFormattingRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentRangeFormattingOptions
}

type DocumentRangesFormattingParams struct {
	WorkDoneProgressParams

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

	// The ranges to format
	Ranges []Range `json:"ranges"`

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

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 document 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 *ClientSymbolKindOptions `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 *ClientSymbolTagOptions `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 DocumentSymbolOptions struct {
	WorkDoneProgressOptions

	// A human-readable string that is shown when multiple outlines 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 DocumentSymbolRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentSymbolOptions
}

type DocumentUri string // !!!

type EditRangeWithInsertReplace struct {
	Insert Range `json:"insert"`

	Replace Range `json:"replace"`
}

type ErrorCode struct {
	Name string
	Code int32
}

type ErrorCodes int32

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 ExecuteCommandRegistrationOptions struct {
	ExecuteCommandOptions
}

type ExecutionSummary struct {
	// A strict monotonically increasing value
	// indicating the execution order of a cell
	// inside a notebook.
	ExecutionOrder uint32 `json:"executionOrder"`

	// Whether the execution was successful or
	// not if known by the client.
	Success *bool `json:"success,omitempty"`
}

type FailureHandlingKind string

type FileChangeType uint32

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 registration 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 scheme like `file` or `untitled`.
	Scheme *string `json:"scheme,omitempty"`

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

type FileOperationOptions struct {
	// The server is interested in receiving didCreateFiles notifications.
	DidCreate *FileOperationRegistrationOptions `json:"didCreate,omitempty"`

	// The server is interested in receiving willCreateFiles requests.
	WillCreate *FileOperationRegistrationOptions `json:"willCreate,omitempty"`

	// The server is interested in receiving didRenameFiles notifications.
	DidRename *FileOperationRegistrationOptions `json:"didRename,omitempty"`

	// The server is interested in receiving willRenameFiles requests.
	WillRename *FileOperationRegistrationOptions `json:"willRename,omitempty"`

	// The server is interested in receiving didDeleteFiles file notifications.
	DidDelete *FileOperationRegistrationOptions `json:"didDelete,omitempty"`

	// The server is interested in receiving willDeleteFiles file requests.
	WillDelete *FileOperationRegistrationOptions `json:"willDelete,omitempty"`
}

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 original 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 FileSystemWatcher struct {
	// The glob pattern to watch. See pattern for more detail.
	//
	// Since: 3.17.0 support for relative patterns.
	GlobPattern GlobPattern `json:"globPattern"`

	// The kind of events of interest. If omitted it defaults
	// to WatchKind.Create | WatchKind.Change | WatchKind.Delete
	// which is 7.
	Kind *WatchKind `json:"kind,omitempty"`
}

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 uint32 `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 *uint32 `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 uint32 `json:"endLine"`

	// The zero-based character offset before the folded range ends. If not defined, defaults to the length of the end line.
	EndCharacter *uint32 `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 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
	CollapsedText *string `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 *uint32 `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 *ClientFoldingRangeKindOptions `json:"foldingRangeKind,omitempty"`

	// Specific options for the folding range.
	//
	// Since: 3.17.0
	FoldingRange *ClientFoldingRangeOptions `json:"foldingRange,omitempty"`
}

type FoldingRangeKind string

type FoldingRangeOptions struct {
	WorkDoneProgressOptions
}

type FoldingRangeParams struct {
	WorkDoneProgressParams
	PartialResultParams

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

type FoldingRangeRegistrationOptions struct {
	TextDocumentRegistrationOptions
	FoldingRangeOptions
	StaticRegistrationOptions
}

type FoldingRangeWorkspaceClientCapabilities 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
	// folding ranges 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.
	//
	// Since: 3.18.0
	//
	// Proposed.
	RefreshSupport *bool `json:"refreshSupport,omitempty"`
}

type FormattingOptions struct {
	// Size of a tab in spaces.
	TabSize uint32 `json:"tabSize"`

	// Prefer spaces over tabs.
	InsertSpaces bool `json:"insertSpaces"`

	// Trim trailing whitespace on a line.
	//
	// Since: 3.15.0
	TrimTrailingWhitespace *bool `json:"trimTrailingWhitespace,omitempty"`

	// Insert a newline character at the end of the file if one does not exist.
	//
	// Since: 3.15.0
	InsertFinalNewline *bool `json:"insertFinalNewline,omitempty"`

	// Trim all newlines after the final newline at the end of the file.
	//
	// Since: 3.15.0
	TrimFinalNewlines *bool `json:"trimFinalNewlines,omitempty"`
}

type FullDocumentDiagnosticReport struct {
	// A full document diagnostic report.
	Kind StringLiteralFull `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 FullDocumentDiagnosticReportOrUnchangedDocumentDiagnosticReport struct {
	FullDocumentDiagnosticReport      *FullDocumentDiagnosticReport
	UnchangedDocumentDiagnosticReport *UnchangedDocumentDiagnosticReport
}

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
	// anymore since the information is outdated).
	//
	// Since: 3.17.0
	StaleRequestSupport *StaleRequestSupportOptions `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
	// sides.
	//
	// 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 GlobPattern = PatternOrRelativePattern

type Hover struct {
	// The hover's content
	Contents MarkupContentOrMarkedStringOrMarkedStrings `json:"contents,omitempty"`

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

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

	// Client supports the following content formats for the content
	// property. The order describes the preferred format of the client.
	ContentFormat *[]MarkupKind `json:"contentFormat,omitempty"`
}

type HoverOptions struct {
	WorkDoneProgressOptions
}

type HoverParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
}

type HoverRegistrationOptions struct {
	TextDocumentRegistrationOptions
	HoverOptions
}

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

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

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

type ImplementationOptions struct {
	WorkDoneProgressOptions
}

type ImplementationParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams
}

type ImplementationRegistrationOptions struct {
	TextDocumentRegistrationOptions
	ImplementationOptions
	StaticRegistrationOptions
}

type InitializeError struct {
	// Indicates whether the client execute the following retry logic:
	// (1) show the message provided by the ResponseError to the user
	// (2) user selects retry or cancel
	// (3) if user selected retry the initialize method is sent again.
	Retry bool `json:"retry"`
}

type InitializeParams struct {
	WorkspaceFoldersInitializeParams
	// contains filtered or unexported fields
}

type InitializeResult struct {
	// The capabilities the language server provides.
	Capabilities ServerCapabilities `json:"capabilities"`

	// Information about the server.
	//
	// Since: 3.15.0
	ServerInfo *ServerInfo `json:"serverInfo,omitempty"`
}

type InitializedParams struct {
}

type InlayHint struct {
	// The position of this hint.
	//
	// If multiple hints have the same position, they will be shown in the order
	// they appear in the response.
	Position Position `json:"position"`

	// The label of this hint. A human readable string or an array of
	// InlayHintLabelPart label parts.
	//
	// *Note* that neither the string nor the label part can be empty.
	Label StringOrInlayHintLabelParts `json:"label,omitempty"`

	// The kind of this hint. Can be omitted in which case the client
	// should fall back to a reasonable default.
	Kind *InlayHintKind `json:"kind,omitempty"`

	// Optional text edits that are performed when accepting this inlay hint.
	//
	// *Note* that edits are expected to change the document so that the inlay
	// hint (or its nearest variant) is now part of the document and the inlay
	// hint itself is now obsolete.
	TextEdits *[]TextEdit `json:"textEdits,omitempty"`

	// The tooltip text when you hover over this item.
	Tooltip *StringOrMarkupContent `json:"tooltip,omitempty"`

	// Render padding before the hint.
	//
	// Note: Padding should use the editor's background color, not the
	// background color of the hint itself. That means padding can be used
	// to visually align/separate an inlay hint.
	PaddingLeft *bool `json:"paddingLeft,omitempty"`

	// Render padding after the hint.
	//
	// Note: Padding should use the editor's background color, not the
	// background color of the hint itself. That means padding can be used
	// to visually align/separate an inlay hint.
	PaddingRight *bool `json:"paddingRight,omitempty"`

	// A data entry field that is preserved on an inlay hint between
	// a `textDocument/inlayHint` and a `inlayHint/resolve` request.
	Data *LSPAny `json:"data,omitempty"`
}

type InlayHintClientCapabilities struct {
	// Whether inlay hints support dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// Indicates which properties a client can resolve lazily on an inlay
	// hint.
	ResolveSupport *ClientInlayHintResolveOptions `json:"resolveSupport,omitempty"`
}

type InlayHintKind uint32

type InlayHintLabelPart struct {
	// The value of this label part.
	Value string `json:"value"`

	// The tooltip text when you hover over this label part. Depending on
	// the client capability `inlayHint.resolveSupport` clients might resolve
	// this property late using the resolve request.
	Tooltip *StringOrMarkupContent `json:"tooltip,omitempty"`

	// An optional source code location that represents this
	// label part.
	//
	// The editor will use this location for the hover and for code navigation
	// features: This part will become a clickable link that resolves to the
	// definition of the symbol at the given location (not necessarily the
	// location itself), it shows the hover that shows at the given location,
	// and it shows a context menu with further code navigation commands.
	//
	// Depending on the client capability `inlayHint.resolveSupport` clients
	// might resolve this property late using the resolve request.
	Location *Location `json:"location,omitempty"`

	// An optional command for this label part.
	//
	// Depending on the client capability `inlayHint.resolveSupport` clients
	// might resolve this property late using the resolve request.
	Command *Command `json:"command,omitempty"`
}

type InlayHintOptions struct {
	WorkDoneProgressOptions

	// The server provides support to resolve additional
	// information for an inlay hint item.
	ResolveProvider *bool `json:"resolveProvider,omitempty"`
}

type InlayHintParams struct {
	WorkDoneProgressParams

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

	// The document range for which inlay hints should be computed.
	Range Range `json:"range"`
}

type InlayHintRegistrationOptions struct {
	InlayHintOptions
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
}

type InlayHintWorkspaceClientCapabilities 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
	// inlay hints 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 InlineCompletionClientCapabilities struct {
	// Whether implementation supports dynamic registration for inline completion providers.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type InlineCompletionContext struct {
	// Describes how the inline completion was triggered.
	TriggerKind InlineCompletionTriggerKind `json:"triggerKind"`

	// Provides information about the currently selected item in the autocomplete widget if it is visible.
	SelectedCompletionInfo *SelectedCompletionInfo `json:"selectedCompletionInfo,omitempty"`
}

type InlineCompletionItem struct {
	// The text to replace the range with. Must be set.
	InsertText StringOrStringValue `json:"insertText,omitempty"`

	// A text that is used to decide if this inline completion should be shown. When `falsy` the InlineCompletionItem.insertText is used.
	FilterText *string `json:"filterText,omitempty"`

	// The range to replace. Must begin and end on the same line.
	Range *Range `json:"range,omitempty"`

	// An optional Command that is executed *after* inserting this completion.
	Command *Command `json:"command,omitempty"`
}

type InlineCompletionList struct {
	// The inline completion items
	Items []InlineCompletionItem `json:"items"`
}

type InlineCompletionOptions struct {
	WorkDoneProgressOptions
}

type InlineCompletionParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams

	// Additional information about the context in which inline completions were
	// requested.
	Context InlineCompletionContext `json:"context"`
}

type InlineCompletionRegistrationOptions struct {
	InlineCompletionOptions
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
}

type InlineCompletionTriggerKind uint32

type InlineValue = InlineValueTextOrInlineValueVariableLookupOrInlineValueEvaluatableExpression

type InlineValueClientCapabilities struct {
	// Whether implementation supports dynamic registration for inline value providers.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type InlineValueContext struct {
	// The stack frame (as a DAP Id) where the execution has stopped.
	FrameId int32 `json:"frameId"`

	// The document range where execution has stopped.
	// Typically the end position of the range denotes the line where the inline values are shown.
	StoppedLocation Range `json:"stoppedLocation"`
}

type InlineValueEvaluatableExpression struct {
	// The document range for which the inline value applies.
	// The range is used to extract the evaluatable expression from the underlying document.
	Range Range `json:"range"`

	// If specified the expression overrides the extracted expression.
	Expression *string `json:"expression,omitempty"`
}

type InlineValueOptions struct {
	WorkDoneProgressOptions
}

type InlineValueParams struct {
	WorkDoneProgressParams

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

	// The document range for which inline values should be computed.
	Range Range `json:"range"`

	// Additional information about the context in which inline values were
	// requested.
	Context InlineValueContext `json:"context"`
}

type InlineValueRegistrationOptions struct {
	InlineValueOptions
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
}

type InlineValueText struct {
	// The document range for which the inline value applies.
	Range Range `json:"range"`

	// The text of the inline value.
	Text string `json:"text"`
}

type InlineValueTextOrInlineValueVariableLookupOrInlineValueEvaluatableExpression struct {
	InlineValueText                  *InlineValueText
	InlineValueVariableLookup        *InlineValueVariableLookup
	InlineValueEvaluatableExpression *InlineValueEvaluatableExpression
}

type InlineValueVariableLookup struct {
	// The document range for which the inline value applies.
	// The range is used to extract the variable name from the underlying document.
	Range Range `json:"range"`

	// If specified the name of the variable to look up.
	VariableName *string `json:"variableName,omitempty"`

	// How to perform the lookup.
	CaseSensitiveLookup bool `json:"caseSensitiveLookup"`
}

type InlineValueWorkspaceClientCapabilities 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
	// inline values 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 InsertReplaceEdit struct {
	// The string to be inserted.
	NewText string `json:"newText"`

	// The range if the insert is requested
	Insert Range `json:"insert"`

	// The range if the replace is requested.
	Replace Range `json:"replace"`
}

type InsertTextFormat uint32

type InsertTextMode uint32

type IntegerOrString struct {
	Integer *int32
	String  *string
}

type JSONRPCVersion struct{}