defines

type AnnotatedTextEdit struct {
	TextEdit

	// The actual identifier of the change annotation
	AnnotationId ChangeAnnotationIdentifier `json:"annotationId,omitempty"`
}

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

type ApplyWorkspaceEditRequest string

type ApplyWorkspaceEditResponse ApplyWorkspaceEditResult

type ApplyWorkspaceEditResult struct {

	// Indicates whether the edit was applied or not.
	Applied bool `json:"applied,omitempty"`

	// 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 *uint `json:"failedChange,omitempty"`
}

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

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

type CallHierarchyIncomingCallsParams struct {
	WorkDoneProgressParams
	PartialResultParams

	Item CallHierarchyItem `json:"item,omitempty"`
}

type CallHierarchyItem struct {

	// The name of this item.
	Name string `json:"name,omitempty"`

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

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

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

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

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

type CallHierarchyOptions struct {
	WorkDoneProgressOptions
}

type CallHierarchyOutgoingCall struct {

	// The item that is called.
	To CallHierarchyItem `json:"to,omitempty"`

	// The range at which this item is called. This is the range relative to the caller, e.g the item
	// passed to [`provideCallHierarchyOutgoingCalls`](#CallHierarchyItemProvider.provideCallHierarchyOutgoingCalls)
	// and not [`this.to`](#CallHierarchyOutgoingCall.to).
	FromRanges []Range `json:"fromRanges,omitempty"`
}

type CallHierarchyOutgoingCallsParams struct {
	WorkDoneProgressParams
	PartialResultParams

	Item CallHierarchyItem `json:"item,omitempty"`
}

type CallHierarchyPrepareParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
}

type CallHierarchyRegistrationOptions struct {
	TextDocumentRegistrationOptions
	CallHierarchyOptions
	StaticRegistrationOptions
}

type ChangeAnnotation struct {

	// A human-readable string describing the actual change. The string
	// is rendered prominent in the user interface.
	Label string `json:"label,omitempty"`

	// 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 ClientCapabilities struct {
	WorkspaceFoldersClientCapabilities
	ConfigurationClientCapabilities
	WorkDoneProgressClientCapabilities
	// contains filtered or unexported fields
}

