lsp 0.1.0

use serde::{Deserialize, Serialize, de, ser};
use std::{collections::HashMap, fmt};

use crate::*;

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ImplementationParams {
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:         PartialResultParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// Represents a location inside a resource, such as a line
/// inside a text file.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Location {
  pub uri:   Uri,
  pub range: Range,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ImplementationRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub implementation_options:             ImplementationOptions,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TypeDefinitionParams {
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:         PartialResultParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TypeDefinitionRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub type_definition_options:            TypeDefinitionOptions,
}

/// A workspace folder inside a client.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceFolder {
  /// The associated URI for this workspace folder.
  pub uri:  Uri,
  /// The name of the workspace folder. Used to refer to this
  /// workspace folder in the user interface.
  pub name: String,
}

/// The parameters of a `workspace/didChangeWorkspaceFolders` notification.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidChangeWorkspaceFoldersParams {
  /// The actual workspace folder change event.
  pub event: WorkspaceFoldersChangeEvent,
}

/// The parameters of a configuration request.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ConfigurationParams {
  pub items: Vec<ConfigurationItem>,
}

/// Parameters for a
/// [`DocumentColorRequest`](crate::request::TextDocumentDocumentColor).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentColorParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// Represents a color range from a document.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ColorInformation {
  /// The range in the document where this color appears.
  pub range: Range,
  /// The actual color value for this color range.
  pub color: Color,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentColorRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub document_color_options:             DocumentColorOptions,
}

/// Parameters for a
/// [`ColorPresentationRequest`](crate::request::TextDocumentColorPresentation).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ColorPresentationParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// The color to request presentations for.
  pub color:                     Color,
  /// The range where the color would be inserted. Serves as a context.
  pub range:                     Range,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ColorPresentation {
  /// 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.
  pub label:                 String,
  /// An [`edit`](crate::TextEdit) which is applied to a document when selecting
  /// this presentation for the color.  When `falsy` the
  /// [`label`](crate::ColorPresentation) is used.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "textEdit")]
  pub text_edit:             Option<TextEdit>,
  /// An optional array of additional [`text edits`](crate::TextEdit) that are
  /// applied when selecting this color presentation. Edits must not overlap
  /// with the main [`edit`](crate::ColorPresentation) nor with themselves.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "additionalTextEdits")]
  pub additional_text_edits: Option<Vec<TextEdit>>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkDoneProgressOptions {
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "workDoneProgress")]
  pub work_done_progress: Option<bool>,
}

/// General text document registration options.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextDocumentRegistrationOptions {
  /// 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.
  #[serde(rename = "documentSelector")]
  pub document_selector: Option<DocumentSelector>,
}

/// Parameters for a
/// [`FoldingRangeRequest`](crate::request::TextDocumentFoldingRange).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FoldingRangeParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// Represents a folding range. To be valid, start and end line must be bigger
/// than zero and smaller than the number of lines in the document. Clients are
/// free to ignore invalid ranges.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FoldingRange {
  /// 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.
  #[serde(rename = "startLine")]
  pub start_line:      u32,
  /// The zero-based character offset from where the folded range starts. If not
  /// defined, defaults to the length of the start line.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "startCharacter")]
  pub start_character: Option<u32>,
  /// 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.
  #[serde(rename = "endLine")]
  pub end_line:        u32,
  /// The zero-based character offset before the folded range ends. If not
  /// defined, defaults to the length of the end line.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "endCharacter")]
  pub end_character:   Option<u32>,
  /// 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`](crate::FoldingRangeKind)
  /// for an enumeration of standardized kinds.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub kind:            Option<FoldingRangeKind>,
  /// The text that the client should show when the specified range is
  /// collapsed. If not defined or not supported by the client, a default
  /// will be chosen by the client.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "collapsedText")]
  pub collapsed_text:  Option<String>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FoldingRangeRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub folding_range_options:              FoldingRangeOptions,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DeclarationParams {
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:         PartialResultParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DeclarationRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub declaration_options:                DeclarationOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
}

/// A parameter literal used in selection range requests.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SelectionRangeParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// The positions inside the text document.
  pub positions:                 Vec<Position>,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// A selection range represents a part of a selection hierarchy. A selection
/// range may have a parent selection range that contains it.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SelectionRange {
  /// The [`range`](crate::Range) of this selection range.
  pub range:  Range,
  /// The parent selection range containing this range. Therefore `parent.range`
  /// must contain `this.range`.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub parent: Option<Box<SelectionRange>>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SelectionRangeRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub selection_range_options:            SelectionRangeOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkDoneProgressCreateParams {
  /// The token to be used to report progress.
  pub token: ProgressToken,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkDoneProgressCancelParams {
  /// The token to be used to report progress.
  pub token: ProgressToken,
}

/// The parameter of a `textDocument/prepareCallHierarchy` request.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CallHierarchyPrepareParams {
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// Represents programming constructs like functions or constructors in the
/// context of call hierarchy.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CallHierarchyItem {
  /// The name of this item.
  pub name:            String,
  /// The kind of this item.
  pub kind:            SymbolKind,
  /// Tags for this item.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub tags:            Option<Vec<SymbolTag>>,
  /// More detail for this item, e.g. the signature of a function.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub detail:          Option<String>,
  /// The resource identifier of this item.
  pub uri:             Uri,
  /// The range enclosing this symbol not including leading/trailing whitespace
  /// but everything else, e.g. comments and code.
  pub range:           Range,
  /// The range that should be selected and revealed when this symbol is being
  /// picked, e.g. the name of a function. Must be contained by the
  /// [``range``](crate::CallHierarchyItem).
  #[serde(rename = "selectionRange")]
  pub selection_range: Range,
  /// A data entry field that is preserved between a call hierarchy prepare and
  /// incoming calls or outgoing calls requests.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:            Option<Value>,
}

/// Call hierarchy options used during static or dynamic registration.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CallHierarchyRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub call_hierarchy_options:             CallHierarchyOptions,
}

/// The parameter of a `callHierarchy/incomingCalls` request.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CallHierarchyIncomingCallsParams {
  pub item:                      CallHierarchyItem,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// Represents an incoming call, e.g. a caller of a method or constructor.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CallHierarchyIncomingCall {
  /// The item that makes the call.
  pub from:        CallHierarchyItem,
  /// The ranges at which the calls appear. This is relative to the caller
  /// denoted by [``this.from``](crate::CallHierarchyIncomingCall).
  #[serde(rename = "fromRanges")]
  pub from_ranges: Vec<Range>,
}

/// The parameter of a `callHierarchy/outgoingCalls` request.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CallHierarchyOutgoingCallsParams {
  pub item:                      CallHierarchyItem,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// Represents an outgoing call, e.g. calling a getter from a method or a method
/// from a constructor etc.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CallHierarchyOutgoingCall {
  /// The item that is called.
  pub to:          CallHierarchyItem,
  /// The range at which this item is called. This is the range relative to the
  /// caller, e.g the item
  /// passed to [``provideCallHierarchyOutgoingCalls``](crate::CallHierarchyItem)
  /// and not [``this.to``](crate::CallHierarchyOutgoingCall).
  #[serde(rename = "fromRanges")]
  pub from_ranges: Vec<Range>,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokens {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resultId")]
  pub result_id: Option<String>,
  /// The actual tokens.
  pub data:      Vec<u32>,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensPartialResult {
  pub data: Vec<u32>,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub semantic_tokens_options:            SemanticTokensOptions,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensDeltaParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// 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.
  #[serde(rename = "previousResultId")]
  pub previous_result_id:        String,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensDelta {
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resultId")]
  pub result_id: Option<String>,
  /// The semantic token edits to transform a previous result into a new result.
  pub edits:     Vec<SemanticTokensEdit>,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensDeltaPartialResult {
  pub edits: Vec<SemanticTokensEdit>,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensRangeParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// The range the semantic tokens are requested for.
  pub range:                     Range,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// Params to show a resource in the UI.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ShowDocumentParams {
  /// The uri to show.
  pub uri:        Uri,
  /// 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`.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub external:   Option<bool>,
  /// 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 is started.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "takeFocus")]
  pub take_focus: Option<bool>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub selection:  Option<Range>,
}

/// The result of a showDocument request.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ShowDocumentResult {
  /// A boolean indicating if the show was successful.
  pub success: bool,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct LinkedEditingRangeParams {
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// The result of a linked editing range request.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct LinkedEditingRanges {
  /// A list of ranges that can be edited together. The ranges must have
  /// identical length and contain identical text content. The ranges cannot
  /// overlap.
  pub ranges:       Vec<Range>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "wordPattern")]
  pub word_pattern: Option<String>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct LinkedEditingRangeRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub linked_editing_range_options:       LinkedEditingRangeOptions,
}

/// The parameters sent in notifications/requests for user-initiated creation of
/// files.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CreateFilesParams {
  /// An array of all files/folders created in this operation.
  pub files: Vec<FileCreate>,
}

/// A workspace edit represents changes to many resources managed in the
/// workspace. The edit should either provide `changes` or `documentChanges`. If
/// documentChanges are present they are preferred over `changes` if the client
/// can handle versioned document edits.
///
/// Since version 3.13.0 a workspace edit can contain resource operations as
/// well. If resource operations are present clients need to execute the
/// operations in the order in which they are provided. So a workspace edit for
/// example can consist of the following two changes: (1) a create file a.txt
/// and (2) a text document edit which insert text into file a.txt.
///
/// An invalid sequence (e.g. (1) delete file a.txt and (2) insert text into
/// file a.txt) will cause failure of the operation. How the client recovers
/// from the failure is described by the client capability:
/// `workspace.workspaceEdit.failureHandling`
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceEdit {
  /// Holds changes to existing resources.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub changes:            Option<HashMap<Uri, Vec<TextEdit>>>,
  /// Depending on the client capability
  /// `workspace.workspaceEdit.resourceOperations` document changes are either
  /// an array of `TextDocumentEdit`s to express changes to n different text
  /// documents where each text document edit addresses a specific version of
  /// a text document. Or it can contain above `TextDocumentEdit`s mixed with
  /// create, rename and delete file / folder operations.
  ///
  /// Whether a client supports versioned document edits is expressed via
  /// `workspace.workspaceEdit.documentChanges` client capability.
  ///
  /// If a client neither supports `documentChanges` nor
  /// `workspace.workspaceEdit.resourceOperations` then only plain `TextEdit`s
  /// using the `changes` property are supported.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentChanges")]
  pub document_changes:   Option<Vec<Or2<TextDocumentEdit, FileChangeContents>>>,
  /// A map of change annotations that can be referenced in `AnnotatedTextEdit`s
  /// or create, rename and delete file / folder operations.
  ///
  /// Whether clients honor this property depends on the client capability
  /// `workspace.changeAnnotationSupport`.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "changeAnnotations")]
  pub change_annotations: Option<HashMap<ChangeAnnotationIdentifier, ChangeAnnotation>>,
}

/// The options to register for file operations.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FileOperationRegistrationOptions {
  /// The actual filters.
  pub filters: Vec<FileOperationFilter>,
}

/// The parameters sent in notifications/requests for user-initiated renames of
/// files.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RenameFilesParams {
  /// An array of all files/folders renamed in this operation. When a folder is
  /// renamed, only the folder will be included, and not its children.
  pub files: Vec<FileRename>,
}

/// The parameters sent in notifications/requests for user-initiated deletes of
/// files.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DeleteFilesParams {
  /// An array of all files/folders deleted in this operation.
  pub files: Vec<FileDelete>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct MonikerParams {
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:         PartialResultParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// Moniker definition to match LSIF 0.5 moniker definition.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Moniker {
  /// The scheme of the moniker. For example tsc or .Net
  pub scheme:     String,
  /// The identifier of the moniker. The value is opaque in LSIF however
  /// schema owners are allowed to define the structure if they want.
  pub identifier: String,
  /// The scope in which the moniker is unique
  pub unique:     UniquenessLevel,
  /// The moniker kind if known.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub kind:       Option<MonikerKind>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct MonikerRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub moniker_options:                    MonikerOptions,
}

/// The parameter of a `textDocument/prepareTypeHierarchy` request.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TypeHierarchyPrepareParams {
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TypeHierarchyItem {
  /// The name of this item.
  pub name:            String,
  /// The kind of this item.
  pub kind:            SymbolKind,
  /// Tags for this item.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub tags:            Option<Vec<SymbolTag>>,
  /// More detail for this item, e.g. the signature of a function.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub detail:          Option<String>,
  /// The resource identifier of this item.
  pub uri:             Uri,
  /// The range enclosing this symbol not including leading/trailing whitespace
  /// but everything else, e.g. comments and code.
  pub range:           Range,
  /// The range that should be selected and revealed when this symbol is being
  /// picked, e.g. the name of a function. Must be contained by the
  /// [``range``](crate::TypeHierarchyItem).
  #[serde(rename = "selectionRange")]
  pub selection_range: Range,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:            Option<Value>,
}

/// Type hierarchy options used during static or dynamic registration.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TypeHierarchyRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub type_hierarchy_options:             TypeHierarchyOptions,
}

/// The parameter of a `typeHierarchy/supertypes` request.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TypeHierarchySupertypesParams {
  pub item:                      TypeHierarchyItem,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// The parameter of a `typeHierarchy/subtypes` request.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TypeHierarchySubtypesParams {
  pub item:                      TypeHierarchyItem,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// A parameter literal used in inline value requests.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineValueParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// The document range for which inline values should be computed.
  pub range:                     Range,
  /// Additional information about the context in which inline values were
  /// requested.
  pub context:                   InlineValueContext,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
}

/// Inline value options used during static or dynamic registration.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineValueRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub inline_value_options:               InlineValueOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
}

/// A parameter literal used in inlay hint requests.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlayHintParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// The document range for which inlay hints should be computed.
  pub range:                     Range,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
}

/// Inlay hint information.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlayHint {
  /// The position of this hint.
  ///
  /// If multiple hints have the same position, they will be shown in the order
  /// they appear in the response.
  pub position:      Position,
  /// The label of this hint. A human readable string or an array of
  /// InlayHintLabelPart label parts.
  ///
  /// *Note* that neither the string nor the label part can be empty.
  pub label:         Or2<String, Vec<InlayHintLabelPart>>,
  /// The kind of this hint. Can be omitted in which case the client
  /// should fall back to a reasonable default.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub kind:          Option<InlayHintKind>,
  /// Optional text edits that are performed when accepting this inlay hint.
  ///
  /// *Note* that edits are expected to change the document so that the inlay
  /// hint (or its nearest variant) is now part of the document and the inlay
  /// hint itself is now obsolete.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "textEdits")]
  pub text_edits:    Option<Vec<TextEdit>>,
  /// The tooltip text when you hover over this item.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub tooltip:       Option<Or2<String, MarkupContent>>,
  /// Render padding before the hint.
  ///
  /// Note: Padding should use the editor's background color, not the
  /// background color of the hint itself. That means padding can be used
  /// to visually align/separate an inlay hint.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "paddingLeft")]
  pub padding_left:  Option<bool>,
  /// Render padding after the hint.
  ///
  /// Note: Padding should use the editor's background color, not the
  /// background color of the hint itself. That means padding can be used
  /// to visually align/separate an inlay hint.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "paddingRight")]
  pub padding_right: Option<bool>,
  /// A data entry field that is preserved on an inlay hint between
  /// a `textDocument/inlayHint` and a `inlayHint/resolve` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:          Option<Value>,
}

/// Inlay hint options used during static or dynamic registration.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlayHintRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub inlay_hint_options:                 InlayHintOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
}

/// Parameters of the document diagnostic request.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentDiagnosticParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// The additional identifier  provided during registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub identifier:                Option<String>,
  /// The result id of a previous response if provided.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "previousResultId")]
  pub previous_result_id:        Option<String>,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// A partial result for a document diagnostic report.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentDiagnosticReportPartialResult {
  #[serde(rename = "relatedDocuments")]
  pub related_documents: HashMap<Uri, DocumentDiagnosticReportContents>,
}

/// Cancellation data returned from a diagnostic request.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DiagnosticServerCancellationData {
  #[serde(rename = "retriggerRequest")]
  pub retrigger_request: bool,
}

/// Diagnostic registration options.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DiagnosticRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub diagnostic_options:                 DiagnosticOptions,
}

/// Parameters of the workspace diagnostic request.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceDiagnosticParams {
  /// The additional identifier provided during registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub identifier:                Option<String>,
  /// The currently known diagnostic reports with their
  /// previous result ids.
  #[serde(rename = "previousResultIds")]
  pub previous_result_ids:       Vec<PreviousResultId>,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// A workspace diagnostic report.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceDiagnosticReport {
  pub items: Vec<WorkspaceDocumentDiagnosticReport>,
}

/// A partial result for a workspace diagnostic report.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceDiagnosticReportPartialResult {
  pub items: Vec<WorkspaceDocumentDiagnosticReport>,
}

/// The params sent in an open notebook document notification.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidOpenNotebookDocumentParams {
  /// The notebook document that got opened.
  #[serde(rename = "notebookDocument")]
  pub notebook_document:   NotebookDocument,
  /// The text documents that represent the content
  /// of a notebook cell.
  #[serde(rename = "cellTextDocuments")]
  pub cell_text_documents: Vec<TextDocumentItem>,
}

/// The params sent in a change notebook document notification.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidChangeNotebookDocumentParams {
  /// The notebook document that did change. The version number points
  /// to the version after all provided changes have been applied. If
  /// only the text document content of a cell changes the notebook version
  /// doesn't necessarily have to change.
  #[serde(rename = "notebookDocument")]
  pub notebook_document: VersionedNotebookDocumentIdentifier,
  /// The actual changes to the notebook document.
  ///
  /// The changes describe single state changes to the notebook document.
  /// So if there are two changes c1 (at array index 0) and c2 (at array
  /// index 1) for a notebook in state S then c1 moves the notebook from
  /// S to S' and c2 from S' to S''. So c1 is computed on the state S and
  /// c2 is computed on the state S'.
  ///
  /// To mirror the content of a notebook using change events use the following
  /// approach:
  /// - start with the same initial content
  /// - apply the 'notebookDocument/didChange' notifications in the order you
  ///   receive them.
  /// - apply the `NotebookChangeEvent`s in a single notification in the order
  ///   you receive them.
  pub change:            NotebookDocumentChangeEvent,
}

/// The params sent in a save notebook document notification.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidSaveNotebookDocumentParams {
  /// The notebook document that got saved.
  #[serde(rename = "notebookDocument")]
  pub notebook_document: NotebookDocumentIdentifier,
}

/// The params sent in a close notebook document notification.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidCloseNotebookDocumentParams {
  /// The notebook document that got closed.
  #[serde(rename = "notebookDocument")]
  pub notebook_document:   NotebookDocumentIdentifier,
  /// The text documents that represent the content
  /// of a notebook cell that got closed.
  #[serde(rename = "cellTextDocuments")]
  pub cell_text_documents: Vec<TextDocumentIdentifier>,
}

/// A parameter literal used in inline completion requests.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineCompletionParams {
  /// Additional information about the context in which inline completions were
  /// requested.
  pub context:                       InlineCompletionContext,
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// Represents a collection of [`inline completion
/// items`](crate::InlineCompletionItem) to be presented in the editor.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineCompletionList {
  /// The inline completion items
  pub items: Vec<InlineCompletionItem>,
}

/// An inline completion item represents a text snippet that is proposed inline
/// to complete text that is being typed.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineCompletionItem {
  /// The text to replace the range with. Must be set.
  #[serde(rename = "insertText")]
  pub insert_text: Or2<String, StringValue>,
  /// A text that is used to decide if this inline completion should be shown.
  /// When `falsy` the
  /// [`InlineCompletionItem.insertText`](crate::InlineCompletionItem) is used.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "filterText")]
  pub filter_text: Option<String>,
  /// The range to replace. Must begin and end on the same line.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub range:       Option<Range>,
  /// An optional [`Command`](crate::Command) that is executed *after* inserting
  /// this completion.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub command:     Option<Command>,
}

/// Inline completion options used during static or dynamic registration.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineCompletionRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:        StaticRegistrationOptions,
  #[serde(flatten)]
  pub inline_completion_options:          InlineCompletionOptions,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RegistrationParams {
  pub registrations: Vec<Registration>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct UnregistrationParams {
  pub unregisterations: Vec<Unregistration>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InitializeParams {
  /// The process Id of the parent process that started
  /// the server.
  ///
  /// Is `null` if the process has not been started by another process.
  /// If the parent process is not alive then the server should exit.
  #[serde(rename = "processId")]
  pub process_id:                          Option<i32>,
  /// Information about the client
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "clientInfo")]
  pub client_info:                         Option<InitializeParamsClientInfo>,
  /// The locale the client is currently showing the user interface
  /// in. This must not necessarily be the locale of the operating
  /// system.
  ///
  /// Uses IETF language tags as the value's syntax
  /// (See https://en.wikipedia.org/wiki/IETF_language_tag)
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub locale:                              Option<String>,
  /// The rootPath of the workspace. Is null
  /// if no folder is open.
  #[deprecated = "in favour of rootUri."]
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "rootPath")]
  pub root_path:                           Option<String>,
  /// The rootUri of the workspace. Is null if no
  /// folder is open. If both `rootPath` and `rootUri` are set
  /// `rootUri` wins.
  #[deprecated = "in favour of workspaceFolders."]
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "rootUri")]
  pub root_uri:                            Option<Uri>,
  /// The capabilities provided by the client (editor or tool)
  pub capabilities:                        ClientCapabilities,
  /// User provided initialization options.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "initializationOptions")]
  pub initialization_options:              Option<Value>,
  /// The initial trace setting. If omitted trace is disabled ('off').
  #[serde(skip_serializing_if = "Option::is_none")]
  pub trace:                               Option<TraceValues>,
  #[serde(flatten)]
  pub work_done_progress_params:           WorkDoneProgressParams,
  #[serde(flatten)]
  pub workspace_folders_initialize_params: WorkspaceFoldersInitializeParams,
}

/// The result returned from an initialize request.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InitializeResult {
  /// The capabilities the language server provides.
  pub capabilities: ServerCapabilities,
  /// Information about the server.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "serverInfo")]
  pub server_info:  Option<InitializeResultServerInfo>,
}

/// The data type of the ResponseError if the
/// initialize request fails.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InitializeError {
  /// 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.
  pub retry: bool,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InitializedParams {}

/// The parameters of a change configuration notification.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidChangeConfigurationParams {
  /// The actual changed settings
  pub settings: Value,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidChangeConfigurationRegistrationOptions {
  #[serde(skip_serializing_if = "Option::is_none")]
  pub section: Option<Or2<String, Vec<String>>>,
}

/// The parameters of a notification message.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ShowMessageParams {
  /// The message type. See [`MessageType`](crate::MessageType)
  #[serde(rename = "type")]
  pub ty:      MessageType,
  /// The actual message.
  pub message: String,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ShowMessageRequestParams {
  /// The message type. See [`MessageType`](crate::MessageType)
  #[serde(rename = "type")]
  pub ty:      MessageType,
  /// The actual message.
  pub message: String,
  /// The message action items to present.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub actions: Option<Vec<MessageActionItem>>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct MessageActionItem {
  /// A short title like 'Retry', 'Open Log' etc.
  pub title: String,
}

