protocol

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

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

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

type ClientCapabilities struct{}

type ClientInfo struct {
	// The name of the client as defined by the client.
	// For example "vscode", "emacs" or "vim".
	Name string `json:"name"`

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

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

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

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

	// Marks this as a preferred action.
	// Preferred actions are used by the `auto fix` command and can be targeted by keybindings.
	// @since 3.15.0
	IsPreferred bool `json:"isPreferred,omitempty"`

	// Marks that the code action cannot currently be applied.
	// Clients should follow the `disabled` property to determine if the action is shown in the UI.
	// @since 3.16.0
	Disabled *CodeActionDisabled `json:"disabled,omitempty"`

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

	// A command this code action executes. If both `edit` and `command` are specified, edit is applied first.
	Command *Command `json:"command,omitempty"`

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

type CodeActionContext struct {
	// An array of diagnostics known on the client side overlapping the range provided to the `textDocument/codeAction` request.
	Diagnostics []Diagnostic `json:"diagnostics"`

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

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

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

type CodeActionKind string

type CodeActionParams struct {
	WorkDoneProgressParams
	PartialResultParams

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

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

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

type CodeActionTriggerKind int

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type CompletionItemKind int

type CompletionItemLabelDetails struct {
	// An optional string which is rendered less prominently directly after `CompletionItem.label`, without any spacing.
	Detail *string `json:"detail,omitempty"`

	// An optional string which is rendered less prominently after `CompletionItem.detail`. It should be used for additional
	// information, like type or symbol information.
	Description *string `json:"description,omitempty"`
}

type CompletionItemTag int

type CompletionList struct {
	// IsIncomplete indicates if the list is complete.
	// If true, the client should re-trigger completion when typing more characters.
	IsIncomplete bool `json:"isIncomplete"`

	// Items contains the completion items.
	Items []CompletionItem `json:"items"`
}

type CompletionOptions struct {
	WorkDoneProgressOptions

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

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

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

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

type CompletionParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
	PartialResultParams

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

type CompletionResponse struct {
	// When the result is a list of completion items.
	Items []CompletionItem

	// When the result is a completion list with additional metadata like isIncomplete.
	List *CompletionList

	// If null
	Null bool
}

type CompletionTriggerKind int

type CreateFile struct {
	ResourceOperation
	URI     DocumentURI        `json:"uri"`
	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 DefinitionParams struct {
	WorkDoneProgressParams
	PartialResultParams
	TextDocumentPositionParams
}

type DefinitionResponse struct {
	Location      *Location
	LocationList  []Location
	LocationLinks []LocationLink
	Null          bool
}

type DeleteFile struct {
	ResourceOperation
	URI     DocumentURI        `json:"uri"`
	Options *DeleteFileOptions `json:"options,omitempty"`
}

type DeleteFileOptions struct {
	// Delete 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 Diagnostic struct {
	// The range at which the message applies.
	Range Range `json:"range"`

	// The diagnostic's severity. To avoid interpretation mismatches when a
	// server is used with different clients it is highly recommended that
	// servers always provide a severity value. If omitted, it’s recommended
	// for the client to interpret it as an Error severity.
	Severity DiagnosticSeverity `json:"severity,omitempty"`

	// The diagnostic's code, which might appear in the user interface.
	Code any `json:"code,omitempty"` // integer or string

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

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

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

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

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

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

type DiagnosticOptions struct {
	WorkDoneProgressOptions

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

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

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

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

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

type DiagnosticSeverity int

type DiagnosticTag int

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

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

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

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

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

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

type DocumentChangeOperation interface {
	// contains filtered or unexported methods
}

type DocumentDiagnosticParams struct {
	WorkDoneProgressParams
	PartialResultParams

	// The text document to request diagnostics for.
	TextDocument TextDocumentIdentifier `json:"textDocument"`

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

	// The current version of the document.
	// If provided, servers can avoid computing diagnostics again if the document version hasn’t changed.
	PreviousResultID string `json:"previousResultId,omitempty"`
}

type DocumentDiagnosticReport struct {
	Full      *FullDocumentDiagnosticReport
	Unchanged *UnchangedDocumentDiagnosticReport
}

type DocumentURI string

type FullDocumentDiagnosticReport struct {
	Kind     string       `json:"kind"` // Should always be "full"
	ResultID string       `json:"resultId,omitempty"`
	Items    []Diagnostic `json:"items"`
}

type Hover struct {
	// The hover's content.
	Contents MarkupContentOrMarkedString `json:"contents"`

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

type HoverParams struct {
	TextDocumentPositionParams
	WorkDoneProgressParams
}

type HoverResult struct {
	Hover *Hover
	Null  bool
}

type InitializeParams struct {
	WorkDoneProgressParams

	// The process Id of the parent process that started the server.
	// Is null if the process has not been started by another process.
	ProcessID *int `json:"processId,omitempty"`

	// The information about the client.
	//
	// @since 3.15.0
	ClientInfo *ClientInfo `json:"clientInfo,omitempty"`

	// The locale the client is currently showing the user interface in.
	// This must not be used to influence the content of hover, completion, signature help etc.
	//
	// @since 3.16.0
	Locale *string `json:"locale,omitempty"`

	// The rootPath of the workspace. Is null if no folder is open.
	//
	// @deprecated in favour of rootUri.
	RootPath string `json:"rootPath,omitempty"`

	// The rootUri of the workspace. Is null if no folder is open.
	// If both `rootPath` and `rootUri` are set `rootUri` wins.
	RootURI DocumentURI `json:"rootUri,omitempty"`

	// User provided initialization options.
	InitializationOptions LSPAny `json:"initializationOptions,omitempty"`

	// The capabilities provided by the client (editor or tool)
	Capabilities ClientCapabilities `json:"capabilities"`

	// The initial trace setting. If omitted trace is disabled ('off').
	Trace *TraceValue `json:"trace,omitempty"`

	// The workspace folders configured in the client when the server starts.
	// This property is only available if the client supports workspace folders.
	//
	// @since 3.6.0
	WorkspaceFolders []WorkspaceFolder `json:"workspaceFolders,omitempty"`
}

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

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

type InsertTextFormat int

type InsertTextMode int

type LSPAny = any

type LanguageID string

type Location struct {
	// URI of the document.
	URI DocumentURI `json:"uri"`

	// The range within the document.
	Range Range `json:"range"`
}

type LocationLink struct {
	// Span of the origin of this link.
	// Used as the underlined span for mouse interaction.
	// Clients should omit this property if the origin selection range is not applicable.
	OriginSelectionRange *Range `json:"originSelectionRange,omitempty"`

	// The target resource identifier.
	TargetURI DocumentURI `json:"targetUri"`

	// 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 leading/trailing whitespace but everything else
	// like comments. This information is typically used to highlight the range in the editor.
	TargetRange Range `json:"targetRange"`

	// 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 `targetRange`. See also `DocumentSymbol#range`.
	TargetSelectionRange Range `json:"targetSelectionRange"`
}

type MarkedString struct {
	Language string `json:"language,omitempty"`
	Value    string `json:"value"`
}

type MarkupContent struct {
	Kind  MarkupKind `json:"kind"`
	Value string     `json:"value"` // actual content
}

type MarkupContentOrMarkedString struct {
	Markup        *MarkupContent
	MarkedString  *MarkedString
	MarkedStrings []MarkedString
}

type MarkupKind string

type PartialResultParams struct {
	// PartialResultToken is a token for handling partial result updates.
	PartialResultToken *ProgressToken `json:"partialResultToken,omitempty"`
}

type Position struct {
	// Line position in a document (zero-based).
	Line uint32 `json:"line"`

	// Character offset on a line in a document (zero-based).
	//
	// The meaning of this offset is determined by the negotiated
	// `PositionEncodingKind`.
	Character uint32 `json:"character"`
}

type PositionEncodingKind string

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

type Range struct {
	// The range's start position.
	Start Position `json:"start"`

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

type RenameFile struct {
	ResourceOperation
	OldURI  DocumentURI        `json:"oldUri"`
	NewURI  DocumentURI        `json:"newUri"`
	Options *RenameFileOptions `json:"options,omitempty"`
}

type RenameFileOptions struct {
	// Overwrite target if existing.
	Overwrite bool `json:"overwrite,omitempty"`

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

type ResourceOperation struct {
	// resource operation kind
	Kind string `json:"kind"`

	// An optional annotation identifier describing the operation.
	AnnotationID string `json:"annotationId,omitempty"`
}

type ServerCapabilities struct {
	// The position encoding the server picked from the encodings offered
	// by the client via the client capability `general.positionEncodings`.
	//
	// If the client didn't provide any position encodings the only valid
	// value that a server can return is 'utf-16'.
	//
	// If omitted it defaults to 'utf-16'.
	//
	// @since 3.17.0
	PositionEncoding *PositionEncodingKind `json:"positionEncoding,omitempty"`

	// Defines how text documents are synced. Is either a detailed structure
	// defining each notification or for backwards compatibility the
	// TextDocumentSyncKind number.
	// If omitted it defaults to `TextDocumentSyncKind.None`.
	TextDocumentSync any `json:"textDocumentSync,omitempty"` // *TextDocumentSyncOptions | TextDocumentSyncKind

	// The server provides completion support.
	CompletionProvider *CompletionOptions `json:"completionProvider,omitempty"`

	// The server provides hover support.
	HoverProvider bool `json:"hoverProvider,omitempty"`

	// The server provides signature help support.
	SignatureHelpProvider *SignatureHelpOptions `json:"signatureHelpProvider,omitempty"`

	// The server provides goto definition support.
	DefinitionProvider bool `json:"definitionProvider,omitempty"`

	// The server provides code actions. The `CodeActionOptions` return type is
	// only valid if the client signals code action literal support via the
	// property `textDocument.codeAction.codeActionLiteralSupport`.
	CodeActionProvider bool `json:"codeActionProvider,omitempty"`

	// The server has support for pull model diagnostics.
	//
	// @since 3.17.0
	DiagnosticProvider any `json:"diagnosticProvider,omitempty"` // DiagnosticOptions | DiagnosticRegistrationOptions

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

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

	// The server's version, if provided.
	Version string `json:"version,omitempty"`
}

type SignatureHelpOptions struct {
	// The characters that trigger signature help automatically.
	TriggerCharacters []string `json:"triggerCharacters,omitempty"`

	// List of characters that re-trigger signature help.
	// These are typically the same as `triggerCharacters`, but may contain additional characters.
	// @since 3.2.0
	RetriggerCharacters []string `json:"retriggerCharacters,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 of the document.
	Text string `json:"text"`
}

type TextDocumentEdit struct {
	// TextDocument identifies the text document to change.
	TextDocument VersionedTextDocumentIdentifier `json:"textDocument"`

	// Edits is an array of edits to apply to the text document.
	Edits []TextEdit `json:"edits"`
}

type TextDocumentIdentifier struct {
	// URI is the unique resource identifier of the document that was closed.
	URI string `json:"uri"`
}

type TextDocumentItem struct {
	// URI is the unique resource identifier of the document (usually a file path or URL).
	URI string `json:"uri"`

	// LanguageID is the language identifier associated with the document (e.g., "python", "javascript").
	LanguageID LanguageID `json:"languageId"`

	// Version is the version number of the document.
	Version int `json:"version"`

	// Text is the content of the document.
	Text string `json:"text"`
}

type TextDocumentPositionParams struct {
	// TextDocument holds the identifier of the text document.
	TextDocument TextDocumentIdentifier `json:"textDocument"`

	// Position specifies the position within the text document.
	Position Position `json:"position"`
}

type TextDocumentSyncKind int

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

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

type TraceValue string

type UnchangedDocumentDiagnosticReport struct {
	Kind     string `json:"kind"` // Should always be "unchanged"
	ResultID string `json:"resultId"`
}

type VersionedTextDocumentIdentifier struct {
	TextDocumentIdentifier

	// Version is the version number of the document.
	Version int `json:"version"`
}

type WorkDoneProgressOptions struct {
	// WorkDoneProgress is a flag that indicates whether progress reporting is supported.
	WorkDoneProgress bool `json:"workDoneProgress,omitempty"`
}

type WorkDoneProgressParams struct {
	// WorkDoneToken an optional token that a server can use to report work done progress.
	WorkDoneToken *ProgressToken `json:"workDoneToken,omitempty"`
}

type WorkspaceEdit struct {
	// Holds changes to existing resources.
	// Each entry describes edits to a single document.
	Changes map[DocumentURI][]TextEdit `json:"changes,omitempty"`

	// Depending on the client capability `workspace.workspaceEdit.resourceOperations` document changes are either
	// an array of `TextDocumentEdit`s or a mix of `TextDocumentEdit`, `CreateFile`, `RenameFile`, and `DeleteFile` operations.
	//
	// Changes to existing files are described with `TextDocumentEdit`.
	// Changes to the workspace are described with resource operations like `RenameFile`, `CreateFile`, and `DeleteFile`.
	//
	// @since 3.13.0
	DocumentChanges []DocumentChangeOperation `json:"documentChanges,omitempty"`

	// A map of change annotations that can be referenced in `AnnotatedTextEdit`s or create, rename and delete file operations.
	//
	// @since 3.16.0
	ChangeAnnotations map[string]ChangeAnnotation `json:"changeAnnotations,omitempty"`
}

type WorkspaceFolder struct {
	// The associated URI for this workspace folder.
	URI DocumentURI `json:"uri"`

	// The name of the workspace folder. Used to refer to this
	// workspace folder in the user interface.
	Name string `json:"name"`
}