type CodeAction struct {

	// A short, human-readable, title for this code action.
	Title string `json:"title,omitempty"`

	// 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 [lightbulb](https:code.visualstudio.comdocseditoreditingevolved#_code-action)
	// code action menu.
	//
	// - Disabled actions are shown as faded out in the code action menu when the user request a more specific type
	// of code action, such as refactorings.
	//
	// - If the user has a [keybinding](https:code.visualstudio.comdocseditorrefactoring#_keybindings-for-code-actions)
	// that auto applies a code action and only a disabled code actions are returned, the client should show the user an
	// error message with `reason` in the editor.
	//
	// @since 3.16.0
	Disabled *struct {

		// Human readable description of why the code action is currently disabled.
		//
		// This is displayed in the code actions UI.
		Reason string `json:"reason,omitempty"`
	} `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 a 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 `textDocumentcodeAction` and a `codeActionresolve` request.
	//
	// @since 3.16.0
	Data interface{} `json:"data,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 `textDocumentcodeAction` request. If the property is not
	// set the request can only return `Command` literals.
	//
	// @since 3.8.0
	CodeActionLiteralSupport *struct {

		// The code action kind is support with the following value
		// set.
		CodeActionKind struct {

			// The code action kind values the client supports. When this
			// property exists the client also guarantees that it will
			// handle values outside its set gracefully and falls back
			// to a default value when unknown.
			ValueSet []CodeActionKind `json:"valueSet,omitempty"`
		} `json:"codeActionKind,omitempty"`
	} `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 `textDocumentcodeAction` and a
	// `codeActionresolve` request.
	//
	// @since 3.16.0
	DataSupport *bool `json:"dataSupport,omitempty"`

	// Whether the client support resolving additional code action
	// properties via a separate `codeActionresolve` request.
	//
	// @since 3.16.0
	ResolveSupport *struct {

		// The properties that a client can resolve lazily.
		Properties []string `json:"properties,omitempty"`
	} `json:"resolveSupport,omitempty"`

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

type CodeActionContext struct {

	// An array of diagnostics known on the client side overlapping the range provided to the
	// `textDocumentcodeAction` 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,omitempty"`

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

type CodeActionKind string

type CodeActionOptions struct {
	WorkDoneProgressOptions

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

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

type CodeActionParams struct {
	WorkDoneProgressParams
	PartialResultParams

	// The document in which the command was invoked.
	TextDocument TextDocumentIdentifier `json:"textDocument,omitempty"`

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

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

type CodeActionRegistrationOptions struct {
	TextDocumentRegistrationOptions
	CodeActionOptions
}

type CodeActionRequest string

type CodeActionResolveRequest string

type CodeDescription struct {

	// An URI to open with more information about the diagnostic error.
	Href URI `json:"href,omitempty"`
}

type CodeLens struct {

	// The range in which this code lens is valid. Should only span a single line.
	Range Range `json:"range,omitempty"`

	// 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](#CodeLensRequest) and a [CodeLensResolveRequest]
	// (#CodeLensResolveRequest)
	Data interface{} `json:"data,omitempty"`
}

type CodeLensClientCapabilities struct {

	// Whether code lens supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,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,omitempty"`
}

type CodeLensRefreshRequest string

type CodeLensRegistrationOptions struct {
	TextDocumentRegistrationOptions
	CodeLensOptions
}

type CodeLensRequest string

type CodeLensResolveRequest string

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 float32 `json:"red,omitempty"`

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

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

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

type ColorInformation struct {

	// The range in the document where this color appears.
	Range Range `json:"range,omitempty"`

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

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

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

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

type ColorPresentationParams struct {
	WorkDoneProgressParams
	PartialResultParams

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

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

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

type Command struct {

	// Title of the command, like `save`.
	Title string `json:"title,omitempty"`

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

	// Arguments that the command handler should be
	// invoked with.
	Arguments *[]interface{} `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 interface{} `json:"completionItem,omitempty"` //i, n, t, e, r, f, a, c, e, {, },  ,  , /, /,

	CompletionItemKind *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"`
	} `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
	// `textDocumentcompletion` request.
	ContextSupport *bool `json:"contextSupport,omitempty"`
}

type CompletionContext struct {

	// How the completion was triggered.
	TriggerKind CompletionTriggerKind `json:"triggerKind,omitempty"`

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

	// Additional details for the label
	//
	// @since 3.17.0 - proposed state
	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 interface{} `json:"documentation,omitempty"` // string, MarkupContent,

	// 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](#CompletionItem.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](#CompletionItem.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](#CompletionItem.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 ignored the clients default value depends on
	// the `textDocument.completion.insertTextMode` client capability.
	//
	// @since 3.16.0
	InsertTextMode *InsertTextMode `json:"insertTextMode,omitempty"`

	// An [edit](#TextEdit) which is applied to a document when selecting
	// this completion. When an edit is provided the value of
	// [insertText](#CompletionItem.insertText) is ignored.
	//
	// Most editors support two different operation 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 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 a 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 interface{} `json:"textEdit,omitempty"` // TextEdit, InsertReplaceEdit,

	// An optional array of additional [text edits](#TextEdit) that are applied when
	// selecting this completion. Edits must not overlap (including the same insert position)
	// with the main [edit](#CompletionItem.textEdit) 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](#Command) that is executed after inserting this completion. Note that
	// additional modifications to the current document should be described with the
	// [additionalTextEdits](#CompletionItem.additionalTextEdits)-property.
	Command *Command `json:"command,omitempty"`

	// A data entry field that is preserved on a completion item between a
	// [CompletionRequest](#CompletionRequest) and a [CompletionResolveRequest](#CompletionResolveRequest).
	Data interface{} `json:"data,omitempty"`
}

type CompletionItemKind int

type CompletionItemLabelDetails struct {

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

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

type CompletionItemTag int

type CompletionList struct {

	// This list it not complete. Further typing results in recomputing this list.
	IsIncomplete bool `json:"isIncomplete,omitempty"`

	// The completion items.
	Items []CompletionItem `json:"items,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 - proposed state
	CompletionItem *struct {

		// The server has support for completion item label
		// details (see also `CompletionItemLabelDetails`) when
		// receiving a completion item in a resolve call.
		//
		// @since 3.17.0 - proposed state
		LabelDetailsSupport *bool `json:"labelDetailsSupport,omitempty"`
	} `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 CompletionRequest string

type CompletionResolveRequest string

type CompletionTriggerKind int

type ConfigurationClientCapabilities struct {

	// The workspace client capabilities
	Workspace *struct {

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

type ConfigurationItem struct {

	// The scope to get the configuration section for.
	ScopeUri *string `json:"scopeUri,omitempty"`

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

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

type CreateFile struct {
	ResourceOperation

	// A create
	Kind interface{} `json:"kind,omitempty"` // 'create'

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

	// 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 filesfolders created in this operation.
	Files []FileCreate `json:"files,omitempty"`
}

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 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 DefinitionRequest string

type DeleteFile struct {
	ResourceOperation

	// A delete
	Kind interface{} `json:"kind,omitempty"` // 'delete'

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

	// 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 filesfolders deleted in this operation.
	Files []FileDelete `json:"files,omitempty"`
}

type Diagnostic struct {

	// The range at which the message applies
	Range Range `json:"range,omitempty"`

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

	// The diagnostic's code, which usually appear in the user interface.
	Code interface{} `json:"code,omitempty"` // int, string,

	// An optional property to describe the error code.
	// Requires the code field (above) to be presentnot 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,omitempty"`

	// 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 `textDocumentpublishDiagnostics`
	// notification and `textDocumentcodeAction` request.
	//
	// @since 3.16.0
	Data interface{} `json:"data,omitempty"`
}

type DiagnosticClientCapabilities struct {

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

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

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

type DiagnosticRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DiagnosticOptions
	StaticRegistrationOptions
}

type DiagnosticRelatedInformation struct {

	// The location of this related diagnostic information.
	Location Location `json:"location,omitempty"`

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

type DiagnosticServerCancellationData struct {
	RetriggerRequest bool `json:"retriggerRequest,omitempty"`
}

type DiagnosticSeverity int

type DiagnosticTag int

type DidChangeConfigurationClientCapabilities struct {

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

type DidChangeConfigurationNotification string

type DidChangeConfigurationParams struct {

	// The actual changed settings
	Settings interface{} `json:"settings,omitempty"`
}

type DidChangeConfigurationRegistrationOptions struct {
	Section interface{} `json:"section,omitempty"` // string, []string,
}

type DidChangeTextDocumentNotification string

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

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

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

type DidChangeWatchedFilesNotification string

type DidChangeWatchedFilesParams struct {

	// The actual file events.
	Changes []FileEvent `json:"changes,omitempty"`
}

type DidChangeWatchedFilesRegistrationOptions struct {

	// The watchers to register.
	Watchers []FileSystemWatcher `json:"watchers,omitempty"`
}

type DidChangeWorkspaceFoldersParams struct {

	// The actual workspace folder change event.
	Event WorkspaceFoldersChangeEvent `json:"event,omitempty"`
}

type DidCloseTextDocumentNotification string

type DidCloseTextDocumentParams struct {

	// The document that was closed.
	TextDocument TextDocumentIdentifier `json:"textDocument,omitempty"`
}

type DidOpenTextDocumentNotification string

type DidOpenTextDocumentParams struct {

	// The document that was opened.
	TextDocument TextDocumentItem `json:"textDocument,omitempty"`
}

type DidSaveTextDocumentNotification string

type DidSaveTextDocumentParams struct {

	// The document that was closed.
	TextDocument TextDocumentIdentifier `json:"textDocument,omitempty"`

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

type DocumentColorRegistrationOptions struct {
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
	DocumentColorOptions
}

type DocumentDiagnosticParams struct {
	WorkDoneProgressParams
	PartialResultParams

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

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

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

type DocumentDiagnosticReportKind string

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

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

type DocumentFormattingRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentFormattingOptions
}

type DocumentFormattingRequest string

type DocumentHighlight struct {

	// The range this highlight applies to.
	Range Range `json:"range,omitempty"`

	// The highlight kind, default is [text](#DocumentHighlightKind.Text).
	Kind *DocumentHighlightKind `json:"kind,omitempty"`
}

type DocumentHighlightClientCapabilities struct {

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

type DocumentHighlightKind int

type DocumentHighlightOptions struct {
	WorkDoneProgressOptions
}

type DocumentHighlightParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams
}

type DocumentHighlightRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentHighlightOptions
}

type DocumentHighlightRequest string

type DocumentLink struct {

	// The range this link applies to.
	Range Range `json:"range,omitempty"`

	// The uri this link points to.
	Target *string `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 interface{} `json:"data,omitempty"`
}

type DocumentLinkClientCapabilities struct {

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

	// Whether the client support 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,omitempty"`
}

type DocumentLinkRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentLinkOptions
}

type DocumentLinkRequest string

type DocumentLinkResolveRequest string

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

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

type DocumentOnTypeFormattingParams struct {

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

	// The position at which this request was send.
	Position Position `json:"position,omitempty"`

	// The character that has been typed.
	Ch string `json:"ch,omitempty"`

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

type DocumentOnTypeFormattingRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentOnTypeFormattingOptions
}

type DocumentOnTypeFormattingRequest string

type DocumentRangeFormattingClientCapabilities struct {

	// Whether range formatting supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type DocumentRangeFormattingOptions struct {
	WorkDoneProgressOptions
}

type DocumentRangeFormattingParams struct {
	WorkDoneProgressParams

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

	// The range to format
	Range Range `json:"range,omitempty"`

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

type DocumentRangeFormattingRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentRangeFormattingOptions
}

type DocumentRangeFormattingRequest string

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

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

	// 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 leadingtrailing whitespace but everything else
	// like comments. This information is typically used to determine if the the clients cursor is
	// inside the symbol to reveal in the symbol in the UI.
	Range Range `json:"range,omitempty"`

	// 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 the `range`.
	SelectionRange Range `json:"selectionRange,omitempty"`

	// 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`.
	SymbolKind *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"`
	} `json:"symbolKind,omitempty"`

	// The client support 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 *struct {

		// The tags supported by the client.
		ValueSet []SymbolTag `json:"valueSet,omitempty"`
	} `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,omitempty"`
}

type DocumentSymbolRegistrationOptions struct {
	TextDocumentRegistrationOptions
	DocumentSymbolOptions
}

type DocumentSymbolRequest string

type DocumentUri string

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

type ExecuteCommandParams struct {
	WorkDoneProgressParams

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

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

type ExecuteCommandRegistrationOptions struct {
	ExecuteCommandOptions
}

type ExecuteCommandRequest string

type ExitNotification string

type FailureHandlingKind string

type FileChangeType int

type FileCreate struct {

	// A file: URI for the location of the filefolder being created.
	Uri string `json:"uri,omitempty"`
}

type FileDelete struct {

	// A file: URI for the location of the filefolder being deleted.
	Uri string `json:"uri,omitempty"`
}

type FileEvent struct {

	// The file's uri.
	Uri DocumentUri `json:"uri,omitempty"`

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

type FileOperationClientCapabilities struct {

	// Whether the client supports dynamic registration for file requestsnotifications.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

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

	// The client has support for 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 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 willDeleteFiles requests.
	WillDelete *bool `json:"willDelete,omitempty"`
}

type FileOperationFilter struct {

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

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

type FileOperationOptions struct {

	// The server is interested in didCreateFiles notifications.
	DidCreate *FileOperationRegistrationOptions `json:"didCreate,omitempty"`

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

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

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

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

	// The server is interested in 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,omitempty"`

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

type FileRename struct {

	// A file: URI for the original location of the filefolder being renamed.
	OldUri string `json:"oldUri,omitempty"`

	// A file: URI for the new location of the filefolder being renamed.
	NewUri string `json:"newUri,omitempty"`
}

type FileSystemWatcher struct {

	// The  glob pattern to watch. 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 conditions (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`)
	GlobPattern string `json:"globPattern,omitempty"`

	// The kind of events of interest. If omitted it defaults
	// to WatchKind.Create | WatchKind.Change | WatchKind.Delete
	// which is 7.
	Kind *uint `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 uint `json:"startLine,omitempty"`

	// The zero-based character offset from where the folded range starts. If not defined, defaults to the length of the start line.
	StartCharacter *uint `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 uint `json:"endLine,omitempty"`

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

	// Describes the kind of the folding range such as `comment' or 'region'. The kind
	// is used to categorize folding ranges and used by commands like 'Fold all comments'. See
	// [FoldingRangeKind](#FoldingRangeKind) for an enumeration of standardized kinds.
	Kind *string `json:"kind,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 *uint `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"`
}

type FoldingRangeKind string

type FoldingRangeOptions struct {
	WorkDoneProgressOptions
}

type FoldingRangeParams struct {
	WorkDoneProgressParams
	PartialResultParams

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

type FoldingRangeRegistrationOptions struct {
	TextDocumentRegistrationOptions
	FoldingRangeOptions
	StaticRegistrationOptions
}

type FormattingOptions struct {

	// Size of a tab in spaces.
	TabSize uint `json:"tabSize,omitempty"`

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

	// Trim trailing whitespaces 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"`

	// Signature for further properties.
	Key interface{} `json:"key,omitempty"` // bool, int, string, undefined,
}

type FullDocumentDiagnosticReport struct {
	Kind     interface{}   `json:"kind,omitempty"` // DocumentDiagnosticReportKind.full
	ResultId *string       `json:"resultId,omitempty"`
	Items    []interface{} `json:"items,omitempty"`
}

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 interface{} `json:"staleRequestSupport,omitempty"` // cancel, retryOnContentModified,

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

type Hover struct {

	// The hover's content
	Contents interface{} `json:"contents,omitempty"` // MarkupContent, MarkedString, []MarkedString,

	// An optional range
	Range *Range `json:"range,omitempty"`
}

type HoverClientCapabilities struct {

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

	// Client supports the follow 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 HoverRequest string

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

type InitializeErrorCode int

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

type InitializeRequest string

type InitializeResult struct {

	// The capabilities the language server provides.
	Capabilities ServerCapabilities `json:"capabilities,omitempty"`

	// Information about the server.
	//
	// @since 3.15.0
	ServerInfo *struct {
		Name    string  `json:"name,omitempty"`
		Version *string `json:"version,omitempty"`
	} `json:"serverInfo,omitempty"` // name, version,

	// Custom initialization results.
	Custom interface{} `json:"custom,omitempty"`
}

type InitializedNotification string

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

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

type InlineValueText struct {

	// The document range for which the inline value applies.
	Range Range `json:"range,omitempty"`

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

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

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

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

type InlineValuesClientCapabilities struct {

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

type InlineValuesContext struct {

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

type InlineValuesOptions struct {
	WorkDoneProgressOptions
}

type InlineValuesParams struct {
	WorkDoneProgressParams

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

	// The visible document range for which inline values should be computed.
	ViewPort Range `json:"viewPort,omitempty"`

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

type InlineValuesRegistrationOptions struct {
	InlineValuesOptions
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
}

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

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

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

type InsertTextFormat int

type InsertTextMode int

type LSPErrorCodes int

type LinkedEditingRangeClientCapabilities 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 LinkedEditingRangeOptions struct {
	WorkDoneProgressOptions
}

type LinkedEditingRangeParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
}

type LinkedEditingRangeRegistrationOptions struct {
	TextDocumentRegistrationOptions
	LinkedEditingRangeOptions
	StaticRegistrationOptions
}

type LinkedEditingRanges struct {

	// A list of ranges that can be edited together. The ranges must have
	// identical length and contain identical text content. The ranges cannot overlap.
	Ranges []Range `json:"ranges,omitempty"`

	// An optional word pattern (regular expression) that describes valid contents for
	// the given ranges. If no pattern is provided, the client configuration's word
	// pattern will be used.
	WordPattern *string `json:"wordPattern,omitempty"`
}

type Location struct {
	Uri DocumentUri `json:"uri,omitempty"`

	Range Range `json:"range,omitempty"`
}

type LocationLink struct {

	// Span of the origin of this link.
	//
	// Used as the underlined span for mouse definition hover. Defaults to the word range at
	// the definition position.
	OriginSelectionRange *Range `json:"originSelectionRange,omitempty"`

	// The target resource identifier of this link.
	TargetUri DocumentUri `json:"targetUri,omitempty"`

	// The full target range of this link. If the target for example is a symbol then target range is the
	// range enclosing this symbol not including leadingtrailing whitespace but everything else
	// like comments. This information is typically used to highlight the range in the editor.
	TargetRange Range `json:"targetRange,omitempty"`

	// The range that should be selected and revealed when this link is being followed, e.g the name of a function.
	// Must be contained by the the `targetRange`. See also `DocumentSymbol#range`
	TargetSelectionRange Range `json:"targetSelectionRange,omitempty"`
}

type LogMessageNotification string

type LogMessageParams struct {

	// The message type. See {@link MessageType}
	Type MessageType `json:"type,omitempty"`

	// The actual message
	Message string `json:"message,omitempty"`
}

type MarkdownClientCapabilities struct {

	// The name of the parser.
	Parser string `json:"parser,omitempty"`

	// The version of the parser.
	Version *string `json:"version,omitempty"`
}

type MarkupContent struct {

	// The type of the Markup
	Kind MarkupKind `json:"kind,omitempty"`

	// The content itself
	Value string `json:"value,omitempty"`
}

type MarkupKind string

type MessageActionItem struct {

	// A short title like 'Retry', 'Open Log' etc.
	Title string `json:"title,omitempty"`

	// Additional attributes that the client preserves and
	// sends back to the server. This depends on the client
	// capability window.messageActionItem.additionalPropertiesSupport
	Key interface{} `json:"key,omitempty"` // string, bool, int, interface{},
}

type MessageType int

type Moniker struct {

	// The scheme of the moniker. For example tsc or .Net
	Scheme string `json:"scheme,omitempty"`

	// The identifier of the moniker. The value is opaque in LSIF however
	// schema owners are allowed to define the structure if they want.
	Identifier string `json:"identifier,omitempty"`

	// The scope in which the moniker is unique
	Unique UniquenessLevel `json:"unique,omitempty"`

	// The moniker kind if known.
	Kind *MonikerKind `json:"kind,omitempty"`
}

type MonikerClientCapabilities struct {

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

type MonikerKind string

type MonikerOptions struct {
	WorkDoneProgressOptions
}

type MonikerParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams
}

type MonikerRegistrationOptions struct {
	TextDocumentRegistrationOptions
	MonikerOptions
}

type MonikerRequest string

type OptionalVersionedTextDocumentIdentifier struct {
	TextDocumentIdentifier

	// The version number of this document. If a versioned text document identifier
	// is sent from the server to the client and the file is not open in the editor
	// (the server has not received an open notification before) the server can send
	// `null` to indicate that the version is unknown and the content on disk is the
	// truth (as specified with document content ownership).
	Version interface{} `json:"version,omitempty"` // int, null,
}

type ParameterInformation struct {
	/**
	 * The label of this parameter information.
	 *
	 * Either a string or an inclusive start and exclusive end offsets within its containing
	 * signature label. (see SignatureInformation.label). The offsets are based on a UTF-16
	 * string representation as `Position` and `Range` does.
	 *
	 * *Note*: a label of type string should be a substring of its containing signature label.
	 * Its intended use case is to highlight the parameter label part in the `SignatureInformation.label`.
	 */
	Label interface{} `json:"label,omitempty"` // string | [int, int]
	/**
	 * The human-readable doc-comment of this signature. Will be shown
	 * in the UI but can be omitted.
	 */
	Documentation interface{} `json:"documentation,omitempty"` // string | MarkupContent
}

type PartialResultParams struct {

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

type Position struct {

	// Line position in a document (zero-based).
	Line uint `json:"line"`

	// Character offset on a line in a document (zero-based). Assuming that the line is
	// represented as a string, the `character` value represents the gap between the
	// `character` and `character + 1`.
	//
	// If the character value is greater than the line length it defaults back to the
	// line length.
	Character uint `json:"character"`
}

type PrepareRenameParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
}

type PrepareRenameRequest string

type PrepareSupportDefaultBehavior int

type PreviousResultId struct {
	Uri   URI    `json:"uri,omitempty"`
	Value string `json:"value,omitempty"`
}

type ProgressToken interface{} // number | string

type PublishDiagnosticsClientCapabilities 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 *struct {

		// The tags supported by the client.
		ValueSet []DiagnosticTag `json:"valueSet,omitempty"`
	} `json:"tagSupport,omitempty"`

	// Whether the client interprets the version property of the
	// `textDocumentpublishDiagnostics` notification`s parameter.
	//
	// @since 3.15.0
	VersionSupport *bool `json:"versionSupport,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 `textDocumentpublishDiagnostics` and
	// `textDocumentcodeAction` request.
	//
	// @since 3.16.0
	DataSupport *bool `json:"dataSupport,omitempty"`
}

type PublishDiagnosticsNotification string

type PublishDiagnosticsParams struct {

	// The URI for which diagnostic information is reported.
	Uri DocumentUri `json:"uri,omitempty"`

	// Optional the version number of the document the diagnostics are published for.
	//
	// @since 3.15.0
	Version *int `json:"version,omitempty"`

	// An array of diagnostic information items.
	Diagnostics []Diagnostic `json:"diagnostics"`
}

type Range struct {

	// The range's start position
	Start Position `json:"start,omitempty"`

	// The range's end position.
	End Position `json:"end,omitempty"`
}

type ReferenceClientCapabilities struct {

	// Whether references supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`
}

type ReferenceContext struct {

	// Include the declaration of the current symbol.
	IncludeDeclaration bool `json:"includeDeclaration,omitempty"`
}

type ReferenceOptions struct {
	WorkDoneProgressOptions
}

type ReferenceParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams

	Context ReferenceContext `json:"context,omitempty"`
}

type ReferenceRegistrationOptions struct {
	TextDocumentRegistrationOptions
	ReferenceOptions
}

type ReferencesRequest string

type Registration struct {

	// The id used to register the request. The id can be used to deregister
	// the request again.
	Id string `json:"id,omitempty"`

	// The method to register for.
	Method string `json:"method,omitempty"`

	// Options necessary for the registration.
	RegisterOptions interface{} `json:"registerOptions,omitempty"`
}

type RegistrationParams struct {
	Registrations []Registration `json:"registrations,omitempty"`
}

type RegistrationRequest string

type RegularExpressionsClientCapabilities struct {

	// The engine's name.
	Engine string `json:"engine,omitempty"`

	// The engine's version.
	Version *string `json:"version,omitempty"`
}

type RenameClientCapabilities struct {

	// Whether rename supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// Client supports testing for validity of rename operations
	// before execution.
	//
	// @since 3.12.0
	PrepareSupport *bool `json:"prepareSupport,omitempty"`

	// Client supports the default behavior result.
	//
	// The value indicates the default behavior used by the
	// client.
	//
	// @since 3.16.0
	PrepareSupportDefaultBehavior *PrepareSupportDefaultBehavior `json:"prepareSupportDefaultBehavior,omitempty"`

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

type RenameFile struct {
	ResourceOperation

	// A rename
	Kind interface{} `json:"kind,omitempty"` // 'rename'

	// The old (existing) location.
	OldUri DocumentUri `json:"oldUri,omitempty"`

	// The new location.
	NewUri DocumentUri `json:"newUri,omitempty"`

	// Rename options.
	Options *RenameFileOptions `json:"options,omitempty"`
}

type RenameFileOptions struct {

	// Overwrite target if existing. Overwrite wins over `ignoreIfExists`
	Overwrite *bool `json:"overwrite,omitempty"`

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

type RenameFilesParams struct {

	// An array of all filesfolders renamed in this operation. When a folder is renamed, only
	// the folder will be included, and not its children.
	Files []FileRename `json:"files,omitempty"`
}

type RenameOptions struct {
	WorkDoneProgressOptions

	// Renames should be checked and tested before being executed.
	//
	// @since version 3.12.0
	PrepareProvider *bool `json:"prepareProvider,omitempty"`
}

type RenameParams struct {
	WorkDoneProgressParams

	// The document to rename.
	TextDocument TextDocumentIdentifier `json:"textDocument,omitempty"`

	// The position at which this request was sent.
	Position Position `json:"position,omitempty"`

	// The new name of the symbol. If the given name is not valid the
	// request must return a [ResponseError](#ResponseError) with an
	// appropriate message set.
	NewName string `json:"newName,omitempty"`
}

type RenameRegistrationOptions struct {
	TextDocumentRegistrationOptions
	RenameOptions
}

type RenameRequest string

type ResourceOperation struct {

	// The resource operation kind.
	Kind string `json:"kind,omitempty"`

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

type ResourceOperationKind string

type SaveOptions struct {

	// The client is supposed to include the content on save.
	IncludeText *bool `json:"includeText,omitempty"`
}

type SelectionRange struct {

	// The [range](#Range) of this selection range.
	Range Range `json:"range,omitempty"`

	// The parent selection range containing this range. Therefore `parent.range` must contain `this.range`.
	Parent *SelectionRange `json:"parent,omitempty"`
}

type SelectionRangeClientCapabilities struct {

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

type SelectionRangeOptions struct {
	WorkDoneProgressOptions
}

type SelectionRangeParams struct {
	WorkDoneProgressParams
	PartialResultParams

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

	// The positions inside the text document.
	Positions []Position `json:"positions,omitempty"`
}

type SelectionRangeRegistrationOptions struct {
	SelectionRangeOptions
	TextDocumentRegistrationOptions
	StaticRegistrationOptions
}

type SemanticTokenModifiers string

type SemanticTokenTypes string

type SemanticTokens struct {

	// An optional result id. If provided and clients support delta updating
	// the client will include the result id in the next semantic token request.
	// A server can then instead of computing all semantic tokens again simply
	// send a delta.
	ResultId *string `json:"resultId,omitempty"`

	// The actual tokens.
	Data []uint `json:"data,omitempty"`
}

type SemanticTokensClientCapabilities 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"`

	// Which requests the client supports and might send to the server
	// depending on the server's capability. Please note that clients might not
	// show semantic tokens or degrade some of the user experience if a range
	// or full request is advertised by the client but not provided by the
	// server. If for example the client capability `requests.full` and
	// `request.range` are both set to true but the server only provides a
	// range provider the client might not render a minimap correctly or might
	// even decide to not show any semantic tokens at all.
	Requests interface{} `json:"requests,omitempty"` // range, full,

	// The token types that the client supports.
	TokenTypes []string `json:"tokenTypes,omitempty"`

	// The token modifiers that the client supports.
	TokenModifiers []string `json:"tokenModifiers,omitempty"`

	// The token formats the clients supports.
	Formats []TokenFormat `json:"formats,omitempty"`

	// Whether the client supports tokens that can overlap each other.
	OverlappingTokenSupport *bool `json:"overlappingTokenSupport,omitempty"`

	// Whether the client supports tokens that can span multiple lines.
	MultilineTokenSupport *bool `json:"multilineTokenSupport,omitempty"`

	// Whether the client allows the server to actively cancel a
	// semantic token request, e.g. supports returning
	// LSPErrorCodes.ServerCancelled. If a server does the client
	// needs to retrigger the request.
	//
	// @since 3.17.0
	ServerCancelSupport *bool `json:"serverCancelSupport,omitempty"`
}

type SemanticTokensDelta struct {
	ResultId *string `json:"resultId,omitempty"`

	// The semantic token edits to transform a previous result into a new result.
	Edits []SemanticTokensEdit `json:"edits,omitempty"`
}

type SemanticTokensDeltaParams struct {
	WorkDoneProgressParams
	PartialResultParams

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

	// The result id of a previous response. The result Id can either point to a full response
	// or a delta response depending on what was received last.
	PreviousResultId string `json:"previousResultId,omitempty"`
}

type SemanticTokensDeltaPartialResult struct {
	Edits []SemanticTokensEdit `json:"edits,omitempty"`
}

type SemanticTokensEdit struct {

	// The start offset of the edit.
	Start uint `json:"start,omitempty"`

	// The count of elements to remove.
	DeleteCount uint `json:"deleteCount,omitempty"`

	// The elements to insert.
	Data *[]uint `json:"data,omitempty"`
}

type SemanticTokensLegend struct {

	// The token types a server uses.
	TokenTypes []string `json:"tokenTypes,omitempty"`

	// The token modifiers a server uses.
	TokenModifiers []string `json:"tokenModifiers,omitempty"`
}

type SemanticTokensOptions struct {
	WorkDoneProgressOptions

	// The legend used by the server
	Legend SemanticTokensLegend `json:"legend,omitempty"`

	// Server supports providing semantic tokens for a specific range
	// of a document.
	Range *bool `json:"range,omitempty"`

	// Server supports providing semantic tokens for a full document.
	Full *bool `json:"full,omitempty"`
}

type SemanticTokensParams struct {
	WorkDoneProgressParams
	PartialResultParams

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

type SemanticTokensPartialResult struct {
	Data []uint `json:"data,omitempty"`
}

type SemanticTokensRangeParams struct {
	WorkDoneProgressParams
	PartialResultParams

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

	// The range the semantic tokens are requested for.
	Range Range `json:"range,omitempty"`
}

type SemanticTokensRegistrationOptions struct {
	TextDocumentRegistrationOptions
	SemanticTokensOptions
	StaticRegistrationOptions
}

type SemanticTokensRegistrationType string

type SemanticTokensWorkspaceClientCapabilities 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
	// semantic tokens 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 ServerCapabilities struct {
	WorkspaceFoldersServerCapabilities
	// contains filtered or unexported fields
}

type ShowDocumentClientCapabilities struct {

	// The client has support for the show document
	// request.
	Support bool `json:"support,omitempty"`
}

type ShowDocumentParams struct {

	// The document uri to show.
	Uri URI `json:"uri,omitempty"`

	// Indicates to show the resource in an external program.
	// To show for example `https:code.visualstudio.com`
	// in the default WEB browser set `external` to `true`.
	External *bool `json:"external,omitempty"`

	// An optional property to indicate whether the editor
	// showing the document should take focus or not.
	// Clients might ignore this property if an external
	// program in started.
	TakeFocus *bool `json:"takeFocus,omitempty"`

	// An optional selection range if the document is a text
	// document. Clients might ignore the property if an
	// external program is started or the file is not a text
	// file.
	Selection *Range `json:"selection,omitempty"`
}

type ShowDocumentResult struct {

	// A boolean indicating if the show was successful.
	Success bool `json:"success,omitempty"`
}

type ShowMessageNotification string

type ShowMessageParams struct {

	// The message type. See {@link MessageType}
	Type MessageType `json:"type,omitempty"`

	// The actual message
	Message string `json:"message,omitempty"`
}

type ShowMessageRequest string

type ShowMessageRequestClientCapabilities struct {

	// Capabilities specific to the `MessageActionItem` type.
	MessageActionItem *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"`
	} `json:"messageActionItem,omitempty"`
}

type ShowMessageRequestParams struct {

	// The message type. See {@link MessageType}
	Type MessageType `json:"type,omitempty"`

	// The actual message
	Message string `json:"message,omitempty"`

	// The message action items to present.
	Actions *[]MessageActionItem `json:"actions,omitempty"`
}

type ShutdownRequest string

type SignatureHelp struct {

	// One or more signatures.
	Signatures []SignatureInformation `json:"signatures,omitempty"`

	// The active signature. If omitted or the value lies outside the
	// range of `signatures` the value defaults to zero or is ignored if
	// the `SignatureHelp` has no signatures.
	//
	// Whenever possible implementors should make an active decision about
	// the active signature and shouldn't rely on a default value.
	//
	// In future version of the protocol this property might become
	// mandatory to better express this.
	ActiveSignature *uint `json:"activeSignature,omitempty"`

	// The active parameter of the active signature. If omitted or the value
	// lies outside the range of `signatures[activeSignature].parameters`
	// defaults to 0 if the active signature has parameters. If
	// the active signature has no parameters it is ignored.
	// In future version of the protocol this property might become
	// mandatory to better express the active parameter if the
	// active signature does have any.
	ActiveParameter *uint `json:"activeParameter,omitempty"`
}

type SignatureHelpClientCapabilities struct {

	// Whether signature help supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// The client supports the following `SignatureInformation`
	// specific properties.
	SignatureInformation interface{} `json:"signatureInformation,omitempty"` // documentationFormat, parameterInformation, activeParameterSupport,

	// The client supports to send additional context information for a
	// `textDocumentsignatureHelp` request. A client that opts into
	// contextSupport will also support the `retriggerCharacters` on
	// `SignatureHelpOptions`.
	//
	// @since 3.15.0
	ContextSupport *bool `json:"contextSupport,omitempty"`
}

type SignatureHelpContext struct {

	// Action that caused signature help to be triggered.
	TriggerKind SignatureHelpTriggerKind `json:"triggerKind,omitempty"`

	// Character that caused signature help to be triggered.
	//
	// This is undefined when `triggerKind !== SignatureHelpTriggerKind.TriggerCharacter`
	TriggerCharacter *string `json:"triggerCharacter,omitempty"`

	// `true` if signature help was already showing when it was triggered.
	//
	// Retrigger occurs when the signature help is already active and can be caused by actions such as
	// typing a trigger character, a cursor move, or document content changes.
	IsRetrigger bool `json:"isRetrigger,omitempty"`

	// The currently active `SignatureHelp`.
	//
	// The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field updated based on
	// the user navigating through available signatures.
	ActiveSignatureHelp *SignatureHelp `json:"activeSignatureHelp,omitempty"`
}

type SignatureHelpOptions struct {
	WorkDoneProgressOptions

	// List of characters that trigger signature help.
	TriggerCharacters *[]string `json:"triggerCharacters,omitempty"`

	// List of characters that re-trigger signature help.
	//
	// These trigger characters are only active when signature help is already showing. All trigger characters
	// are also counted as re-trigger characters.
	//
	// @since 3.15.0
	RetriggerCharacters *[]string `json:"retriggerCharacters,omitempty"`
}

type SignatureHelpParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams

	// The signature help context. This is only available if the client specifies
	// to send this using the client capability `textDocument.signatureHelp.contextSupport === true`
	//
	// @since 3.15.0
	Context *SignatureHelpContext `json:"context,omitempty"`
}

type SignatureHelpRegistrationOptions struct {
	TextDocumentRegistrationOptions
	SignatureHelpOptions
}

type SignatureHelpRequest string

type SignatureHelpTriggerKind int

type SignatureInformation struct {

	// The label of this signature. Will be shown in
	// the UI.
	Label string `json:"label,omitempty"`

	// The human-readable doc-comment of this signature. Will be shown
	// in the UI but can be omitted.
	Documentation interface{} `json:"documentation,omitempty"` // string, MarkupContent,

	// The parameters of this signature.
	Parameters *[]ParameterInformation `json:"parameters,omitempty"`

	// The index of the active parameter.
	//
	// If provided, this is used in place of `SignatureHelp.activeParameter`.
	//
	// @since 3.16.0
	ActiveParameter *uint `json:"activeParameter,omitempty"`
}

type StaticRegistrationOptions struct {

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

type SymbolInformation struct {

	// The name of this symbol.
	Name string `json:"name,omitempty"`

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

	// Tags for this completion item.
	//
	// @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 location of this symbol. The location's range is used by a tool
	// to reveal the location in the editor. If the symbol is selected in the
	// tool the range's start information is used to position the cursor. So
	// the range usually spans more than the actual symbol's name and does
	// normally include thinks like visibility modifiers.
	//
	// The range doesn't have to denote a node range in the sense of a abstract
	// syntax tree. It can therefore not be used to re-construct a hierarchy of
	// the symbols.
	Location Location `json:"location,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 SymbolKind int

type SymbolTag int

type TelemetryEventNotification string

type TextDocument struct {

	// The associated URI for this document. Most documents have the __file__-scheme, indicating that they
	// represent files on disk. However, some documents may have other schemes indicating that they are not
	// available on disk.
	//
	// @readonly
	Uri DocumentUri `json:"uri,omitempty"`

	// The identifier of the language associated with this document.
	//
	// @readonly
	LanguageId string `json:"languageId,omitempty"`

	// The version number of this document (it will increase after each
	// change, including undoredo).
	//
	// @readonly
	Version int `json:"version,omitempty"`

	// The number of lines in this document.
	//
	// @readonly
	LineCount uint `json:"lineCount,omitempty"`
}

type TextDocumentChangeRegistrationOptions struct {
	TextDocumentRegistrationOptions

	// How documents are synced to the server.
	SyncKind TextDocumentSyncKind `json:"syncKind,omitempty"`
}

type TextDocumentClientCapabilities struct {

	// Defines which synchronization capabilities the client supports.
	Synchronization *TextDocumentSyncClientCapabilities `json:"synchronization,omitempty"`

	// Capabilities specific to the `textDocumentcompletion`
	Completion *CompletionClientCapabilities `json:"completion,omitempty"`

	// Capabilities specific to the `textDocumenthover`
	Hover *HoverClientCapabilities `json:"hover,omitempty"`

	// Capabilities specific to the `textDocumentsignatureHelp`
	SignatureHelp *SignatureHelpClientCapabilities `json:"signatureHelp,omitempty"`

	// Capabilities specific to the `textDocumentdeclaration`
	//
	// @since 3.14.0
	Declaration *DeclarationClientCapabilities `json:"declaration,omitempty"`

	// Capabilities specific to the `textDocumentdefinition`
	Definition *DefinitionClientCapabilities `json:"definition,omitempty"`

	// Capabilities specific to the `textDocumenttypeDefinition`
	//
	// @since 3.6.0
	TypeDefinition *TypeDefinitionClientCapabilities `json:"typeDefinition,omitempty"`

	// Capabilities specific to the `textDocumentimplementation`
	//
	// @since 3.6.0
	Implementation *ImplementationClientCapabilities `json:"implementation,omitempty"`

	// Capabilities specific to the `textDocumentreferences`
	References *ReferenceClientCapabilities `json:"references,omitempty"`

	// Capabilities specific to the `textDocumentdocumentHighlight`
	DocumentHighlight *DocumentHighlightClientCapabilities `json:"documentHighlight,omitempty"`

	// Capabilities specific to the `textDocumentdocumentSymbol`
	DocumentSymbol *DocumentSymbolClientCapabilities `json:"documentSymbol,omitempty"`

	// Capabilities specific to the `textDocumentcodeAction`
	CodeAction *CodeActionClientCapabilities `json:"codeAction,omitempty"`

	// Capabilities specific to the `textDocumentcodeLens`
	CodeLens *CodeLensClientCapabilities `json:"codeLens,omitempty"`

	// Capabilities specific to the `textDocumentdocumentLink`
	DocumentLink *DocumentLinkClientCapabilities `json:"documentLink,omitempty"`

	// Capabilities specific to the `textDocumentdocumentColor`
	ColorProvider *DocumentColorClientCapabilities `json:"colorProvider,omitempty"`

	// Capabilities specific to the `textDocumentformatting`
	Formatting *DocumentFormattingClientCapabilities `json:"formatting,omitempty"`

	// Capabilities specific to the `textDocumentrangeFormatting`
	RangeFormatting *DocumentRangeFormattingClientCapabilities `json:"rangeFormatting,omitempty"`

	// Capabilities specific to the `textDocumentonTypeFormatting`
	OnTypeFormatting *DocumentOnTypeFormattingClientCapabilities `json:"onTypeFormatting,omitempty"`

	// Capabilities specific to the `textDocumentrename`
	Rename *RenameClientCapabilities `json:"rename,omitempty"`

	// Capabilities specific to `textDocumentfoldingRange` request.
	//
	// @since 3.10.0
	FoldingRange *FoldingRangeClientCapabilities `json:"foldingRange,omitempty"`

	// Capabilities specific to `textDocumentselectionRange` request.
	//
	// @since 3.15.0
	SelectionRange *SelectionRangeClientCapabilities `json:"selectionRange,omitempty"`

	// Capabilities specific to `textDocumentpublishDiagnostics` notification.
	PublishDiagnostics *PublishDiagnosticsClientCapabilities `json:"publishDiagnostics,omitempty"`

	// Capabilities specific to the various call hierarchy request.
	//
	// @since 3.16.0
	CallHierarchy *CallHierarchyClientCapabilities `json:"callHierarchy,omitempty"`

	// Capabilities specific to the various semantic token request.
	//
	// @since 3.16.0
	SemanticTokens *SemanticTokensClientCapabilities `json:"semanticTokens,omitempty"`

	// Capabilities specific to the linked editing range request.
	//
	// @since 3.16.0
	LinkedEditingRange *LinkedEditingRangeClientCapabilities `json:"linkedEditingRange,omitempty"`

	// Client capabilities specific to the moniker request.
	//
	// @since 3.16.0
	Moniker *MonikerClientCapabilities `json:"moniker,omitempty"`

	// Capabilities specific to the various type hierarchy requests.
	//
	// @since 3.17.0 - proposed state
	TypeHierarchy *TypeHierarchyClientCapabilities `json:"typeHierarchy,omitempty"`

	// Capabilities specific to the `textDocumentinlineValues` request.
	//
	// @since 3.17.0 - proposed state
	InlineValues *InlineValuesClientCapabilities `json:"inlineValues,omitempty"`
}

type TextDocumentContentChangeEvent struct {

	// The range of the document that changed.
	Range Range `json:"range,omitempty"`

	// The optional length of the range that got replaced.
	//
	// @deprecated use range instead.
	RangeLength *uint `json:"rangeLength,omitempty"`

	// The new text for the provided range.
	Text interface{} `json:"text,omitempty"` // string, {"text": string}
}

type TextDocumentEdit struct {
	/**
	 * The text document to change.
	 */
	TextDocument OptionalVersionedTextDocumentIdentifier `json:"textDocument,omitempty"`

	/**
	 * The edits to be applied.
	 *
	 * @since 3.16.0 - support for AnnotatedTextEdit. This is guarded using a
	 * client capability.
	 */
	Edits []interface{} `json:"edits,omitempty"` // (TextEdit | AnnotatedTextEdit)[]
}

type TextDocumentIdentifier struct {

	// The text document's uri.
	Uri DocumentUri `json:"uri,omitempty"`
}

type TextDocumentItem struct {

	// The text document's uri.
	Uri DocumentUri `json:"uri,omitempty"`

	// The text document's language identifier
	LanguageId string `json:"languageId,omitempty"`

	// The version number of this document (it will increase after each
	// change, including undoredo).
	Version int `json:"version,omitempty"`

	// The content of the opened text document.
	Text string `json:"text,omitempty"`
}

type TextDocumentPositionParams struct {

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

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

type TextDocumentRegistrationOptions 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 interface{} `json:"documentSelector,omitempty"` // DocumentSelector, null,
}

type TextDocumentSaveReason int

type TextDocumentSaveRegistrationOptions struct {
	TextDocumentRegistrationOptions
	SaveOptions
}

type TextDocumentSyncClientCapabilities struct {

	// Whether text document synchronization supports dynamic registration.
	DynamicRegistration *bool `json:"dynamicRegistration,omitempty"`

	// The client supports sending will save notifications.
	WillSave *bool `json:"willSave,omitempty"`

	// The client supports sending a will save request and
	// waits for a response providing text edits which will
	// be applied to the document before it is saved.
	WillSaveWaitUntil *bool `json:"willSaveWaitUntil,omitempty"`

	// The client supports did save notifications.
	DidSave *bool `json:"didSave,omitempty"`
}

type TextDocumentSyncKind int

type TextDocumentSyncOptions struct {

	// Open and close notifications are sent to the server. If omitted open close notification should not
	// be sent.
	OpenClose *bool `json:"openClose,omitempty"`

	// Change notifications are sent to the server. See TextDocumentSyncKind.None, TextDocumentSyncKind.Full
	// and TextDocumentSyncKind.Incremental. If omitted it defaults to TextDocumentSyncKind.None.
	Change *TextDocumentSyncKind `json:"change,omitempty"`

	// If present will save notifications are sent to the server. If omitted the notification should not be
	// sent.
	WillSave *bool `json:"willSave,omitempty"`

	// If present will save wait until requests are sent to the server. If omitted the request should not be
	// sent.
	WillSaveWaitUntil *bool `json:"willSaveWaitUntil,omitempty"`

	// If present save notifications are sent to the server. If omitted the notification should not be
	// sent.
	Save interface{} `json:"save,omitempty"` // bool, SaveOptions,
}

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

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

type TokenFormat string

type TypeDefinitionClientCapabilities struct {

	// Whether implementation supports dynamic registration. If this is set to `true`
	// the client supports the new `TypeDefinitionRegistrationOptions` 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 TypeDefinitionOptions struct {
	WorkDoneProgressOptions
}

type TypeDefinitionParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams
}

type TypeDefinitionRegistrationOptions struct {
	TextDocumentRegistrationOptions
	TypeDefinitionOptions
	StaticRegistrationOptions
}

type TypeHierarchyClientCapabilities 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 TypeHierarchyItem struct {

	// The name of this item.
	Name string `json:"name,omitempty"`

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

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

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

	// 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`](#TypeHierarchyItem.range).
	SelectionRange Range `json:"selectionRange,omitempty"`

	// A data entry field that is preserved between a type hierarchy prepare and
	// supertypes or subtypes requests. It could also be used to identify the
	// type hierarchy in the server, helping improve the performance on
	// resolving supertypes and subtypes.
	Data interface{} `json:"data,omitempty"`
}

type TypeHierarchyOptions struct {
	WorkDoneProgressOptions
}

type TypeHierarchyPrepareParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
}

type TypeHierarchyRegistrationOptions struct {
	TextDocumentRegistrationOptions
	TypeHierarchyOptions
	StaticRegistrationOptions
}

type TypeHierarchySubtypesParams struct {
	WorkDoneProgressParams
	PartialResultParams

	Item TypeHierarchyItem `json:"item,omitempty"`
}

type TypeHierarchySupertypesParams struct {
	WorkDoneProgressParams
	PartialResultParams

	Item TypeHierarchyItem `json:"item,omitempty"`
}

type URI string

type UnchangedDocumentDiagnosticReport struct {
	Kind     interface{} `json:"kind,omitempty"` //DocumentDiagnosticReportKind.unChanged
	ResultId string      `json:"resultId,omitempty"`
}

type UniquenessLevel string