/// The log message parameters.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct LogMessageParams {
  /// The message type. See [`MessageType`](crate::MessageType)
  #[serde(rename = "type")]
  pub ty:      MessageType,
  /// The actual message.
  pub message: String,
}

/// The parameters sent in an open text document notification
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidOpenTextDocumentParams {
  /// The document that was opened.
  #[serde(rename = "textDocument")]
  pub text_document: TextDocumentItem,
}

/// The change text document notification's parameters.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidChangeTextDocumentParams {
  /// The document that did change. The version number points
  /// to the version after all provided content changes have
  /// been applied.
  #[serde(rename = "textDocument")]
  pub text_document:   VersionedTextDocumentIdentifier,
  /// 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.
  #[serde(rename = "contentChanges")]
  pub content_changes: Vec<TextDocumentContentChangeEvent>,
}

/// Describe options to be used when registered for text document change events.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextDocumentChangeRegistrationOptions {
  /// How documents are synced to the server.
  #[serde(rename = "syncKind")]
  pub sync_kind:                          TextDocumentSyncKind,
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
}

/// The parameters sent in a close text document notification
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidCloseTextDocumentParams {
  /// The document that was closed.
  #[serde(rename = "textDocument")]
  pub text_document: TextDocumentIdentifier,
}

/// The parameters sent in a save text document notification
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidSaveTextDocumentParams {
  /// The document that was saved.
  #[serde(rename = "textDocument")]
  pub text_document: TextDocumentIdentifier,
  /// Optional the content when saved. Depends on the includeText value
  /// when the save notification was requested.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub text:          Option<String>,
}

/// Save registration options.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextDocumentSaveRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub save_options:                       SaveOptions,
}

/// The parameters sent in a will save text document notification.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WillSaveTextDocumentParams {
  /// The document that will be saved.
  #[serde(rename = "textDocument")]
  pub text_document: TextDocumentIdentifier,
  /// The 'TextDocumentSaveReason'.
  pub reason:        TextDocumentSaveReason,
}

/// A text edit applicable to a text document.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextEdit {
  /// The range of the text document to be manipulated. To insert
  /// text into a document create a range where start === end.
  pub range:    Range,
  /// The string to be inserted. For delete operations use an
  /// empty string.
  #[serde(rename = "newText")]
  pub new_text: String,
}

/// The watched files change notification's parameters.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidChangeWatchedFilesParams {
  /// The actual file events.
  pub changes: Vec<FileEvent>,
}

/// Describe options to be used when registered for text document change events.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidChangeWatchedFilesRegistrationOptions {
  /// The watchers to register.
  pub watchers: Vec<FileSystemWatcher>,
}

/// The publish diagnostic notification's parameters.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct PublishDiagnosticsParams {
  /// The URI for which diagnostic information is reported.
  pub uri:         Uri,
  /// Optional the version number of the document the diagnostics are published
  /// for.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub version:     Option<i32>,
  /// An array of diagnostic information items.
  pub diagnostics: Vec<Diagnostic>,
}

/// Completion parameters
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionParams {
  /// The completion context. This is only available if the client specifies
  /// to send this using the client capability
  /// `textDocument.completion.contextSupport === true`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub context:                       Option<CompletionContext>,
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:         PartialResultParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// A completion item represents a text snippet that is
/// proposed to complete text that is being typed.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionItem {
  /// 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.
  pub label:                 String,
  /// Additional details for the label
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "labelDetails")]
  pub label_details:         Option<CompletionItemLabelDetails>,
  /// The kind of this completion item. Based of the kind
  /// an icon is chosen by the editor.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub kind:                  Option<CompletionItemKind>,
  /// Tags for this completion item.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub tags:                  Option<Vec<CompletionItemTag>>,
  /// A human-readable string with additional information
  /// about this item, like type or symbol information.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub detail:                Option<String>,
  /// A human-readable string that represents a doc-comment.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub documentation:         Option<Or2<String, MarkupContent>>,
  /// Indicates if this item is deprecated.
  #[deprecated = "Use `tags` instead."]
  #[serde(skip_serializing_if = "Option::is_none")]
  pub deprecated:            Option<bool>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub preselect:             Option<bool>,
  /// A string that should be used when comparing this item
  /// with other items. When `falsy` the [`label`](crate::CompletionItem)
  /// is used.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "sortText")]
  pub sort_text:             Option<String>,
  /// A string that should be used when filtering a set of
  /// completion items. When `falsy` the [`label`](crate::CompletionItem)
  /// is used.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "filterText")]
  pub filter_text:           Option<String>,
  /// A string that should be inserted into a document when selecting
  /// this completion. When `falsy` the [`label`](crate::CompletionItem)
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "insertText")]
  pub insert_text:           Option<String>,
  /// 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`.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "insertTextFormat")]
  pub insert_text_format:    Option<InsertTextFormat>,
  /// How whitespace and indentation is handled during completion
  /// item insertion. If not provided the clients default value depends on
  /// the `textDocument.completion.insertTextMode` client capability.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "insertTextMode")]
  pub insert_text_mode:      Option<InsertTextMode>,
  /// An [`edit`](crate::TextEdit) which is applied to a document when selecting
  /// this completion. When an edit is provided the value of
  /// [`insertText`](crate::CompletionItem) is ignored.
  ///
  /// Most editors support two different operations when accepting a completion
  /// item. One is to insert a completion text and the other is to replace an
  /// existing text with a completion text. Since this can usually not be
  /// predetermined by a server it can report both ranges. Clients need to
  /// signal support for `InsertReplaceEdits` via the
  /// `textDocument.completion.insertReplaceSupport` client capability
  /// property.
  ///
  /// *Note 1:* The text edit's range as well as both ranges from an insert
  /// replace edit must be a [single line] and they must contain the position
  /// at which completion has been requested.
  /// *Note 2:* If an `InsertReplaceEdit` is returned the edit's insert range
  /// must be a prefix of the edit's replace range, that means it must be
  /// contained and starting at the same position.
  ///
  /// @since 3.16.0 additional type `InsertReplaceEdit`
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "textEdit")]
  pub text_edit:             Option<Or2<TextEdit, InsertReplaceEdit>>,
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "textEditText")]
  pub text_edit_text:        Option<String>,
  /// An optional array of additional [`text edits`](crate::TextEdit) that are
  /// applied when selecting this completion. Edits must not overlap
  /// (including the same insert position) with the main
  /// [`edit`](crate::CompletionItem) 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).
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "additionalTextEdits")]
  pub additional_text_edits: Option<Vec<TextEdit>>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "commitCharacters")]
  pub commit_characters:     Option<Vec<String>>,
  /// An optional [`command`](crate::Command) that is executed *after* inserting
  /// this completion. *Note* that additional modifications to the current
  /// document should be described with the
  /// [`additionalTextEdits`](crate::CompletionItem)-property.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub command:               Option<Command>,
  /// A data entry field that is preserved on a completion item between a
  /// [`CompletionRequest`](crate::request::TextDocumentCompletion) and a
  /// [`CompletionResolveRequest`](crate::request::CompletionItemResolve).
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:                  Option<Value>,
}

/// Represents a collection of [`completion items`](crate::CompletionItem) to be
/// presented in the editor.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionList {
  /// This list it not complete. Further typing results in recomputing this
  /// list.
  ///
  /// Recomputed lists have all their items replaced (not appended) in the
  /// incomplete completion sessions.
  #[serde(rename = "isIncomplete")]
  pub is_incomplete: bool,
  /// In many cases the items of an actual completion result share the same
  /// value for properties like `commitCharacters` or the range of a text
  /// edit. A completion list can therefore define item defaults which will
  /// be used if a completion item itself doesn't specify the value.
  ///
  /// If a completion list specifies a default value and a completion item
  /// also specifies a corresponding value the one from the item is used.
  ///
  /// Servers are only allowed to return default values if the client
  /// signals support for this via the `completionList.itemDefaults`
  /// capability.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "itemDefaults")]
  pub item_defaults: Option<CompletionListItemDefaults>,
  /// The completion items.
  pub items:         Vec<CompletionItem>,
}

/// Registration options for a
/// [`CompletionRequest`](crate::request::TextDocumentCompletion).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub completion_options:                 CompletionOptions,
}

/// Parameters for a [`HoverRequest`](crate::request::TextDocumentHover).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct HoverParams {
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// The result of a hover request.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Hover {
  /// The hover's content
  pub contents: Or3<MarkupContent, MarkedString, Vec<MarkedString>>,
  /// An optional range inside the text document that is used to
  /// visualize the hover, e.g. by changing the background color.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub range:    Option<Range>,
}

/// Registration options for a
/// [`HoverRequest`](crate::request::TextDocumentHover).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct HoverRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub hover_options:                      HoverOptions,
}

/// Parameters for a
/// [`SignatureHelpRequest`](crate::request::TextDocumentSignatureHelp).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SignatureHelpParams {
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  pub context:                       Option<SignatureHelpContext>,
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// Signature help represents the signature of something
/// callable. There can be multiple signature but only one
/// active and only one active parameter.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SignatureHelp {
  /// One or more signatures.
  pub signatures:       Vec<SignatureInformation>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "activeSignature")]
  pub active_signature: Option<u32>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "activeParameter")]
  pub active_parameter: Option<u32>,
}

/// Registration options for a
/// [`SignatureHelpRequest`](crate::request::TextDocumentSignatureHelp).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SignatureHelpRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub signature_help_options:             SignatureHelpOptions,
}

/// Parameters for a
/// [`DefinitionRequest`](crate::request::TextDocumentDefinition).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DefinitionParams {
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:         PartialResultParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// Registration options for a
/// [`DefinitionRequest`](crate::request::TextDocumentDefinition).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DefinitionRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub definition_options:                 DefinitionOptions,
}

/// Parameters for a
/// [`ReferencesRequest`](crate::request::TextDocumentReferences).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ReferenceParams {
  pub context:                       ReferenceContext,
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:         PartialResultParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// Registration options for a
/// [`ReferencesRequest`](crate::request::TextDocumentReferences).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ReferenceRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub reference_options:                  ReferenceOptions,
}

/// Parameters for a
/// [`DocumentHighlightRequest`](crate::request::TextDocumentDocumentHighlight).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentHighlightParams {
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:         PartialResultParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// A document highlight is a range inside a text document which deserves
/// special attention. Usually a document highlight is visualized by changing
/// the background color of its range.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentHighlight {
  /// The range this highlight applies to.
  pub range: Range,
  /// The highlight kind, default is [`text`](crate::DocumentHighlightKind).
  #[serde(skip_serializing_if = "Option::is_none")]
  pub kind:  Option<DocumentHighlightKind>,
}

/// Registration options for a
/// [`DocumentHighlightRequest`](crate::request::TextDocumentDocumentHighlight).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentHighlightRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub document_highlight_options:         DocumentHighlightOptions,
}

/// Parameters for a
/// [`DocumentSymbolRequest`](crate::request::TextDocumentDocumentSymbol).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentSymbolParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// Represents information about programming constructs like variables, classes,
/// interfaces etc.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SymbolInformation {
  /// Indicates if this symbol is deprecated.
  #[deprecated = "Use tags instead"]
  #[serde(skip_serializing_if = "Option::is_none")]
  pub deprecated:              Option<bool>,
  /// 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 things like visibility modifiers.
  ///
  /// The range doesn't have to denote a node range in the sense of an abstract
  /// syntax tree. It can therefore not be used to re-construct a hierarchy of
  /// the symbols.
  pub location:                Location,
  #[serde(flatten)]
  pub base_symbol_information: BaseSymbolInformation,
}

/// Represents programming constructs like variables, classes, interfaces etc.
/// that appear in a document. Document symbols can be hierarchical and they
/// have two ranges: one that encloses its definition and one that points to
/// its most interesting range, e.g. the range of an identifier.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentSymbol {
  /// 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.
  pub name:            String,
  /// More detail for this symbol, e.g the signature of a function.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub detail:          Option<String>,
  /// The kind of this symbol.
  pub kind:            SymbolKind,
  /// Tags for this document symbol.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub tags:            Option<Vec<SymbolTag>>,
  /// Indicates if this symbol is deprecated.
  #[deprecated = "Use tags instead"]
  #[serde(skip_serializing_if = "Option::is_none")]
  pub deprecated:      Option<bool>,
  /// The range enclosing this symbol not including leading/trailing whitespace
  /// but everything else like comments. This information is typically used to
  /// determine if the clients cursor is inside the symbol to reveal in the
  /// symbol in the UI.
  pub range:           Range,
  /// The range that should be selected and revealed when this symbol is being
  /// picked, e.g the name of a function. Must be contained by the `range`.
  #[serde(rename = "selectionRange")]
  pub selection_range: Range,
  /// Children of this symbol, e.g. properties of a class.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub children:        Option<Vec<DocumentSymbol>>,
}

/// Registration options for a
/// [`DocumentSymbolRequest`](crate::request::TextDocumentDocumentSymbol).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentSymbolRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub document_symbol_options:            DocumentSymbolOptions,
}

/// The parameters of a
/// [`CodeActionRequest`](crate::request::TextDocumentCodeAction).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeActionParams {
  /// The document in which the command was invoked.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// The range for which the command was invoked.
  pub range:                     Range,
  /// Context carrying additional information.
  pub context:                   CodeActionContext,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// Represents a reference to a command. Provides a title which
/// will be used to represent a command in the UI and, optionally,
/// an array of arguments which will be passed to the command handler
/// function when invoked.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Command {
  /// Title of the command, like `save`.
  pub title:     String,
  /// The identifier of the actual command handler.
  pub command:   String,
  /// Arguments that the command handler should be
  /// invoked with.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub arguments: Option<Vec<Value>>,
}

/// A code action represents a change that can be performed in code, e.g. to fix
/// a problem or to refactor code.
///
/// A CodeAction must set either `edit` and/or a `command`. If both are
/// supplied, the `edit` is applied first, then the `command` is executed.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeAction {
  /// A short, human-readable, title for this code action.
  pub title:        String,
  /// The kind of the code action.
  ///
  /// Used to filter code actions.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub kind:         Option<CodeActionKind>,
  /// The diagnostics that this code action resolves.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub diagnostics:  Option<Vec<Diagnostic>>,
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "isPreferred")]
  pub is_preferred: Option<bool>,
  /// Marks that the code action cannot currently be applied.
  ///
  /// Clients should follow the following guidelines regarding disabled code
  /// actions:
  ///
  ///   - Disabled code actions are not shown in automatic [lightbulbs](https://code.visualstudio.com/docs/editor/editingevolved#_code-action)
  ///     code action menus.
  ///
  ///   - Disabled actions are shown as faded out in the code action menu when
  ///     the user requests a more specific type of code action, such as
  ///     refactorings.
  ///
  ///   - If the user has a [keybinding](https://code.visualstudio.com/docs/editor/refactoring#_keybindings-for-code-actions)
  ///     that auto applies a code action and only disabled code actions are
  ///     returned, the client should show the user an error message with
  ///     `reason` in the editor.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub disabled:     Option<CodeActionDisabled>,
  /// The workspace edit this code action performs.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub edit:         Option<WorkspaceEdit>,
  /// A command this code action executes. If a code action
  /// provides an edit and a command, first the edit is
  /// executed and then the command.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub command:      Option<Command>,
  /// A data entry field that is preserved on a code action between
  /// a `textDocument/codeAction` and a `codeAction/resolve` request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:         Option<Value>,
}

/// Registration options for a
/// [`CodeActionRequest`](crate::request::TextDocumentCodeAction).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeActionRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub code_action_options:                CodeActionOptions,
}

/// The parameters of a
/// [`WorkspaceSymbolRequest`](crate::request::WorkspaceSymbolRequest).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceSymbolParams {
  /// A query string to filter symbols by. Clients may send an empty
  /// string here to request all symbols.
  pub query:                     String,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// A special workspace symbol that supports locations without a range.
///
/// See also SymbolInformation.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceSymbol {
  /// The location of the symbol. Whether a server is allowed to
  /// return a location without a range depends on the client
  /// capability `workspace.symbol.resolveSupport`.
  ///
  /// See SymbolInformation#location for more details.
  pub location:                Or2<Location, WorkspaceSymbolLocation>,
  /// A data entry field that is preserved on a workspace symbol between a
  /// workspace symbol request and a workspace symbol resolve request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:                    Option<Value>,
  #[serde(flatten)]
  pub base_symbol_information: BaseSymbolInformation,
}

/// Registration options for a
/// [`WorkspaceSymbolRequest`](crate::request::WorkspaceSymbolRequest).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceSymbolRegistrationOptions {
  #[serde(flatten)]
  pub workspace_symbol_options: WorkspaceSymbolOptions,
}

/// The parameters of a
/// [`CodeLensRequest`](crate::request::TextDocumentCodeLens).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeLensParams {
  /// The document to request code lens for.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// A code lens represents a [`command`](crate::Command) that should be shown
/// along with source text, like the number of references, a way to run tests,
/// etc.
///
/// A code lens is _unresolved_ when no command is associated to it. For
/// performance reasons the creation of a code lens and resolving should be done
/// in two stages.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeLens {
  /// The range in which this code lens is valid. Should only span a single
  /// line.
  pub range:   Range,
  /// The command this code lens represents.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub command: Option<Command>,
  /// A data entry field that is preserved on a code lens item between
  /// a [`CodeLensRequest`](crate::request::TextDocumentCodeLens) and a
  /// [`CodeLensResolveRequest`](crate::request::CodeLensResolve)
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:    Option<Value>,
}

/// Registration options for a
/// [`CodeLensRequest`](crate::request::TextDocumentCodeLens).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeLensRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub code_lens_options:                  CodeLensOptions,
}

/// The parameters of a
/// [`DocumentLinkRequest`](crate::request::TextDocumentDocumentLink).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentLinkParams {
  /// The document to provide document links for.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
  #[serde(flatten)]
  pub partial_result_params:     PartialResultParams,
}

/// A document link is a range in a text document that links to an internal or
/// external resource, like another text document or a web site.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentLink {
  /// The range this link applies to.
  pub range:   Range,
  /// The uri this link points to. If missing a resolve request is sent later.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub target:  Option<Uri>,
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  pub tooltip: Option<String>,
  /// A data entry field that is preserved on a document link between a
  /// DocumentLinkRequest and a DocumentLinkResolveRequest.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:    Option<Value>,
}

/// Registration options for a
/// [`DocumentLinkRequest`](crate::request::TextDocumentDocumentLink).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentLinkRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub document_link_options:              DocumentLinkOptions,
}

/// The parameters of a
/// [`DocumentFormattingRequest`](crate::request::TextDocumentFormatting).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentFormattingParams {
  /// The document to format.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// The format options.
  pub options:                   FormattingOptions,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
}

/// Registration options for a
/// [`DocumentFormattingRequest`](crate::request::TextDocumentFormatting).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentFormattingRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub document_formatting_options:        DocumentFormattingOptions,
}

/// The parameters of a
/// [`DocumentRangeFormattingRequest`](crate::request::TextDocumentRangeFormatting).
///
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentRangeFormattingParams {
  /// The document to format.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// The range to format
  pub range:                     Range,
  /// The format options
  pub options:                   FormattingOptions,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
}

/// Registration options for a
/// [`DocumentRangeFormattingRequest`](crate::request::TextDocumentRangeFormatting).
///
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentRangeFormattingRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub document_range_formatting_options:  DocumentRangeFormattingOptions,
}

/// The parameters of a
/// [`DocumentRangesFormattingRequest`](crate::request::TextDocumentRangesFormatting).
///
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentRangesFormattingParams {
  /// The document to format.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// The ranges to format
  pub ranges:                    Vec<Range>,
  /// The format options
  pub options:                   FormattingOptions,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
}

/// The parameters of a
/// [`DocumentOnTypeFormattingRequest`](crate::request::TextDocumentOnTypeFormatting).
///
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentOnTypeFormattingParams {
  /// The document to format.
  #[serde(rename = "textDocument")]
  pub text_document: TextDocumentIdentifier,
  /// The position around which the on type formatting should happen.
  /// This is not necessarily the exact position where the character denoted
  /// by the property `ch` got typed.
  pub position:      Position,
  /// The character that has been typed that triggered the formatting
  /// on type request. That is not necessarily the last character that
  /// got inserted into the document since the client could auto insert
  /// characters as well (e.g. like automatic brace completion).
  pub ch:            String,
  /// The formatting options.
  pub options:       FormattingOptions,
}

/// Registration options for a
/// [`DocumentOnTypeFormattingRequest`](crate::request::TextDocumentOnTypeFormatting).
///
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentOnTypeFormattingRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options:  TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub document_on_type_formatting_options: DocumentOnTypeFormattingOptions,
}

/// The parameters of a [`RenameRequest`](crate::request::TextDocumentRename).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RenameParams {
  /// The document to rename.
  #[serde(rename = "textDocument")]
  pub text_document:             TextDocumentIdentifier,
  /// The position at which this request was sent.
  pub position:                  Position,
  /// The new name of the symbol. If the given name is not valid the
  /// request must return a [`ResponseError`]() with an
  /// appropriate message set.
  #[serde(rename = "newName")]
  pub new_name:                  String,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
}

/// Registration options for a
/// [`RenameRequest`](crate::request::TextDocumentRename).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RenameRegistrationOptions {
  #[serde(flatten)]
  pub text_document_registration_options: TextDocumentRegistrationOptions,
  #[serde(flatten)]
  pub rename_options:                     RenameOptions,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct PrepareRenameParams {
  #[serde(flatten)]
  pub work_done_progress_params:     WorkDoneProgressParams,
  #[serde(flatten)]
  pub text_document_position_params: TextDocumentPositionParams,
}

/// The parameters of a
/// [`ExecuteCommandRequest`](crate::request::WorkspaceExecuteCommand).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ExecuteCommandParams {
  /// The identifier of the actual command handler.
  pub command:                   String,
  /// Arguments that the command should be invoked with.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub arguments:                 Option<Vec<Value>>,
  #[serde(flatten)]
  pub work_done_progress_params: WorkDoneProgressParams,
}

/// Registration options for a
/// [`ExecuteCommandRequest`](crate::request::WorkspaceExecuteCommand).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ExecuteCommandRegistrationOptions {
  #[serde(flatten)]
  pub execute_command_options: ExecuteCommandOptions,
}

/// The parameters passed via an apply workspace edit request.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ApplyWorkspaceEditParams {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub label: Option<String>,
  /// The edits to apply.
  pub edit:  WorkspaceEdit,
}

/// The result returned from the apply workspace edit request.
///
/// @since 3.17 renamed from ApplyWorkspaceEditResponse
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ApplyWorkspaceEditResult {
  /// Indicates whether the edit was applied or not.
  pub applied:        bool,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "failureReason")]
  pub failure_reason: Option<String>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "failedChange")]
  pub failed_change:  Option<u32>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkDoneProgressBegin {
  /// Mandatory title of the progress operation. Used to briefly inform about
  /// the kind of operation being performed.
  ///
  /// Examples: "Indexing" or "Linking dependencies".
  pub title:       String,
  /// Controls if a cancel button should show to allow the user to cancel the
  /// long running operation. Clients that don't support cancellation are
  /// allowed to ignore the setting.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub cancellable: Option<bool>,
  /// Optional, more detailed associated progress message. Contains
  /// complementary information to the `title`.
  ///
  /// Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
  /// If unset, the previous progress message (if any) is still valid.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub message:     Option<String>,
  /// Optional progress percentage to display (value 100 is considered 100%).
  /// If not provided infinite progress is assumed and clients are allowed
  /// to ignore the `percentage` value in subsequent report notifications.
  ///
  /// The value should be steadily rising. Clients are free to ignore values
  /// that are not following this rule. The value range is [0, 100].
  #[serde(skip_serializing_if = "Option::is_none")]
  pub percentage:  Option<u32>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkDoneProgressReport {
  /// Controls enablement state of a cancel button.
  ///
  /// Clients that don't support cancellation or don't support controlling the
  /// button's enablement state are allowed to ignore the property.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub cancellable: Option<bool>,
  /// Optional, more detailed associated progress message. Contains
  /// complementary information to the `title`.
  ///
  /// Examples: "3/25 files", "project/src/module2", "node_modules/some_dep".
  /// If unset, the previous progress message (if any) is still valid.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub message:     Option<String>,
  /// Optional progress percentage to display (value 100 is considered 100%).
  /// If not provided infinite progress is assumed and clients are allowed
  /// to ignore the `percentage` value in subsequent report notifications.
  ///
  /// The value should be steadily rising. Clients are free to ignore values
  /// that are not following this rule. The value range is [0, 100].
  #[serde(skip_serializing_if = "Option::is_none")]
  pub percentage:  Option<u32>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkDoneProgressEnd {
  /// Optional, a final message indicating to for example indicate the outcome
  /// of the operation.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub message: Option<String>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SetTraceParams {
  pub value: TraceValues,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct LogTraceParams {
  pub message: String,
  #[serde(skip_serializing_if = "Option::is_none")]
  pub verbose: Option<String>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CancelParams {
  /// The request id to cancel.
  pub id: Or2<i32, String>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ProgressParams {
  /// The progress token provided by the client or server.
  pub token: ProgressToken,
  /// The progress data.
  pub value: Value,
}

/// A parameter literal used in requests to pass a text document and a position
/// inside that document.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextDocumentPositionParams {
  /// The text document.
  #[serde(rename = "textDocument")]
  pub text_document: TextDocumentIdentifier,
  /// The position inside the text document.
  pub position:      Position,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkDoneProgressParams {
  /// An optional token that a server can use to report work done progress.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "workDoneToken")]
  pub work_done_token: Option<ProgressToken>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct PartialResultParams {
  /// An optional token that a server can use to report partial results (e.g.
  /// streaming) to the client.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "partialResultToken")]
  pub partial_result_token: Option<ProgressToken>,
}

/// Represents the connection of two locations. Provides additional metadata
/// over normal [`locations`](crate::Location), including an origin range.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct LocationLink {
  /// Span of the origin of this link.
  ///
  /// Used as the underlined span for mouse interaction. Defaults to the word
  /// range at the definition position.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "originSelectionRange")]
  pub origin_selection_range: Option<Range>,
  /// The target resource identifier of this link.
  #[serde(rename = "targetUri")]
  pub target_uri:             Uri,
  /// 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.
  #[serde(rename = "targetRange")]
  pub target_range:           Range,
  /// 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`
  #[serde(rename = "targetSelectionRange")]
  pub target_selection_range: Range,
}

/// A range in a text document expressed as (zero-based) start and end
/// positions.
///
/// If you want to specify a range that contains a line including the line
/// ending character(s) then use an end position denoting the start of the next
/// line. For example:
///
/// ```ts
/// {
///     start: { line: 5, character: 23 }
///     end : { line 6, character : 0 }
/// }
/// ```
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Range {
  /// The range's start position.
  pub start: Position,
  /// The range's end position.
  pub end:   Position,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ImplementationOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Static registration options to be returned in the initialize
/// request.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct StaticRegistrationOptions {
  /// The id used to register the request. The id can be used to deregister
  /// the request again. See also Registration#id.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub id: Option<String>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TypeDefinitionOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// The workspace folder change event.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceFoldersChangeEvent {
  /// The array of added workspace folders
  pub added:   Vec<WorkspaceFolder>,
  /// The array of the removed workspace folders
  pub removed: Vec<WorkspaceFolder>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ConfigurationItem {
  /// The scope to get the configuration section for.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "scopeUri")]
  pub scope_uri: Option<Uri>,
  /// The configuration section asked for.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub section:   Option<String>,
}

/// A literal to identify a text document in the client.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextDocumentIdentifier {
  /// The text document's uri.
  pub uri: Uri,
}

/// Represents a color in RGBA space.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Color {
  /// The red component of this color in the range [0-1].
  pub red:   f64,
  /// The green component of this color in the range [0-1].
  pub green: f64,
  /// The blue component of this color in the range [0-1].
  pub blue:  f64,
  /// The alpha component of this color in the range [0-1].
  pub alpha: f64,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentColorOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FoldingRangeOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DeclarationOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Position in a text document expressed as zero-based line and character
/// offset. Prior to 3.17 the offsets were always based on a UTF-16 string
/// representation. So a string of the form `a𐐀b` the character offset of the
/// character `a` is 0, the character offset of `𐐀` is 1 and the character
/// offset of b is 3 since `𐐀` is represented using two code units in UTF-16.
/// Since 3.17 clients and servers can agree on a different string encoding
/// representation (e.g. UTF-8). The client announces it's supported encoding
/// via the client capability [`general.positionEncodings`](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#clientCapabilities).
/// The value is an array of position encodings the client supports, with
/// decreasing preference (e.g. the encoding at index `0` is the most preferred
/// one). To stay backwards compatible the only mandatory encoding is UTF-16
/// represented via the string `utf-16`. The server can pick one of the
/// encodings offered by the client and signals that encoding back to the
/// client via the initialize result's property
/// [`capabilities.positionEncoding`](https://microsoft.github.io/language-server-protocol/specifications/specification-current/#serverCapabilities). If the string value
/// `utf-16` is missing from the client's capability `general.positionEncodings`
/// servers can safely assume that the client supports UTF-16. If the server
/// omits the position encoding in its initialize result the encoding defaults
/// to the string value `utf-16`. Implementation considerations: since the
/// conversion from one encoding into another requires the content of the
/// file / line the conversion is best done where the file is read which is
/// usually on the server side.
///
/// Positions are line end character agnostic. So you can not specify a position
/// that denotes `\r|\n` or `\n|` where `|` represents the character offset.
///
/// @since 3.17.0 - support for negotiated position encoding.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Position {
  /// Line position in a document (zero-based).
  ///
  /// If a line number is greater than the number of lines in a document, it
  /// defaults back to the number of lines in the document. If a line number
  /// is negative, it defaults to 0.
  pub line:      u32,
  /// Character offset on a line in a document (zero-based).
  ///
  /// The meaning of this offset is determined by the negotiated
  /// `PositionEncodingKind`.
  ///
  /// If the character value is greater than the line length it defaults back to
  /// the line length.
  pub character: u32,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SelectionRangeOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Call hierarchy options used during static registration.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CallHierarchyOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensOptions {
  /// The legend used by the server
  pub legend:                     SemanticTokensLegend,
  /// Server supports providing semantic tokens for a specific range
  /// of a document.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub range:                      Option<bool>,
  /// Server supports providing semantic tokens for a full document.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub full:                       Option<Or2<bool, SemanticTokensOptionsFull>>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensEdit {
  /// The start offset of the edit.
  pub start:        u32,
  /// The count of elements to remove.
  #[serde(rename = "deleteCount")]
  pub delete_count: u32,
  /// The elements to insert.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:         Option<Vec<u32>>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct LinkedEditingRangeOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Represents information on a file/folder create.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FileCreate {
  /// A file:// URI for the location of the file/folder being created.
  pub uri: String,
}

/// Describes textual changes on a text document. A TextDocumentEdit describes
/// all changes on a document version Si and after they are applied move the
/// document to version Si+1. So the creator of a TextDocumentEdit doesn't need
/// to sort the array of edits or do any kind of ordering. However the edits
/// must be non overlapping.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextDocumentEdit {
  /// The text document to change.
  #[serde(rename = "textDocument")]
  pub text_document: OptionalVersionedTextDocumentIdentifier,
  /// The edits to be applied.
  ///
  /// @since 3.16.0 - support for AnnotatedTextEdit. This is guarded using a
  /// client capability.
  pub edits:         Vec<Or2<TextEdit, AnnotatedTextEdit>>,
}

/// Create file operation.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CreateFile {
  /// The resource to create.
  pub uri:                Uri,
  /// Additional options
  #[serde(skip_serializing_if = "Option::is_none")]
  pub options:            Option<CreateFileOptions>,
  #[serde(flatten)]
  pub resource_operation: ResourceOperation,
}

/// Rename file operation
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RenameFile {
  /// The old (existing) location.
  #[serde(rename = "oldUri")]
  pub old_uri:            Uri,
  /// The new location.
  #[serde(rename = "newUri")]
  pub new_uri:            Uri,
  /// Rename options.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub options:            Option<RenameFileOptions>,
  #[serde(flatten)]
  pub resource_operation: ResourceOperation,
}

/// Delete file operation
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DeleteFile {
  /// The file to delete.
  pub uri:                Uri,
  /// Delete options.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub options:            Option<DeleteFileOptions>,
  #[serde(flatten)]
  pub resource_operation: ResourceOperation,
}

/// Additional information that describes document changes.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ChangeAnnotation {
  /// A human-readable string describing the actual change. The string
  /// is rendered prominent in the user interface.
  pub label:              String,
  /// A flag which indicates that user confirmation is needed
  /// before applying the change.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "needsConfirmation")]
  pub needs_confirmation: Option<bool>,
  /// A human-readable string which is rendered less prominent in
  /// the user interface.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub description:        Option<String>,
}

/// A filter to describe in which file operation requests or notifications
/// the server is interested in receiving.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FileOperationFilter {
  /// A Uri scheme like `file` or `untitled`.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub scheme:  Option<String>,
  /// The actual file operation pattern.
  pub pattern: FileOperationPattern,
}

/// Represents information on a file/folder rename.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FileRename {
  /// A file:// URI for the original location of the file/folder being renamed.
  #[serde(rename = "oldUri")]
  pub old_uri: String,
  /// A file:// URI for the new location of the file/folder being renamed.
  #[serde(rename = "newUri")]
  pub new_uri: String,
}

/// Represents information on a file/folder delete.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FileDelete {
  /// A file:// URI for the location of the file/folder being deleted.
  pub uri: String,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct MonikerOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Type hierarchy options used during static registration.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TypeHierarchyOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineValueContext {
  /// The stack frame (as a DAP Id) where the execution has stopped.
  #[serde(rename = "frameId")]
  pub frame_id:         i32,
  /// The document range where execution has stopped.
  /// Typically the end position of the range denotes the line where the inline
  /// values are shown.
  #[serde(rename = "stoppedLocation")]
  pub stopped_location: Range,
}

/// Provide inline value as text.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineValueText {
  /// The document range for which the inline value applies.
  pub range: Range,
  /// The text of the inline value.
  pub text:  String,
}

/// Provide inline value through a variable lookup.
/// If only a range is specified, the variable name will be extracted from the
/// underlying document. An optional variable name can be used to override the
/// extracted name.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineValueVariableLookup {
  /// The document range for which the inline value applies.
  /// The range is used to extract the variable name from the underlying
  /// document.
  pub range:                 Range,
  /// If specified the name of the variable to look up.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "variableName")]
  pub variable_name:         Option<String>,
  /// How to perform the lookup.
  #[serde(rename = "caseSensitiveLookup")]
  pub case_sensitive_lookup: bool,
}

/// Provide an inline value through an expression evaluation.
/// If only a range is specified, the expression will be extracted from the
/// underlying document. An optional expression can be used to override the
/// extracted expression.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineValueEvaluatableExpression {
  /// The document range for which the inline value applies.
  /// The range is used to extract the evaluatable expression from the
  /// underlying document.
  pub range:      Range,
  /// If specified the expression overrides the extracted expression.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub expression: Option<String>,
}

/// Inline value options used during static registration.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineValueOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// An inlay hint label part allows for interactive and composite labels
/// of inlay hints.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlayHintLabelPart {
  /// The value of this label part.
  pub value:    String,
  /// The tooltip text when you hover over this label part. Depending on
  /// the client capability `inlayHint.resolveSupport` clients might resolve
  /// this property late using the resolve request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub tooltip:  Option<Or2<String, MarkupContent>>,
  /// An optional source code location that represents this
  /// label part.
  ///
  /// The editor will use this location for the hover and for code navigation
  /// features: This part will become a clickable link that resolves to the
  /// definition of the symbol at the given location (not necessarily the
  /// location itself), it shows the hover that shows at the given location,
  /// and it shows a context menu with further code navigation commands.
  ///
  /// Depending on the client capability `inlayHint.resolveSupport` clients
  /// might resolve this property late using the resolve request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub location: Option<Location>,
  /// An optional command for this label part.
  ///
  /// Depending on the client capability `inlayHint.resolveSupport` clients
  /// might resolve this property late using the resolve request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub command:  Option<Command>,
}

/// A `MarkupContent` literal represents a string value which content is
/// interpreted base on its kind flag. Currently the protocol supports
/// `plaintext` and `markdown` as markup kinds.
///
/// If the kind is `markdown` then the value can contain fenced code blocks like
/// in GitHub issues. See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
///
/// Here is an example how such a string can be constructed using JavaScript /
/// TypeScript:
///
/// ```ts
/// let markdown: MarkdownContent = {
///  kind: MarkupKind.Markdown,
///  value: [
///    '# Header',
///    'Some text',
///    '```typescript',
///    'someCode();',
///    '```'
///  ].join('\n')
/// };
/// ```
///
/// *Please Note* that clients might sanitize the return markdown. A client
/// could decide to remove HTML from the markdown to avoid script execution.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct MarkupContent {
  /// The type of the Markup
  pub kind:  MarkupKind,
  /// The content itself
  pub value: String,
}

/// Inlay hint options used during static registration.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlayHintOptions {
  /// The server provides support to resolve additional
  /// information for an inlay hint item.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resolveProvider")]
  pub resolve_provider:           Option<bool>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// A full diagnostic report with a set of related documents.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RelatedFullDocumentDiagnosticReport {
  /// Diagnostics of related documents. This information is useful
  /// in programming languages where code in a file A can generate
  /// diagnostics in a file B which A depends on. An example of
  /// such a language is C/C++ where marco definitions in a file
  /// a.cpp and result in errors in a header file b.hpp.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "relatedDocuments")]
  pub related_documents:               Option<HashMap<Uri, DocumentDiagnosticReportContents>>,
  #[serde(flatten)]
  pub full_document_diagnostic_report: FullDocumentDiagnosticReport,
}

/// An unchanged diagnostic report with a set of related documents.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RelatedUnchangedDocumentDiagnosticReport {
  /// Diagnostics of related documents. This information is useful
  /// in programming languages where code in a file A can generate
  /// diagnostics in a file B which A depends on. An example of
  /// such a language is C/C++ where marco definitions in a file
  /// a.cpp and result in errors in a header file b.hpp.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "relatedDocuments")]
  pub related_documents:                    Option<HashMap<Uri, DocumentDiagnosticReportContents>>,
  #[serde(flatten)]
  pub unchanged_document_diagnostic_report: UnchangedDocumentDiagnosticReport,
}

/// A diagnostic report with a full set of problems.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FullDocumentDiagnosticReport {
  /// An optional result id. If provided it will
  /// be sent on the next diagnostic request for the
  /// same document.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resultId")]
  pub result_id: Option<String>,
  /// The actual items.
  pub items:     Vec<Diagnostic>,
}

/// A diagnostic report indicating that the last returned
/// report is still accurate.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct UnchangedDocumentDiagnosticReport {
  /// A result id which will be sent on the next
  /// diagnostic request for the same document.
  #[serde(rename = "resultId")]
  pub result_id: String,
}

/// Diagnostic options.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DiagnosticOptions {
  /// An optional identifier under which the diagnostics are
  /// managed by the client.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub identifier:                 Option<String>,
  /// 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.
  #[serde(rename = "interFileDependencies")]
  pub inter_file_dependencies:    bool,
  /// The server provides support for workspace diagnostics as well.
  #[serde(rename = "workspaceDiagnostics")]
  pub workspace_diagnostics:      bool,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// A previous result id in a workspace pull request.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct PreviousResultId {
  /// The URI for which the client knowns a
  /// result id.
  pub uri:   Uri,
  /// The value of the previous result id.
  pub value: String,
}

/// A notebook document.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocument {
  /// The notebook document's uri.
  pub uri:           Uri,
  /// The type of the notebook.
  #[serde(rename = "notebookType")]
  pub notebook_type: String,
  /// The version number of this document (it will increase after each
  /// change, including undo/redo).
  pub version:       i32,
  /// Additional metadata stored with the notebook
  /// document.
  ///
  /// Note: should always be an object literal (e.g. LSPObject)
  #[serde(skip_serializing_if = "Option::is_none")]
  pub metadata:      Option<LSPObject>,
  /// The cells of a notebook.
  pub cells:         Vec<NotebookCell>,
}

/// An item to transfer a text document from the client to the
/// server.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextDocumentItem {
  /// The text document's uri.
  pub uri:         Uri,
  /// The text document's language identifier.
  #[serde(rename = "languageId")]
  pub language_id: String,
  /// The version number of this document (it will increase after each
  /// change, including undo/redo).
  pub version:     i32,
  /// The content of the opened text document.
  pub text:        String,
}

/// A versioned notebook document identifier.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct VersionedNotebookDocumentIdentifier {
  /// The version number of this notebook document.
  pub version: i32,
  /// The notebook document's uri.
  pub uri:     Uri,
}

/// A change event for a notebook document.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentChangeEvent {
  /// The changed meta data if any.
  ///
  /// Note: should always be an object literal (e.g. LSPObject)
  #[serde(skip_serializing_if = "Option::is_none")]
  pub metadata: Option<LSPObject>,
  /// Changes to cells
  #[serde(skip_serializing_if = "Option::is_none")]
  pub cells:    Option<NotebookDocumentChangeEventCells>,
}

/// A literal to identify a notebook document in the client.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentIdentifier {
  /// The notebook document's uri.
  pub uri: Uri,
}

/// Provides information about the context in which an inline completion was
/// requested.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineCompletionContext {
  /// Describes how the inline completion was triggered.
  #[serde(rename = "triggerKind")]
  pub trigger_kind:             InlineCompletionTriggerKind,
  /// Provides information about the currently selected item in the autocomplete
  /// widget if it is visible.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "selectedCompletionInfo")]
  pub selected_completion_info: Option<SelectedCompletionInfo>,
}

/// A string value used as a snippet is a template which allows to insert text
/// and to control the editor cursor when insertion happens.
///
/// A snippet can define tab stops and placeholders with `$1`, `$2`
/// and `${3:foo}`. `$0` defines the final tab stop, it defaults to
/// the end of the snippet. Variables are defined with `$name` and
/// `${name:default value}`.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct StringValue {
  /// The snippet string.
  pub value: String,
}

/// Inline completion options used during static registration.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineCompletionOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// General parameters to register for a notification or to register a provider.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Registration {
  /// The id used to register the request. The id can be used to deregister
  /// the request again.
  pub id:               String,
  /// The method / capability to register for.
  pub method:           String,
  /// Options necessary for the registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "registerOptions")]
  pub register_options: Option<Value>,
}

/// General parameters to unregister a request or notification.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Unregistration {
  /// The id used to unregister the request or notification. Usually an id
  /// provided during the register request.
  pub id:     String,
  /// The method to unregister for.
  pub method: String,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceFoldersInitializeParams {
  /// The workspace folders configured in the client when the server starts.
  ///
  /// This property is only available if the client supports workspace folders.
  /// It can be `null` if the client supports workspace folders but none are
  /// configured.
  ///
  /// @since 3.6.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "workspaceFolders")]
  pub workspace_folders: Option<Vec<WorkspaceFolder>>,
}

/// Defines the capabilities provided by a language
/// server.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ServerCapabilities {
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "positionEncoding")]
  pub position_encoding:                    Option<PositionEncodingKind>,
  /// Defines how text documents are synced. Is either a detailed structure
  /// defining each notification or for backwards compatibility the
  /// TextDocumentSyncKind number.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "textDocumentSync")]
  pub text_document_sync: Option<Or2<TextDocumentSyncOptions, TextDocumentSyncKind>>,
  /// Defines how notebook documents are synced.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "notebookDocumentSync")]
  pub notebook_document_sync:
    Option<Or2<NotebookDocumentSyncOptions, NotebookDocumentSyncRegistrationOptions>>,
  /// The server provides completion support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "completionProvider")]
  pub completion_provider:                  Option<CompletionOptions>,
  /// The server provides hover support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "hoverProvider")]
  pub hover_provider:                       Option<Or2<bool, HoverOptions>>,
  /// The server provides signature help support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "signatureHelpProvider")]
  pub signature_help_provider:              Option<SignatureHelpOptions>,
  /// The server provides Goto Declaration support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "declarationProvider")]
  pub declaration_provider: Option<Or3<bool, DeclarationOptions, DeclarationRegistrationOptions>>,
  /// The server provides goto definition support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "definitionProvider")]
  pub definition_provider:                  Option<Or2<bool, DefinitionOptions>>,
  /// The server provides Goto Type Definition support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "typeDefinitionProvider")]
  pub type_definition_provider:
    Option<Or3<bool, TypeDefinitionOptions, TypeDefinitionRegistrationOptions>>,
  /// The server provides Goto Implementation support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "implementationProvider")]
  pub implementation_provider:
    Option<Or3<bool, ImplementationOptions, ImplementationRegistrationOptions>>,
  /// The server provides find references support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "referencesProvider")]
  pub references_provider:                  Option<Or2<bool, ReferenceOptions>>,
  /// The server provides document highlight support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentHighlightProvider")]
  pub document_highlight_provider:          Option<Or2<bool, DocumentHighlightOptions>>,
  /// The server provides document symbol support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentSymbolProvider")]
  pub document_symbol_provider:             Option<Or2<bool, DocumentSymbolOptions>>,
  /// The server provides code actions. CodeActionOptions may only be
  /// specified if the client states that it supports
  /// `codeActionLiteralSupport` in its initial `initialize` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "codeActionProvider")]
  pub code_action_provider:                 Option<Or2<bool, CodeActionOptions>>,
  /// The server provides code lens.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "codeLensProvider")]
  pub code_lens_provider:                   Option<CodeLensOptions>,
  /// The server provides document link support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentLinkProvider")]
  pub document_link_provider:               Option<DocumentLinkOptions>,
  /// The server provides color provider support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "colorProvider")]
  pub color_provider: Option<Or3<bool, DocumentColorOptions, DocumentColorRegistrationOptions>>,
  /// The server provides workspace symbol support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "workspaceSymbolProvider")]
  pub workspace_symbol_provider:            Option<Or2<bool, WorkspaceSymbolOptions>>,
  /// The server provides document formatting.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentFormattingProvider")]
  pub document_formatting_provider:         Option<Or2<bool, DocumentFormattingOptions>>,
  /// The server provides document range formatting.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentRangeFormattingProvider")]
  pub document_range_formatting_provider:   Option<Or2<bool, DocumentRangeFormattingOptions>>,
  /// The server provides document formatting on typing.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentOnTypeFormattingProvider")]
  pub document_on_type_formatting_provider: Option<DocumentOnTypeFormattingOptions>,
  /// The server provides rename support. RenameOptions may only be
  /// specified if the client states that it supports
  /// `prepareSupport` in its initial `initialize` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "renameProvider")]
  pub rename_provider:                      Option<Or2<bool, RenameOptions>>,
  /// The server provides folding provider support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "foldingRangeProvider")]
  pub folding_range_provider:
    Option<Or3<bool, FoldingRangeOptions, FoldingRangeRegistrationOptions>>,
  /// The server provides selection range support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "selectionRangeProvider")]
  pub selection_range_provider:
    Option<Or3<bool, SelectionRangeOptions, SelectionRangeRegistrationOptions>>,
  /// The server provides execute command support.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "executeCommandProvider")]
  pub execute_command_provider:             Option<ExecuteCommandOptions>,
  /// The server provides call hierarchy support.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "callHierarchyProvider")]
  pub call_hierarchy_provider:
    Option<Or3<bool, CallHierarchyOptions, CallHierarchyRegistrationOptions>>,
  /// The server provides linked editing range support.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "linkedEditingRangeProvider")]
  pub linked_editing_range_provider:
    Option<Or3<bool, LinkedEditingRangeOptions, LinkedEditingRangeRegistrationOptions>>,
  /// The server provides semantic tokens support.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "semanticTokensProvider")]
  pub semantic_tokens_provider:
    Option<Or2<SemanticTokensOptions, SemanticTokensRegistrationOptions>>,
  /// The server provides moniker support.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "monikerProvider")]
  pub moniker_provider: Option<Or3<bool, MonikerOptions, MonikerRegistrationOptions>>,
  /// The server provides type hierarchy support.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "typeHierarchyProvider")]
  pub type_hierarchy_provider:
    Option<Or3<bool, TypeHierarchyOptions, TypeHierarchyRegistrationOptions>>,
  /// The server provides inline values.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "inlineValueProvider")]
  pub inline_value_provider: Option<Or3<bool, InlineValueOptions, InlineValueRegistrationOptions>>,
  /// The server provides inlay hints.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "inlayHintProvider")]
  pub inlay_hint_provider: Option<Or3<bool, InlayHintOptions, InlayHintRegistrationOptions>>,
  /// The server has support for pull model diagnostics.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "diagnosticProvider")]
  pub diagnostic_provider: Option<Or2<DiagnosticOptions, DiagnosticRegistrationOptions>>,
  /// Inline completion options used during static registration.
  ///
  /// @since 3.18.0
  /// @proposed
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "inlineCompletionProvider")]
  pub inline_completion_provider:           Option<Or2<bool, InlineCompletionOptions>>,
  /// Workspace specific server capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub workspace:                            Option<WorkspaceCapabilities>,
  /// Experimental server capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub experimental:                         Option<Value>,
}

/// A text document identifier to denote a specific version of a text document.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct VersionedTextDocumentIdentifier {
  /// The version number of this document.
  pub version:                  i32,
  #[serde(flatten)]
  pub text_document_identifier: TextDocumentIdentifier,
}

/// Save options.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SaveOptions {
  /// The client is supposed to include the content on save.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "includeText")]
  pub include_text: Option<bool>,
}

/// An event describing a file change.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FileEvent {
  /// The file's uri.
  pub uri: Uri,
  /// The change type.
  #[serde(rename = "type")]
  pub ty:  FileChangeType,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FileSystemWatcher {
  /// The glob pattern to watch. See [`glob pattern`](crate::GlobPattern) for
  /// more detail.
  ///
  /// @since 3.17.0 support for relative patterns.
  #[serde(rename = "globPattern")]
  pub glob_pattern: GlobPattern,
  /// The kind of events of interest. If omitted it defaults
  /// to WatchKind.Create | WatchKind.Change | WatchKind.Delete
  /// which is 7.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub kind:         Option<WatchKind>,
}

/// Represents a diagnostic, such as a compiler error or warning. Diagnostic
/// objects are only valid in the scope of a resource.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct Diagnostic {
  /// The range at which the message applies
  pub range:               Range,
  /// The diagnostic's severity. Can be omitted. If omitted it is up to the
  /// client to interpret diagnostics as error, warning, info or hint.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub severity:            Option<DiagnosticSeverity>,
  /// The diagnostic's code, which usually appear in the user interface.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub code:                Option<Or2<i32, String>>,
  /// An optional property to describe the error code.
  /// Requires the code field (above) to be present/not null.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "codeDescription")]
  pub code_description:    Option<CodeDescription>,
  /// A human-readable string describing the source of this
  /// diagnostic, e.g. 'typescript' or 'super lint'. It usually
  /// appears in the user interface.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub source:              Option<String>,
  /// The diagnostic's message. It usually appears in the user interface
  pub message:             String,
  /// Additional metadata about the diagnostic.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub tags:                Option<Vec<DiagnosticTag>>,
  /// An array of related diagnostic information, e.g. when symbol-names within
  /// a scope collide all definitions can be marked via this property.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "relatedInformation")]
  pub related_information: Option<Vec<DiagnosticRelatedInformation>>,
  /// A data entry field that is preserved between a
  /// `textDocument/publishDiagnostics` notification and
  /// `textDocument/codeAction` request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:                Option<Value>,
}

/// Contains additional information about the context in which a completion
/// request is triggered.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionContext {
  /// How the completion was triggered.
  #[serde(rename = "triggerKind")]
  pub trigger_kind:      CompletionTriggerKind,
  /// The trigger character (a single character) that has trigger code complete.
  /// Is undefined if `triggerKind !== CompletionTriggerKind.TriggerCharacter`
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "triggerCharacter")]
  pub trigger_character: Option<String>,
}

/// Additional details for a completion item label.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionItemLabelDetails {
  /// An optional string which is rendered less prominently directly after
  /// [`label`](crate::CompletionItem), without any spacing. Should be used
  /// for function signatures and type annotations.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub detail:      Option<String>,
  /// An optional string which is rendered less prominently after
  /// [`CompletionItem.detail`](crate::CompletionItem). Should be used
  /// for fully qualified names and file paths.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub description: Option<String>,
}

/// A special text edit to provide an insert and a replace operation.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InsertReplaceEdit {
  /// The string to be inserted.
  #[serde(rename = "newText")]
  pub new_text: String,
  /// The range if the insert is requested
  pub insert:   Range,
  /// The range if the replace is requested.
  pub replace:  Range,
}

/// Completion options.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionOptions {
  /// 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`.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "triggerCharacters")]
  pub trigger_characters:         Option<Vec<String>>,
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "allCommitCharacters")]
  pub all_commit_characters:      Option<Vec<String>>,
  /// The server provides support to resolve additional
  /// information for a completion item.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resolveProvider")]
  pub resolve_provider:           Option<bool>,
  /// The server supports the following `CompletionItem` specific
  /// capabilities.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "completionItem")]
  pub completion_item:            Option<CompletionOptionsCompletionItem>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Hover options.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct HoverOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Additional information about the context in which a signature help request
/// was triggered.
///
/// @since 3.15.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SignatureHelpContext {
  /// Action that caused signature help to be triggered.
  #[serde(rename = "triggerKind")]
  pub trigger_kind:          SignatureHelpTriggerKind,
  /// Character that caused signature help to be triggered.
  ///
  /// This is undefined when `triggerKind !==
  /// SignatureHelpTriggerKind.TriggerCharacter`
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "triggerCharacter")]
  pub trigger_character:     Option<String>,
  /// `true` if signature help was already showing when it was triggered.
  ///
  /// Retriggers 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.
  #[serde(rename = "isRetrigger")]
  pub is_retrigger:          bool,
  /// The currently active `SignatureHelp`.
  ///
  /// The `activeSignatureHelp` has its `SignatureHelp.activeSignature` field
  /// updated based on the user navigating through available signatures.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "activeSignatureHelp")]
  pub active_signature_help: Option<SignatureHelp>,
}

/// Represents the signature of something callable. A signature
/// can have a label, like a function-name, a doc-comment, and
/// a set of parameters.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SignatureInformation {
  /// The label of this signature. Will be shown in
  /// the UI.
  pub label:            String,
  /// The human-readable doc-comment of this signature. Will be shown
  /// in the UI but can be omitted.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub documentation:    Option<Or2<String, MarkupContent>>,
  /// The parameters of this signature.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub parameters:       Option<Vec<ParameterInformation>>,
  /// The index of the active parameter.
  ///
  /// If provided, this is used in place of `SignatureHelp.activeParameter`.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "activeParameter")]
  pub active_parameter: Option<u32>,
}

/// Server Capabilities for a
/// [`SignatureHelpRequest`](crate::request::TextDocumentSignatureHelp).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SignatureHelpOptions {
  /// List of characters that trigger signature help automatically.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "triggerCharacters")]
  pub trigger_characters:         Option<Vec<String>>,
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "retriggerCharacters")]
  pub retrigger_characters:       Option<Vec<String>>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Server Capabilities for a
/// [`DefinitionRequest`](crate::request::TextDocumentDefinition).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DefinitionOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Value-object that contains additional information when
/// requesting references.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ReferenceContext {
  /// Include the declaration of the current symbol.
  #[serde(rename = "includeDeclaration")]
  pub include_declaration: bool,
}

/// Reference options.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ReferenceOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Provider options for a
/// [`DocumentHighlightRequest`](crate::request::TextDocumentDocumentHighlight).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentHighlightOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// A base for all symbol information.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct BaseSymbolInformation {
  /// The name of this symbol.
  pub name:           String,
  /// The kind of this symbol.
  pub kind:           SymbolKind,
  /// Tags for this symbol.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub tags:           Option<Vec<SymbolTag>>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "containerName")]
  pub container_name: Option<String>,
}

/// Provider options for a
/// [`DocumentSymbolRequest`](crate::request::TextDocumentDocumentSymbol).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentSymbolOptions {
  /// A human-readable string that is shown when multiple outlines trees
  /// are shown for the same document.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub label:                      Option<String>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Contains additional diagnostic information about the context in which
/// a [`code action`](crate::request::TextDocumentCodeAction) is run.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeActionContext {
  /// An array of diagnostics known on the client side overlapping the range
  /// provided to the `textDocument/codeAction` request. They are provided so
  /// that the server knows which errors are currently presented to the user
  /// for the given range. There is no guarantee that these accurately reflect
  /// the error state of the resource. The primary parameter to compute code
  /// actions is the provided range.
  pub diagnostics:  Vec<Diagnostic>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub only:         Option<Vec<CodeActionKind>>,
  /// The reason why code actions were requested.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "triggerKind")]
  pub trigger_kind: Option<CodeActionTriggerKind>,
}

/// Provider options for a
/// [`CodeActionRequest`](crate::request::TextDocumentCodeAction).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeActionOptions {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "codeActionKinds")]
  pub code_action_kinds:          Option<Vec<CodeActionKind>>,
  /// The server provides support to resolve additional
  /// information for a code action.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resolveProvider")]
  pub resolve_provider:           Option<bool>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Server capabilities for a
/// [`WorkspaceSymbolRequest`](crate::request::WorkspaceSymbolRequest).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceSymbolOptions {
  /// The server provides support to resolve additional
  /// information for a workspace symbol.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resolveProvider")]
  pub resolve_provider:           Option<bool>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Code Lens provider options of a
/// [`CodeLensRequest`](crate::request::TextDocumentCodeLens).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeLensOptions {
  /// Code lens has a resolve provider as well.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resolveProvider")]
  pub resolve_provider:           Option<bool>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Provider options for a
/// [`DocumentLinkRequest`](crate::request::TextDocumentDocumentLink).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentLinkOptions {
  /// Document links have a resolve provider as well.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resolveProvider")]
  pub resolve_provider:           Option<bool>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Value-object describing what options formatting should use.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FormattingOptions {
  /// Size of a tab in spaces.
  #[serde(rename = "tabSize")]
  pub tab_size:                 u32,
  /// Prefer spaces over tabs.
  #[serde(rename = "insertSpaces")]
  pub insert_spaces:            bool,
  /// Trim trailing whitespace on a line.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "trimTrailingWhitespace")]
  pub trim_trailing_whitespace: Option<bool>,
  /// Insert a newline character at the end of the file if one does not exist.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "insertFinalNewline")]
  pub insert_final_newline:     Option<bool>,
  /// Trim all newlines after the final newline at the end of the file.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "trimFinalNewlines")]
  pub trim_final_newlines:      Option<bool>,
}

/// Provider options for a
/// [`DocumentFormattingRequest`](crate::request::TextDocumentFormatting).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentFormattingOptions {
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Provider options for a
/// [`DocumentRangeFormattingRequest`](crate::request::TextDocumentRangeFormatting).
///
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentRangeFormattingOptions {
  /// Whether the server supports formatting multiple ranges at once.
  ///
  /// @since 3.18.0
  /// @proposed
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "rangesSupport")]
  pub ranges_support:             Option<bool>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Provider options for a
/// [`DocumentOnTypeFormattingRequest`](crate::request::TextDocumentOnTypeFormatting).
///
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentOnTypeFormattingOptions {
  /// A character on which formatting should be triggered, like `{`.
  #[serde(rename = "firstTriggerCharacter")]
  pub first_trigger_character: String,
  /// More trigger characters.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "moreTriggerCharacter")]
  pub more_trigger_character:  Option<Vec<String>>,
}

/// Provider options for a
/// [`RenameRequest`](crate::request::TextDocumentRename).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RenameOptions {
  /// Renames should be checked and tested before being executed.
  ///
  /// @since version 3.12.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "prepareProvider")]
  pub prepare_provider:           Option<bool>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// The server capabilities of a
/// [`ExecuteCommandRequest`](crate::request::WorkspaceExecuteCommand).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ExecuteCommandOptions {
  /// The commands to be executed on the server
  pub commands:                   Vec<String>,
  #[serde(flatten)]
  pub work_done_progress_options: WorkDoneProgressOptions,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensLegend {
  /// The token types a server uses.
  #[serde(rename = "tokenTypes")]
  pub token_types:     Vec<String>,
  /// The token modifiers a server uses.
  #[serde(rename = "tokenModifiers")]
  pub token_modifiers: Vec<String>,
}

/// A text document identifier to optionally denote a specific version of a text
/// document.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct OptionalVersionedTextDocumentIdentifier {
  /// 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).
  pub version:                  Option<i32>,
  #[serde(flatten)]
  pub text_document_identifier: TextDocumentIdentifier,
}

/// A special text edit with an additional change annotation.
///
/// @since 3.16.0.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct AnnotatedTextEdit {
  /// The actual identifier of the change annotation
  #[serde(rename = "annotationId")]
  pub annotation_id: ChangeAnnotationIdentifier,
  #[serde(flatten)]
  pub text_edit:     TextEdit,
}

/// A generic resource operation.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ResourceOperation {
  /// The resource operation kind.
  pub kind:          String,
  /// An optional annotation identifier describing the operation.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "annotationId")]
  pub annotation_id: Option<ChangeAnnotationIdentifier>,
}

/// Options to create a file.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CreateFileOptions {
  /// Overwrite existing file. Overwrite wins over `ignoreIfExists`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub overwrite:        Option<bool>,
  /// Ignore if exists.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "ignoreIfExists")]
  pub ignore_if_exists: Option<bool>,
}

/// Rename file options
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RenameFileOptions {
  /// Overwrite target if existing. Overwrite wins over `ignoreIfExists`
  #[serde(skip_serializing_if = "Option::is_none")]
  pub overwrite:        Option<bool>,
  /// Ignores if target exists.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "ignoreIfExists")]
  pub ignore_if_exists: Option<bool>,
}

/// Delete file options
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DeleteFileOptions {
  /// Delete the content recursively if a folder is denoted.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub recursive:            Option<bool>,
  /// Ignore the operation if the file doesn't exist.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "ignoreIfNotExists")]
  pub ignore_if_not_exists: Option<bool>,
}

/// A pattern to describe in which file operation requests or notifications
/// the server is interested in receiving.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FileOperationPattern {
  /// The glob pattern to match. Glob patterns can have the following syntax:
  /// - `*` to match zero 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`)
  pub glob:    String,
  /// Whether to match files or folders with this pattern.
  ///
  /// Matches both if undefined.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub matches: Option<FileOperationPatternKind>,
  /// Additional options used during matching.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub options: Option<FileOperationPatternOptions>,
}

/// A full document diagnostic report for a workspace diagnostic result.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceFullDocumentDiagnosticReport {
  /// The URI for which diagnostic information is reported.
  pub uri:                             Uri,
  /// The version number for which the diagnostics are reported.
  /// If the document is not marked as open `null` can be provided.
  pub version:                         Option<i32>,
  #[serde(flatten)]
  pub full_document_diagnostic_report: FullDocumentDiagnosticReport,
}

/// An unchanged document diagnostic report for a workspace diagnostic result.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceUnchangedDocumentDiagnosticReport {
  /// The URI for which diagnostic information is reported.
  pub uri:                                  Uri,
  /// The version number for which the diagnostics are reported.
  /// If the document is not marked as open `null` can be provided.
  pub version:                              Option<i32>,
  #[serde(flatten)]
  pub unchanged_document_diagnostic_report: UnchangedDocumentDiagnosticReport,
}

/// A notebook cell.
///
/// A cell's document URI must be unique across ALL notebook
/// cells and can therefore be used to uniquely identify a
/// notebook cell or the cell's text document.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookCell {
  /// The cell's kind
  pub kind:              NotebookCellKind,
  /// The URI of the cell's text document
  /// content.
  pub document:          Uri,
  /// Additional metadata stored with the cell.
  ///
  /// Note: should always be an object literal (e.g. LSPObject)
  #[serde(skip_serializing_if = "Option::is_none")]
  pub metadata:          Option<LSPObject>,
  /// Additional execution summary information
  /// if supported by the client.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "executionSummary")]
  pub execution_summary: Option<ExecutionSummary>,
}

/// A change describing how to move a `NotebookCell`
/// array from state S to S'.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookCellArrayChange {
  /// The start oftest of the cell that changed.
  pub start:        u32,
  /// The deleted cells
  #[serde(rename = "deleteCount")]
  pub delete_count: u32,
  /// The new cells, if any
  #[serde(skip_serializing_if = "Option::is_none")]
  pub cells:        Option<Vec<NotebookCell>>,
}

/// Describes the currently selected completion item.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SelectedCompletionInfo {
  /// The range that will be replaced if this completion item is accepted.
  pub range: Range,
  /// The text the range will be replaced with if this completion is accepted.
  pub text:  String,
}

/// Defines the capabilities provided by the client.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ClientCapabilities {
  /// Workspace specific client capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub workspace:         Option<WorkspaceClientCapabilities>,
  /// Text document specific client capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "textDocument")]
  pub text_document:     Option<TextDocumentClientCapabilities>,
  /// Capabilities specific to the notebook document support.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "notebookDocument")]
  pub notebook_document: Option<NotebookDocumentClientCapabilities>,
  /// Window specific client capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub window:            Option<WindowClientCapabilities>,
  /// General client capabilities.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub general:           Option<GeneralClientCapabilities>,
  /// Experimental client capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub experimental:      Option<Value>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextDocumentSyncOptions {
  /// Open and close notifications are sent to the server. If omitted open close
  /// notification should not be sent.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "openClose")]
  pub open_close:           Option<bool>,
  /// Change notifications are sent to the server. See
  /// TextDocumentSyncKind.None, TextDocumentSyncKind.Full
  /// and TextDocumentSyncKind.Incremental. If omitted it defaults to
  /// TextDocumentSyncKind.None.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub change:               Option<TextDocumentSyncKind>,
  /// If present will save notifications are sent to the server. If omitted the
  /// notification should not be sent.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "willSave")]
  pub will_save:            Option<bool>,
  /// If present will save wait until requests are sent to the server. If
  /// omitted the request should not be sent.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "willSaveWaitUntil")]
  pub will_save_wait_until: Option<bool>,
  /// If present save notifications are sent to the server. If omitted the
  /// notification should not be sent.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub save:                 Option<Or2<bool, SaveOptions>>,
}

/// Options specific to a notebook plus its cells
/// to be synced to the server.
///
/// If a selector provides a notebook document
/// filter but no cell selector all cells of a
/// matching notebook document will be synced.
///
/// If a selector provides no notebook document
/// filter but only a cell selector all notebook
/// document that contain at least one matching
/// cell will be synced.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentSyncOptions {
  /// The notebooks to be synced
  #[serde(rename = "notebookSelector")]
  pub notebook_selector: Vec<NotebookDocumentSyncOptionsNotebookSelector>,
  /// Whether save notification should be forwarded to
  /// the server. Will only be honored if mode === `notebook`.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub save:              Option<bool>,
}

/// Registration options specific to a notebook.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentSyncRegistrationOptions {
  #[serde(flatten)]
  pub static_registration_options:    StaticRegistrationOptions,
  #[serde(flatten)]
  pub notebook_document_sync_options: NotebookDocumentSyncOptions,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceFoldersServerCapabilities {
  /// The server has support for workspace folders
  #[serde(skip_serializing_if = "Option::is_none")]
  pub supported:            Option<bool>,
  /// Whether the server wants to receive workspace folder
  /// change notifications.
  ///
  /// If a string is provided the string is treated as an ID
  /// under which the notification is registered on the client
  /// side. The ID can be used to unregister for these events
  /// using the `client/unregisterCapability` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "changeNotifications")]
  pub change_notifications: Option<Or2<String, bool>>,
}

/// Options for notifications/requests for user operations on files.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FileOperationOptions {
  /// The server is interested in receiving didCreateFiles notifications.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "didCreate")]
  pub did_create:  Option<FileOperationRegistrationOptions>,
  /// The server is interested in receiving willCreateFiles requests.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "willCreate")]
  pub will_create: Option<FileOperationRegistrationOptions>,
  /// The server is interested in receiving didRenameFiles notifications.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "didRename")]
  pub did_rename:  Option<FileOperationRegistrationOptions>,
  /// The server is interested in receiving willRenameFiles requests.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "willRename")]
  pub will_rename: Option<FileOperationRegistrationOptions>,
  /// The server is interested in receiving didDeleteFiles file notifications.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "didDelete")]
  pub did_delete:  Option<FileOperationRegistrationOptions>,
  /// The server is interested in receiving willDeleteFiles file requests.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "willDelete")]
  pub will_delete: Option<FileOperationRegistrationOptions>,
}

/// Structure to capture a description for an error code.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeDescription {
  /// An URI to open with more information about the diagnostic error.
  pub href: Uri,
}

/// Represents a related message and source code location for a diagnostic. This
/// should be used to point to code locations that cause or related to a
/// diagnostics, e.g when duplicating a symbol in a scope.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DiagnosticRelatedInformation {
  /// The location of this related diagnostic information.
  pub location: Location,
  /// The message of this related diagnostic information.
  pub message:  String,
}

/// Represents a parameter of a callable-signature. A parameter can
/// have a label and a doc-comment.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ParameterInformation {
  /// 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`.
  pub label:         Or2<String, (u32, u32)>,
  /// The human-readable doc-comment of this parameter. Will be shown
  /// in the UI but can be omitted.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub documentation: Option<Or2<String, MarkupContent>>,
}

/// A notebook cell text document filter denotes a cell text
/// document by different properties.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookCellTextDocumentFilter {
  /// A filter that matches against the notebook
  /// containing the notebook cell. If a string
  /// value is provided it matches against the
  /// notebook type. '*' matches every notebook.
  pub notebook: Or2<String, NotebookDocumentFilter>,
  /// A language id like `python`.
  ///
  /// Will be matched against the language id of the
  /// notebook cell document. '*' matches every language.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub language: Option<String>,
}

/// Matching options for the file operation pattern.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FileOperationPatternOptions {
  /// The pattern should be matched ignoring casing.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "ignoreCase")]
  pub ignore_case: Option<bool>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ExecutionSummary {
  /// A strict monotonically increasing value
  /// indicating the execution order of a cell
  /// inside a notebook.
  #[serde(rename = "executionOrder")]
  pub execution_order: u32,
  /// Whether the execution was successful or
  /// not if known by the client.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub success:         Option<bool>,
}

/// Workspace specific client capabilities.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceClientCapabilities {
  /// The client supports applying batch edits
  /// to the workspace by supporting the request
  /// 'workspace/applyEdit'
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "applyEdit")]
  pub apply_edit:               Option<bool>,
  /// Capabilities specific to `WorkspaceEdit`s.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "workspaceEdit")]
  pub workspace_edit:           Option<WorkspaceEditClientCapabilities>,
  /// Capabilities specific to the `workspace/didChangeConfiguration`
  /// notification.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "didChangeConfiguration")]
  pub did_change_configuration: Option<DidChangeConfigurationClientCapabilities>,
  /// Capabilities specific to the `workspace/didChangeWatchedFiles`
  /// notification.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "didChangeWatchedFiles")]
  pub did_change_watched_files: Option<DidChangeWatchedFilesClientCapabilities>,
  /// Capabilities specific to the `workspace/symbol` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub symbol:                   Option<WorkspaceSymbolClientCapabilities>,
  /// Capabilities specific to the `workspace/executeCommand` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "executeCommand")]
  pub execute_command:          Option<ExecuteCommandClientCapabilities>,
  /// The client has support for workspace folders.
  ///
  /// @since 3.6.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "workspaceFolders")]
  pub workspace_folders:        Option<bool>,
  /// The client supports `workspace/configuration` requests.
  ///
  /// @since 3.6.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub configuration:            Option<bool>,
  /// Capabilities specific to the semantic token requests scoped to the
  /// workspace.
  ///
  /// @since 3.16.0.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "semanticTokens")]
  pub semantic_tokens:          Option<SemanticTokensWorkspaceClientCapabilities>,
  /// Capabilities specific to the code lens requests scoped to the
  /// workspace.
  ///
  /// @since 3.16.0.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "codeLens")]
  pub code_lens:                Option<CodeLensWorkspaceClientCapabilities>,
  /// The client has support for file notifications/requests for user operations
  /// on files.
  ///
  /// Since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "fileOperations")]
  pub file_operations:          Option<FileOperationClientCapabilities>,
  /// Capabilities specific to the inline values requests scoped to the
  /// workspace.
  ///
  /// @since 3.17.0.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "inlineValue")]
  pub inline_value:             Option<InlineValueWorkspaceClientCapabilities>,
  /// Capabilities specific to the inlay hint requests scoped to the
  /// workspace.
  ///
  /// @since 3.17.0.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "inlayHint")]
  pub inlay_hint:               Option<InlayHintWorkspaceClientCapabilities>,
  /// Capabilities specific to the diagnostic requests scoped to the
  /// workspace.
  ///
  /// @since 3.17.0.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub diagnostics:              Option<DiagnosticWorkspaceClientCapabilities>,
  /// Capabilities specific to the folding range requests scoped to the
  /// workspace.
  ///
  /// @since 3.18.0
  /// @proposed
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "foldingRange")]
  pub folding_range:            Option<FoldingRangeWorkspaceClientCapabilities>,
}

/// Text document specific client capabilities.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextDocumentClientCapabilities {
  /// Defines which synchronization capabilities the client supports.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub synchronization:      Option<TextDocumentSyncClientCapabilities>,
  /// Capabilities specific to the `textDocument/completion` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub completion:           Option<CompletionClientCapabilities>,
  /// Capabilities specific to the `textDocument/hover` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub hover:                Option<HoverClientCapabilities>,
  /// Capabilities specific to the `textDocument/signatureHelp` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "signatureHelp")]
  pub signature_help:       Option<SignatureHelpClientCapabilities>,
  /// Capabilities specific to the `textDocument/declaration` request.
  ///
  /// @since 3.14.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub declaration:          Option<DeclarationClientCapabilities>,
  /// Capabilities specific to the `textDocument/definition` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub definition:           Option<DefinitionClientCapabilities>,
  /// Capabilities specific to the `textDocument/typeDefinition` request.
  ///
  /// @since 3.6.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "typeDefinition")]
  pub type_definition:      Option<TypeDefinitionClientCapabilities>,
  /// Capabilities specific to the `textDocument/implementation` request.
  ///
  /// @since 3.6.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub implementation:       Option<ImplementationClientCapabilities>,
  /// Capabilities specific to the `textDocument/references` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub references:           Option<ReferenceClientCapabilities>,
  /// Capabilities specific to the `textDocument/documentHighlight` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentHighlight")]
  pub document_highlight:   Option<DocumentHighlightClientCapabilities>,
  /// Capabilities specific to the `textDocument/documentSymbol` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentSymbol")]
  pub document_symbol:      Option<DocumentSymbolClientCapabilities>,
  /// Capabilities specific to the `textDocument/codeAction` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "codeAction")]
  pub code_action:          Option<CodeActionClientCapabilities>,
  /// Capabilities specific to the `textDocument/codeLens` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "codeLens")]
  pub code_lens:            Option<CodeLensClientCapabilities>,
  /// Capabilities specific to the `textDocument/documentLink` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentLink")]
  pub document_link:        Option<DocumentLinkClientCapabilities>,
  /// Capabilities specific to the `textDocument/documentColor` and the
  /// `textDocument/colorPresentation` request.
  ///
  /// @since 3.6.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "colorProvider")]
  pub color_provider:       Option<DocumentColorClientCapabilities>,
  /// Capabilities specific to the `textDocument/formatting` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub formatting:           Option<DocumentFormattingClientCapabilities>,
  /// Capabilities specific to the `textDocument/rangeFormatting` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "rangeFormatting")]
  pub range_formatting:     Option<DocumentRangeFormattingClientCapabilities>,
  /// Capabilities specific to the `textDocument/onTypeFormatting` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "onTypeFormatting")]
  pub on_type_formatting:   Option<DocumentOnTypeFormattingClientCapabilities>,
  /// Capabilities specific to the `textDocument/rename` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub rename:               Option<RenameClientCapabilities>,
  /// Capabilities specific to the `textDocument/foldingRange` request.
  ///
  /// @since 3.10.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "foldingRange")]
  pub folding_range:        Option<FoldingRangeClientCapabilities>,
  /// Capabilities specific to the `textDocument/selectionRange` request.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "selectionRange")]
  pub selection_range:      Option<SelectionRangeClientCapabilities>,
  /// Capabilities specific to the `textDocument/publishDiagnostics`
  /// notification.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "publishDiagnostics")]
  pub publish_diagnostics:  Option<PublishDiagnosticsClientCapabilities>,
  /// Capabilities specific to the various call hierarchy requests.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "callHierarchy")]
  pub call_hierarchy:       Option<CallHierarchyClientCapabilities>,
  /// Capabilities specific to the various semantic token request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "semanticTokens")]
  pub semantic_tokens:      Option<SemanticTokensClientCapabilities>,
  /// Capabilities specific to the `textDocument/linkedEditingRange` request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "linkedEditingRange")]
  pub linked_editing_range: Option<LinkedEditingRangeClientCapabilities>,
  /// Client capabilities specific to the `textDocument/moniker` request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub moniker:              Option<MonikerClientCapabilities>,
  /// Capabilities specific to the various type hierarchy requests.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "typeHierarchy")]
  pub type_hierarchy:       Option<TypeHierarchyClientCapabilities>,
  /// Capabilities specific to the `textDocument/inlineValue` request.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "inlineValue")]
  pub inline_value:         Option<InlineValueClientCapabilities>,
  /// Capabilities specific to the `textDocument/inlayHint` request.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "inlayHint")]
  pub inlay_hint:           Option<InlayHintClientCapabilities>,
  /// Capabilities specific to the diagnostic pull model.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub diagnostic:           Option<DiagnosticClientCapabilities>,
  /// Client capabilities specific to inline completions.
  ///
  /// @since 3.18.0
  /// @proposed
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "inlineCompletion")]
  pub inline_completion:    Option<InlineCompletionClientCapabilities>,
}

/// Capabilities specific to the notebook document support.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentClientCapabilities {
  /// Capabilities specific to notebook document synchronization
  ///
  /// @since 3.17.0
  pub synchronization: NotebookDocumentSyncClientCapabilities,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WindowClientCapabilities {
  /// It indicates whether the client supports server initiated
  /// progress using the `window/workDoneProgress/create` request.
  ///
  /// The capability also controls Whether client supports handling
  /// of progress notifications. If set servers are allowed to report a
  /// `workDoneProgress` property in the request specific server
  /// capabilities.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "workDoneProgress")]
  pub work_done_progress: Option<bool>,
  /// Capabilities specific to the showMessage request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "showMessage")]
  pub show_message:       Option<ShowMessageRequestClientCapabilities>,
  /// Capabilities specific to the showDocument request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "showDocument")]
  pub show_document:      Option<ShowDocumentClientCapabilities>,
}

/// General client capabilities.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct GeneralClientCapabilities {
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "staleRequestSupport")]
  pub stale_request_support: Option<StaleRequestSupportCapabilities>,
  /// Client capabilities specific to regular expressions.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "regularExpressions")]
  pub regular_expressions:   Option<RegularExpressionsClientCapabilities>,
  /// Client capabilities specific to the client's markdown parser.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub markdown:              Option<MarkdownClientCapabilities>,
  /// The position encodings supported by the client. Client and server
  /// have to agree on the same position encoding to ensure that offsets
  /// (e.g. character position in a line) are interpreted the same on both
  /// sides.
  ///
  /// To keep the protocol backwards compatible the following applies: if
  /// the value 'utf-16' is missing from the array of position encodings
  /// servers can assume that the client supports UTF-16. UTF-16 is
  /// therefore a mandatory encoding.
  ///
  /// If omitted it defaults to ['utf-16'].
  ///
  /// Implementation considerations: since the conversion from one encoding
  /// into another requires the content of the file / line the conversion
  /// is best done where the file is read which is usually on the server
  /// side.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "positionEncodings")]
  pub position_encodings:    Option<Vec<PositionEncodingKind>>,
}

/// A relative pattern is a helper to construct glob patterns that are matched
/// relatively to a base URI. The common value for a `baseUri` is a workspace
/// folder root, but it can be another absolute URI as well.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RelativePattern {
  /// A workspace folder or a base URI to which this pattern will be matched
  /// against relatively.
  #[serde(rename = "baseUri")]
  pub base_uri: Or2<WorkspaceFolder, Uri>,
  /// The actual glob pattern;
  pub pattern:  Pattern,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceEditClientCapabilities {
  /// The client supports versioned document changes in `WorkspaceEdit`s
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentChanges")]
  pub document_changes:          Option<bool>,
  /// The resource operations the client supports. Clients should at least
  /// support 'create', 'rename' and 'delete' files and folders.
  ///
  /// @since 3.13.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resourceOperations")]
  pub resource_operations:       Option<Vec<ResourceOperationKind>>,
  /// The failure handling strategy of a client if applying the workspace edit
  /// fails.
  ///
  /// @since 3.13.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "failureHandling")]
  pub failure_handling:          Option<FailureHandlingKind>,
  /// Whether the client normalizes line endings to the client specific
  /// setting.
  /// If set to `true` the client will normalize line ending characters
  /// in a workspace edit to the client-specified new line
  /// character.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "normalizesLineEndings")]
  pub normalizes_line_endings:   Option<bool>,
  /// Whether the client in general supports change annotations on text edits,
  /// create file, rename file and delete file changes.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "changeAnnotationSupport")]
  pub change_annotation_support: Option<ChangeAnnotationSupportCapabilities>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidChangeConfigurationClientCapabilities {
  /// Did change configuration notification supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DidChangeWatchedFilesClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration:     Option<bool>,
  /// Whether the client has support for [`relative
  /// pattern`](crate::RelativePattern) or not.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "relativePatternSupport")]
  pub relative_pattern_support: Option<bool>,
}

/// Client capabilities for a
/// [`WorkspaceSymbolRequest`](crate::request::WorkspaceSymbolRequest).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceSymbolClientCapabilities {
  /// Symbol request supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// Specific capabilities for the `SymbolKind` in the `workspace/symbol`
  /// request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "symbolKind")]
  pub symbol_kind:          Option<SymbolKindCapabilities>,
  /// The client supports tags on `SymbolInformation`.
  /// Clients supporting tags have to handle unknown tags gracefully.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "tagSupport")]
  pub tag_support:          Option<WorkspaceSymbolTagSupportCapabilities>,
  /// The client support partial workspace symbols. The client will send the
  /// request `workspaceSymbol/resolve` to the server to resolve additional
  /// properties.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resolveSupport")]
  pub resolve_support:      Option<WorkspaceSymbolResolveSupportCapabilities>,
}

/// The client capabilities of a
/// [`ExecuteCommandRequest`](crate::request::WorkspaceExecuteCommand).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ExecuteCommandClientCapabilities {
  /// Execute command supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensWorkspaceClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "refreshSupport")]
  pub refresh_support: Option<bool>,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeLensWorkspaceClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "refreshSupport")]
  pub refresh_support: Option<bool>,
}

/// Capabilities relating to events from file operations by the user in the
/// client.
///
/// These events do not come from the file system, they come from user
/// operations like renaming a file in the UI.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FileOperationClientCapabilities {
  /// Whether the client supports dynamic registration for file
  /// requests/notifications.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// The client has support for sending didCreateFiles notifications.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "didCreate")]
  pub did_create:           Option<bool>,
  /// The client has support for sending willCreateFiles requests.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "willCreate")]
  pub will_create:          Option<bool>,
  /// The client has support for sending didRenameFiles notifications.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "didRename")]
  pub did_rename:           Option<bool>,
  /// The client has support for sending willRenameFiles requests.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "willRename")]
  pub will_rename:          Option<bool>,
  /// The client has support for sending didDeleteFiles notifications.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "didDelete")]
  pub did_delete:           Option<bool>,
  /// The client has support for sending willDeleteFiles requests.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "willDelete")]
  pub will_delete:          Option<bool>,
}

/// Client workspace capabilities specific to inline values.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineValueWorkspaceClientCapabilities {
  /// Whether the client implementation supports a refresh request sent from the
  /// server to the client.
  ///
  /// Note that this event is global and will force the client to refresh all
  /// inline values currently shown. It should be used with absolute care and is
  /// useful for situation where a server for example detects a project wide
  /// change that requires such a calculation.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "refreshSupport")]
  pub refresh_support: Option<bool>,
}

/// Client workspace capabilities specific to inlay hints.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlayHintWorkspaceClientCapabilities {
  /// Whether the client implementation supports a refresh request sent from
  /// the server to the client.
  ///
  /// Note that this event is global and will force the client to refresh all
  /// inlay hints currently shown. It should be used with absolute care and
  /// is useful for situation where a server for example detects a project wide
  /// change that requires such a calculation.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "refreshSupport")]
  pub refresh_support: Option<bool>,
}

/// Workspace client capabilities specific to diagnostic pull requests.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DiagnosticWorkspaceClientCapabilities {
  /// Whether the client implementation supports a refresh request sent from
  /// the server to the client.
  ///
  /// Note that this event is global and will force the client to refresh all
  /// pulled diagnostics currently shown. It should be used with absolute care
  /// and is useful for situation where a server for example detects a project
  /// wide change that requires such a calculation.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "refreshSupport")]
  pub refresh_support: Option<bool>,
}

/// Client workspace capabilities specific to folding ranges
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FoldingRangeWorkspaceClientCapabilities {
  /// Whether the client implementation supports a refresh request sent from the
  /// server to the client.
  ///
  /// Note that this event is global and will force the client to refresh all
  /// folding ranges currently shown. It should be used with absolute care and
  /// is useful for situation where a server for example detects a project
  /// wide change that requires such a calculation.
  ///
  /// @since 3.18.0
  /// @proposed
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "refreshSupport")]
  pub refresh_support: Option<bool>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextDocumentSyncClientCapabilities {
  /// Whether text document synchronization supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// The client supports sending will save notifications.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "willSave")]
  pub will_save:            Option<bool>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "willSaveWaitUntil")]
  pub will_save_wait_until: Option<bool>,
  /// The client supports did save notifications.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "didSave")]
  pub did_save:             Option<bool>,
}

/// Completion client capabilities
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionClientCapabilities {
  /// Whether completion supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// The client supports the following `CompletionItem` specific
  /// capabilities.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "completionItem")]
  pub completion_item:      Option<CompletionItemCapabilities>,
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "completionItemKind")]
  pub completion_item_kind: Option<CompletionItemKindCapabilities>,
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "insertTextMode")]
  pub insert_text_mode:     Option<InsertTextMode>,
  /// The client supports to send additional context information for a
  /// `textDocument/completion` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "contextSupport")]
  pub context_support:      Option<bool>,
  /// The client supports the following `CompletionList` specific
  /// capabilities.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "completionList")]
  pub completion_list:      Option<CompletionListCapabilities>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct HoverClientCapabilities {
  /// Whether hover supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// Client supports the following content formats for the content
  /// property. The order describes the preferred format of the client.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "contentFormat")]
  pub content_format:       Option<Vec<MarkupKind>>,
}

/// Client Capabilities for a
/// [`SignatureHelpRequest`](crate::request::TextDocumentSignatureHelp).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SignatureHelpClientCapabilities {
  /// Whether signature help supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration:  Option<bool>,
  /// The client supports the following `SignatureInformation`
  /// specific properties.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "signatureInformation")]
  pub signature_information: Option<SignatureInformationCapabilities>,
  /// The client supports to send additional context information for a
  /// `textDocument/signatureHelp` request. A client that opts into
  /// contextSupport will also support the `retriggerCharacters` on
  /// `SignatureHelpOptions`.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "contextSupport")]
  pub context_support:       Option<bool>,
}

/// @since 3.14.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DeclarationClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// The client supports additional metadata in the form of declaration links.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "linkSupport")]
  pub link_support:         Option<bool>,
}

/// Client Capabilities for a
/// [`DefinitionRequest`](crate::request::TextDocumentDefinition).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DefinitionClientCapabilities {
  /// Whether definition supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// The client supports additional metadata in the form of definition links.
  ///
  /// @since 3.14.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "linkSupport")]
  pub link_support:         Option<bool>,
}

/// Since 3.6.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TypeDefinitionClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// The client supports additional metadata in the form of definition links.
  ///
  /// Since 3.14.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "linkSupport")]
  pub link_support:         Option<bool>,
}

/// @since 3.6.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ImplementationClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// The client supports additional metadata in the form of definition links.
  ///
  /// @since 3.14.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "linkSupport")]
  pub link_support:         Option<bool>,
}

/// Client Capabilities for a
/// [`ReferencesRequest`](crate::request::TextDocumentReferences).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ReferenceClientCapabilities {
  /// Whether references supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// Client Capabilities for a
/// [`DocumentHighlightRequest`](crate::request::TextDocumentDocumentHighlight).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentHighlightClientCapabilities {
  /// Whether document highlight supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// Client Capabilities for a
/// [`DocumentSymbolRequest`](crate::request::TextDocumentDocumentSymbol).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentSymbolClientCapabilities {
  /// Whether document symbol supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration:                 Option<bool>,
  /// Specific capabilities for the `SymbolKind` in the
  /// `textDocument/documentSymbol` request.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "symbolKind")]
  pub symbol_kind:                          Option<SymbolKindCapabilities>,
  /// The client supports hierarchical document symbols.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "hierarchicalDocumentSymbolSupport")]
  pub hierarchical_document_symbol_support: Option<bool>,
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "tagSupport")]
  pub tag_support:                          Option<DocumentSymbolTagSupportCapabilities>,
  /// The client supports an additional label presented in the UI when
  /// registering a document symbol provider.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "labelSupport")]
  pub label_support:                        Option<bool>,
}

/// The Client Capabilities of a
/// [`CodeActionRequest`](crate::request::TextDocumentCodeAction).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeActionClientCapabilities {
  /// Whether code action supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration:        Option<bool>,
  /// The client support code action literals of type `CodeAction` as a valid
  /// response of the `textDocument/codeAction` request. If the property is not
  /// set the request can only return `Command` literals.
  ///
  /// @since 3.8.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "codeActionLiteralSupport")]
  pub code_action_literal_support: Option<CodeActionLiteralSupportCapabilities>,
  /// Whether code action supports the `isPreferred` property.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "isPreferredSupport")]
  pub is_preferred_support:        Option<bool>,
  /// Whether code action supports the `disabled` property.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "disabledSupport")]
  pub disabled_support:            Option<bool>,
  /// Whether code action supports the `data` property which is
  /// preserved between a `textDocument/codeAction` and a
  /// `codeAction/resolve` request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dataSupport")]
  pub data_support:                Option<bool>,
  /// Whether the client supports resolving additional code action
  /// properties via a separate `codeAction/resolve` request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resolveSupport")]
  pub resolve_support:             Option<CodeActionResolveSupportCapabilities>,
  /// Whether the client honors the change annotations in
  /// text edits and resource operations returned via the
  /// `CodeAction#edit` property by for example presenting
  /// the workspace edit in the user interface and asking
  /// for confirmation.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "honorsChangeAnnotations")]
  pub honors_change_annotations:   Option<bool>,
}

/// The client capabilities  of a
/// [`CodeLensRequest`](crate::request::TextDocumentCodeLens).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeLensClientCapabilities {
  /// Whether code lens supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// The client capabilities of a
/// [`DocumentLinkRequest`](crate::request::TextDocumentDocumentLink).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentLinkClientCapabilities {
  /// Whether document link supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// Whether the client supports the `tooltip` property on `DocumentLink`.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "tooltipSupport")]
  pub tooltip_support:      Option<bool>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentColorClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// Client capabilities of a
/// [`DocumentFormattingRequest`](crate::request::TextDocumentFormatting).
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentFormattingClientCapabilities {
  /// Whether formatting supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// Client capabilities of a
/// [`DocumentRangeFormattingRequest`](crate::request::TextDocumentRangeFormatting).
///
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentRangeFormattingClientCapabilities {
  /// Whether range formatting supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// Whether the client supports formatting multiple ranges at once.
  ///
  /// @since 3.18.0
  /// @proposed
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "rangesSupport")]
  pub ranges_support:       Option<bool>,
}

/// Client capabilities of a
/// [`DocumentOnTypeFormattingRequest`](crate::request::TextDocumentOnTypeFormatting).
///
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentOnTypeFormattingClientCapabilities {
  /// Whether on type formatting supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RenameClientCapabilities {
  /// Whether rename supports dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration:             Option<bool>,
  /// Client supports testing for validity of rename operations
  /// before execution.
  ///
  /// @since 3.12.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "prepareSupport")]
  pub prepare_support:                  Option<bool>,
  /// Client supports the default behavior result.
  ///
  /// The value indicates the default behavior used by the
  /// client.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "prepareSupportDefaultBehavior")]
  pub prepare_support_default_behavior: Option<PrepareSupportDefaultBehavior>,
  /// Whether the 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "honorsChangeAnnotations")]
  pub honors_change_annotations:        Option<bool>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FoldingRangeClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "rangeLimit")]
  pub range_limit:          Option<u32>,
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "lineFoldingOnly")]
  pub line_folding_only:    Option<bool>,
  /// Specific options for the folding range kind.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "foldingRangeKind")]
  pub folding_range_kind:   Option<FoldingRangeKindCapabilities>,
  /// Specific options for the folding range.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "foldingRange")]
  pub folding_range:        Option<FoldingRangeCapabilities>,
}

#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SelectionRangeClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// The publish diagnostic client capabilities.
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct PublishDiagnosticsClientCapabilities {
  /// Whether the clients accepts diagnostics with related information.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "relatedInformation")]
  pub related_information:      Option<bool>,
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "tagSupport")]
  pub tag_support:              Option<PublishDiagnosticsTagSupportCapabilities>,
  /// Whether the client interprets the version property of the
  /// `textDocument/publishDiagnostics` notification's parameter.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "versionSupport")]
  pub version_support:          Option<bool>,
  /// Client supports a codeDescription property
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "codeDescriptionSupport")]
  pub code_description_support: Option<bool>,
  /// Whether code action supports the `data` property which is
  /// preserved between a `textDocument/publishDiagnostics` and
  /// `textDocument/codeAction` request.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dataSupport")]
  pub data_support:             Option<bool>,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CallHierarchyClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration:      Option<bool>,
  /// 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.
  pub requests:                  RequestsCapabilities,
  /// The token types that the client supports.
  #[serde(rename = "tokenTypes")]
  pub token_types:               Vec<String>,
  /// The token modifiers that the client supports.
  #[serde(rename = "tokenModifiers")]
  pub token_modifiers:           Vec<String>,
  /// The token formats the clients supports.
  pub formats:                   Vec<TokenFormat>,
  /// Whether the client supports tokens that can overlap each other.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "overlappingTokenSupport")]
  pub overlapping_token_support: Option<bool>,
  /// Whether the client supports tokens that can span multiple lines.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "multilineTokenSupport")]
  pub multiline_token_support:   Option<bool>,
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "serverCancelSupport")]
  pub server_cancel_support:     Option<bool>,
  /// Whether the client uses semantic tokens to augment existing
  /// syntax tokens. If set to `true` client side created syntax
  /// tokens and semantic tokens are both used for colorization. If
  /// set to `false` the client only uses the returned semantic tokens
  /// for colorization.
  ///
  /// If the value is `undefined` then the client behavior is not
  /// specified.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "augmentsSyntaxTokens")]
  pub augments_syntax_tokens:    Option<bool>,
}

/// Client capabilities for the linked editing range request.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct LinkedEditingRangeClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// Client capabilities specific to the moniker request.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct MonikerClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TypeHierarchyClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// Client capabilities specific to inline values.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineValueClientCapabilities {
  /// Whether implementation supports dynamic registration for inline value
  /// providers.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// Inlay hint client capabilities.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlayHintClientCapabilities {
  /// Whether inlay hints support dynamic registration.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
  /// Indicates which properties a client can resolve lazily on an inlay
  /// hint.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resolveSupport")]
  pub resolve_support:      Option<InlayHintResolveSupportCapabilities>,
}

/// Client capabilities specific to diagnostic pull requests.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DiagnosticClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration:     Option<bool>,
  /// Whether the clients supports related documents for document diagnostic
  /// pulls.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "relatedDocumentSupport")]
  pub related_document_support: Option<bool>,
}

/// Client capabilities specific to inline completions.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlineCompletionClientCapabilities {
  /// Whether implementation supports dynamic registration for inline completion
  /// providers.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration: Option<bool>,
}

/// Notebook specific client capabilities.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentSyncClientCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "dynamicRegistration")]
  pub dynamic_registration:      Option<bool>,
  /// The client supports sending execution summary data per cell.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "executionSummarySupport")]
  pub execution_summary_support: Option<bool>,
}

/// Show message request client capabilities
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ShowMessageRequestClientCapabilities {
  /// Capabilities specific to the `MessageActionItem` type.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "messageActionItem")]
  pub message_action_item: Option<MessageActionItemCapabilities>,
}

/// Client capabilities for the showDocument request.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ShowDocumentClientCapabilities {
  /// The client has support for the showDocument
  /// request.
  pub support: bool,
}

/// Client capabilities specific to regular expressions.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RegularExpressionsClientCapabilities {
  /// The engine's name.
  pub engine:  String,
  /// The engine's version.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub version: Option<String>,
}

/// Client capabilities specific to the used markdown parser.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct MarkdownClientCapabilities {
  /// The name of the parser.
  pub parser:       String,
  /// The version of the parser.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub version:      Option<String>,
  /// A list of HTML tags that the client allows / supports in
  /// Markdown.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "allowedTags")]
  pub allowed_tags: Option<Vec<String>>,
}

/// A set of predefined token types. This set is not fixed
/// an clients can specify additional token types via the
/// corresponding client capabilities.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone)]
pub enum SemanticTokenTypes {
  #[default]
  Namespace,
  /// Represents a generic type. Acts as a fallback for types which can't be
  /// mapped to a specific type like class or enum.
  Type,
  Class,
  Enum,
  Interface,
  Struct,
  TypeParameter,
  Parameter,
  Variable,
  Property,
  EnumMember,
  Event,
  Function,
  Method,
  Macro,
  Keyword,
  Modifier,
  Comment,
  String,
  Number,
  Regexp,
  Operator,
  /// @since 3.17.0
  Decorator,
  Custom(String),
}
impl SemanticTokenTypes {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Namespace => "namespace",
      Self::Type => "type",
      Self::Class => "class",
      Self::Enum => "enum",
      Self::Interface => "interface",
      Self::Struct => "struct",
      Self::TypeParameter => "typeParameter",
      Self::Parameter => "parameter",
      Self::Variable => "variable",
      Self::Property => "property",
      Self::EnumMember => "enumMember",
      Self::Event => "event",
      Self::Function => "function",
      Self::Method => "method",
      Self::Macro => "macro",
      Self::Keyword => "keyword",
      Self::Modifier => "modifier",
      Self::Comment => "comment",
      Self::String => "string",
      Self::Number => "number",
      Self::Regexp => "regexp",
      Self::Operator => "operator",
      Self::Decorator => "decorator",
      Self::Custom(value) => value,
    }
  }
}
impl From<String> for SemanticTokenTypes {
  fn from(value: String) -> Self {
    match value.as_str() {
      "namespace" => Self::Namespace,
      "type" => Self::Type,
      "class" => Self::Class,
      "enum" => Self::Enum,
      "interface" => Self::Interface,
      "struct" => Self::Struct,
      "typeParameter" => Self::TypeParameter,
      "parameter" => Self::Parameter,
      "variable" => Self::Variable,
      "property" => Self::Property,
      "enumMember" => Self::EnumMember,
      "event" => Self::Event,
      "function" => Self::Function,
      "method" => Self::Method,
      "macro" => Self::Macro,
      "keyword" => Self::Keyword,
      "modifier" => Self::Modifier,
      "comment" => Self::Comment,
      "string" => Self::String,
      "number" => Self::Number,
      "regexp" => Self::Regexp,
      "operator" => Self::Operator,
      "decorator" => Self::Decorator,
      _ => Self::Custom(value),
    }
  }
}
impl Serialize for SemanticTokenTypes {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for SemanticTokenTypes {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = SemanticTokenTypes;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_string<E>(self, value: String) -> Result<SemanticTokenTypes, E>
      where
        E: de::Error,
      {
        Ok(SemanticTokenTypes::from(value))
      }
      fn visit_str<E>(self, value: &str) -> Result<SemanticTokenTypes, E>
      where
        E: de::Error,
      {
        Ok(SemanticTokenTypes::from(String::from(value)))
      }
    }
    deserializer.deserialize_string(Visitor)
  }
}

/// A set of predefined token modifiers. This set is not fixed
/// an clients can specify additional token types via the
/// corresponding client capabilities.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone)]
pub enum SemanticTokenModifiers {
  #[default]
  Declaration,
  Definition,
  Readonly,
  Static,
  Deprecated,
  Abstract,
  Async,
  Modification,
  Documentation,
  DefaultLibrary,
  Custom(String),
}
impl SemanticTokenModifiers {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Declaration => "declaration",
      Self::Definition => "definition",
      Self::Readonly => "readonly",
      Self::Static => "static",
      Self::Deprecated => "deprecated",
      Self::Abstract => "abstract",
      Self::Async => "async",
      Self::Modification => "modification",
      Self::Documentation => "documentation",
      Self::DefaultLibrary => "defaultLibrary",
      Self::Custom(value) => value,
    }
  }
}
impl From<String> for SemanticTokenModifiers {
  fn from(value: String) -> Self {
    match value.as_str() {
      "declaration" => Self::Declaration,
      "definition" => Self::Definition,
      "readonly" => Self::Readonly,
      "static" => Self::Static,
      "deprecated" => Self::Deprecated,
      "abstract" => Self::Abstract,
      "async" => Self::Async,
      "modification" => Self::Modification,
      "documentation" => Self::Documentation,
      "defaultLibrary" => Self::DefaultLibrary,
      _ => Self::Custom(value),
    }
  }
}
impl Serialize for SemanticTokenModifiers {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for SemanticTokenModifiers {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = SemanticTokenModifiers;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_string<E>(self, value: String) -> Result<SemanticTokenModifiers, E>
      where
        E: de::Error,
      {
        Ok(SemanticTokenModifiers::from(value))
      }
      fn visit_str<E>(self, value: &str) -> Result<SemanticTokenModifiers, E>
      where
        E: de::Error,
      {
        Ok(SemanticTokenModifiers::from(String::from(value)))
      }
    }
    deserializer.deserialize_string(Visitor)
  }
}

/// The document diagnostic report kinds.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone)]
pub enum DocumentDiagnosticReportKind {
  /// A diagnostic report with a full
  /// set of problems.
  #[default]
  Full,
  /// A report indicating that the last
  /// returned report is still accurate.
  Unchanged,
}
impl DocumentDiagnosticReportKind {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Full => "full",
      Self::Unchanged => "unchanged",
    }
  }
}
impl TryFrom<&str> for DocumentDiagnosticReportKind {
  type Error = ();
  fn try_from(value: &str) -> Result<Self, ()> {
    match value {
      "full" => Ok(Self::Full),
      "unchanged" => Ok(Self::Unchanged),
      _ => Err(()),
    }
  }
}
impl Serialize for DocumentDiagnosticReportKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for DocumentDiagnosticReportKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = DocumentDiagnosticReportKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_str<E>(self, value: &str) -> Result<DocumentDiagnosticReportKind, E>
      where
        E: de::Error,
      {
        if let Ok(v) = DocumentDiagnosticReportKind::try_from(value) {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Str(value), &self))
        }
      }
    }
    deserializer.deserialize_str(Visitor)
  }
}

/// Predefined error codes.
#[derive(Debug, Default, Clone, Copy)]
pub enum ErrorCodes {
  #[default]
  ParseError,
  InvalidRequest,
  MethodNotFound,
  InvalidParams,
  InternalError,
  /// Error code indicating that a server received a notification or
  /// request before the server has received the `initialize` request.
  ServerNotInitialized,
  UnknownErrorCode,
  Custom(i32),
}
impl ErrorCodes {
  pub fn as_i32(self) -> i32 {
    match self {
      Self::ParseError => -32700,
      Self::InvalidRequest => -32600,
      Self::MethodNotFound => -32601,
      Self::InvalidParams => -32602,
      Self::InternalError => -32603,
      Self::ServerNotInitialized => -32002,
      Self::UnknownErrorCode => -32001,
      Self::Custom(value) => value,
    }
  }
}
impl From<i32> for ErrorCodes {
  fn from(value: i32) -> Self {
    match value {
      -32700 => Self::ParseError,
      -32600 => Self::InvalidRequest,
      -32601 => Self::MethodNotFound,
      -32602 => Self::InvalidParams,
      -32603 => Self::InternalError,
      -32002 => Self::ServerNotInitialized,
      -32001 => Self::UnknownErrorCode,
      _ => Self::Custom(value),
    }
  }
}
impl Serialize for ErrorCodes {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_i32(self.as_i32())
  }
}
impl<'de> Deserialize<'de> for ErrorCodes {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = ErrorCodes;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<ErrorCodes, E>
      where
        E: de::Error,
      {
        if let Ok(n) = i32::try_from(value) {
          Ok(ErrorCodes::from(n))
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<ErrorCodes, E>
      where
        E: de::Error,
      {
        if let Ok(n) = i32::try_from(value) {
          Ok(ErrorCodes::from(n))
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_i32(Visitor)
  }
}

#[derive(Debug, Default, Clone, Copy)]
pub enum LSPErrorCodes {
  /// A request failed but it was syntactically correct, e.g the
  /// method name was known and the parameters were valid. The error
  /// message should contain human readable information about why
  /// the request failed.
  ///
  /// @since 3.17.0
  #[default]
  RequestFailed,
  /// The server cancelled the request. This error code should
  /// only be used for requests that explicitly support being
  /// server cancellable.
  ///
  /// @since 3.17.0
  ServerCancelled,
  /// The server detected that the content of a document got
  /// modified outside normal conditions. A server should
  /// NOT send this error code if it detects a content change
  /// in it unprocessed messages. The result even computed
  /// on an older state might still be useful for the client.
  ///
  /// If a client decides that a result is not of any use anymore
  /// the client should cancel the request.
  ContentModified,
  /// The client has canceled a request and a server has detected
  /// the cancel.
  RequestCancelled,
  Custom(i32),
}
impl LSPErrorCodes {
  pub fn as_i32(self) -> i32 {
    match self {
      Self::RequestFailed => -32803,
      Self::ServerCancelled => -32802,
      Self::ContentModified => -32801,
      Self::RequestCancelled => -32800,
      Self::Custom(value) => value,
    }
  }
}
impl From<i32> for LSPErrorCodes {
  fn from(value: i32) -> Self {
    match value {
      -32803 => Self::RequestFailed,
      -32802 => Self::ServerCancelled,
      -32801 => Self::ContentModified,
      -32800 => Self::RequestCancelled,
      _ => Self::Custom(value),
    }
  }
}
impl Serialize for LSPErrorCodes {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_i32(self.as_i32())
  }
}
impl<'de> Deserialize<'de> for LSPErrorCodes {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = LSPErrorCodes;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<LSPErrorCodes, E>
      where
        E: de::Error,
      {
        if let Ok(n) = i32::try_from(value) {
          Ok(LSPErrorCodes::from(n))
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<LSPErrorCodes, E>
      where
        E: de::Error,
      {
        if let Ok(n) = i32::try_from(value) {
          Ok(LSPErrorCodes::from(n))
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_i32(Visitor)
  }
}

/// A set of predefined range kinds.
#[derive(Debug, Default, Clone)]
pub enum FoldingRangeKind {
  /// Folding range for a comment
  #[default]
  Comment,
  /// Folding range for an import or include
  Imports,
  /// Folding range for a region (e.g. `#region`)
  Region,
  Custom(String),
}
impl FoldingRangeKind {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Comment => "comment",
      Self::Imports => "imports",
      Self::Region => "region",
      Self::Custom(value) => value,
    }
  }
}
impl From<String> for FoldingRangeKind {
  fn from(value: String) -> Self {
    match value.as_str() {
      "comment" => Self::Comment,
      "imports" => Self::Imports,
      "region" => Self::Region,
      _ => Self::Custom(value),
    }
  }
}
impl Serialize for FoldingRangeKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for FoldingRangeKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = FoldingRangeKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_string<E>(self, value: String) -> Result<FoldingRangeKind, E>
      where
        E: de::Error,
      {
        Ok(FoldingRangeKind::from(value))
      }
      fn visit_str<E>(self, value: &str) -> Result<FoldingRangeKind, E>
      where
        E: de::Error,
      {
        Ok(FoldingRangeKind::from(String::from(value)))
      }
    }
    deserializer.deserialize_string(Visitor)
  }
}

/// A symbol kind.
#[derive(Debug, Default, Clone, Copy)]
pub enum SymbolKind {
  #[default]
  File          = 1,
  Module        = 2,
  Namespace     = 3,
  Package       = 4,
  Class         = 5,
  Method        = 6,
  Property      = 7,
  Field         = 8,
  Constructor   = 9,
  Enum          = 10,
  Interface     = 11,
  Function      = 12,
  Variable      = 13,
  Constant      = 14,
  String        = 15,
  Number        = 16,
  Boolean       = 17,
  Array         = 18,
  Object        = 19,
  Key           = 20,
  Null          = 21,
  EnumMember    = 22,
  Struct        = 23,
  Event         = 24,
  Operator      = 25,
  TypeParameter = 26,
}
impl SymbolKind {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for SymbolKind {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::File),
      2 => Ok(Self::Module),
      3 => Ok(Self::Namespace),
      4 => Ok(Self::Package),
      5 => Ok(Self::Class),
      6 => Ok(Self::Method),
      7 => Ok(Self::Property),
      8 => Ok(Self::Field),
      9 => Ok(Self::Constructor),
      10 => Ok(Self::Enum),
      11 => Ok(Self::Interface),
      12 => Ok(Self::Function),
      13 => Ok(Self::Variable),
      14 => Ok(Self::Constant),
      15 => Ok(Self::String),
      16 => Ok(Self::Number),
      17 => Ok(Self::Boolean),
      18 => Ok(Self::Array),
      19 => Ok(Self::Object),
      20 => Ok(Self::Key),
      21 => Ok(Self::Null),
      22 => Ok(Self::EnumMember),
      23 => Ok(Self::Struct),
      24 => Ok(Self::Event),
      25 => Ok(Self::Operator),
      26 => Ok(Self::TypeParameter),
      _ => Err(()),
    }
  }
}
impl Serialize for SymbolKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for SymbolKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = SymbolKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<SymbolKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = SymbolKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<SymbolKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = SymbolKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// Symbol tags are extra annotations that tweak the rendering of a symbol.
///
/// @since 3.16
#[derive(Debug, Default, Clone, Copy)]
pub enum SymbolTag {
  /// Render a symbol as obsolete, usually using a strike-out.
  #[default]
  Deprecated = 1,
}
impl SymbolTag {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for SymbolTag {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Deprecated),
      _ => Err(()),
    }
  }
}
impl Serialize for SymbolTag {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for SymbolTag {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = SymbolTag;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<SymbolTag, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = SymbolTag::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<SymbolTag, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = SymbolTag::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// Moniker uniqueness level to define scope of the moniker.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone)]
pub enum UniquenessLevel {
  /// The moniker is only unique inside a document
  #[default]
  Document,
  /// The moniker is unique inside a project for which a dump got created
  Project,
  /// The moniker is unique inside the group to which a project belongs
  Group,
  /// The moniker is unique inside the moniker scheme.
  Scheme,
  /// The moniker is globally unique
  Global,
}
impl UniquenessLevel {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Document => "document",
      Self::Project => "project",
      Self::Group => "group",
      Self::Scheme => "scheme",
      Self::Global => "global",
    }
  }
}
impl TryFrom<&str> for UniquenessLevel {
  type Error = ();
  fn try_from(value: &str) -> Result<Self, ()> {
    match value {
      "document" => Ok(Self::Document),
      "project" => Ok(Self::Project),
      "group" => Ok(Self::Group),
      "scheme" => Ok(Self::Scheme),
      "global" => Ok(Self::Global),
      _ => Err(()),
    }
  }
}
impl Serialize for UniquenessLevel {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for UniquenessLevel {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = UniquenessLevel;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_str<E>(self, value: &str) -> Result<UniquenessLevel, E>
      where
        E: de::Error,
      {
        if let Ok(v) = UniquenessLevel::try_from(value) {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Str(value), &self))
        }
      }
    }
    deserializer.deserialize_str(Visitor)
  }
}

/// The moniker kind.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone)]
pub enum MonikerKind {
  /// The moniker represent a symbol that is imported into a project
  #[default]
  Import,
  /// The moniker represents a symbol that is exported from a project
  Export,
  /// The moniker represents a symbol that is local to a project (e.g. a local
  /// variable of a function, a class not visible outside the project, ...)
  Local,
}
impl MonikerKind {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Import => "import",
      Self::Export => "export",
      Self::Local => "local",
    }
  }
}
impl TryFrom<&str> for MonikerKind {
  type Error = ();
  fn try_from(value: &str) -> Result<Self, ()> {
    match value {
      "import" => Ok(Self::Import),
      "export" => Ok(Self::Export),
      "local" => Ok(Self::Local),
      _ => Err(()),
    }
  }
}
impl Serialize for MonikerKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for MonikerKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = MonikerKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_str<E>(self, value: &str) -> Result<MonikerKind, E>
      where
        E: de::Error,
      {
        if let Ok(v) = MonikerKind::try_from(value) {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Str(value), &self))
        }
      }
    }
    deserializer.deserialize_str(Visitor)
  }
}

/// Inlay hint kinds.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Copy)]
pub enum InlayHintKind {
  /// An inlay hint that for a type annotation.
  #[default]
  Type      = 1,
  /// An inlay hint that is for a parameter.
  Parameter = 2,
}
impl InlayHintKind {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for InlayHintKind {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Type),
      2 => Ok(Self::Parameter),
      _ => Err(()),
    }
  }
}
impl Serialize for InlayHintKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for InlayHintKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = InlayHintKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<InlayHintKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = InlayHintKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<InlayHintKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = InlayHintKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// The message type
#[derive(Debug, Default, Clone, Copy)]
pub enum MessageType {
  /// An error message.
  #[default]
  Error   = 1,
  /// A warning message.
  Warning = 2,
  /// An information message.
  Info    = 3,
  /// A log message.
  Log     = 4,
  /// A debug message.
  ///
  /// @since 3.18.0
  Debug   = 5,
}
impl MessageType {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for MessageType {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Error),
      2 => Ok(Self::Warning),
      3 => Ok(Self::Info),
      4 => Ok(Self::Log),
      5 => Ok(Self::Debug),
      _ => Err(()),
    }
  }
}
impl Serialize for MessageType {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for MessageType {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = MessageType;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<MessageType, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = MessageType::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<MessageType, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = MessageType::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// Defines how the host (editor) should sync
/// document changes to the language server.
#[derive(Debug, Default, Clone, Copy)]
pub enum TextDocumentSyncKind {
  /// Documents should not be synced at all.
  #[default]
  None        = 0,
  /// Documents are synced by always sending the full content
  /// of the document.
  Full        = 1,
  /// Documents are synced by sending the full content on open.
  /// After that only incremental updates to the document are
  /// send.
  Incremental = 2,
}
impl TextDocumentSyncKind {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for TextDocumentSyncKind {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      0 => Ok(Self::None),
      1 => Ok(Self::Full),
      2 => Ok(Self::Incremental),
      _ => Err(()),
    }
  }
}
impl Serialize for TextDocumentSyncKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for TextDocumentSyncKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = TextDocumentSyncKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<TextDocumentSyncKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = TextDocumentSyncKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<TextDocumentSyncKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = TextDocumentSyncKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// Represents reasons why a text document is saved.
#[derive(Debug, Default, Clone, Copy)]
pub enum TextDocumentSaveReason {
  /// Manually triggered, e.g. by the user pressing save, by starting debugging,
  /// or by an API call.
  #[default]
  Manual     = 1,
  /// Automatic after a delay.
  AfterDelay = 2,
  /// When the editor lost focus.
  FocusOut   = 3,
}
impl TextDocumentSaveReason {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for TextDocumentSaveReason {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Manual),
      2 => Ok(Self::AfterDelay),
      3 => Ok(Self::FocusOut),
      _ => Err(()),
    }
  }
}
impl Serialize for TextDocumentSaveReason {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for TextDocumentSaveReason {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = TextDocumentSaveReason;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<TextDocumentSaveReason, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = TextDocumentSaveReason::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<TextDocumentSaveReason, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = TextDocumentSaveReason::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// The kind of a completion entry.
#[derive(Debug, Default, Clone, Copy)]
pub enum CompletionItemKind {
  #[default]
  Text          = 1,
  Method        = 2,
  Function      = 3,
  Constructor   = 4,
  Field         = 5,
  Variable      = 6,
  Class         = 7,
  Interface     = 8,
  Module        = 9,
  Property      = 10,
  Unit          = 11,
  Value         = 12,
  Enum          = 13,
  Keyword       = 14,
  Snippet       = 15,
  Color         = 16,
  File          = 17,
  Reference     = 18,
  Folder        = 19,
  EnumMember    = 20,
  Constant      = 21,
  Struct        = 22,
  Event         = 23,
  Operator      = 24,
  TypeParameter = 25,
}
impl CompletionItemKind {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for CompletionItemKind {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Text),
      2 => Ok(Self::Method),
      3 => Ok(Self::Function),
      4 => Ok(Self::Constructor),
      5 => Ok(Self::Field),
      6 => Ok(Self::Variable),
      7 => Ok(Self::Class),
      8 => Ok(Self::Interface),
      9 => Ok(Self::Module),
      10 => Ok(Self::Property),
      11 => Ok(Self::Unit),
      12 => Ok(Self::Value),
      13 => Ok(Self::Enum),
      14 => Ok(Self::Keyword),
      15 => Ok(Self::Snippet),
      16 => Ok(Self::Color),
      17 => Ok(Self::File),
      18 => Ok(Self::Reference),
      19 => Ok(Self::Folder),
      20 => Ok(Self::EnumMember),
      21 => Ok(Self::Constant),
      22 => Ok(Self::Struct),
      23 => Ok(Self::Event),
      24 => Ok(Self::Operator),
      25 => Ok(Self::TypeParameter),
      _ => Err(()),
    }
  }
}
impl Serialize for CompletionItemKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for CompletionItemKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = CompletionItemKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<CompletionItemKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = CompletionItemKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<CompletionItemKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = CompletionItemKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// Completion item tags are extra annotations that tweak the rendering of a
/// completion item.
///
/// @since 3.15.0
#[derive(Debug, Default, Clone, Copy)]
pub enum CompletionItemTag {
  /// Render a completion as obsolete, usually using a strike-out.
  #[default]
  Deprecated = 1,
}
impl CompletionItemTag {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for CompletionItemTag {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Deprecated),
      _ => Err(()),
    }
  }
}
impl Serialize for CompletionItemTag {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for CompletionItemTag {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = CompletionItemTag;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<CompletionItemTag, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = CompletionItemTag::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<CompletionItemTag, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = CompletionItemTag::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// Defines whether the insert text in a completion item should be interpreted
/// as plain text or a snippet.
#[derive(Debug, Default, Clone, Copy)]
pub enum InsertTextFormat {
  /// The primary text to be inserted is treated as a plain string.
  #[default]
  PlainText = 1,
  /// The primary text to be inserted is treated as a snippet.
  ///
  /// A snippet can define tab stops and placeholders with `$1`, `$2`
  /// and `${3:foo}`. `$0` defines the final tab stop, it defaults to
  /// the end of the snippet. Placeholders with equal identifiers are linked,
  /// that is typing in one will update others too.
  ///
  /// See also: https://microsoft.github.io/language-server-protocol/specifications/specification-current/#snippet_syntax
  Snippet   = 2,
}
impl InsertTextFormat {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for InsertTextFormat {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::PlainText),
      2 => Ok(Self::Snippet),
      _ => Err(()),
    }
  }
}
impl Serialize for InsertTextFormat {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for InsertTextFormat {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = InsertTextFormat;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<InsertTextFormat, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = InsertTextFormat::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<InsertTextFormat, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = InsertTextFormat::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// How whitespace and indentation is handled during completion
/// item insertion.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone, Copy)]
pub enum InsertTextMode {
  /// The insertion or replace strings is taken as it is. If the
  /// value is multi line the lines below the cursor will be
  /// inserted using the indentation defined in the string value.
  /// The client will not apply any kind of adjustments to the
  /// string.
  #[default]
  AsIs              = 1,
  /// The editor adjusts leading whitespace of new lines so that
  /// they match the indentation up to the cursor of the line for
  /// which the item is accepted.
  ///
  /// Consider a line like this: <2tabs><cursor><3tabs>foo. Accepting a
  /// multi line completion item is indented using 2 tabs and all
  /// following lines inserted will be indented using 2 tabs as well.
  AdjustIndentation = 2,
}
impl InsertTextMode {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for InsertTextMode {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::AsIs),
      2 => Ok(Self::AdjustIndentation),
      _ => Err(()),
    }
  }
}
impl Serialize for InsertTextMode {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for InsertTextMode {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = InsertTextMode;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<InsertTextMode, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = InsertTextMode::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<InsertTextMode, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = InsertTextMode::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// A document highlight kind.
#[derive(Debug, Default, Clone, Copy)]
pub enum DocumentHighlightKind {
  /// A textual occurrence.
  #[default]
  Text  = 1,
  /// Read-access of a symbol, like reading a variable.
  Read  = 2,
  /// Write-access of a symbol, like writing to a variable.
  Write = 3,
}
impl DocumentHighlightKind {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for DocumentHighlightKind {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Text),
      2 => Ok(Self::Read),
      3 => Ok(Self::Write),
      _ => Err(()),
    }
  }
}
impl Serialize for DocumentHighlightKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for DocumentHighlightKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = DocumentHighlightKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<DocumentHighlightKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = DocumentHighlightKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<DocumentHighlightKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = DocumentHighlightKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// A set of predefined code action kinds
#[derive(Debug, Default, Clone)]
pub enum CodeActionKind {
  /// Empty kind.
  #[default]
  Empty,
  /// Base kind for quickfix actions: 'quickfix'
  QuickFix,
  /// Base kind for refactoring actions: 'refactor'
  Refactor,
  /// Base kind for refactoring extraction actions: 'refactor.extract'
  ///
  /// Example extract actions:
  ///
  /// - Extract method
  /// - Extract function
  /// - Extract variable
  /// - Extract interface from class
  /// - ...
  RefactorExtract,
  /// Base kind for refactoring inline actions: 'refactor.inline'
  ///
  /// Example inline actions:
  ///
  /// - Inline function
  /// - Inline variable
  /// - Inline constant
  /// - ...
  RefactorInline,
  /// Base kind for refactoring rewrite actions: 'refactor.rewrite'
  ///
  /// Example rewrite actions:
  ///
  /// - Convert JavaScript function to class
  /// - Add or remove parameter
  /// - Encapsulate field
  /// - Make method static
  /// - Move method to base class
  /// - ...
  RefactorRewrite,
  /// Base kind for source actions: `source`
  ///
  /// Source code actions apply to the entire file.
  Source,
  /// Base kind for an organize imports source action: `source.organizeImports`
  SourceOrganizeImports,
  /// Base kind for auto-fix source actions: `source.fixAll`.
  ///
  /// Fix all actions automatically fix errors that have a clear fix that do not
  /// require user input. They should not suppress errors or perform unsafe
  /// fixes such as generating new types or classes.
  ///
  /// @since 3.15.0
  SourceFixAll,
  Custom(String),
}
impl CodeActionKind {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Empty => "",
      Self::QuickFix => "quickfix",
      Self::Refactor => "refactor",
      Self::RefactorExtract => "refactor.extract",
      Self::RefactorInline => "refactor.inline",
      Self::RefactorRewrite => "refactor.rewrite",
      Self::Source => "source",
      Self::SourceOrganizeImports => "source.organizeImports",
      Self::SourceFixAll => "source.fixAll",
      Self::Custom(value) => value,
    }
  }
}
impl From<String> for CodeActionKind {
  fn from(value: String) -> Self {
    match value.as_str() {
      "" => Self::Empty,
      "quickfix" => Self::QuickFix,
      "refactor" => Self::Refactor,
      "refactor.extract" => Self::RefactorExtract,
      "refactor.inline" => Self::RefactorInline,
      "refactor.rewrite" => Self::RefactorRewrite,
      "source" => Self::Source,
      "source.organizeImports" => Self::SourceOrganizeImports,
      "source.fixAll" => Self::SourceFixAll,
      _ => Self::Custom(value),
    }
  }
}
impl Serialize for CodeActionKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for CodeActionKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = CodeActionKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_string<E>(self, value: String) -> Result<CodeActionKind, E>
      where
        E: de::Error,
      {
        Ok(CodeActionKind::from(value))
      }
      fn visit_str<E>(self, value: &str) -> Result<CodeActionKind, E>
      where
        E: de::Error,
      {
        Ok(CodeActionKind::from(String::from(value)))
      }
    }
    deserializer.deserialize_string(Visitor)
  }
}

#[derive(Debug, Default, Clone)]
pub enum TraceValues {
  /// Turn tracing off.
  #[default]
  Off,
  /// Trace messages only.
  Messages,
  /// Verbose message tracing.
  Verbose,
}
impl TraceValues {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Off => "off",
      Self::Messages => "messages",
      Self::Verbose => "verbose",
    }
  }
}
impl TryFrom<&str> for TraceValues {
  type Error = ();
  fn try_from(value: &str) -> Result<Self, ()> {
    match value {
      "off" => Ok(Self::Off),
      "messages" => Ok(Self::Messages),
      "verbose" => Ok(Self::Verbose),
      _ => Err(()),
    }
  }
}
impl Serialize for TraceValues {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for TraceValues {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = TraceValues;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_str<E>(self, value: &str) -> Result<TraceValues, E>
      where
        E: de::Error,
      {
        if let Ok(v) = TraceValues::try_from(value) {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Str(value), &self))
        }
      }
    }
    deserializer.deserialize_str(Visitor)
  }
}

/// Describes the content type that a client supports in various
/// result literals like `Hover`, `ParameterInfo` or `CompletionItem`.
///
/// Please note that `MarkupKinds` must not start with a `$`. This kinds
/// are reserved for internal usage.
#[derive(Debug, Default, Clone)]
pub enum MarkupKind {
  /// Plain text is supported as a content format
  #[default]
  PlainText,
  /// Markdown is supported as a content format
  Markdown,
}
impl MarkupKind {
  pub fn as_str(&self) -> &str {
    match self {
      Self::PlainText => "plaintext",
      Self::Markdown => "markdown",
    }
  }
}
impl TryFrom<&str> for MarkupKind {
  type Error = ();
  fn try_from(value: &str) -> Result<Self, ()> {
    match value {
      "plaintext" => Ok(Self::PlainText),
      "markdown" => Ok(Self::Markdown),
      _ => Err(()),
    }
  }
}
impl Serialize for MarkupKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for MarkupKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = MarkupKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_str<E>(self, value: &str) -> Result<MarkupKind, E>
      where
        E: de::Error,
      {
        if let Ok(v) = MarkupKind::try_from(value) {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Str(value), &self))
        }
      }
    }
    deserializer.deserialize_str(Visitor)
  }
}

/// Describes how an [`inline completion provider`](crate::InlineCompletionItem)
/// was triggered.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug, Default, Clone, Copy)]
pub enum InlineCompletionTriggerKind {
  /// Completion was triggered explicitly by a user gesture.
  #[default]
  Invoked   = 0,
  /// Completion was triggered automatically while editing.
  Automatic = 1,
}
impl InlineCompletionTriggerKind {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for InlineCompletionTriggerKind {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      0 => Ok(Self::Invoked),
      1 => Ok(Self::Automatic),
      _ => Err(()),
    }
  }
}
impl Serialize for InlineCompletionTriggerKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for InlineCompletionTriggerKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = InlineCompletionTriggerKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<InlineCompletionTriggerKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = InlineCompletionTriggerKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<InlineCompletionTriggerKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = InlineCompletionTriggerKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// A set of predefined position encoding kinds.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone)]
pub enum PositionEncodingKind {
  /// Character offsets count UTF-8 code units (e.g. bytes).
  #[default]
  Utf8,
  /// Character offsets count UTF-16 code units.
  ///
  /// This is the default and must always be supported
  /// by servers
  Utf16,
  /// Character offsets count UTF-32 code units.
  ///
  /// Implementation note: these are the same as Unicode codepoints,
  /// so this `PositionEncodingKind` may also be used for an
  /// encoding-agnostic representation of character offsets.
  Utf32,
  Custom(String),
}
impl PositionEncodingKind {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Utf8 => "utf-8",
      Self::Utf16 => "utf-16",
      Self::Utf32 => "utf-32",
      Self::Custom(value) => value,
    }
  }
}
impl From<String> for PositionEncodingKind {
  fn from(value: String) -> Self {
    match value.as_str() {
      "utf-8" => Self::Utf8,
      "utf-16" => Self::Utf16,
      "utf-32" => Self::Utf32,
      _ => Self::Custom(value),
    }
  }
}
impl Serialize for PositionEncodingKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for PositionEncodingKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = PositionEncodingKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_string<E>(self, value: String) -> Result<PositionEncodingKind, E>
      where
        E: de::Error,
      {
        Ok(PositionEncodingKind::from(value))
      }
      fn visit_str<E>(self, value: &str) -> Result<PositionEncodingKind, E>
      where
        E: de::Error,
      {
        Ok(PositionEncodingKind::from(String::from(value)))
      }
    }
    deserializer.deserialize_string(Visitor)
  }
}

/// The file event type
#[derive(Debug, Default, Clone, Copy)]
pub enum FileChangeType {
  /// The file got created.
  #[default]
  Created = 1,
  /// The file got changed.
  Changed = 2,
  /// The file got deleted.
  Deleted = 3,
}
impl FileChangeType {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for FileChangeType {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Created),
      2 => Ok(Self::Changed),
      3 => Ok(Self::Deleted),
      _ => Err(()),
    }
  }
}
impl Serialize for FileChangeType {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for FileChangeType {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = FileChangeType;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<FileChangeType, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = FileChangeType::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<FileChangeType, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = FileChangeType::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

#[derive(Debug, Default, Clone, Copy)]
pub enum WatchKind {
  /// Interested in create events.
  #[default]
  Create,
  /// Interested in change events
  Change,
  /// Interested in delete events
  Delete,
  Custom(u32),
}
impl WatchKind {
  pub fn as_u32(self) -> u32 {
    match self {
      Self::Create => 1,
      Self::Change => 2,
      Self::Delete => 4,
      Self::Custom(value) => value,
    }
  }
}
impl From<u32> for WatchKind {
  fn from(value: u32) -> Self {
    match value {
      1 => Self::Create,
      2 => Self::Change,
      4 => Self::Delete,
      _ => Self::Custom(value),
    }
  }
}
impl Serialize for WatchKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for WatchKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = WatchKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<WatchKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value) {
          Ok(WatchKind::from(n))
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<WatchKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value) {
          Ok(WatchKind::from(n))
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// The diagnostic's severity.
#[derive(Debug, Default, Clone, Copy)]
pub enum DiagnosticSeverity {
  /// Reports an error.
  #[default]
  Error       = 1,
  /// Reports a warning.
  Warning     = 2,
  /// Reports an information.
  Information = 3,
  /// Reports a hint.
  Hint        = 4,
}
impl DiagnosticSeverity {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for DiagnosticSeverity {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Error),
      2 => Ok(Self::Warning),
      3 => Ok(Self::Information),
      4 => Ok(Self::Hint),
      _ => Err(()),
    }
  }
}
impl Serialize for DiagnosticSeverity {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for DiagnosticSeverity {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = DiagnosticSeverity;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<DiagnosticSeverity, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = DiagnosticSeverity::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<DiagnosticSeverity, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = DiagnosticSeverity::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// The diagnostic tags.
///
/// @since 3.15.0
#[derive(Debug, Default, Clone, Copy)]
pub enum DiagnosticTag {
  /// Unused or unnecessary code.
  ///
  /// Clients are allowed to render diagnostics with this tag faded out instead
  /// of having an error squiggle.
  #[default]
  Unnecessary = 1,
  /// Deprecated or obsolete code.
  ///
  /// Clients are allowed to rendered diagnostics with this tag strike through.
  Deprecated  = 2,
}
impl DiagnosticTag {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for DiagnosticTag {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Unnecessary),
      2 => Ok(Self::Deprecated),
      _ => Err(()),
    }
  }
}
impl Serialize for DiagnosticTag {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for DiagnosticTag {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = DiagnosticTag;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<DiagnosticTag, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = DiagnosticTag::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<DiagnosticTag, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = DiagnosticTag::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// How a completion was triggered
#[derive(Debug, Default, Clone, Copy)]
pub enum CompletionTriggerKind {
  /// Completion was triggered by typing an identifier (24x7 code
  /// complete), manual invocation (e.g Ctrl+Space) or via API.
  #[default]
  Invoked                         = 1,
  /// Completion was triggered by a trigger character specified by
  /// the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
  TriggerCharacter                = 2,
  /// Completion was re-triggered as current completion list is incomplete
  TriggerForIncompleteCompletions = 3,
}
impl CompletionTriggerKind {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for CompletionTriggerKind {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Invoked),
      2 => Ok(Self::TriggerCharacter),
      3 => Ok(Self::TriggerForIncompleteCompletions),
      _ => Err(()),
    }
  }
}
impl Serialize for CompletionTriggerKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for CompletionTriggerKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = CompletionTriggerKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<CompletionTriggerKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = CompletionTriggerKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<CompletionTriggerKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = CompletionTriggerKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// How a signature help was triggered.
///
/// @since 3.15.0
#[derive(Debug, Default, Clone, Copy)]
pub enum SignatureHelpTriggerKind {
  /// Signature help was invoked manually by the user or by a command.
  #[default]
  Invoked          = 1,
  /// Signature help was triggered by a trigger character.
  TriggerCharacter = 2,
  /// Signature help was triggered by the cursor moving or by the document
  /// content changing.
  ContentChange    = 3,
}
impl SignatureHelpTriggerKind {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for SignatureHelpTriggerKind {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Invoked),
      2 => Ok(Self::TriggerCharacter),
      3 => Ok(Self::ContentChange),
      _ => Err(()),
    }
  }
}
impl Serialize for SignatureHelpTriggerKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for SignatureHelpTriggerKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = SignatureHelpTriggerKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<SignatureHelpTriggerKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = SignatureHelpTriggerKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<SignatureHelpTriggerKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = SignatureHelpTriggerKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// The reason why code actions were requested.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Copy)]
pub enum CodeActionTriggerKind {
  /// Code actions were explicitly requested by the user or by an extension.
  #[default]
  Invoked   = 1,
  /// Code actions were requested automatically.
  ///
  /// This typically happens when current selection in a file changes, but can
  /// also be triggered when file content changes.
  Automatic = 2,
}
impl CodeActionTriggerKind {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for CodeActionTriggerKind {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Invoked),
      2 => Ok(Self::Automatic),
      _ => Err(()),
    }
  }
}
impl Serialize for CodeActionTriggerKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for CodeActionTriggerKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = CodeActionTriggerKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<CodeActionTriggerKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = CodeActionTriggerKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<CodeActionTriggerKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = CodeActionTriggerKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

/// A pattern kind describing if a glob pattern matches a file a folder or
/// both.
///
/// @since 3.16.0
#[derive(Debug, Default, Clone)]
pub enum FileOperationPatternKind {
  /// The pattern matches a file only.
  #[default]
  File,
  /// The pattern matches a folder only.
  Folder,
}
impl FileOperationPatternKind {
  pub fn as_str(&self) -> &str {
    match self {
      Self::File => "file",
      Self::Folder => "folder",
    }
  }
}
impl TryFrom<&str> for FileOperationPatternKind {
  type Error = ();
  fn try_from(value: &str) -> Result<Self, ()> {
    match value {
      "file" => Ok(Self::File),
      "folder" => Ok(Self::Folder),
      _ => Err(()),
    }
  }
}
impl Serialize for FileOperationPatternKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for FileOperationPatternKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = FileOperationPatternKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_str<E>(self, value: &str) -> Result<FileOperationPatternKind, E>
      where
        E: de::Error,
      {
        if let Ok(v) = FileOperationPatternKind::try_from(value) {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Str(value), &self))
        }
      }
    }
    deserializer.deserialize_str(Visitor)
  }
}

/// A notebook cell kind.
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Copy)]
pub enum NotebookCellKind {
  /// A markup-cell is formatted source that is used for display.
  #[default]
  Markup = 1,
  /// A code-cell is source code.
  Code   = 2,
}
impl NotebookCellKind {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for NotebookCellKind {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Markup),
      2 => Ok(Self::Code),
      _ => Err(()),
    }
  }
}
impl Serialize for NotebookCellKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for NotebookCellKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = NotebookCellKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<NotebookCellKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = NotebookCellKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<NotebookCellKind, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = NotebookCellKind::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

#[derive(Debug, Default, Clone)]
pub enum ResourceOperationKind {
  /// Supports creating new files and folders.
  #[default]
  Create,
  /// Supports renaming existing files and folders.
  Rename,
  /// Supports deleting existing files and folders.
  Delete,
}
impl ResourceOperationKind {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Create => "create",
      Self::Rename => "rename",
      Self::Delete => "delete",
    }
  }
}
impl TryFrom<&str> for ResourceOperationKind {
  type Error = ();
  fn try_from(value: &str) -> Result<Self, ()> {
    match value {
      "create" => Ok(Self::Create),
      "rename" => Ok(Self::Rename),
      "delete" => Ok(Self::Delete),
      _ => Err(()),
    }
  }
}
impl Serialize for ResourceOperationKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for ResourceOperationKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = ResourceOperationKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_str<E>(self, value: &str) -> Result<ResourceOperationKind, E>
      where
        E: de::Error,
      {
        if let Ok(v) = ResourceOperationKind::try_from(value) {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Str(value), &self))
        }
      }
    }
    deserializer.deserialize_str(Visitor)
  }
}

#[derive(Debug, Default, Clone)]
pub enum FailureHandlingKind {
  /// Applying the workspace change is simply aborted if one of the changes
  /// provided fails. All operations executed before the failing operation
  /// stay executed.
  #[default]
  Abort,
  /// All operations are executed transactional. That means they either all
  /// succeed or no changes at all are applied to the workspace.
  Transactional,
  /// If the workspace edit contains only textual file changes they are executed
  /// transactional. If resource changes (create, rename or delete file) are
  /// part of the change the failure handling strategy is abort.
  TextOnlyTransactional,
  /// The client tries to undo the operations already executed. But there is no
  /// guarantee that this is succeeding.
  Undo,
}
impl FailureHandlingKind {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Abort => "abort",
      Self::Transactional => "transactional",
      Self::TextOnlyTransactional => "textOnlyTransactional",
      Self::Undo => "undo",
    }
  }
}
impl TryFrom<&str> for FailureHandlingKind {
  type Error = ();
  fn try_from(value: &str) -> Result<Self, ()> {
    match value {
      "abort" => Ok(Self::Abort),
      "transactional" => Ok(Self::Transactional),
      "textOnlyTransactional" => Ok(Self::TextOnlyTransactional),
      "undo" => Ok(Self::Undo),
      _ => Err(()),
    }
  }
}
impl Serialize for FailureHandlingKind {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for FailureHandlingKind {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = FailureHandlingKind;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_str<E>(self, value: &str) -> Result<FailureHandlingKind, E>
      where
        E: de::Error,
      {
        if let Ok(v) = FailureHandlingKind::try_from(value) {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Str(value), &self))
        }
      }
    }
    deserializer.deserialize_str(Visitor)
  }
}

#[derive(Debug, Default, Clone, Copy)]
pub enum PrepareSupportDefaultBehavior {
  /// The client's default behavior is to select the identifier
  /// according the to language's syntax rule.
  #[default]
  Identifier = 1,
}
impl PrepareSupportDefaultBehavior {
  pub fn as_u32(self) -> u32 { self as u32 }
}
impl TryFrom<u32> for PrepareSupportDefaultBehavior {
  type Error = ();
  fn try_from(value: u32) -> Result<Self, ()> {
    match value {
      1 => Ok(Self::Identifier),
      _ => Err(()),
    }
  }
}
impl Serialize for PrepareSupportDefaultBehavior {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_u32(self.as_u32())
  }
}
impl<'de> Deserialize<'de> for PrepareSupportDefaultBehavior {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = PrepareSupportDefaultBehavior;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("unsigned integer")
      }
      fn visit_u64<E>(self, value: u64) -> Result<PrepareSupportDefaultBehavior, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = PrepareSupportDefaultBehavior::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Unsigned(value), &self))
        }
      }
      fn visit_i64<E>(self, value: i64) -> Result<PrepareSupportDefaultBehavior, E>
      where
        E: de::Error,
      {
        if let Ok(n) = u32::try_from(value)
          && let Ok(v) = PrepareSupportDefaultBehavior::try_from(n)
        {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Signed(value), &self))
        }
      }
    }
    deserializer.deserialize_u32(Visitor)
  }
}

#[derive(Debug, Default, Clone)]
pub enum TokenFormat {
  #[default]
  Relative,
}
impl TokenFormat {
  pub fn as_str(&self) -> &str {
    match self {
      Self::Relative => "relative",
    }
  }
}
impl TryFrom<&str> for TokenFormat {
  type Error = ();
  fn try_from(value: &str) -> Result<Self, ()> {
    match value {
      "relative" => Ok(Self::Relative),
      _ => Err(()),
    }
  }
}
impl Serialize for TokenFormat {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  where
    S: ser::Serializer,
  {
    serializer.serialize_str(self.as_str())
  }
}
impl<'de> Deserialize<'de> for TokenFormat {
  fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  where
    D: de::Deserializer<'de>,
  {
    struct Visitor;
    impl<'de> de::Visitor<'de> for Visitor {
      type Value = TokenFormat;
      fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("string")
      }
      fn visit_str<E>(self, value: &str) -> Result<TokenFormat, E>
      where
        E: de::Error,
      {
        if let Ok(v) = TokenFormat::try_from(value) {
          Ok(v)
        } else {
          Err(de::Error::invalid_value(de::Unexpected::Str(value), &self))
        }
      }
    }
    deserializer.deserialize_str(Visitor)
  }
}

/// The definition of a symbol represented as one or many
/// [`locations`](crate::Location). For most programming languages there is only
/// one location at which a symbol is defined.
///
/// Servers should prefer returning `DefinitionLink` over `Definition` if
/// supported by the client.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Definition {
  Location(Location),
  Many(Vec<Location>),
}

impl Default for Definition {
  fn default() -> Self { Definition::Location(Default::default()) }
}

/// Information about where a symbol is defined.
///
/// Provides additional metadata over normal [`location`](crate::Location)
/// definitions, including the range of the defining symbol
pub type DefinitionLink = LocationLink;

/// The declaration of a symbol representation as one or many
/// [`locations`](crate::Location).
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum Declaration {
  Location(Location),
  Many(Vec<Location>),
}

impl Default for Declaration {
  fn default() -> Self { Declaration::Location(Default::default()) }
}

/// Information about where a symbol is declared.
///
/// Provides additional metadata over normal [`location`](crate::Location)
/// declarations, including the range of the declaring symbol.
///
/// Servers should prefer returning `DeclarationLink` over `Declaration` if
/// supported by the client.
pub type DeclarationLink = LocationLink;

/// Inline value information can be provided by different means:
/// - directly as a text value (class InlineValueText).
/// - as a name to use for a variable lookup (class InlineValueVariableLookup)
/// - as an evaluatable expression (class InlineValueEvaluatableExpression)
/// The InlineValue types combines all inline value types into one type.
///
/// @since 3.17.0
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum InlineValue {
  InlineValueText(InlineValueText),
  InlineValueVariableLookup(InlineValueVariableLookup),
  InlineValueEvaluatableExpression(InlineValueEvaluatableExpression),
}

impl Default for InlineValue {
  fn default() -> Self { InlineValue::InlineValueText(Default::default()) }
}

/// The result of a document diagnostic pull request. A report can
/// either be a full report containing all diagnostics for the
/// requested document or an unchanged report indicating that nothing
/// has changed in terms of diagnostics in comparison to the last
/// pull request.
///
/// @since 3.17.0
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DocumentDiagnosticReport {
  RelatedFullDocumentDiagnosticReport(RelatedFullDocumentDiagnosticReport),
  RelatedUnchangedDocumentDiagnosticReport(RelatedUnchangedDocumentDiagnosticReport),
}

impl Default for DocumentDiagnosticReport {
  fn default() -> Self {
    DocumentDiagnosticReport::RelatedFullDocumentDiagnosticReport(Default::default())
  }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PrepareRenameResult {
  Range(Range),
  RangeRangePlaceholderString {
    range:       Range,
    placeholder: String,
  },
  DefaultBehaviorBoolean {
    #[serde(rename = "defaultBehavior")]
    default_behavior: bool,
  },
}

impl Default for PrepareRenameResult {
  fn default() -> Self { PrepareRenameResult::Range(Default::default()) }
}

/// A document selector is the combination of one or many document filters.
///
/// @sample `let sel:DocumentSelector = [{ language: 'typescript' }, { language:
/// 'json', pattern: '**∕tsconfig.json' }]`;
///
/// The use of a string as a document filter is deprecated @since 3.16.0.
pub type DocumentSelector = Vec<DocumentFilter>;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ProgressToken {
  Integer(i32),
  String(String),
}

impl Default for ProgressToken {
  fn default() -> Self { ProgressToken::Integer(Default::default()) }
}

/// An identifier to refer to a change annotation stored with a workspace edit.
pub type ChangeAnnotationIdentifier = String;

/// A workspace diagnostic document report.
///
/// @since 3.17.0
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum WorkspaceDocumentDiagnosticReport {
  WorkspaceFullDocumentDiagnosticReport(WorkspaceFullDocumentDiagnosticReport),
  WorkspaceUnchangedDocumentDiagnosticReport(WorkspaceUnchangedDocumentDiagnosticReport),
}

impl Default for WorkspaceDocumentDiagnosticReport {
  fn default() -> Self {
    WorkspaceDocumentDiagnosticReport::WorkspaceFullDocumentDiagnosticReport(Default::default())
  }
}

/// An event describing a change to a text document. If only a text is provided
/// it is considered to be the full content of the document.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TextDocumentContentChangeEvent {
  RangeRangeRangeLengthUintegerTextString {
    /// The range of the document that changed.
    range:        Range,
    /// The optional length of the range that got replaced.
    #[deprecated = "use range instead."]
    #[serde(skip_serializing_if = "Option::is_none")]
    #[serde(rename = "rangeLength")]
    range_length: Option<u32>,
    /// The new text for the provided range.
    text:         String,
  },
  TextString {
    /// The new text of the whole document.
    text: String,
  },
}

/// MarkedString can be used to render human readable text. It is either a
/// markdown string or a code-block that provides a language and a code snippet.
/// The language identifier is semantically equal to the optional language
/// identifier in fenced code blocks in GitHub issues. See https://help.github.com/articles/creating-and-highlighting-code-blocks/#syntax-highlighting
///
/// The pair of a language and a value is an equivalent to markdown:
/// ```${language}
/// ${value}
/// ```
///
/// Note that markdown strings will be sanitized - that means html will be
/// escaped.
#[deprecated = "use MarkupContent instead."]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum MarkedString {
  String(String),
  LanguageStringValueString { language: String, value: String },
}

impl Default for MarkedString {
  fn default() -> Self { MarkedString::String(Default::default()) }
}

/// A document filter describes a top level text document or
/// a notebook cell document.
///
/// @since 3.17.0 - proposed support for NotebookCellTextDocumentFilter.
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DocumentFilter {
  TextDocumentFilter(TextDocumentFilter),
  NotebookCellTextDocumentFilter(NotebookCellTextDocumentFilter),
}

impl Default for DocumentFilter {
  fn default() -> Self { DocumentFilter::TextDocumentFilter(Default::default()) }
}

/// LSP object definition.
/// @since 3.17.0
pub type LSPObject = HashMap<String, Value>;

/// The glob pattern. Either a string pattern or a relative pattern.
///
/// @since 3.17.0
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GlobPattern {
  Pattern(Pattern),
  RelativePattern(RelativePattern),
}

impl Default for GlobPattern {
  fn default() -> Self { GlobPattern::Pattern(Default::default()) }
}

/// A document filter denotes a document by different properties like
/// the [`language`](crate::TextDocumentIdentifier), the [`scheme`](String) of
/// its resource, or a glob-pattern that is applied to the
/// [`path`](crate::TextDocumentIdentifier).
///
/// Glob patterns can have the following syntax:
/// - `*` to match zero 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`)
///
/// # Sample
///
/// A language filter that applies to typescript files on disk:
///
///
/// ```ts
/// { language: 'typescript', scheme: 'file' }
/// ```
///
/// # Sample
///
/// A language filter that applies to all package.json paths:
///
///
/// ```ts
/// { language: 'json', pattern: '**package.json' }
/// ```
///
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct TextDocumentFilter {
  /// A language id, like `typescript`.
  language: String,
  /// A Uri [`scheme`](String), like `file` or `untitled`.
  #[serde(skip_serializing_if = "Option::is_none")]
  scheme:   Option<String>,
  /// A glob pattern, like **/*.{ts,js}. See TextDocumentFilter for examples.
  #[serde(skip_serializing_if = "Option::is_none")]
  pattern:  Option<String>,
}

/// A notebook document filter denotes a notebook document by
/// different properties. The properties will be match
/// against the notebook's URI (same as with documents)
///
/// @since 3.17.0
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentFilter {
  /// The type of the enclosing notebook.
  #[serde(rename = "notebookType")]
  notebook_type: String,
  /// A Uri [`scheme`](String), like `file` or `untitled`.
  #[serde(skip_serializing_if = "Option::is_none")]
  scheme:        Option<String>,
  /// A glob pattern.
  #[serde(skip_serializing_if = "Option::is_none")]
  pattern:       Option<String>,
}

/// The glob pattern to watch relative to the base path. Glob patterns can have
/// the following syntax:
/// - `*` to match zero 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`)
///
/// @since 3.17.0
pub type Pattern = String;
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind")]
pub enum FileChangeContents {
  #[serde(rename = "create")]
  Create(CreateFile),
  #[serde(rename = "rename")]
  Rename(RenameFile),
  #[serde(rename = "delete")]
  Delete(DeleteFile),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind")]
pub enum DocumentDiagnosticReportContents {
  #[serde(rename = "full")]
  Full(FullDocumentDiagnosticReport),
  #[serde(rename = "unchanged")]
  Unchanged(UnchangedDocumentDiagnosticReport),
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InitializeParamsClientInfo {
  /// The name of the client as defined by the client.
  pub name:    String,
  /// The client's version as defined by the client.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub version: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InitializeResultServerInfo {
  /// The name of the server as defined by the server.
  pub name:    String,
  /// The server's version as defined by the server.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub version: Option<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionListItemDefaults {
  /// A default commit character set.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "commitCharacters")]
  pub commit_characters:  Option<Vec<String>>,
  /// A default edit range.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "editRange")]
  pub edit_range:         Option<Or2<Range, CompletionListItemDefaultsEditRange>>,
  /// A default insert text format.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "insertTextFormat")]
  pub insert_text_format: Option<InsertTextFormat>,
  /// A default insert text mode.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "insertTextMode")]
  pub insert_text_mode:   Option<InsertTextMode>,
  /// A default data value.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:               Option<Value>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeActionDisabled {
  /// Human readable description of why the code action is currently disabled.
  ///
  /// This is displayed in the code actions UI.
  pub reason: String,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceSymbolLocation {
  pub uri: Uri,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SemanticTokensOptionsFull {
  /// The server supports deltas for full documents.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub delta: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentChangeEventCells {
  /// Changes to the cell structure to add or
  /// remove cells.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub structure:    Option<NotebookDocumentChangeEventCellsStructure>,
  /// Changes to notebook cells properties like its
  /// kind, execution summary or metadata.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub data:         Option<Vec<NotebookCell>>,
  /// Changes to the text content of notebook cells.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "textContent")]
  pub text_content: Option<Vec<NotebookDocumentChangeEventCellsTextContent>>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceCapabilities {
  /// The server supports workspace folder.
  ///
  /// @since 3.6.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "workspaceFolders")]
  pub workspace_folders: Option<WorkspaceFoldersServerCapabilities>,
  /// The server is interested in notifications/requests for operations on
  /// files.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "fileOperations")]
  pub file_operations:   Option<FileOperationOptions>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionOptionsCompletionItem {
  /// 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
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "labelDetailsSupport")]
  pub label_details_support: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentSyncOptionsNotebookSelector {
  /// The notebook to be synced If a string
  /// value is provided it matches against the
  /// notebook type. '*' matches every notebook.
  pub notebook: Or2<String, NotebookDocumentFilter>,
  /// The cells of the matching notebook to be synced.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub cells:    Option<Vec<NotebookDocumentSyncOptionsNotebookSelectorCells>>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct StaleRequestSupportCapabilities {
  /// The client will actively cancel the request.
  pub cancel:                    bool,
  /// The list of requests for which the client
  /// will retry the request if it receives a
  /// response with error code `ContentModified`
  #[serde(rename = "retryOnContentModified")]
  pub retry_on_content_modified: Vec<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ChangeAnnotationSupportCapabilities {
  /// Whether the client groups edits with equal labels into tree nodes,
  /// for instance all edits labelled with "Changes in Strings" would
  /// be a tree node.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "groupsOnLabel")]
  pub groups_on_label: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SymbolKindCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "valueSet")]
  pub value_set: Option<Vec<SymbolKind>>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceSymbolTagSupportCapabilities {
  /// The tags supported by the client.
  #[serde(rename = "valueSet")]
  pub value_set: Vec<SymbolTag>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct WorkspaceSymbolResolveSupportCapabilities {
  /// The properties that a client can resolve lazily. Usually
  /// `location.range`
  pub properties: Vec<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionItemCapabilities {
  /// Client supports snippets as insert text.
  ///
  /// A snippet can define tab stops and placeholders with `$1`, `$2`
  /// and `${3:foo}`. `$0` defines the final tab stop, it defaults to
  /// the end of the snippet. Placeholders with equal identifiers are linked,
  /// that is typing in one will update others too.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "snippetSupport")]
  pub snippet_support:           Option<bool>,
  /// Client supports commit characters on a completion item.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "commitCharactersSupport")]
  pub commit_characters_support: Option<bool>,
  /// Client supports the following content formats for the documentation
  /// property. The order describes the preferred format of the client.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentationFormat")]
  pub documentation_format:      Option<Vec<MarkupKind>>,
  /// Client supports the deprecated property on a completion item.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "deprecatedSupport")]
  pub deprecated_support:        Option<bool>,
  /// Client supports the preselect property on a completion item.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "preselectSupport")]
  pub preselect_support:         Option<bool>,
  /// Client supports the tag property on a completion item. Clients supporting
  /// tags have to handle unknown tags gracefully. Clients especially need to
  /// preserve unknown tags when sending a completion item back to the server in
  /// a resolve call.
  ///
  /// @since 3.15.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "tagSupport")]
  pub tag_support:               Option<CompletionItemTagSupportCapabilities>,
  /// Client support insert replace edit to control different behavior if a
  /// completion item is inserted in the text or should replace text.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "insertReplaceSupport")]
  pub insert_replace_support:    Option<bool>,
  /// Indicates which properties a client can resolve lazily on a completion
  /// item. Before version 3.16.0 only the predefined properties `documentation`
  /// and `details` could be resolved lazily.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "resolveSupport")]
  pub resolve_support:           Option<ResolveSupportCapabilities>,
  /// The client supports the `insertTextMode` property on
  /// a completion item to override the whitespace handling mode
  /// as defined by the client (see `insertTextMode`).
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "insertTextModeSupport")]
  pub insert_text_mode_support:  Option<InsertTextModeSupportCapabilities>,
  /// The client has support for completion item label
  /// details (see also `CompletionItemLabelDetails`).
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "labelDetailsSupport")]
  pub label_details_support:     Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionItemKindCapabilities {
  /// 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.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "valueSet")]
  pub value_set: Option<Vec<CompletionItemKind>>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionListCapabilities {
  /// The client supports the following itemDefaults on
  /// a completion list.
  ///
  /// The value lists the supported property names of the
  /// `CompletionList.itemDefaults` object. If omitted
  /// no properties are supported.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "itemDefaults")]
  pub item_defaults: Option<Vec<String>>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct SignatureInformationCapabilities {
  /// Client supports the following content formats for the documentation
  /// property. The order describes the preferred format of the client.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "documentationFormat")]
  pub documentation_format:     Option<Vec<MarkupKind>>,
  /// Client capabilities specific to parameter information.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "parameterInformation")]
  pub parameter_information:    Option<ParameterInformationCapabilities>,
  /// The client supports the `activeParameter` property on
  /// `SignatureInformation` literal.
  ///
  /// @since 3.16.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "activeParameterSupport")]
  pub active_parameter_support: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct DocumentSymbolTagSupportCapabilities {
  /// The tags supported by the client.
  #[serde(rename = "valueSet")]
  pub value_set: Vec<SymbolTag>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeActionLiteralSupportCapabilities {
  /// The code action kind is support with the following value
  /// set.
  #[serde(rename = "codeActionKind")]
  pub code_action_kind: CodeActionKindCapabilities,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeActionResolveSupportCapabilities {
  /// The properties that a client can resolve lazily.
  pub properties: Vec<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FoldingRangeKindCapabilities {
  /// The folding range kind values the client supports. When this
  /// property exists the client also guarantees that it will
  /// handle values outside its set gracefully and falls back
  /// to a default value when unknown.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "valueSet")]
  pub value_set: Option<Vec<FoldingRangeKind>>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FoldingRangeCapabilities {
  /// If set, the client signals that it supports setting collapsedText on
  /// folding ranges to display custom labels instead of the default text.
  ///
  /// @since 3.17.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "collapsedText")]
  pub collapsed_text: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct PublishDiagnosticsTagSupportCapabilities {
  /// The tags supported by the client.
  #[serde(rename = "valueSet")]
  pub value_set: Vec<DiagnosticTag>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct RequestsCapabilities {
  /// The client will send the `textDocument/semanticTokens/range` request if
  /// the server provides a corresponding handler.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub range: Option<bool>,
  /// The client will send the `textDocument/semanticTokens/full` request if
  /// the server provides a corresponding handler.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub full:  Option<Or2<bool, FullCapabilities>>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InlayHintResolveSupportCapabilities {
  /// The properties that a client can resolve lazily.
  pub properties: Vec<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct MessageActionItemCapabilities {
  /// Whether the client supports additional attributes which
  /// are preserved and send back to the server in the
  /// request's response.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "additionalPropertiesSupport")]
  pub additional_properties_support: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionListItemDefaultsEditRange {
  pub insert:  Range,
  pub replace: Range,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentChangeEventCellsStructure {
  /// The change to the cell array.
  pub array:     NotebookCellArrayChange,
  /// Additional opened cell text documents.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "didOpen")]
  pub did_open:  Option<Vec<TextDocumentItem>>,
  /// Additional closed cell text documents.
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "didClose")]
  pub did_close: Option<Vec<TextDocumentIdentifier>>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentChangeEventCellsTextContent {
  pub document: VersionedTextDocumentIdentifier,
  pub changes:  Vec<TextDocumentContentChangeEvent>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct NotebookDocumentSyncOptionsNotebookSelectorCells {
  pub language: String,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CompletionItemTagSupportCapabilities {
  /// The tags supported by the client.
  #[serde(rename = "valueSet")]
  pub value_set: Vec<CompletionItemTag>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ResolveSupportCapabilities {
  /// The properties that a client can resolve lazily.
  pub properties: Vec<String>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct InsertTextModeSupportCapabilities {
  #[serde(rename = "valueSet")]
  pub value_set: Vec<InsertTextMode>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct ParameterInformationCapabilities {
  /// The client supports processing label offsets instead of a
  /// simple label string.
  ///
  /// @since 3.14.0
  #[serde(skip_serializing_if = "Option::is_none")]
  #[serde(rename = "labelOffsetSupport")]
  pub label_offset_support: Option<bool>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct CodeActionKindCapabilities {
  /// 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.
  #[serde(rename = "valueSet")]
  pub value_set: Vec<CodeActionKind>,
}
#[derive(Debug, Default, Clone, Serialize, Deserialize)]
pub struct FullCapabilities {
  /// The client will send the `textDocument/semanticTokens/full/delta` request
  /// if the server provides a corresponding handler.
  #[serde(skip_serializing_if = "Option::is_none")]
  pub delta: Option<bool>,
}