gen-lsp-types 0.1.0

//! This file is generated by an xtask. Do not edit.
#![allow(
    deprecated,
    clippy::doc_lazy_continuation,
    unreachable_patterns,
    clippy::large_enum_variant,
    rustdoc::invalid_codeblock_attributes
)]
#![cfg_attr(any(), rustfmt::skip)]

use derive_more::From;
use serde::{de::DeserializeOwned, Deserialize, Deserializer, Serialize};
use std::{borrow::Cow, collections::HashMap, fmt};

fn deserialize_some<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
where
    T: Deserialize<'de>,
    D: Deserializer<'de>,
{
    T::deserialize(deserializer).map(Some)
}
/// Indicates in which direction a message is sent in the protocol.
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
pub enum MessageDirection {
    ClientToServer,
    ServerToClient,
    Both,
}
pub trait Notification {
    type Params: DeserializeOwned + Serialize + Send + Sync;
    const METHOD: LspNotificationMethods;
    const MESSAGE_DIRECTION: MessageDirection;
}
pub trait Request {
    type Params: DeserializeOwned + Serialize + Send + Sync;
    type Result: DeserializeOwned + Serialize + Send + Sync;
    const METHOD: LspRequestMethods;
    const MESSAGE_DIRECTION: MessageDirection;
}
/// URIs are transferred as strings. The URI's format is defined in https://tools.ietf.org/html/rfc3986.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, From)]
#[from(String, &str)]
pub struct Uri(pub String);
impl AsRef<str> for Uri {
    fn as_ref(&self) -> &str {
        &self.0
    }
}
impl fmt::Display for Uri {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct Location {
    pub uri: Uri,
    pub range: Range,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct DidChangeWorkspaceFoldersParams {
    /// The actual workspace folder change event.
    pub event: WorkspaceFoldersChangeEvent,
}

/// The parameters of a configuration request.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ConfigurationParams {
    pub items: Vec<ConfigurationItem>,
}

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct WorkDoneProgressOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_done_progress: Option<bool>,
}

/// General text document registration options.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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.
    pub document_selector: Option<DocumentSelector>,
}

/// Parameters for a [FoldingRangeRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct FoldingRangeParams {
    /// The text document.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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.
    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")]
    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.
    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")]
    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] 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")]
    pub collapsed_text: Option<String>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct SelectionRangeParams {
    /// The text document.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct SelectionRange {
    /// The [range][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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct WorkDoneProgressCreateParams {
    /// The token to be used to report progress.
    pub token: ProgressToken,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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`][`CallHierarchyItem::range`].
    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<LspAny>,
}

/// Call hierarchy options used during static or dynamic registration.
///
/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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`][`CallHierarchyIncomingCall::from`].
    pub from_ranges: Vec<Range>,
}

/// The parameter of a `callHierarchy/outgoingCalls` request.
///
/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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`][`CallHierarchyItemProvider::provideCallHierarchyOutgoingCalls`]
    /// and not [`this.to`][`CallHierarchyOutgoingCall::to`].
    pub from_ranges: Vec<Range>,
}

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

/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub result_id: Option<String>,
    /// The actual tokens.
    pub data: Vec<u32>,
}

/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct SemanticTokensPartialResult {
    pub data: Vec<u32>,
}

/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct SemanticTokensDeltaParams {
    /// The text document.
    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.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct SemanticTokensDelta {
    #[serde(skip_serializing_if = "Option::is_none")]
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct SemanticTokensDeltaPartialResult {
    pub edits: Vec<SemanticTokensEdit>,
}

/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct SemanticTokensRangeParams {
    /// The text document.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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")]
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ShowDocumentResult {
    /// A boolean indicating if the show was successful.
    pub success: bool,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub word_pattern: Option<String>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub document_changes: Option<Vec<DocumentChange>>,
    /// 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")]
    pub change_annotations: Option<
        HashMap<ChangeAnnotationIdentifier, ChangeAnnotation>,
    >,
}

/// The options to register for file operations.
///
/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct DeleteFilesParams {
    /// An array of all files/folders deleted in this operation.
    pub files: Vec<FileDelete>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct TypeHierarchyPrepareParams {
    #[serde(flatten)]
    pub work_done_progress_params: WorkDoneProgressParams,
    #[serde(flatten)]
    pub text_document_position_params: TextDocumentPositionParams,
}

/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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`][`TypeHierarchyItem::range`].
    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<LspAny>,
}

/// Type hierarchy options used during static or dynamic registration.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct InlineValueParams {
    /// The text document.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct InlayHintParams {
    /// The text document.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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: Label,
    /// 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")]
    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<Tooltip>,
    /// 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")]
    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")]
    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<LspAny>,
}

/// Inlay hint options used during static or dynamic registration.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct DocumentDiagnosticParams {
    /// The text document.
    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")]
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct DocumentDiagnosticReportPartialResult {
    pub related_documents: HashMap<Uri, RelatedDocument>,
}

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

/// Diagnostic registration options.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceDiagnosticReport {
    pub items: Vec<WorkspaceDocumentDiagnosticReport>,
}

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

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

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

/// The params sent in a change notebook document notification.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct DidSaveNotebookDocumentParams {
    /// The notebook document that got saved.
    pub notebook_document: NotebookDocumentIdentifier,
}

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

/// A parameter literal used in inline completion requests.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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][InlineCompletionItem] to be presented in the editor.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
pub struct InlineCompletionItem {
    /// The text to replace the range with. Must be set.
    pub insert_text: InsertText,
    /// A text that is used to decide if this inline completion should be shown. When `falsy` the [`InlineCompletionItem::insertText`] is used.
    #[serde(skip_serializing_if = "Option::is_none")]
    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] 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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,
}

/// Parameters for the `workspace/textDocumentContent` request.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentContentParams {
    /// The uri of the text document.
    pub uri: Uri,
}

/// Result of the `workspace/textDocumentContent` request.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentContentResult {
    /// The text content of the text document. Please note, that the content of
    /// any subsequent open notifications for the text document might differ
    /// from the returned content due to whitespace and line ending
    /// normalizations done on the client
    pub text: String,
}

/// Text document content provider registration options.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentContentRegistrationOptions {
    #[serde(flatten)]
    pub static_registration_options: StaticRegistrationOptions,
    #[serde(flatten)]
    pub text_document_content_options: TextDocumentContentOptions,
}

/// Parameters for the `workspace/textDocumentContent/refresh` request.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentContentRefreshParams {
    /// The uri of the text document to refresh.
    pub uri: Uri,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct RegistrationParams {
    pub registrations: Vec<Registration>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct UnregistrationParams {
    pub unregisterations: Vec<Unregistration>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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.
    pub process_id: Option<i32>,
    /// Information about the client
    ///
    /// @since 3.15.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client_info: Option<ClientInfo>,
    /// 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.
    #[deprecated(note = "in favour of rootUri.")]
    #[serde(default, deserialize_with = "deserialize_some")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub root_path: Option<RootPath>,
    /// 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.
    #[deprecated(note = "in favour of workspaceFolders.")]
    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")]
    pub initialization_options: Option<LspAny>,
    /// The initial trace setting. If omitted trace is disabled ('off').
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trace: Option<TraceValue>,
    #[serde(flatten)]
    pub work_done_progress_params: WorkDoneProgressParams,
    #[serde(flatten)]
    pub workspace_folders_initialize_params: WorkspaceFoldersInitializeParams,
}

/// The result returned from an initialize request.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub server_info: Option<ServerInfo>,
}

/// The data type of the ResponseError if the
/// initialize request fails.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct InitializedParams {}

/// The parameters of a change configuration notification.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct DidChangeConfigurationParams {
    /// The actual changed settings
    pub settings: LspAny,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct DidChangeConfigurationRegistrationOptions {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub section: Option<Section>,
}

/// The parameters of a notification message.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct ShowMessageParams {
    /// The message type. See [MessageType]
    #[serde(rename = "type")]
    pub kind: MessageType,
    /// The actual message.
    pub message: String,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct ShowMessageRequestParams {
    /// The message type. See [MessageType]
    #[serde(rename = "type")]
    pub kind: 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct MessageActionItem {
    /// A short title like 'Retry', 'Open Log' etc.
    pub title: String,
}

/// The log message parameters.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct LogMessageParams {
    /// The message type. See [MessageType]
    #[serde(rename = "type")]
    pub kind: MessageType,
    /// The actual message.
    pub message: String,
}

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

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

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

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

/// The parameters sent in a save text document notification
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct DidSaveTextDocumentParams {
    /// The document that was saved.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct WillSaveTextDocumentParams {
    /// The document that will be saved.
    pub text_document: TextDocumentIdentifier,
    /// The 'TextDocumentSaveReason'.
    pub reason: TextDocumentSaveReason,
}

/// A text edit applicable to a text document.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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.
    pub new_text: String,
}

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

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

/// The publish diagnostic notification's parameters.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct CompletionParams {
    /// The completion context. This is only available it 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    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<Documentation>,
    /// Indicates if this item is deprecated.
    /// @deprecated Use `tags` instead.
    #[deprecated(note = "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][`CompletionItem::label`]
    /// is used.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort_text: Option<String>,
    /// A string that should be used when filtering a set of
    /// completion items. When `falsy` the [label][`CompletionItem::label`]
    /// is used.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filter_text: Option<String>,
    /// A string that should be inserted into a document when selecting
    /// this completion. When `falsy` the [label][`CompletionItem::label`]
    /// is used.
    ///
    /// The `insertText` is subject to interpretation by the client side.
    /// Some tools might not take the string literally. For example
    /// VS Code when code complete is requested in this example
    /// `con<cursor position>` and a completion item with an `insertText` of
    /// `console` is provided it will only insert `sole`. Therefore it is
    /// recommended to use `textEdit` instead since it avoids additional client
    /// side interpretation.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    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")]
    pub insert_text_mode: Option<InsertTextMode>,
    /// An [edit][TextEdit] which is applied to a document when selecting
    /// this completion. When an edit is provided the value of
    /// [insertText][`CompletionItem::insertText`] is ignored.
    ///
    /// Most editors support two different 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")]
    pub text_edit: Option<CompletionItemTextEdit>,
    /// 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")]
    pub text_edit_text: Option<String>,
    /// An optional array of additional [text edits][TextEdit] that are applied when
    /// selecting this completion. Edits must not overlap (including the same insert position)
    /// with the main [edit][`CompletionItem::textEdit`] nor with themselves.
    ///
    /// Additional text edits should be used to change text unrelated to the current cursor position
    /// (for example adding an import statement at the top of the file if the completion item will
    /// insert an unqualified type).
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub commit_characters: Option<Vec<String>>,
    /// An optional [command][Command] that is executed *after* inserting this completion. *Note* that
    /// additional modifications to the current document should be described with the
    /// [additionalTextEdits][`CompletionItem::additionalTextEdits`]-property.
    #[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] and a [CompletionResolveRequest].
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<LspAny>,
}

/// Represents a collection of [completion items][CompletionItem] to be presented
/// in the editor.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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.
    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 rules for combining these are
    /// defined by `applyKinds` (if the client supports it), defaulting to
    /// ApplyKind.Replace.
    ///
    /// Servers are only allowed to return default values if the client
    /// signals support for this via the `completionList.itemDefaults`
    /// capability.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub item_defaults: Option<CompletionItemDefaults>,
    /// Specifies how fields from a completion item should be combined with those
    /// from `completionList.itemDefaults`.
    ///
    /// If unspecified, all fields will be treated as ApplyKind.Replace.
    ///
    /// If a field's value is ApplyKind.Replace, the value from a completion item
    /// (if provided and not `null`) will always be used instead of the value
    /// from `completionItem.itemDefaults`.
    ///
    /// If a field's value is ApplyKind.Merge, the values will be merged using
    /// the rules defined against each field below.
    ///
    /// Servers are only allowed to return `applyKind` if the client
    /// signals support for this via the `completionList.applyKindSupport`
    /// capability.
    ///
    /// @since 3.18.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub apply_kind: Option<CompletionItemApplyKinds>,
    /// The completion items.
    pub items: Vec<CompletionItem>,
}

/// Registration options for a [CompletionRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct CompletionRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub completion_options: CompletionOptions,
}

/// Parameters for a [HoverRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct Hover {
    /// The hover's content
    pub contents: Contents,
    /// 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].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct HoverRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub hover_options: HoverOptions,
}

/// Parameters for a [SignatureHelpRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub active_signature: Option<u32>,
    /// The active parameter of the active signature.
    ///
    /// If `null`, no parameter of the signature is active (for example a named
    /// argument that does not match any declared parameters). This is only valid
    /// if the client specifies the client capability
    /// `textDocument.signatureHelp.noActiveParameterSupport === true`
    ///
    /// 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 (but still nullable) to better express the active parameter if
    /// the active signature does have any.
    #[serde(default, deserialize_with = "deserialize_some")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active_parameter: Option<ActiveParameter>,
}

/// Registration options for a [SignatureHelpRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct SignatureHelpRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub signature_help_options: SignatureHelpOptions,
}

/// Parameters for a [DefinitionRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct DefinitionRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub definition_options: DefinitionOptions,
}

/// Parameters for a [ReferencesRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ReferenceRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub reference_options: ReferenceOptions,
}

/// Parameters for a [DocumentHighlightRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DocumentHighlight {
    /// The range this highlight applies to.
    pub range: Range,
    /// The highlight kind, default is [text][`DocumentHighlightKind::Text`].
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kind: Option<DocumentHighlightKind>,
}

/// Registration options for a [DocumentHighlightRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct DocumentHighlightRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub document_highlight_options: DocumentHighlightOptions,
}

/// Parameters for a [DocumentSymbolRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct DocumentSymbolParams {
    /// The text document.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct SymbolInformation {
    /// Indicates if this symbol is deprecated.
    ///
    /// @deprecated Use tags instead
    #[deprecated(note = "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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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
    #[deprecated(note = "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`.
    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].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct DocumentSymbolRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub document_symbol_options: DocumentSymbolOptions,
}

/// The parameters of a [CodeActionRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
pub struct CodeActionParams {
    /// The document in which the command was invoked.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct Command {
    /// Title of the command, like `save`.
    pub title: String,
    /// An optional tooltip.
    ///
    /// @since 3.18.0
    /// @proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tooltip: Option<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<LspAny>>,
}

/// 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    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<LspAny>,
    /// Tags for this code action.
    ///
    /// @since 3.18.0 - proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<CodeActionTag>>,
}

/// Registration options for a [CodeActionRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct CodeActionRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub code_action_options: CodeActionOptions,
}

/// The parameters of a [WorkspaceSymbolRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceSymbolParams {
    /// A query string to filter symbols by. Clients may send an empty
    /// string here to request all symbols.
    ///
    /// The `query`-parameter should be interpreted in a *relaxed way* as editors
    /// will apply their own highlighting and scoring on the results. A good rule
    /// of thumb is to match case-insensitive and to simply check that the
    /// characters of *query* appear in their order in a candidate symbol.
    /// Servers shouldn't use prefix, substring, or similar strict matching.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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: 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<LspAny>,
    #[serde(flatten)]
    pub base_symbol_information: BaseSymbolInformation,
}

/// Registration options for a [WorkspaceSymbolRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceSymbolRegistrationOptions {
    #[serde(flatten)]
    pub workspace_symbol_options: WorkspaceSymbolOptions,
}

/// The parameters of a [CodeLensRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct CodeLensParams {
    /// The document to request code lens for.
    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][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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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] and a [CodeLensResolveRequest]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<LspAny>,
}

/// Registration options for a [CodeLensRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct CodeLensRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub code_lens_options: CodeLensOptions,
}

/// The parameters of a [DocumentLinkRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct DocumentLinkParams {
    /// The document to provide document links for.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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<LspAny>,
}

/// Registration options for a [DocumentLinkRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct DocumentLinkRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub document_link_options: DocumentLinkOptions,
}

/// The parameters of a [DocumentFormattingRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct DocumentFormattingParams {
    /// The document to format.
    pub text_document: TextDocumentIdentifier,
    /// The format options.
    pub options: FormattingOptions,
    #[serde(flatten)]
    pub work_done_progress_params: WorkDoneProgressParams,
}

/// Registration options for a [DocumentFormattingRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct DocumentFormattingRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub document_formatting_options: DocumentFormattingOptions,
}

/// The parameters of a [DocumentRangeFormattingRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct DocumentRangeFormattingParams {
    /// The document to format.
    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].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct DocumentRangeFormattingRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub document_range_formatting_options: DocumentRangeFormattingOptions,
}

/// The parameters of a [DocumentRangesFormattingRequest].
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct DocumentRangesFormattingParams {
    /// The document to format.
    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].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct DocumentOnTypeFormattingParams {
    /// The document to format.
    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].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct RenameParams {
    /// The new name of the symbol. If the given name is not valid the
    /// request must return a [ResponseError] with an
    /// appropriate message set.
    pub new_name: String,
    #[serde(flatten)]
    pub work_done_progress_params: WorkDoneProgressParams,
    #[serde(flatten)]
    pub text_document_position_params: TextDocumentPositionParams,
}

/// Registration options for a [RenameRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct RenameRegistrationOptions {
    #[serde(flatten)]
    pub text_document_registration_options: TextDocumentRegistrationOptions,
    #[serde(flatten)]
    pub rename_options: RenameOptions,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct PrepareRenameParams {
    #[serde(flatten)]
    pub work_done_progress_params: WorkDoneProgressParams,
    #[serde(flatten)]
    pub text_document_position_params: TextDocumentPositionParams,
}

/// The parameters of a [ExecuteCommandRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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<LspAny>>,
    #[serde(flatten)]
    pub work_done_progress_params: WorkDoneProgressParams,
}

/// Registration options for a [ExecuteCommandRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ExecuteCommandRegistrationOptions {
    #[serde(flatten)]
    pub execute_command_options: ExecuteCommandOptions,
}

/// The parameters passed via an apply workspace edit request.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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,
    /// Additional data about the edit.
    ///
    /// @since 3.18.0
    /// @proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<WorkspaceEditMetadata>,
}

/// The result returned from the apply workspace edit request.
///
/// @since 3.17 renamed from ApplyWorkspaceEditResponse
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    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")]
    pub failed_change: Option<u32>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
#[serde(try_from = "ShadowWorkDoneProgressBegin", into = "ShadowWorkDoneProgressBegin")]
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 in 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
struct ShadowWorkDoneProgressBegin {
    /// 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 in 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>,
    pub kind: String,
}
impl TryFrom<ShadowWorkDoneProgressBegin> for WorkDoneProgressBegin {
    type Error = String;
    fn try_from(shadow: ShadowWorkDoneProgressBegin) -> Result<Self, Self::Error> {
        if shadow.kind != "begin" {
            return Err(format!("Invalid value for prop kind: {}", shadow.kind));
        }
        Ok(WorkDoneProgressBegin {
            title: shadow.title,
            cancellable: shadow.cancellable,
            message: shadow.message,
            percentage: shadow.percentage,
        })
    }
}
impl From<WorkDoneProgressBegin> for ShadowWorkDoneProgressBegin {
    fn from(original: WorkDoneProgressBegin) -> Self {
        ShadowWorkDoneProgressBegin {
            title: original.title,
            cancellable: original.cancellable,
            message: original.message,
            percentage: original.percentage,
            kind: "begin".to_string(),
        }
    }
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
#[serde(
    try_from = "ShadowWorkDoneProgressReport",
    into = "ShadowWorkDoneProgressReport"
)]
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 in 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
struct ShadowWorkDoneProgressReport {
    /// 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 in 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>,
    pub kind: String,
}
impl TryFrom<ShadowWorkDoneProgressReport> for WorkDoneProgressReport {
    type Error = String;
    fn try_from(shadow: ShadowWorkDoneProgressReport) -> Result<Self, Self::Error> {
        if shadow.kind != "report" {
            return Err(format!("Invalid value for prop kind: {}", shadow.kind));
        }
        Ok(WorkDoneProgressReport {
            cancellable: shadow.cancellable,
            message: shadow.message,
            percentage: shadow.percentage,
        })
    }
}
impl From<WorkDoneProgressReport> for ShadowWorkDoneProgressReport {
    fn from(original: WorkDoneProgressReport) -> Self {
        ShadowWorkDoneProgressReport {
            cancellable: original.cancellable,
            message: original.message,
            percentage: original.percentage,
            kind: "report".to_string(),
        }
    }
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
#[serde(try_from = "ShadowWorkDoneProgressEnd", into = "ShadowWorkDoneProgressEnd")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
struct ShadowWorkDoneProgressEnd {
    /// 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>,
    pub kind: String,
}
impl TryFrom<ShadowWorkDoneProgressEnd> for WorkDoneProgressEnd {
    type Error = String;
    fn try_from(shadow: ShadowWorkDoneProgressEnd) -> Result<Self, Self::Error> {
        if shadow.kind != "end" {
            return Err(format!("Invalid value for prop kind: {}", shadow.kind));
        }
        Ok(WorkDoneProgressEnd {
            message: shadow.message,
        })
    }
}
impl From<WorkDoneProgressEnd> for ShadowWorkDoneProgressEnd {
    fn from(original: WorkDoneProgressEnd) -> Self {
        ShadowWorkDoneProgressEnd {
            message: original.message,
            kind: "end".to_string(),
        }
    }
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Copy)]
#[serde(rename_all = "camelCase")]
pub struct SetTraceParams {
    pub value: TraceValue,
}

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct CancelParams {
    /// The request id to cancel.
    pub id: Id,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
pub struct ProgressParams {
    /// The progress token provided by the client or server.
    pub token: ProgressToken,
    /// The progress data.
    pub value: LspAny,
}

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

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub partial_result_token: Option<ProgressToken>,
}

/// Represents the connection of two locations. Provides additional metadata over normal [locations][Location],
/// including an origin range.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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")]
    pub origin_selection_range: Option<Range>,
    /// The target resource identifier of this link.
    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.
    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`
    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(
    Serialize,
    Deserialize,
    PartialEq,
    Debug,
    Clone,
    Eq,
    Hash,
    Default,
    Copy,
    PartialOrd,
    Ord
)]
#[serde(rename_all = "camelCase")]
pub struct Range {
    /// The range's start position.
    pub start: Position,
    /// The range's end position.
    pub end: Position,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ImplementationOptions {
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Static registration options to be returned in the initialize
/// request.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct TypeDefinitionOptions {
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

/// The workspace folder change event.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ConfigurationItem {
    /// The scope to get the configuration section for.
    #[serde(skip_serializing_if = "Option::is_none")]
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentIdentifier {
    /// The text document's uri.
    pub uri: Uri,
}

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DocumentColorOptions {
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct FoldingRangeOptions {
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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(
    Serialize,
    Deserialize,
    PartialEq,
    Debug,
    Clone,
    Eq,
    Hash,
    Default,
    Copy,
    PartialOrd,
    Ord
)]
#[serde(rename_all = "camelCase")]
pub struct Position {
    /// Line position in a document (zero-based).
    pub line: u32,
    /// Character offset on a line in a document (zero-based).
    ///
    /// The meaning of this offset is determined by the negotiated
    /// `PositionEncodingKind`.
    pub character: u32,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct SelectionRangeOptions {
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

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

/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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<SemanticTokensOptionsRange>,
    /// Server supports providing semantic tokens for a full document.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub full: Option<Full>,
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct LinkedEditingRangeOptions {
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Represents information on a file/folder create.
///
/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentEdit {
    /// The text document to change.
    pub text_document: OptionalVersionedTextDocumentIdentifier,
    /// The edits to be applied.
    ///
    /// @since 3.16.0 - support for AnnotatedTextEdit. This is guarded using a
    /// client capability.
    ///
    /// @since 3.18.0 - support for SnippetTextEdit. This is guarded using a
    /// client capability.
    pub edits: Vec<Edit>,
}

/// Create file operation.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
#[serde(try_from = "ShadowCreateFile", into = "ShadowCreateFile")]
pub struct CreateFile {
    /// The resource to create.
    pub uri: Uri,
    /// Additional options
    #[serde(skip_serializing_if = "Option::is_none")]
    pub options: Option<CreateFileOptions>,
    /// An optional annotation identifier describing the operation.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotation_id: Option<ChangeAnnotationIdentifier>,
}
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
struct ShadowCreateFile {
    /// The resource to create.
    pub uri: Uri,
    /// Additional options
    #[serde(skip_serializing_if = "Option::is_none")]
    pub options: Option<CreateFileOptions>,
    /// An optional annotation identifier describing the operation.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotation_id: Option<ChangeAnnotationIdentifier>,
    pub kind: String,
}
impl TryFrom<ShadowCreateFile> for CreateFile {
    type Error = String;
    fn try_from(shadow: ShadowCreateFile) -> Result<Self, Self::Error> {
        if shadow.kind != "create" {
            return Err(format!("Invalid value for prop kind: {}", shadow.kind));
        }
        Ok(CreateFile {
            uri: shadow.uri,
            options: shadow.options,
            annotation_id: shadow.annotation_id,
        })
    }
}
impl From<CreateFile> for ShadowCreateFile {
    fn from(original: CreateFile) -> Self {
        ShadowCreateFile {
            uri: original.uri,
            options: original.options,
            annotation_id: original.annotation_id,
            kind: "create".to_string(),
        }
    }
}

/// Rename file operation
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
#[serde(try_from = "ShadowRenameFile", into = "ShadowRenameFile")]
pub struct RenameFile {
    /// The old (existing) location.
    pub old_uri: Uri,
    /// The new location.
    pub new_uri: Uri,
    /// Rename options.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub options: Option<RenameFileOptions>,
    /// An optional annotation identifier describing the operation.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotation_id: Option<ChangeAnnotationIdentifier>,
}
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
struct ShadowRenameFile {
    /// The old (existing) location.
    pub old_uri: Uri,
    /// The new location.
    pub new_uri: Uri,
    /// Rename options.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub options: Option<RenameFileOptions>,
    /// An optional annotation identifier describing the operation.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotation_id: Option<ChangeAnnotationIdentifier>,
    pub kind: String,
}
impl TryFrom<ShadowRenameFile> for RenameFile {
    type Error = String;
    fn try_from(shadow: ShadowRenameFile) -> Result<Self, Self::Error> {
        if shadow.kind != "rename" {
            return Err(format!("Invalid value for prop kind: {}", shadow.kind));
        }
        Ok(RenameFile {
            old_uri: shadow.old_uri,
            new_uri: shadow.new_uri,
            options: shadow.options,
            annotation_id: shadow.annotation_id,
        })
    }
}
impl From<RenameFile> for ShadowRenameFile {
    fn from(original: RenameFile) -> Self {
        ShadowRenameFile {
            old_uri: original.old_uri,
            new_uri: original.new_uri,
            options: original.options,
            annotation_id: original.annotation_id,
            kind: "rename".to_string(),
        }
    }
}

/// Delete file operation
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
#[serde(try_from = "ShadowDeleteFile", into = "ShadowDeleteFile")]
pub struct DeleteFile {
    /// The file to delete.
    pub uri: Uri,
    /// Delete options.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub options: Option<DeleteFileOptions>,
    /// An optional annotation identifier describing the operation.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotation_id: Option<ChangeAnnotationIdentifier>,
}
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
struct ShadowDeleteFile {
    /// The file to delete.
    pub uri: Uri,
    /// Delete options.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub options: Option<DeleteFileOptions>,
    /// An optional annotation identifier describing the operation.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotation_id: Option<ChangeAnnotationIdentifier>,
    pub kind: String,
}
impl TryFrom<ShadowDeleteFile> for DeleteFile {
    type Error = String;
    fn try_from(shadow: ShadowDeleteFile) -> Result<Self, Self::Error> {
        if shadow.kind != "delete" {
            return Err(format!("Invalid value for prop kind: {}", shadow.kind));
        }
        Ok(DeleteFile {
            uri: shadow.uri,
            options: shadow.options,
            annotation_id: shadow.annotation_id,
        })
    }
}
impl From<DeleteFile> for ShadowDeleteFile {
    fn from(original: DeleteFile) -> Self {
        ShadowDeleteFile {
            uri: original.uri,
            options: original.options,
            annotation_id: original.annotation_id,
            kind: "delete".to_string(),
        }
    }
}

/// Additional information that describes document changes.
///
/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct FileRename {
    /// A file:// URI for the original location of the file/folder being renamed.
    pub old_uri: String,
    /// A file:// URI for the new location of the file/folder being renamed.
    pub new_uri: String,
}

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct MonikerOptions {
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

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

/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct InlineValueContext {
    /// The stack frame (as a DAP Id) where the execution has stopped.
    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.
    pub stopped_location: Range,
}

/// Provide inline value as text.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub variable_name: Option<String>,
    /// How to perform the lookup.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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<Tooltip>,
    /// 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct InlayHintOptions {
    /// The server provides support to resolve additional
    /// information for an inlay hint item.
    #[serde(skip_serializing_if = "Option::is_none")]
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub related_documents: Option<HashMap<Uri, RelatedDocument>>,
    #[serde(flatten)]
    pub full_document_diagnostic_report: FullDocumentDiagnosticReport,
}

/// An unchanged diagnostic report with a set of related documents.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub related_documents: Option<HashMap<Uri, RelatedDocument>>,
    #[serde(flatten)]
    pub unchanged_document_diagnostic_report: UnchangedDocumentDiagnosticReport,
}

/// A diagnostic report with a full set of problems.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
#[serde(
    try_from = "ShadowFullDocumentDiagnosticReport",
    into = "ShadowFullDocumentDiagnosticReport"
)]
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")]
    pub result_id: Option<String>,
    /// The actual items.
    pub items: Vec<Diagnostic>,
}
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
struct ShadowFullDocumentDiagnosticReport {
    /// 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")]
    pub result_id: Option<String>,
    /// The actual items.
    pub items: Vec<Diagnostic>,
    pub kind: String,
}
impl TryFrom<ShadowFullDocumentDiagnosticReport> for FullDocumentDiagnosticReport {
    type Error = String;
    fn try_from(
        shadow: ShadowFullDocumentDiagnosticReport,
    ) -> Result<Self, Self::Error> {
        if shadow.kind != "full" {
            return Err(format!("Invalid value for prop kind: {}", shadow.kind));
        }
        Ok(FullDocumentDiagnosticReport {
            result_id: shadow.result_id,
            items: shadow.items,
        })
    }
}
impl From<FullDocumentDiagnosticReport> for ShadowFullDocumentDiagnosticReport {
    fn from(original: FullDocumentDiagnosticReport) -> Self {
        ShadowFullDocumentDiagnosticReport {
            result_id: original.result_id,
            items: original.items,
            kind: "full".to_string(),
        }
    }
}

/// A diagnostic report indicating that the last returned
/// report is still accurate.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
#[serde(
    try_from = "ShadowUnchangedDocumentDiagnosticReport",
    into = "ShadowUnchangedDocumentDiagnosticReport"
)]
pub struct UnchangedDocumentDiagnosticReport {
    /// A result id which will be sent on the next
    /// diagnostic request for the same document.
    pub result_id: String,
}
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
struct ShadowUnchangedDocumentDiagnosticReport {
    /// A result id which will be sent on the next
    /// diagnostic request for the same document.
    pub result_id: String,
    pub kind: String,
}
impl TryFrom<ShadowUnchangedDocumentDiagnosticReport>
for UnchangedDocumentDiagnosticReport {
    type Error = String;
    fn try_from(
        shadow: ShadowUnchangedDocumentDiagnosticReport,
    ) -> Result<Self, Self::Error> {
        if shadow.kind != "unchanged" {
            return Err(format!("Invalid value for prop kind: {}", shadow.kind));
        }
        Ok(UnchangedDocumentDiagnosticReport {
            result_id: shadow.result_id,
        })
    }
}
impl From<UnchangedDocumentDiagnosticReport>
for ShadowUnchangedDocumentDiagnosticReport {
    fn from(original: UnchangedDocumentDiagnosticReport) -> Self {
        ShadowUnchangedDocumentDiagnosticReport {
            result_id: original.result_id,
            kind: "unchanged".to_string(),
        }
    }
}

/// Diagnostic options.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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.
    pub inter_file_dependencies: bool,
    /// The server provides support for workspace diagnostics as well.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
pub struct NotebookDocument {
    /// The notebook document's uri.
    pub uri: Uri,
    /// The type of the notebook.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentItem {
    /// The text document's uri.
    pub uri: Uri,
    /// The text document's language identifier.
    pub language_id: LanguageKind,
    /// 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,
}

/// 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct NotebookDocumentSyncOptions {
    /// The notebooks to be synced
    pub notebook_selector: Vec<NotebookSelector>,
    /// 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>,
}

/// A versioned notebook document identifier.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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<NotebookDocumentCellChanges>,
}

/// A literal to identify a notebook document in the client.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct InlineCompletionContext {
    /// Describes how the inline completion was triggered.
    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")]
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
#[serde(try_from = "ShadowStringValue", into = "ShadowStringValue")]
pub struct StringValue {
    /// The snippet string.
    pub value: String,
}
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
struct ShadowStringValue {
    /// The snippet string.
    pub value: String,
    pub kind: String,
}
impl TryFrom<ShadowStringValue> for StringValue {
    type Error = String;
    fn try_from(shadow: ShadowStringValue) -> Result<Self, Self::Error> {
        if shadow.kind != "snippet" {
            return Err(format!("Invalid value for prop kind: {}", shadow.kind));
        }
        Ok(StringValue { value: shadow.value })
    }
}
impl From<StringValue> for ShadowStringValue {
    fn from(original: StringValue) -> Self {
        ShadowStringValue {
            value: original.value,
            kind: "snippet".to_string(),
        }
    }
}

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

/// Text document content provider options.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentContentOptions {
    /// The schemes for which the server provides content.
    pub schemes: Vec<String>,
}

/// General parameters to register for a notification or to register a provider.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub register_options: Option<LspAny>,
}

/// General parameters to unregister a request or notification.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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(default, deserialize_with = "deserialize_some")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub workspace_folders: Option<WorkspaceFolders>,
}

/// Defines the capabilities provided by a language
/// server.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    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")]
    pub text_document_sync: Option<TextDocumentSync>,
    /// Defines how notebook documents are synced.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_document_sync: Option<NotebookDocumentSync>,
    /// The server provides completion support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub completion_provider: Option<CompletionOptions>,
    /// The server provides hover support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hover_provider: Option<HoverProvider>,
    /// The server provides signature help support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature_help_provider: Option<SignatureHelpOptions>,
    /// The server provides Goto Declaration support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub declaration_provider: Option<DeclarationProvider>,
    /// The server provides goto definition support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub definition_provider: Option<DefinitionProvider>,
    /// The server provides Goto Type Definition support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub type_definition_provider: Option<TypeDefinitionProvider>,
    /// The server provides Goto Implementation support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub implementation_provider: Option<ImplementationProvider>,
    /// The server provides find references support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub references_provider: Option<ReferencesProvider>,
    /// The server provides document highlight support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub document_highlight_provider: Option<DocumentHighlightProvider>,
    /// The server provides document symbol support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub document_symbol_provider: Option<DocumentSymbolProvider>,
    /// 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")]
    pub code_action_provider: Option<CodeActionProvider>,
    /// The server provides code lens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub code_lens_provider: Option<CodeLensOptions>,
    /// The server provides document link support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub document_link_provider: Option<DocumentLinkOptions>,
    /// The server provides color provider support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub color_provider: Option<ColorProvider>,
    /// The server provides workspace symbol support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub workspace_symbol_provider: Option<WorkspaceSymbolProvider>,
    /// The server provides document formatting.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub document_formatting_provider: Option<DocumentFormattingProvider>,
    /// The server provides document range formatting.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub document_range_formatting_provider: Option<DocumentRangeFormattingProvider>,
    /// The server provides document formatting on typing.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub rename_provider: Option<RenameProvider>,
    /// The server provides folding provider support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folding_range_provider: Option<FoldingRangeProvider>,
    /// The server provides selection range support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub selection_range_provider: Option<SelectionRangeProvider>,
    /// The server provides execute command support.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub execute_command_provider: Option<ExecuteCommandOptions>,
    /// The server provides call hierarchy support.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub call_hierarchy_provider: Option<CallHierarchyProvider>,
    /// The server provides linked editing range support.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub linked_editing_range_provider: Option<LinkedEditingRangeProvider>,
    /// The server provides semantic tokens support.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub semantic_tokens_provider: Option<SemanticTokensProvider>,
    /// The server provides moniker support.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub moniker_provider: Option<MonikerProvider>,
    /// The server provides type hierarchy support.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub type_hierarchy_provider: Option<TypeHierarchyProvider>,
    /// The server provides inline values.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inline_value_provider: Option<InlineValueProvider>,
    /// The server provides inlay hints.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inlay_hint_provider: Option<InlayHintProvider>,
    /// The server has support for pull model diagnostics.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub diagnostic_provider: Option<DiagnosticProvider>,
    /// Inline completion options used during static registration.
    ///
    /// @since 3.18.0
    /// @proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inline_completion_provider: Option<InlineCompletionProvider>,
    /// Workspace specific server capabilities.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub workspace: Option<WorkspaceOptions>,
    /// Experimental server capabilities.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub experimental: Option<LspAny>,
}

/// Information about the server
///
/// @since 3.15.0
/// @since 3.18.0 ServerInfo type name added.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ServerInfo {
    /// 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>,
}

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

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

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct FileSystemWatcher {
    /// The glob pattern to watch. See [glob pattern][GlobPattern] for more detail.
    ///
    /// @since 3.17.0 support for relative patterns.
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct Diagnostic {
    /// The range at which the message applies
    pub range: Range,
    /// The diagnostic's severity. To avoid interpretation mismatches when a
    /// server is used with different clients it is highly recommended that servers
    /// always provide a severity value.
    #[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<Code>,
    /// 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")]
    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")]
    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<LspAny>,
}

/// Contains additional information about the context in which a completion request is triggered.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct CompletionContext {
    /// How the completion was triggered.
    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")]
    pub trigger_character: Option<String>,
}

/// Additional details for a completion item label.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct CompletionItemLabelDetails {
    /// An optional string which is rendered less prominently directly after [label][`CompletionItem::label`],
    /// 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`]. 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct InsertReplaceEdit {
    /// The string to be inserted.
    pub new_text: String,
    /// The range if the insert is requested
    pub insert: Range,
    /// The range if the replace is requested.
    pub replace: Range,
}

/// In many cases the items of an actual completion result share the same
/// value for properties like `commitCharacters` or the range of a text
/// edit. A completion list can therefore define item defaults which will
/// be used if a completion item itself doesn't specify the value.
///
/// If a completion list specifies a default value and a completion item
/// also specifies a corresponding value, the rules for combining these are
/// defined by `applyKinds` (if the client supports it), defaulting to
/// ApplyKind.Replace.
///
/// Servers are only allowed to return default values if the client
/// signals support for this via the `completionList.itemDefaults`
/// capability.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct CompletionItemDefaults {
    /// A default commit character set.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub commit_characters: Option<Vec<String>>,
    /// A default edit range.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_range: Option<EditRange>,
    /// A default insert text format.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub insert_text_format: Option<InsertTextFormat>,
    /// A default insert text mode.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub insert_text_mode: Option<InsertTextMode>,
    /// A default data value.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<LspAny>,
}

/// Specifies how fields from a completion item should be combined with those
/// from `completionList.itemDefaults`.
///
/// If unspecified, all fields will be treated as ApplyKind.Replace.
///
/// If a field's value is ApplyKind.Replace, the value from a completion item (if
/// provided and not `null`) will always be used instead of the value from
/// `completionItem.itemDefaults`.
///
/// If a field's value is ApplyKind.Merge, the values will be merged using the rules
/// defined against each field below.
///
/// Servers are only allowed to return `applyKind` if the client
/// signals support for this via the `completionList.applyKindSupport`
/// capability.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct CompletionItemApplyKinds {
    /// Specifies whether commitCharacters on a completion will replace or be
    /// merged with those in `completionList.itemDefaults.commitCharacters`.
    ///
    /// If ApplyKind.Replace, the commit characters from the completion item will
    /// always be used unless not provided, in which case those from
    /// `completionList.itemDefaults.commitCharacters` will be used. An
    /// empty list can be used if a completion item does not have any commit
    /// characters and also should not use those from
    /// `completionList.itemDefaults.commitCharacters`.
    ///
    /// If ApplyKind.Merge the commitCharacters for the completion will be the
    /// union of all values in both `completionList.itemDefaults.commitCharacters`
    /// and the completion's own `commitCharacters`.
    ///
    /// @since 3.18.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub commit_characters: Option<ApplyKind>,
    /// Specifies whether the `data` field on a completion will replace or
    /// be merged with data from `completionList.itemDefaults.data`.
    ///
    /// If ApplyKind.Replace, the data from the completion item will be used if
    /// provided (and not `null`), otherwise
    /// `completionList.itemDefaults.data` will be used. An empty object can
    /// be used if a completion item does not have any data but also should
    /// not use the value from `completionList.itemDefaults.data`.
    ///
    /// If ApplyKind.Merge, a shallow merge will be performed between
    /// `completionList.itemDefaults.data` and the completion's own data
    /// using the following rules:
    ///
    /// - If a completion's `data` field is not provided (or `null`), the
    ///   entire `data` field from `completionList.itemDefaults.data` will be
    ///   used as-is.
    /// - If a completion's `data` field is provided, each field will
    ///   overwrite the field of the same name in
    ///   `completionList.itemDefaults.data` but no merging of nested fields
    ///   within that value will occur.
    ///
    /// @since 3.18.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<ApplyKind>,
}

/// Completion options.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    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")]
    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")]
    pub resolve_provider: Option<bool>,
    /// The server supports the following `CompletionItem` specific
    /// capabilities.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub completion_item: Option<ServerCompletionItemOptions>,
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Hover options.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct SignatureHelpContext {
    /// Action that caused signature help to be triggered.
    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")]
    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.
    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")]
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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<Documentation>,
    /// The parameters of this signature.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parameters: Option<Vec<ParameterInformation>>,
    /// The index of the active parameter.
    ///
    /// If `null`, no parameter of the signature is active (for example a named
    /// argument that does not match any declared parameters). This is only valid
    /// if the client specifies the client capability
    /// `textDocument.signatureHelp.noActiveParameterSupport === true`
    ///
    /// If provided (or `null`), this is used in place of
    /// `SignatureHelp.activeParameter`.
    ///
    /// @since 3.16.0
    #[serde(default, deserialize_with = "deserialize_some")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active_parameter: Option<ActiveParameter>,
}

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

/// Server Capabilities for a [DefinitionRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DefinitionOptions {
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

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

/// Reference options.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ReferenceOptions {
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Provider options for a [DocumentHighlightRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DocumentHighlightOptions {
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

/// A base for all symbol information.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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")]
    pub container_name: Option<String>,
}

/// Provider options for a [DocumentSymbolRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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][`CodeActionProvider::provideCodeActions`] is run.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub trigger_kind: Option<CodeActionTriggerKind>,
}

/// Captures why the code action is currently disabled.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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,
}

/// Provider options for a [CodeActionRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub code_action_kinds: Option<Vec<CodeActionKind>>,
    /// Static documentation for a class of code actions.
    ///
    /// Documentation from the provider should be shown in the code actions menu if either:
    ///
    /// - Code actions of `kind` are requested by the editor. In this case, the editor will show the documentation that
    ///   most closely matches the requested code action kind. For example, if a provider has documentation for
    ///   both `Refactor` and `RefactorExtract`, when the user requests code actions for `RefactorExtract`,
    ///   the editor will use the documentation for `RefactorExtract` instead of the documentation for `Refactor`.
    ///
    /// - Any code actions of `kind` are returned by the provider.
    ///
    /// At most one documentation entry should be shown per provider.
    ///
    /// @since 3.18.0
    /// @proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub documentation: Option<Vec<CodeActionKindDocumentation>>,
    /// The server provides support to resolve additional
    /// information for a code action.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resolve_provider: Option<bool>,
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Location with only uri and does not include range.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct LocationUriOnly {
    pub uri: Uri,
}

/// Server capabilities for a [WorkspaceSymbolRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub resolve_provider: Option<bool>,
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Code Lens provider options of a [CodeLensRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct CodeLensOptions {
    /// Code lens has a resolve provider as well.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resolve_provider: Option<bool>,
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Provider options for a [DocumentLinkRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DocumentLinkOptions {
    /// Document links have a resolve provider as well.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resolve_provider: Option<bool>,
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Value-object describing what options formatting should use.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct FormattingOptions {
    /// Size of a tab in spaces.
    pub tab_size: u32,
    /// Prefer spaces over tabs.
    pub insert_spaces: bool,
    /// Trim trailing whitespace on a line.
    ///
    /// @since 3.15.0
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    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")]
    pub trim_final_newlines: Option<bool>,
}

/// Provider options for a [DocumentFormattingRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DocumentFormattingOptions {
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

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

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

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

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct PrepareRenamePlaceholder {
    pub range: Range,
    pub placeholder: String,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct PrepareRenameDefaultBehavior {
    pub default_behavior: bool,
}

/// The server capabilities of a [ExecuteCommandRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ExecuteCommandOptions {
    /// The commands to be executed on the server
    pub commands: Vec<String>,
    #[serde(flatten)]
    pub work_done_progress_options: WorkDoneProgressOptions,
}

/// Additional data about a workspace edit.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceEditMetadata {
    /// Signal to the editor that this edit is a refactoring.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_refactoring: Option<bool>,
}

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

/// Semantic tokens options to support deltas for full documents
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct SemanticTokensFullDelta {
    /// The server supports deltas for full documents.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delta: Option<bool>,
}

/// A text document identifier to optionally denote a specific version of a text document.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct AnnotatedTextEdit {
    /// The actual identifier of the change annotation
    pub annotation_id: ChangeAnnotationIdentifier,
    #[serde(flatten)]
    pub text_edit: TextEdit,
}

/// An interactive text edit.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct SnippetTextEdit {
    /// The range of the text document to be manipulated.
    pub range: Range,
    /// The snippet to be inserted.
    pub snippet: StringValue,
    /// The actual identifier of the snippet edit.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotation_id: Option<ChangeAnnotationIdentifier>,
}

/// A generic resource operation.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub annotation_id: Option<ChangeAnnotationIdentifier>,
}

/// Options to create a file.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub ignore_if_exists: Option<bool>,
}

/// Rename file options
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub ignore_if_exists: Option<bool>,
}

/// Delete file options
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct FileOperationPattern {
    /// The glob pattern to match. Glob patterns can have the following syntax:
    /// - `*` to match one or more characters in a path segment
    /// - `?` to match on one character in a path segment
    /// - `**` to match any number of path segments, including none
    /// - `{}` to group sub patterns into an OR expression. (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
    /// - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
    /// - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
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")]
    pub execution_summary: Option<ExecutionSummary>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct NotebookDocumentFilterWithNotebook {
    /// The notebook to be synced If a string
    /// value is provided it matches against the
    /// notebook type. '*' matches every notebook.
    pub notebook: Notebook,
    /// The cells of the matching notebook to be synced.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cells: Option<Vec<NotebookCellLanguage>>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct NotebookDocumentFilterWithCells {
    /// The notebook to be synced If a string
    /// value is provided it matches against the
    /// notebook type. '*' matches every notebook.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook: Option<Notebook>,
    /// The cells of the matching notebook to be synced.
    pub cells: Vec<NotebookCellLanguage>,
}

/// Cell changes to a notebook document.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct NotebookDocumentCellChanges {
    /// Changes to the cell structure to add or
    /// remove cells.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub structure: Option<NotebookDocumentCellChangeStructure>,
    /// 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")]
    pub text_content: Option<Vec<NotebookDocumentCellContentChanges>>,
}

/// Describes the currently selected completion item.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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,
}

/// Information about the client
///
/// @since 3.15.0
/// @since 3.18.0 ClientInfo type name added.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientInfo {
    /// 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>,
}

/// Defines the capabilities provided by the client.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub text_document: Option<TextDocumentClientCapabilities>,
    /// Capabilities specific to the notebook document support.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    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<LspAny>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    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")]
    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")]
    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<Save>,
}

/// Defines workspace specific capabilities of the server.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceOptions {
    /// The server supports workspace folder.
    ///
    /// @since 3.6.0
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub file_operations: Option<FileOperationOptions>,
    /// The server supports the `workspace/textDocumentContent` request.
    ///
    /// @since 3.18.0
    /// @proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub text_document_content: Option<TextDocumentContent>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentContentChangePartial {
    /// The range of the document that changed.
    pub range: Range,
    /// The optional length of the range that got replaced.
    ///
    /// @deprecated use range instead.
    #[deprecated(note = "use range instead.")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub range_length: Option<u32>,
    /// The new text for the provided range.
    pub text: String,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentContentChangeWholeDocument {
    /// The new text of the whole document.
    pub text: String,
}

/// Structure to capture a description for an error code.
///
/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct DiagnosticRelatedInformation {
    /// The location of this related diagnostic information.
    pub location: Location,
    /// The message of this related diagnostic information.
    pub message: String,
}

/// Edit range variant that includes ranges for insert and replace operations.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct EditRangeWithInsertReplace {
    pub insert: Range,
    pub replace: Range,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ServerCompletionItemOptions {
    /// 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")]
    pub label_details_support: Option<bool>,
}

/// @since 3.18.0
/// @deprecated use MarkupContent instead.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
#[deprecated(note = "use MarkupContent instead.")]
pub struct MarkedStringWithLanguage {
    pub language: String,
    pub value: String,
}

/// Represents a parameter of a callable-signature. A parameter can
/// have a label and a doc-comment.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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.
    ///
    /// To avoid ambiguities a server should use the [start, end] offset value instead of using
    /// a substring. Whether a client support this is controlled via `labelOffsetSupport` client
    /// capability.
    ///
    /// *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: ParameterInformationLabel,
    /// 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<Documentation>,
}

/// Documentation for a class of code actions.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq)]
#[serde(rename_all = "camelCase")]
pub struct CodeActionKindDocumentation {
    /// The kind of the code action being documented.
    ///
    /// If the kind is generic, such as `CodeActionKind.Refactor`, the documentation will be shown whenever any
    /// refactorings are returned. If the kind if more specific, such as `CodeActionKind.RefactorExtract`, the
    /// documentation will only be shown when extract refactoring code actions are returned.
    pub kind: CodeActionKind,
    /// Command that is ued to display the documentation to the user.
    ///
    /// The title of this documentation code action is taken from [`Command::title`]
    pub command: Command,
}

/// A notebook cell text document filter denotes a cell text
/// document by different properties.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
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: Notebook,
    /// 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct FileOperationPatternOptions {
    /// The pattern should be matched ignoring casing.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ignore_case: Option<bool>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ExecutionSummary {
    /// A strict monotonically increasing value
    /// indicating the execution order of a cell
    /// inside a notebook.
    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>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct NotebookCellLanguage {
    pub language: String,
}

/// Structural changes to cells in a notebook document.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct NotebookDocumentCellChangeStructure {
    /// The change to the cell array.
    pub array: NotebookCellArrayChange,
    /// Additional opened cell text documents.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did_open: Option<Vec<TextDocumentItem>>,
    /// Additional closed cell text documents.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did_close: Option<Vec<TextDocumentIdentifier>>,
}

/// Content changes to a cell in a notebook document.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct NotebookDocumentCellContentChanges {
    pub document: VersionedTextDocumentIdentifier,
    pub changes: Vec<TextDocumentContentChangeEvent>,
}

/// Workspace specific client capabilities.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub apply_edit: Option<bool>,
    /// Capabilities specific to `WorkspaceEdit`s.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub workspace_edit: Option<WorkspaceEditClientCapabilities>,
    /// Capabilities specific to the `workspace/didChangeConfiguration` notification.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did_change_configuration: Option<DidChangeConfigurationClientCapabilities>,
    /// Capabilities specific to the `workspace/didChangeWatchedFiles` notification.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub execute_command: Option<ExecuteCommandClientCapabilities>,
    /// The client has support for workspace folders.
    ///
    /// @since 3.6.0
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    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")]
    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")]
    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")]
    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")]
    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")]
    pub folding_range: Option<FoldingRangeWorkspaceClientCapabilities>,
    /// Capabilities specific to the `workspace/textDocumentContent` request.
    ///
    /// @since 3.18.0
    /// @proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub text_document_content: Option<TextDocumentContentClientCapabilities>,
}

/// Text document specific client capabilities.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentClientCapabilities {
    /// Defines which synchronization capabilities the client supports.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub synchronization: Option<TextDocumentSyncClientCapabilities>,
    /// Defines which filters the client supports.
    ///
    /// @since 3.18.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filters: Option<TextDocumentFilterClientCapabilities>,
    /// 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")]
    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")]
    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")]
    pub document_highlight: Option<DocumentHighlightClientCapabilities>,
    /// Capabilities specific to the `textDocument/documentSymbol` request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub document_symbol: Option<DocumentSymbolClientCapabilities>,
    /// Capabilities specific to the `textDocument/codeAction` request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub code_action: Option<CodeActionClientCapabilities>,
    /// Capabilities specific to the `textDocument/codeLens` request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub code_lens: Option<CodeLensClientCapabilities>,
    /// Capabilities specific to the `textDocument/documentLink` request.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    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")]
    pub range_formatting: Option<DocumentRangeFormattingClientCapabilities>,
    /// Capabilities specific to the `textDocument/onTypeFormatting` request.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub folding_range: Option<FoldingRangeClientCapabilities>,
    /// Capabilities specific to the `textDocument/selectionRange` request.
    ///
    /// @since 3.15.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub selection_range: Option<SelectionRangeClientCapabilities>,
    /// Capabilities specific to the `textDocument/publishDiagnostics` notification.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publish_diagnostics: Option<PublishDiagnosticsClientCapabilities>,
    /// Capabilities specific to the various call hierarchy requests.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub call_hierarchy: Option<CallHierarchyClientCapabilities>,
    /// Capabilities specific to the various semantic token request.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub semantic_tokens: Option<SemanticTokensClientCapabilities>,
    /// Capabilities specific to the `textDocument/linkedEditingRange` request.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub type_hierarchy: Option<TypeHierarchyClientCapabilities>,
    /// Capabilities specific to the `textDocument/inlineValue` request.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub inline_value: Option<InlineValueClientCapabilities>,
    /// Capabilities specific to the `textDocument/inlayHint` request.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub inline_completion: Option<InlineCompletionClientCapabilities>,
}

/// Capabilities specific to the notebook document support.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct NotebookDocumentClientCapabilities {
    /// Capabilities specific to notebook document synchronization
    ///
    /// @since 3.17.0
    pub synchronization: NotebookDocumentSyncClientCapabilities,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub work_done_progress: Option<bool>,
    /// Capabilities specific to the showMessage request.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub show_message: Option<ShowMessageRequestClientCapabilities>,
    /// Capabilities specific to the showDocument request.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub show_document: Option<ShowDocumentClientCapabilities>,
}

/// General client capabilities.
///
/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub stale_request_support: Option<StaleRequestSupportOptions>,
    /// Client capabilities specific to regular expressions.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub position_encodings: Option<Vec<PositionEncodingKind>>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub change_notifications: Option<ChangeNotifications>,
}

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

/// 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct RelativePattern {
    /// A workspace folder or a base URI to which this pattern will be matched
    /// against relatively.
    pub base_uri: BaseUri,
    /// The actual glob pattern;
    pub pattern: Pattern,
}

/// A document filter where `language` is required field.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentFilterLanguage {
    /// A language id, like `typescript`.
    pub language: String,
    /// A Uri [scheme][`Uri::scheme`], like `file` or `untitled`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
    /// A glob pattern, like **/*.{ts,js}. See TextDocumentFilter for examples.
    ///
    /// @since 3.18.0 - support for relative patterns. Whether clients support
    /// relative patterns depends on the client capability
    /// `textDocuments.filters.relativePatternSupport`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pattern: Option<GlobPattern>,
}

/// A document filter where `scheme` is required field.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentFilterScheme {
    /// A language id, like `typescript`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// A Uri [scheme][`Uri::scheme`], like `file` or `untitled`.
    pub scheme: String,
    /// A glob pattern, like **/*.{ts,js}. See TextDocumentFilter for examples.
    ///
    /// @since 3.18.0 - support for relative patterns. Whether clients support
    /// relative patterns depends on the client capability
    /// `textDocuments.filters.relativePatternSupport`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pattern: Option<GlobPattern>,
}

/// A document filter where `pattern` is required field.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentFilterPattern {
    /// A language id, like `typescript`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// A Uri [scheme][`Uri::scheme`], like `file` or `untitled`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
    /// A glob pattern, like **/*.{ts,js}. See TextDocumentFilter for examples.
    ///
    /// @since 3.18.0 - support for relative patterns. Whether clients support
    /// relative patterns depends on the client capability
    /// `textDocuments.filters.relativePatternSupport`.
    pub pattern: GlobPattern,
}

/// A notebook document filter where `notebookType` is required field.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct NotebookDocumentFilterNotebookType {
    /// The type of the enclosing notebook.
    pub notebook_type: String,
    /// A Uri [scheme][`Uri::scheme`], like `file` or `untitled`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
    /// A glob pattern.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pattern: Option<GlobPattern>,
}

/// A notebook document filter where `scheme` is required field.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct NotebookDocumentFilterScheme {
    /// The type of the enclosing notebook.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_type: Option<String>,
    /// A Uri [scheme][`Uri::scheme`], like `file` or `untitled`.
    pub scheme: String,
    /// A glob pattern.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pattern: Option<GlobPattern>,
}

/// A notebook document filter where `pattern` is required field.
///
/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash)]
#[serde(rename_all = "camelCase")]
pub struct NotebookDocumentFilterPattern {
    /// The type of the enclosing notebook.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notebook_type: Option<String>,
    /// A Uri [scheme][`Uri::scheme`], like `file` or `untitled`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scheme: Option<String>,
    /// A glob pattern.
    pub pattern: GlobPattern,
}

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceEditClientCapabilities {
    /// The client supports versioned document changes in `WorkspaceEdit`s
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    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")]
    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")]
    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")]
    pub change_annotation_support: Option<ChangeAnnotationsSupportOptions>,
    /// Whether the client supports `WorkspaceEditMetadata` in `WorkspaceEdit`s.
    ///
    /// @since 3.18.0
    /// @proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata_support: Option<bool>,
    /// Whether the client supports snippets as text edits.
    ///
    /// @since 3.18.0
    /// @proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub snippet_edit_support: Option<bool>,
}

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub dynamic_registration: Option<bool>,
    /// Whether the client has support for [relative pattern][RelativePattern]
    /// or not.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub relative_pattern_support: Option<bool>,
}

/// Client capabilities for a [WorkspaceSymbolRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceSymbolClientCapabilities {
    /// Symbol request supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
    /// Specific capabilities for the `SymbolKind` in the `workspace/symbol` request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol_kind: Option<ClientSymbolKindOptions>,
    /// 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")]
    pub tag_support: Option<ClientSymbolTagOptions>,
    /// 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")]
    pub resolve_support: Option<ClientSymbolResolveOptions>,
}

/// The client capabilities of a [ExecuteCommandRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ExecuteCommandClientCapabilities {
    /// Execute command supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
}

/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub refresh_support: Option<bool>,
}

/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct FileOperationClientCapabilities {
    /// Whether the client supports dynamic registration for file requests/notifications.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
    /// The client has support for sending didCreateFiles notifications.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did_create: Option<bool>,
    /// The client has support for sending willCreateFiles requests.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub will_create: Option<bool>,
    /// The client has support for sending didRenameFiles notifications.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did_rename: Option<bool>,
    /// The client has support for sending willRenameFiles requests.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub will_rename: Option<bool>,
    /// The client has support for sending didDeleteFiles notifications.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did_delete: Option<bool>,
    /// The client has support for sending willDeleteFiles requests.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub will_delete: Option<bool>,
}

/// Client workspace capabilities specific to inline values.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub refresh_support: Option<bool>,
}

/// Client workspace capabilities specific to inlay hints.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub refresh_support: Option<bool>,
}

/// Workspace client capabilities specific to diagnostic pull requests.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub refresh_support: Option<bool>,
}

/// Client workspace capabilities specific to folding ranges
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub refresh_support: Option<bool>,
}

/// Client capabilities for a text document content provider.
///
/// @since 3.18.0
/// @proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentContentClientCapabilities {
    /// Text document content provider supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
}

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct TextDocumentFilterClientCapabilities {
    /// The client supports Relative Patterns.
    ///
    /// @since 3.18.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub relative_pattern_support: Option<bool>,
}

/// Completion client capabilities
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct CompletionClientCapabilities {
    /// Whether completion supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
    /// The client supports the following `CompletionItem` specific
    /// capabilities.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub completion_item: Option<ClientCompletionItemOptions>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub completion_item_kind: Option<ClientCompletionItemOptionsKind>,
    /// 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")]
    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")]
    pub context_support: Option<bool>,
    /// The client supports the following `CompletionList` specific
    /// capabilities.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub completion_list: Option<CompletionListCapabilities>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct HoverClientCapabilities {
    /// Whether hover supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub content_format: Option<Vec<MarkupKind>>,
}

/// Client Capabilities for a [SignatureHelpRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct SignatureHelpClientCapabilities {
    /// Whether signature help supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
    /// The client supports the following `SignatureInformation`
    /// specific properties.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature_information: Option<ClientSignatureInformationOptions>,
    /// 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")]
    pub context_support: Option<bool>,
}

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

/// Client Capabilities for a [DefinitionRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DefinitionClientCapabilities {
    /// Whether definition supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub link_support: Option<bool>,
}

/// Since 3.6.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    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")]
    pub link_support: Option<bool>,
}

/// @since 3.6.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    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")]
    pub link_support: Option<bool>,
}

/// Client Capabilities for a [ReferencesRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ReferenceClientCapabilities {
    /// Whether references supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
}

/// Client Capabilities for a [DocumentHighlightRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DocumentHighlightClientCapabilities {
    /// Whether document highlight supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
}

/// Client Capabilities for a [DocumentSymbolRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct DocumentSymbolClientCapabilities {
    /// Whether document symbol supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
    /// Specific capabilities for the `SymbolKind` in the
    /// `textDocument/documentSymbol` request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol_kind: Option<ClientSymbolKindOptions>,
    /// The client supports hierarchical document symbols.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub tag_support: Option<ClientSymbolTagOptions>,
    /// 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")]
    pub label_support: Option<bool>,
}

/// The Client Capabilities of a [CodeActionRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct CodeActionClientCapabilities {
    /// Whether code action supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub code_action_literal_support: Option<ClientCodeActionLiteralOptions>,
    /// Whether code action supports the `isPreferred` property.
    ///
    /// @since 3.15.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_preferred_support: Option<bool>,
    /// Whether code action supports the `disabled` property.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    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")]
    pub resolve_support: Option<ClientCodeActionResolveOptions>,
    /// 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")]
    pub honors_change_annotations: Option<bool>,
    /// Whether the client supports documentation for a class of
    /// code actions.
    ///
    /// @since 3.18.0
    /// @proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub documentation_support: Option<bool>,
    /// Client supports the tag property on a code action. Clients
    /// supporting tags have to handle unknown tags gracefully.
    ///
    /// @since 3.18.0 - proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tag_support: Option<CodeActionTagOptions>,
}

/// The client capabilities  of a [CodeLensRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct CodeLensClientCapabilities {
    /// Whether code lens supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
    /// Whether the client supports resolving additional code lens
    /// properties via a separate `codeLens/resolve` request.
    ///
    /// @since 3.18.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub resolve_support: Option<ClientCodeLensResolveOptions>,
}

/// The client capabilities of a [DocumentLinkRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DocumentLinkClientCapabilities {
    /// Whether document link supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub tooltip_support: Option<bool>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub dynamic_registration: Option<bool>,
}

/// Client capabilities of a [DocumentFormattingRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DocumentFormattingClientCapabilities {
    /// Whether formatting supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
}

/// Client capabilities of a [DocumentRangeFormattingRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DocumentRangeFormattingClientCapabilities {
    /// Whether range formatting supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub ranges_support: Option<bool>,
}

/// Client capabilities of a [DocumentOnTypeFormattingRequest].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct DocumentOnTypeFormattingClientCapabilities {
    /// Whether on type formatting supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dynamic_registration: Option<bool>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct RenameClientCapabilities {
    /// Whether rename supports dynamic registration.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    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")]
    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")]
    pub honors_change_annotations: Option<bool>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    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")]
    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")]
    pub line_folding_only: Option<bool>,
    /// Specific options for the folding range kind.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folding_range_kind: Option<ClientFoldingRangeKindOptions>,
    /// Specific options for the folding range.
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folding_range: Option<ClientFoldingRangeOptions>,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub dynamic_registration: Option<bool>,
}

/// The publish diagnostic client capabilities.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct PublishDiagnosticsClientCapabilities {
    /// 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")]
    pub version_support: Option<bool>,
    #[serde(flatten)]
    pub diagnostics_capabilities: DiagnosticsCapabilities,
}

/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub dynamic_registration: Option<bool>,
}

/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
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")]
    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: ClientSemanticTokensRequestOptions,
    /// The token types that the client supports.
    pub token_types: Vec<String>,
    /// The token modifiers that the client supports.
    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")]
    pub overlapping_token_support: Option<bool>,
    /// Whether the client supports tokens that can span multiple lines.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    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")]
    pub augments_syntax_tokens: Option<bool>,
}

/// Client capabilities for the linked editing range request.
///
/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub dynamic_registration: Option<bool>,
}

/// Client capabilities specific to the moniker request.
///
/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub dynamic_registration: Option<bool>,
}

/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
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")]
    pub dynamic_registration: Option<bool>,
}

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

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

/// Client capabilities specific to diagnostic pull requests.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub dynamic_registration: Option<bool>,
    /// Whether the clients supports related documents for document diagnostic pulls.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub related_document_support: Option<bool>,
    #[serde(flatten)]
    pub diagnostics_capabilities: DiagnosticsCapabilities,
}

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

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

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

/// Client capabilities for the showDocument request.
///
/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ShowDocumentClientCapabilities {
    /// The client has support for the showDocument
    /// request.
    pub support: bool,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct StaleRequestSupportOptions {
    /// 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`
    pub retry_on_content_modified: Vec<String>,
}

/// Client capabilities specific to regular expressions.
///
/// @since 3.16.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct RegularExpressionsClientCapabilities {
    /// The engine's name.
    pub engine: RegularExpressionEngineKind,
    /// 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(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub allowed_tags: Option<Vec<String>>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ChangeAnnotationsSupportOptions {
    /// 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")]
    pub groups_on_label: Option<bool>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientSymbolKindOptions {
    /// 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")]
    pub value_set: Option<Vec<SymbolKind>>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientSymbolTagOptions {
    /// The tags supported by the client.
    pub value_set: Vec<SymbolTag>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientSymbolResolveOptions {
    /// The properties that a client can resolve lazily. Usually
    /// `location.range`
    pub properties: Vec<String>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientCompletionItemOptions {
    /// 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")]
    pub snippet_support: Option<bool>,
    /// Client supports commit characters on a completion item.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub documentation_format: Option<Vec<MarkupKind>>,
    /// Client supports the deprecated property on a completion item.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deprecated_support: Option<bool>,
    /// Client supports the preselect property on a completion item.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub tag_support: Option<CompletionItemTagOptions>,
    /// 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")]
    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")]
    pub resolve_support: Option<ClientCompletionItemResolveOptions>,
    /// 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")]
    pub insert_text_mode_support: Option<ClientCompletionItemInsertTextModeOptions>,
    /// The client has support for completion item label
    /// details (see also `CompletionItemLabelDetails`).
    ///
    /// @since 3.17.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub label_details_support: Option<bool>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientCompletionItemOptionsKind {
    /// 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")]
    pub value_set: Option<Vec<CompletionItemKind>>,
}

/// The client supports the following `CompletionList` specific
/// capabilities.
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
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")]
    pub item_defaults: Option<Vec<String>>,
    /// Specifies whether the client supports `CompletionList.applyKind` to
    /// indicate how supported values from `completionList.itemDefaults`
    /// and `completion` will be combined.
    ///
    /// If a client supports `applyKind` it must support it for all fields
    /// that it supports that are listed in `CompletionList.applyKind`. This
    /// means when clients add support for new/future fields in completion
    /// items the MUST also support merge for them if those fields are
    /// defined in `CompletionList.applyKind`.
    ///
    /// @since 3.18.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub apply_kind_support: Option<bool>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientSignatureInformationOptions {
    /// 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")]
    pub documentation_format: Option<Vec<MarkupKind>>,
    /// Client capabilities specific to parameter information.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub parameter_information: Option<ClientSignatureParameterInformationOptions>,
    /// The client supports the `activeParameter` property on `SignatureInformation`
    /// literal.
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub active_parameter_support: Option<bool>,
    /// The client supports the `activeParameter` property on
    /// `SignatureHelp`/`SignatureInformation` being set to `null` to
    /// indicate that no parameter should be active.
    ///
    /// @since 3.18.0
    /// @proposed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub no_active_parameter_support: Option<bool>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientCodeActionLiteralOptions {
    /// The code action kind is support with the following value
    /// set.
    pub code_action_kind: ClientCodeActionKindOptions,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientCodeActionResolveOptions {
    /// The properties that a client can resolve lazily.
    pub properties: Vec<String>,
}

/// @since 3.18.0 - proposed
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct CodeActionTagOptions {
    /// The tags supported by the client.
    pub value_set: Vec<CodeActionTag>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientCodeLensResolveOptions {
    /// The properties that a client can resolve lazily.
    pub properties: Vec<String>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientFoldingRangeKindOptions {
    /// 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")]
    pub value_set: Option<Vec<FoldingRangeKind>>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ClientFoldingRangeOptions {
    /// 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")]
    pub collapsed_text: Option<bool>,
}

/// General diagnostics capabilities for pull and push model.
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct DiagnosticsCapabilities {
    /// Whether the clients accepts diagnostics with related information.
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub tag_support: Option<ClientDiagnosticsTagOptions>,
    /// Client supports a codeDescription property
    ///
    /// @since 3.16.0
    #[serde(skip_serializing_if = "Option::is_none")]
    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")]
    pub data_support: Option<bool>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientSemanticTokensRequestOptions {
    /// 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<ClientSemanticTokensRequestOptionsRange>,
    /// 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<ClientSemanticTokensRequestOptionsFull>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientInlayHintResolveOptions {
    /// The properties that a client can resolve lazily.
    pub properties: Vec<String>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ClientShowMessageActionItemOptions {
    /// 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")]
    pub additional_properties_support: Option<bool>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct CompletionItemTagOptions {
    /// The tags supported by the client.
    pub value_set: Vec<CompletionItemTag>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientCompletionItemResolveOptions {
    /// The properties that a client can resolve lazily.
    pub properties: Vec<String>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientCompletionItemInsertTextModeOptions {
    pub value_set: Vec<InsertTextMode>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ClientSignatureParameterInformationOptions {
    /// The client supports processing label offsets instead of a
    /// simple label string.
    ///
    /// @since 3.14.0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub label_offset_support: Option<bool>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientCodeActionKindOptions {
    /// 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.
    pub value_set: Vec<CodeActionKind>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default)]
#[serde(rename_all = "camelCase")]
pub struct ClientDiagnosticsTagOptions {
    /// The tags supported by the client.
    pub value_set: Vec<DiagnosticTag>,
}

/// @since 3.18.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, Eq, Hash, Default, Copy)]
#[serde(rename_all = "camelCase")]
pub struct ClientSemanticTokensRequestFullDelta {
    /// 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>,
}

/// 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(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize)]
#[serde(into = "String", from = "String")]
pub enum SemanticTokenTypes {
    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,
    /// @since 3.18.0
    Label,
    /// A custom value.
    #[serde(untagged)]
    Custom(String),
}
impl From<SemanticTokenTypes> for String {
    fn from(e: SemanticTokenTypes) -> Self {
        match e {
            SemanticTokenTypes::Namespace => "namespace".to_string(),
            SemanticTokenTypes::Type => "type".to_string(),
            SemanticTokenTypes::Class => "class".to_string(),
            SemanticTokenTypes::Enum => "enum".to_string(),
            SemanticTokenTypes::Interface => "interface".to_string(),
            SemanticTokenTypes::Struct => "struct".to_string(),
            SemanticTokenTypes::TypeParameter => "typeParameter".to_string(),
            SemanticTokenTypes::Parameter => "parameter".to_string(),
            SemanticTokenTypes::Variable => "variable".to_string(),
            SemanticTokenTypes::Property => "property".to_string(),
            SemanticTokenTypes::EnumMember => "enumMember".to_string(),
            SemanticTokenTypes::Event => "event".to_string(),
            SemanticTokenTypes::Function => "function".to_string(),
            SemanticTokenTypes::Method => "method".to_string(),
            SemanticTokenTypes::Macro => "macro".to_string(),
            SemanticTokenTypes::Keyword => "keyword".to_string(),
            SemanticTokenTypes::Modifier => "modifier".to_string(),
            SemanticTokenTypes::Comment => "comment".to_string(),
            SemanticTokenTypes::String => "string".to_string(),
            SemanticTokenTypes::Number => "number".to_string(),
            SemanticTokenTypes::Regexp => "regexp".to_string(),
            SemanticTokenTypes::Operator => "operator".to_string(),
            SemanticTokenTypes::Decorator => "decorator".to_string(),
            SemanticTokenTypes::Label => "label".to_string(),
            SemanticTokenTypes::Custom(any) => any,
        }
    }
}
impl From<String> for SemanticTokenTypes {
    fn from(v: String) -> Self {
        match v.as_str() {
            "namespace" => SemanticTokenTypes::Namespace,
            "type" => SemanticTokenTypes::Type,
            "class" => SemanticTokenTypes::Class,
            "enum" => SemanticTokenTypes::Enum,
            "interface" => SemanticTokenTypes::Interface,
            "struct" => SemanticTokenTypes::Struct,
            "typeParameter" => SemanticTokenTypes::TypeParameter,
            "parameter" => SemanticTokenTypes::Parameter,
            "variable" => SemanticTokenTypes::Variable,
            "property" => SemanticTokenTypes::Property,
            "enumMember" => SemanticTokenTypes::EnumMember,
            "event" => SemanticTokenTypes::Event,
            "function" => SemanticTokenTypes::Function,
            "method" => SemanticTokenTypes::Method,
            "macro" => SemanticTokenTypes::Macro,
            "keyword" => SemanticTokenTypes::Keyword,
            "modifier" => SemanticTokenTypes::Modifier,
            "comment" => SemanticTokenTypes::Comment,
            "string" => SemanticTokenTypes::String,
            "number" => SemanticTokenTypes::Number,
            "regexp" => SemanticTokenTypes::Regexp,
            "operator" => SemanticTokenTypes::Operator,
            "decorator" => SemanticTokenTypes::Decorator,
            "label" => SemanticTokenTypes::Label,
            _ => SemanticTokenTypes::Custom(v),
        }
    }
}
impl fmt::Display for SemanticTokenTypes {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = self.clone().into();
        write!(f, "{s}")
    }
}

/// 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(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize)]
#[serde(into = "String", from = "String")]
pub enum SemanticTokenModifiers {
    Declaration,
    Definition,
    Readonly,
    Static,
    Deprecated,
    Abstract,
    Async,
    Modification,
    Documentation,
    DefaultLibrary,
    /// A custom value.
    #[serde(untagged)]
    Custom(String),
}
impl From<SemanticTokenModifiers> for String {
    fn from(e: SemanticTokenModifiers) -> Self {
        match e {
            SemanticTokenModifiers::Declaration => "declaration".to_string(),
            SemanticTokenModifiers::Definition => "definition".to_string(),
            SemanticTokenModifiers::Readonly => "readonly".to_string(),
            SemanticTokenModifiers::Static => "static".to_string(),
            SemanticTokenModifiers::Deprecated => "deprecated".to_string(),
            SemanticTokenModifiers::Abstract => "abstract".to_string(),
            SemanticTokenModifiers::Async => "async".to_string(),
            SemanticTokenModifiers::Modification => "modification".to_string(),
            SemanticTokenModifiers::Documentation => "documentation".to_string(),
            SemanticTokenModifiers::DefaultLibrary => "defaultLibrary".to_string(),
            SemanticTokenModifiers::Custom(any) => any,
        }
    }
}
impl From<String> for SemanticTokenModifiers {
    fn from(v: String) -> Self {
        match v.as_str() {
            "declaration" => SemanticTokenModifiers::Declaration,
            "definition" => SemanticTokenModifiers::Definition,
            "readonly" => SemanticTokenModifiers::Readonly,
            "static" => SemanticTokenModifiers::Static,
            "deprecated" => SemanticTokenModifiers::Deprecated,
            "abstract" => SemanticTokenModifiers::Abstract,
            "async" => SemanticTokenModifiers::Async,
            "modification" => SemanticTokenModifiers::Modification,
            "documentation" => SemanticTokenModifiers::Documentation,
            "defaultLibrary" => SemanticTokenModifiers::DefaultLibrary,
            _ => SemanticTokenModifiers::Custom(v),
        }
    }
}
impl fmt::Display for SemanticTokenModifiers {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = self.clone().into();
        write!(f, "{s}")
    }
}

/// The document diagnostic report kinds.
///
/// @since 3.17.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "String", try_from = "String")]
pub enum DocumentDiagnosticReportKind {
    /// A diagnostic report with a full
    /// set of problems.
    Full,
    /// A report indicating that the last
    /// returned report is still accurate.
    Unchanged,
}
impl From<DocumentDiagnosticReportKind> for String {
    fn from(e: DocumentDiagnosticReportKind) -> Self {
        match e {
            DocumentDiagnosticReportKind::Full => "full".to_string(),
            DocumentDiagnosticReportKind::Unchanged => "unchanged".to_string(),
        }
    }
}
impl TryFrom<String> for DocumentDiagnosticReportKind {
    type Error = String;
    fn try_from(v: String) -> Result<Self, <Self as TryFrom<String>>::Error> {
        match v.as_str() {
            "full" => Ok(DocumentDiagnosticReportKind::Full),
            "unchanged" => Ok(DocumentDiagnosticReportKind::Unchanged),
            _ => Err(format!("Invalid DocumentDiagnosticReportKind: {v}")),
        }
    }
}
impl fmt::Display for DocumentDiagnosticReportKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = (*self).into();
        write!(f, "{s}")
    }
}

/// Predefined error codes.
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "i32", from = "i32")]
pub enum ErrorCodes {
    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,
    /// A custom value.
    #[serde(untagged)]
    Custom(i32),
}
impl From<ErrorCodes> for i32 {
    fn from(e: ErrorCodes) -> Self {
        match e {
            ErrorCodes::ParseError => -32700i32,
            ErrorCodes::InvalidRequest => -32600i32,
            ErrorCodes::MethodNotFound => -32601i32,
            ErrorCodes::InvalidParams => -32602i32,
            ErrorCodes::InternalError => -32603i32,
            ErrorCodes::ServerNotInitialized => -32002i32,
            ErrorCodes::UnknownErrorCode => -32001i32,
            ErrorCodes::Custom(any) => any,
        }
    }
}
impl From<i32> for ErrorCodes {
    fn from(v: i32) -> Self {
        match v {
            -32700i32 => ErrorCodes::ParseError,
            -32600i32 => ErrorCodes::InvalidRequest,
            -32601i32 => ErrorCodes::MethodNotFound,
            -32602i32 => ErrorCodes::InvalidParams,
            -32603i32 => ErrorCodes::InternalError,
            -32002i32 => ErrorCodes::ServerNotInitialized,
            -32001i32 => ErrorCodes::UnknownErrorCode,
            _ => ErrorCodes::Custom(v),
        }
    }
}

#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "i32", from = "i32")]
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
    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,
    /// A custom value.
    #[serde(untagged)]
    Custom(i32),
}
impl From<LspErrorCodes> for i32 {
    fn from(e: LspErrorCodes) -> Self {
        match e {
            LspErrorCodes::RequestFailed => -32803i32,
            LspErrorCodes::ServerCancelled => -32802i32,
            LspErrorCodes::ContentModified => -32801i32,
            LspErrorCodes::RequestCancelled => -32800i32,
            LspErrorCodes::Custom(any) => any,
        }
    }
}
impl From<i32> for LspErrorCodes {
    fn from(v: i32) -> Self {
        match v {
            -32803i32 => LspErrorCodes::RequestFailed,
            -32802i32 => LspErrorCodes::ServerCancelled,
            -32801i32 => LspErrorCodes::ContentModified,
            -32800i32 => LspErrorCodes::RequestCancelled,
            _ => LspErrorCodes::Custom(v),
        }
    }
}

/// A set of predefined range kinds.
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize)]
#[serde(into = "String", from = "String")]
pub enum FoldingRangeKind {
    /// Folding range for a comment
    Comment,
    /// Folding range for an import or include
    Imports,
    /// Folding range for a region (e.g. `#region`)
    Region,
    /// A custom value.
    #[serde(untagged)]
    Custom(String),
}
impl From<FoldingRangeKind> for String {
    fn from(e: FoldingRangeKind) -> Self {
        match e {
            FoldingRangeKind::Comment => "comment".to_string(),
            FoldingRangeKind::Imports => "imports".to_string(),
            FoldingRangeKind::Region => "region".to_string(),
            FoldingRangeKind::Custom(any) => any,
        }
    }
}
impl From<String> for FoldingRangeKind {
    fn from(v: String) -> Self {
        match v.as_str() {
            "comment" => FoldingRangeKind::Comment,
            "imports" => FoldingRangeKind::Imports,
            "region" => FoldingRangeKind::Region,
            _ => FoldingRangeKind::Custom(v),
        }
    }
}
impl fmt::Display for FoldingRangeKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = self.clone().into();
        write!(f, "{s}")
    }
}

/// A symbol kind.
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum SymbolKind {
    File,
    Module,
    Namespace,
    Package,
    Class,
    Method,
    Property,
    Field,
    Constructor,
    Enum,
    Interface,
    Function,
    Variable,
    Constant,
    String,
    Number,
    Boolean,
    Array,
    Object,
    Key,
    Null,
    EnumMember,
    Struct,
    Event,
    Operator,
    TypeParameter,
}
impl From<SymbolKind> for u32 {
    fn from(e: SymbolKind) -> Self {
        match e {
            SymbolKind::File => 1u32,
            SymbolKind::Module => 2u32,
            SymbolKind::Namespace => 3u32,
            SymbolKind::Package => 4u32,
            SymbolKind::Class => 5u32,
            SymbolKind::Method => 6u32,
            SymbolKind::Property => 7u32,
            SymbolKind::Field => 8u32,
            SymbolKind::Constructor => 9u32,
            SymbolKind::Enum => 10u32,
            SymbolKind::Interface => 11u32,
            SymbolKind::Function => 12u32,
            SymbolKind::Variable => 13u32,
            SymbolKind::Constant => 14u32,
            SymbolKind::String => 15u32,
            SymbolKind::Number => 16u32,
            SymbolKind::Boolean => 17u32,
            SymbolKind::Array => 18u32,
            SymbolKind::Object => 19u32,
            SymbolKind::Key => 20u32,
            SymbolKind::Null => 21u32,
            SymbolKind::EnumMember => 22u32,
            SymbolKind::Struct => 23u32,
            SymbolKind::Event => 24u32,
            SymbolKind::Operator => 25u32,
            SymbolKind::TypeParameter => 26u32,
        }
    }
}
impl TryFrom<u32> for SymbolKind {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(SymbolKind::File),
            2u32 => Ok(SymbolKind::Module),
            3u32 => Ok(SymbolKind::Namespace),
            4u32 => Ok(SymbolKind::Package),
            5u32 => Ok(SymbolKind::Class),
            6u32 => Ok(SymbolKind::Method),
            7u32 => Ok(SymbolKind::Property),
            8u32 => Ok(SymbolKind::Field),
            9u32 => Ok(SymbolKind::Constructor),
            10u32 => Ok(SymbolKind::Enum),
            11u32 => Ok(SymbolKind::Interface),
            12u32 => Ok(SymbolKind::Function),
            13u32 => Ok(SymbolKind::Variable),
            14u32 => Ok(SymbolKind::Constant),
            15u32 => Ok(SymbolKind::String),
            16u32 => Ok(SymbolKind::Number),
            17u32 => Ok(SymbolKind::Boolean),
            18u32 => Ok(SymbolKind::Array),
            19u32 => Ok(SymbolKind::Object),
            20u32 => Ok(SymbolKind::Key),
            21u32 => Ok(SymbolKind::Null),
            22u32 => Ok(SymbolKind::EnumMember),
            23u32 => Ok(SymbolKind::Struct),
            24u32 => Ok(SymbolKind::Event),
            25u32 => Ok(SymbolKind::Operator),
            26u32 => Ok(SymbolKind::TypeParameter),
            _ => Err(format!("Invalid SymbolKind: {v}")),
        }
    }
}

/// Symbol tags are extra annotations that tweak the rendering of a symbol.
///
/// @since 3.16
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum SymbolTag {
    /// Render a symbol as obsolete, usually using a strike-out.
    Deprecated,
}
impl From<SymbolTag> for u32 {
    fn from(e: SymbolTag) -> Self {
        match e {
            SymbolTag::Deprecated => 1u32,
        }
    }
}
impl TryFrom<u32> for SymbolTag {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(SymbolTag::Deprecated),
            _ => Err(format!("Invalid SymbolTag: {v}")),
        }
    }
}

/// Moniker uniqueness level to define scope of the moniker.
///
/// @since 3.16.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "String", try_from = "String")]
pub enum UniquenessLevel {
    /// The moniker is only unique inside a document
    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 From<UniquenessLevel> for String {
    fn from(e: UniquenessLevel) -> Self {
        match e {
            UniquenessLevel::Document => "document".to_string(),
            UniquenessLevel::Project => "project".to_string(),
            UniquenessLevel::Group => "group".to_string(),
            UniquenessLevel::Scheme => "scheme".to_string(),
            UniquenessLevel::Global => "global".to_string(),
        }
    }
}
impl TryFrom<String> for UniquenessLevel {
    type Error = String;
    fn try_from(v: String) -> Result<Self, <Self as TryFrom<String>>::Error> {
        match v.as_str() {
            "document" => Ok(UniquenessLevel::Document),
            "project" => Ok(UniquenessLevel::Project),
            "group" => Ok(UniquenessLevel::Group),
            "scheme" => Ok(UniquenessLevel::Scheme),
            "global" => Ok(UniquenessLevel::Global),
            _ => Err(format!("Invalid UniquenessLevel: {v}")),
        }
    }
}
impl fmt::Display for UniquenessLevel {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = (*self).into();
        write!(f, "{s}")
    }
}

/// The moniker kind.
///
/// @since 3.16.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "String", try_from = "String")]
pub enum MonikerKind {
    /// The moniker represent a symbol that is imported into a project
    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 From<MonikerKind> for String {
    fn from(e: MonikerKind) -> Self {
        match e {
            MonikerKind::Import => "import".to_string(),
            MonikerKind::Export => "export".to_string(),
            MonikerKind::Local => "local".to_string(),
        }
    }
}
impl TryFrom<String> for MonikerKind {
    type Error = String;
    fn try_from(v: String) -> Result<Self, <Self as TryFrom<String>>::Error> {
        match v.as_str() {
            "import" => Ok(MonikerKind::Import),
            "export" => Ok(MonikerKind::Export),
            "local" => Ok(MonikerKind::Local),
            _ => Err(format!("Invalid MonikerKind: {v}")),
        }
    }
}
impl fmt::Display for MonikerKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = (*self).into();
        write!(f, "{s}")
    }
}

/// Inlay hint kinds.
///
/// @since 3.17.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum InlayHintKind {
    /// An inlay hint that for a type annotation.
    Type,
    /// An inlay hint that is for a parameter.
    Parameter,
}
impl From<InlayHintKind> for u32 {
    fn from(e: InlayHintKind) -> Self {
        match e {
            InlayHintKind::Type => 1u32,
            InlayHintKind::Parameter => 2u32,
        }
    }
}
impl TryFrom<u32> for InlayHintKind {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(InlayHintKind::Type),
            2u32 => Ok(InlayHintKind::Parameter),
            _ => Err(format!("Invalid InlayHintKind: {v}")),
        }
    }
}

/// The message type
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum MessageType {
    /// An error message.
    Error,
    /// A warning message.
    Warning,
    /// An information message.
    Info,
    /// A log message.
    Log,
    /// A debug message.
    ///
    /// @since 3.18.0
    /// @proposed
    Debug,
}
impl From<MessageType> for u32 {
    fn from(e: MessageType) -> Self {
        match e {
            MessageType::Error => 1u32,
            MessageType::Warning => 2u32,
            MessageType::Info => 3u32,
            MessageType::Log => 4u32,
            MessageType::Debug => 5u32,
        }
    }
}
impl TryFrom<u32> for MessageType {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(MessageType::Error),
            2u32 => Ok(MessageType::Warning),
            3u32 => Ok(MessageType::Info),
            4u32 => Ok(MessageType::Log),
            5u32 => Ok(MessageType::Debug),
            _ => Err(format!("Invalid MessageType: {v}")),
        }
    }
}

/// Defines how the host (editor) should sync
/// document changes to the language server.
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum TextDocumentSyncKind {
    /// Documents should not be synced at all.
    None,
    /// Documents are synced by always sending the full content
    /// of the document.
    Full,
    /// Documents are synced by sending the full content on open.
    /// After that only incremental updates to the document are
    /// send.
    Incremental,
}
impl From<TextDocumentSyncKind> for u32 {
    fn from(e: TextDocumentSyncKind) -> Self {
        match e {
            TextDocumentSyncKind::None => 0u32,
            TextDocumentSyncKind::Full => 1u32,
            TextDocumentSyncKind::Incremental => 2u32,
        }
    }
}
impl TryFrom<u32> for TextDocumentSyncKind {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            0u32 => Ok(TextDocumentSyncKind::None),
            1u32 => Ok(TextDocumentSyncKind::Full),
            2u32 => Ok(TextDocumentSyncKind::Incremental),
            _ => Err(format!("Invalid TextDocumentSyncKind: {v}")),
        }
    }
}

/// Represents reasons why a text document is saved.
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum TextDocumentSaveReason {
    /// Manually triggered, e.g. by the user pressing save, by starting debugging,
    /// or by an API call.
    Manual,
    /// Automatic after a delay.
    AfterDelay,
    /// When the editor lost focus.
    FocusOut,
}
impl From<TextDocumentSaveReason> for u32 {
    fn from(e: TextDocumentSaveReason) -> Self {
        match e {
            TextDocumentSaveReason::Manual => 1u32,
            TextDocumentSaveReason::AfterDelay => 2u32,
            TextDocumentSaveReason::FocusOut => 3u32,
        }
    }
}
impl TryFrom<u32> for TextDocumentSaveReason {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(TextDocumentSaveReason::Manual),
            2u32 => Ok(TextDocumentSaveReason::AfterDelay),
            3u32 => Ok(TextDocumentSaveReason::FocusOut),
            _ => Err(format!("Invalid TextDocumentSaveReason: {v}")),
        }
    }
}

/// The kind of a completion entry.
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum CompletionItemKind {
    Text,
    Method,
    Function,
    Constructor,
    Field,
    Variable,
    Class,
    Interface,
    Module,
    Property,
    Unit,
    Value,
    Enum,
    Keyword,
    Snippet,
    Color,
    File,
    Reference,
    Folder,
    EnumMember,
    Constant,
    Struct,
    Event,
    Operator,
    TypeParameter,
}
impl From<CompletionItemKind> for u32 {
    fn from(e: CompletionItemKind) -> Self {
        match e {
            CompletionItemKind::Text => 1u32,
            CompletionItemKind::Method => 2u32,
            CompletionItemKind::Function => 3u32,
            CompletionItemKind::Constructor => 4u32,
            CompletionItemKind::Field => 5u32,
            CompletionItemKind::Variable => 6u32,
            CompletionItemKind::Class => 7u32,
            CompletionItemKind::Interface => 8u32,
            CompletionItemKind::Module => 9u32,
            CompletionItemKind::Property => 10u32,
            CompletionItemKind::Unit => 11u32,
            CompletionItemKind::Value => 12u32,
            CompletionItemKind::Enum => 13u32,
            CompletionItemKind::Keyword => 14u32,
            CompletionItemKind::Snippet => 15u32,
            CompletionItemKind::Color => 16u32,
            CompletionItemKind::File => 17u32,
            CompletionItemKind::Reference => 18u32,
            CompletionItemKind::Folder => 19u32,
            CompletionItemKind::EnumMember => 20u32,
            CompletionItemKind::Constant => 21u32,
            CompletionItemKind::Struct => 22u32,
            CompletionItemKind::Event => 23u32,
            CompletionItemKind::Operator => 24u32,
            CompletionItemKind::TypeParameter => 25u32,
        }
    }
}
impl TryFrom<u32> for CompletionItemKind {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(CompletionItemKind::Text),
            2u32 => Ok(CompletionItemKind::Method),
            3u32 => Ok(CompletionItemKind::Function),
            4u32 => Ok(CompletionItemKind::Constructor),
            5u32 => Ok(CompletionItemKind::Field),
            6u32 => Ok(CompletionItemKind::Variable),
            7u32 => Ok(CompletionItemKind::Class),
            8u32 => Ok(CompletionItemKind::Interface),
            9u32 => Ok(CompletionItemKind::Module),
            10u32 => Ok(CompletionItemKind::Property),
            11u32 => Ok(CompletionItemKind::Unit),
            12u32 => Ok(CompletionItemKind::Value),
            13u32 => Ok(CompletionItemKind::Enum),
            14u32 => Ok(CompletionItemKind::Keyword),
            15u32 => Ok(CompletionItemKind::Snippet),
            16u32 => Ok(CompletionItemKind::Color),
            17u32 => Ok(CompletionItemKind::File),
            18u32 => Ok(CompletionItemKind::Reference),
            19u32 => Ok(CompletionItemKind::Folder),
            20u32 => Ok(CompletionItemKind::EnumMember),
            21u32 => Ok(CompletionItemKind::Constant),
            22u32 => Ok(CompletionItemKind::Struct),
            23u32 => Ok(CompletionItemKind::Event),
            24u32 => Ok(CompletionItemKind::Operator),
            25u32 => Ok(CompletionItemKind::TypeParameter),
            _ => Err(format!("Invalid CompletionItemKind: {v}")),
        }
    }
}

/// Completion item tags are extra annotations that tweak the rendering of a completion
/// item.
///
/// @since 3.15.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum CompletionItemTag {
    /// Render a completion as obsolete, usually using a strike-out.
    Deprecated,
}
impl From<CompletionItemTag> for u32 {
    fn from(e: CompletionItemTag) -> Self {
        match e {
            CompletionItemTag::Deprecated => 1u32,
        }
    }
}
impl TryFrom<u32> for CompletionItemTag {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(CompletionItemTag::Deprecated),
            _ => Err(format!("Invalid CompletionItemTag: {v}")),
        }
    }
}

/// Defines whether the insert text in a completion item should be interpreted as
/// plain text or a snippet.
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum InsertTextFormat {
    /// The primary text to be inserted is treated as a plain string.
    PlainText,
    /// 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,
}
impl From<InsertTextFormat> for u32 {
    fn from(e: InsertTextFormat) -> Self {
        match e {
            InsertTextFormat::PlainText => 1u32,
            InsertTextFormat::Snippet => 2u32,
        }
    }
}
impl TryFrom<u32> for InsertTextFormat {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(InsertTextFormat::PlainText),
            2u32 => Ok(InsertTextFormat::Snippet),
            _ => Err(format!("Invalid InsertTextFormat: {v}")),
        }
    }
}

/// How whitespace and indentation is handled during completion
/// item insertion.
///
/// @since 3.16.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
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.
    AsIs,
    /// 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,
}
impl From<InsertTextMode> for u32 {
    fn from(e: InsertTextMode) -> Self {
        match e {
            InsertTextMode::AsIs => 1u32,
            InsertTextMode::AdjustIndentation => 2u32,
        }
    }
}
impl TryFrom<u32> for InsertTextMode {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(InsertTextMode::AsIs),
            2u32 => Ok(InsertTextMode::AdjustIndentation),
            _ => Err(format!("Invalid InsertTextMode: {v}")),
        }
    }
}

/// A document highlight kind.
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum DocumentHighlightKind {
    /// A textual occurrence.
    Text,
    /// Read-access of a symbol, like reading a variable.
    Read,
    /// Write-access of a symbol, like writing to a variable.
    Write,
}
impl From<DocumentHighlightKind> for u32 {
    fn from(e: DocumentHighlightKind) -> Self {
        match e {
            DocumentHighlightKind::Text => 1u32,
            DocumentHighlightKind::Read => 2u32,
            DocumentHighlightKind::Write => 3u32,
        }
    }
}
impl TryFrom<u32> for DocumentHighlightKind {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(DocumentHighlightKind::Text),
            2u32 => Ok(DocumentHighlightKind::Read),
            3u32 => Ok(DocumentHighlightKind::Write),
            _ => Err(format!("Invalid DocumentHighlightKind: {v}")),
        }
    }
}

/// A set of predefined code action kinds
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize)]
#[serde(into = "String", from = "String")]
pub enum CodeActionKind {
    /// Empty kind.
    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 move actions: `refactor.move`
    ///
    /// Example move actions:
    ///
    /// - Move a function to a new file
    /// - Move a property between classes
    /// - Move method to base class
    /// - ...
    ///
    /// @since 3.18.0
    /// @proposed
    RefactorMove,
    /// 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,
    /// Base kind for all code actions applying to the entire notebook's scope. CodeActionKinds using
    /// this should always begin with `notebook.`
    ///
    /// @since 3.18.0
    Notebook,
    /// A custom value.
    #[serde(untagged)]
    Custom(String),
}
impl From<CodeActionKind> for String {
    fn from(e: CodeActionKind) -> Self {
        match e {
            CodeActionKind::Empty => "".to_string(),
            CodeActionKind::QuickFix => "quickfix".to_string(),
            CodeActionKind::Refactor => "refactor".to_string(),
            CodeActionKind::RefactorExtract => "refactor.extract".to_string(),
            CodeActionKind::RefactorInline => "refactor.inline".to_string(),
            CodeActionKind::RefactorMove => "refactor.move".to_string(),
            CodeActionKind::RefactorRewrite => "refactor.rewrite".to_string(),
            CodeActionKind::Source => "source".to_string(),
            CodeActionKind::SourceOrganizeImports => "source.organizeImports".to_string(),
            CodeActionKind::SourceFixAll => "source.fixAll".to_string(),
            CodeActionKind::Notebook => "notebook".to_string(),
            CodeActionKind::Custom(any) => any,
        }
    }
}
impl From<String> for CodeActionKind {
    fn from(v: String) -> Self {
        match v.as_str() {
            "" => CodeActionKind::Empty,
            "quickfix" => CodeActionKind::QuickFix,
            "refactor" => CodeActionKind::Refactor,
            "refactor.extract" => CodeActionKind::RefactorExtract,
            "refactor.inline" => CodeActionKind::RefactorInline,
            "refactor.move" => CodeActionKind::RefactorMove,
            "refactor.rewrite" => CodeActionKind::RefactorRewrite,
            "source" => CodeActionKind::Source,
            "source.organizeImports" => CodeActionKind::SourceOrganizeImports,
            "source.fixAll" => CodeActionKind::SourceFixAll,
            "notebook" => CodeActionKind::Notebook,
            _ => CodeActionKind::Custom(v),
        }
    }
}
impl fmt::Display for CodeActionKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = self.clone().into();
        write!(f, "{s}")
    }
}

/// Code action tags are extra annotations that tweak the behavior of a code action.
///
/// @since 3.18.0 - proposed
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum CodeActionTag {
    /// Marks the code action as LLM-generated.
    LLMGenerated,
}
impl From<CodeActionTag> for u32 {
    fn from(e: CodeActionTag) -> Self {
        match e {
            CodeActionTag::LLMGenerated => 1u32,
        }
    }
}
impl TryFrom<u32> for CodeActionTag {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(CodeActionTag::LLMGenerated),
            _ => Err(format!("Invalid CodeActionTag: {v}")),
        }
    }
}

#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "String", try_from = "String")]
pub enum TraceValue {
    /// Turn tracing off.
    Off,
    /// Trace messages only.
    Messages,
    /// Verbose message tracing.
    Verbose,
}
impl From<TraceValue> for String {
    fn from(e: TraceValue) -> Self {
        match e {
            TraceValue::Off => "off".to_string(),
            TraceValue::Messages => "messages".to_string(),
            TraceValue::Verbose => "verbose".to_string(),
        }
    }
}
impl TryFrom<String> for TraceValue {
    type Error = String;
    fn try_from(v: String) -> Result<Self, <Self as TryFrom<String>>::Error> {
        match v.as_str() {
            "off" => Ok(TraceValue::Off),
            "messages" => Ok(TraceValue::Messages),
            "verbose" => Ok(TraceValue::Verbose),
            _ => Err(format!("Invalid TraceValue: {v}")),
        }
    }
}
impl fmt::Display for TraceValue {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = (*self).into();
        write!(f, "{s}")
    }
}

/// 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(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "String", try_from = "String")]
pub enum MarkupKind {
    /// Plain text is supported as a content format
    PlainText,
    /// Markdown is supported as a content format
    Markdown,
}
impl From<MarkupKind> for String {
    fn from(e: MarkupKind) -> Self {
        match e {
            MarkupKind::PlainText => "plaintext".to_string(),
            MarkupKind::Markdown => "markdown".to_string(),
        }
    }
}
impl TryFrom<String> for MarkupKind {
    type Error = String;
    fn try_from(v: String) -> Result<Self, <Self as TryFrom<String>>::Error> {
        match v.as_str() {
            "plaintext" => Ok(MarkupKind::PlainText),
            "markdown" => Ok(MarkupKind::Markdown),
            _ => Err(format!("Invalid MarkupKind: {v}")),
        }
    }
}
impl fmt::Display for MarkupKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = (*self).into();
        write!(f, "{s}")
    }
}

/// Predefined Language kinds
/// @since 3.18.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize)]
#[serde(into = "String", from = "String")]
pub enum LanguageKind {
    ABAP,
    WindowsBat,
    BibTeX,
    Clojure,
    Coffeescript,
    C,
    CPP,
    CSharp,
    CSS,
    /// @since 3.18.0
    /// @proposed
    D,
    /// @since 3.18.0
    /// @proposed
    Delphi,
    Diff,
    Dart,
    Dockerfile,
    Elixir,
    Erlang,
    FSharp,
    GitCommit,
    GitRebase,
    Go,
    Groovy,
    Handlebars,
    Haskell,
    HTML,
    Ini,
    Java,
    JavaScript,
    JavaScriptReact,
    JSON,
    LaTeX,
    Less,
    Lua,
    Makefile,
    Markdown,
    ObjectiveC,
    ObjectiveCPP,
    /// @since 3.18.0
    /// @proposed
    Pascal,
    Perl,
    Perl6,
    PHP,
    Powershell,
    Pug,
    Python,
    R,
    Razor,
    Ruby,
    Rust,
    SCSS,
    SASS,
    Scala,
    ShaderLab,
    ShellScript,
    SQL,
    Swift,
    TypeScript,
    TypeScriptReact,
    TeX,
    VisualBasic,
    XML,
    XSL,
    YAML,
    /// A custom value.
    #[serde(untagged)]
    Custom(String),
}
impl From<LanguageKind> for String {
    fn from(e: LanguageKind) -> Self {
        match e {
            LanguageKind::ABAP => "abap".to_string(),
            LanguageKind::WindowsBat => "bat".to_string(),
            LanguageKind::BibTeX => "bibtex".to_string(),
            LanguageKind::Clojure => "clojure".to_string(),
            LanguageKind::Coffeescript => "coffeescript".to_string(),
            LanguageKind::C => "c".to_string(),
            LanguageKind::CPP => "cpp".to_string(),
            LanguageKind::CSharp => "csharp".to_string(),
            LanguageKind::CSS => "css".to_string(),
            LanguageKind::D => "d".to_string(),
            LanguageKind::Delphi => "pascal".to_string(),
            LanguageKind::Diff => "diff".to_string(),
            LanguageKind::Dart => "dart".to_string(),
            LanguageKind::Dockerfile => "dockerfile".to_string(),
            LanguageKind::Elixir => "elixir".to_string(),
            LanguageKind::Erlang => "erlang".to_string(),
            LanguageKind::FSharp => "fsharp".to_string(),
            LanguageKind::GitCommit => "git-commit".to_string(),
            LanguageKind::GitRebase => "rebase".to_string(),
            LanguageKind::Go => "go".to_string(),
            LanguageKind::Groovy => "groovy".to_string(),
            LanguageKind::Handlebars => "handlebars".to_string(),
            LanguageKind::Haskell => "haskell".to_string(),
            LanguageKind::HTML => "html".to_string(),
            LanguageKind::Ini => "ini".to_string(),
            LanguageKind::Java => "java".to_string(),
            LanguageKind::JavaScript => "javascript".to_string(),
            LanguageKind::JavaScriptReact => "javascriptreact".to_string(),
            LanguageKind::JSON => "json".to_string(),
            LanguageKind::LaTeX => "latex".to_string(),
            LanguageKind::Less => "less".to_string(),
            LanguageKind::Lua => "lua".to_string(),
            LanguageKind::Makefile => "makefile".to_string(),
            LanguageKind::Markdown => "markdown".to_string(),
            LanguageKind::ObjectiveC => "objective-c".to_string(),
            LanguageKind::ObjectiveCPP => "objective-cpp".to_string(),
            LanguageKind::Pascal => "pascal".to_string(),
            LanguageKind::Perl => "perl".to_string(),
            LanguageKind::Perl6 => "perl6".to_string(),
            LanguageKind::PHP => "php".to_string(),
            LanguageKind::Powershell => "powershell".to_string(),
            LanguageKind::Pug => "jade".to_string(),
            LanguageKind::Python => "python".to_string(),
            LanguageKind::R => "r".to_string(),
            LanguageKind::Razor => "razor".to_string(),
            LanguageKind::Ruby => "ruby".to_string(),
            LanguageKind::Rust => "rust".to_string(),
            LanguageKind::SCSS => "scss".to_string(),
            LanguageKind::SASS => "sass".to_string(),
            LanguageKind::Scala => "scala".to_string(),
            LanguageKind::ShaderLab => "shaderlab".to_string(),
            LanguageKind::ShellScript => "shellscript".to_string(),
            LanguageKind::SQL => "sql".to_string(),
            LanguageKind::Swift => "swift".to_string(),
            LanguageKind::TypeScript => "typescript".to_string(),
            LanguageKind::TypeScriptReact => "typescriptreact".to_string(),
            LanguageKind::TeX => "tex".to_string(),
            LanguageKind::VisualBasic => "vb".to_string(),
            LanguageKind::XML => "xml".to_string(),
            LanguageKind::XSL => "xsl".to_string(),
            LanguageKind::YAML => "yaml".to_string(),
            LanguageKind::Custom(any) => any,
        }
    }
}
impl From<String> for LanguageKind {
    fn from(v: String) -> Self {
        match v.as_str() {
            "abap" => LanguageKind::ABAP,
            "bat" => LanguageKind::WindowsBat,
            "bibtex" => LanguageKind::BibTeX,
            "clojure" => LanguageKind::Clojure,
            "coffeescript" => LanguageKind::Coffeescript,
            "c" => LanguageKind::C,
            "cpp" => LanguageKind::CPP,
            "csharp" => LanguageKind::CSharp,
            "css" => LanguageKind::CSS,
            "d" => LanguageKind::D,
            "pascal" => LanguageKind::Delphi,
            "diff" => LanguageKind::Diff,
            "dart" => LanguageKind::Dart,
            "dockerfile" => LanguageKind::Dockerfile,
            "elixir" => LanguageKind::Elixir,
            "erlang" => LanguageKind::Erlang,
            "fsharp" => LanguageKind::FSharp,
            "git-commit" => LanguageKind::GitCommit,
            "rebase" => LanguageKind::GitRebase,
            "go" => LanguageKind::Go,
            "groovy" => LanguageKind::Groovy,
            "handlebars" => LanguageKind::Handlebars,
            "haskell" => LanguageKind::Haskell,
            "html" => LanguageKind::HTML,
            "ini" => LanguageKind::Ini,
            "java" => LanguageKind::Java,
            "javascript" => LanguageKind::JavaScript,
            "javascriptreact" => LanguageKind::JavaScriptReact,
            "json" => LanguageKind::JSON,
            "latex" => LanguageKind::LaTeX,
            "less" => LanguageKind::Less,
            "lua" => LanguageKind::Lua,
            "makefile" => LanguageKind::Makefile,
            "markdown" => LanguageKind::Markdown,
            "objective-c" => LanguageKind::ObjectiveC,
            "objective-cpp" => LanguageKind::ObjectiveCPP,
            "pascal" => LanguageKind::Pascal,
            "perl" => LanguageKind::Perl,
            "perl6" => LanguageKind::Perl6,
            "php" => LanguageKind::PHP,
            "powershell" => LanguageKind::Powershell,
            "jade" => LanguageKind::Pug,
            "python" => LanguageKind::Python,
            "r" => LanguageKind::R,
            "razor" => LanguageKind::Razor,
            "ruby" => LanguageKind::Ruby,
            "rust" => LanguageKind::Rust,
            "scss" => LanguageKind::SCSS,
            "sass" => LanguageKind::SASS,
            "scala" => LanguageKind::Scala,
            "shaderlab" => LanguageKind::ShaderLab,
            "shellscript" => LanguageKind::ShellScript,
            "sql" => LanguageKind::SQL,
            "swift" => LanguageKind::Swift,
            "typescript" => LanguageKind::TypeScript,
            "typescriptreact" => LanguageKind::TypeScriptReact,
            "tex" => LanguageKind::TeX,
            "vb" => LanguageKind::VisualBasic,
            "xml" => LanguageKind::XML,
            "xsl" => LanguageKind::XSL,
            "yaml" => LanguageKind::YAML,
            _ => LanguageKind::Custom(v),
        }
    }
}
impl fmt::Display for LanguageKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = self.clone().into();
        write!(f, "{s}")
    }
}

/// Describes how an [inline completion provider][InlineCompletionItemProvider] was triggered.
///
/// @since 3.18.0
/// @proposed
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum InlineCompletionTriggerKind {
    /// Completion was triggered explicitly by a user gesture.
    Invoked,
    /// Completion was triggered automatically while editing.
    Automatic,
}
impl From<InlineCompletionTriggerKind> for u32 {
    fn from(e: InlineCompletionTriggerKind) -> Self {
        match e {
            InlineCompletionTriggerKind::Invoked => 1u32,
            InlineCompletionTriggerKind::Automatic => 2u32,
        }
    }
}
impl TryFrom<u32> for InlineCompletionTriggerKind {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(InlineCompletionTriggerKind::Invoked),
            2u32 => Ok(InlineCompletionTriggerKind::Automatic),
            _ => Err(format!("Invalid InlineCompletionTriggerKind: {v}")),
        }
    }
}

/// A set of predefined position encoding kinds.
///
/// @since 3.17.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize)]
#[serde(into = "String", from = "String")]
pub enum PositionEncodingKind {
    /// Character offsets count UTF-8 code units (e.g. bytes).
    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,
    /// A custom value.
    #[serde(untagged)]
    Custom(String),
}
impl From<PositionEncodingKind> for String {
    fn from(e: PositionEncodingKind) -> Self {
        match e {
            PositionEncodingKind::UTF8 => "utf-8".to_string(),
            PositionEncodingKind::UTF16 => "utf-16".to_string(),
            PositionEncodingKind::UTF32 => "utf-32".to_string(),
            PositionEncodingKind::Custom(any) => any,
        }
    }
}
impl From<String> for PositionEncodingKind {
    fn from(v: String) -> Self {
        match v.as_str() {
            "utf-8" => PositionEncodingKind::UTF8,
            "utf-16" => PositionEncodingKind::UTF16,
            "utf-32" => PositionEncodingKind::UTF32,
            _ => PositionEncodingKind::Custom(v),
        }
    }
}
impl fmt::Display for PositionEncodingKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = self.clone().into();
        write!(f, "{s}")
    }
}

/// The file event type
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum FileChangeType {
    /// The file got created.
    Created,
    /// The file got changed.
    Changed,
    /// The file got deleted.
    Deleted,
}
impl From<FileChangeType> for u32 {
    fn from(e: FileChangeType) -> Self {
        match e {
            FileChangeType::Created => 1u32,
            FileChangeType::Changed => 2u32,
            FileChangeType::Deleted => 3u32,
        }
    }
}
impl TryFrom<u32> for FileChangeType {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(FileChangeType::Created),
            2u32 => Ok(FileChangeType::Changed),
            3u32 => Ok(FileChangeType::Deleted),
            _ => Err(format!("Invalid FileChangeType: {v}")),
        }
    }
}

#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", from = "u32")]
pub enum WatchKind {
    /// Interested in create events.
    Create,
    /// Interested in change events
    Change,
    /// Interested in delete events
    Delete,
    /// A custom value.
    #[serde(untagged)]
    Custom(u32),
}
impl From<WatchKind> for u32 {
    fn from(e: WatchKind) -> Self {
        match e {
            WatchKind::Create => 1u32,
            WatchKind::Change => 2u32,
            WatchKind::Delete => 4u32,
            WatchKind::Custom(any) => any,
        }
    }
}
impl From<u32> for WatchKind {
    fn from(v: u32) -> Self {
        match v {
            1u32 => WatchKind::Create,
            2u32 => WatchKind::Change,
            4u32 => WatchKind::Delete,
            _ => WatchKind::Custom(v),
        }
    }
}

/// The diagnostic's severity.
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum DiagnosticSeverity {
    /// Reports an error.
    Error,
    /// Reports a warning.
    Warning,
    /// Reports an information.
    Information,
    /// Reports a hint.
    Hint,
}
impl From<DiagnosticSeverity> for u32 {
    fn from(e: DiagnosticSeverity) -> Self {
        match e {
            DiagnosticSeverity::Error => 1u32,
            DiagnosticSeverity::Warning => 2u32,
            DiagnosticSeverity::Information => 3u32,
            DiagnosticSeverity::Hint => 4u32,
        }
    }
}
impl TryFrom<u32> for DiagnosticSeverity {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(DiagnosticSeverity::Error),
            2u32 => Ok(DiagnosticSeverity::Warning),
            3u32 => Ok(DiagnosticSeverity::Information),
            4u32 => Ok(DiagnosticSeverity::Hint),
            _ => Err(format!("Invalid DiagnosticSeverity: {v}")),
        }
    }
}

/// The diagnostic tags.
///
/// @since 3.15.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum DiagnosticTag {
    /// Unused or unnecessary code.
    ///
    /// Clients are allowed to render diagnostics with this tag faded out instead of having
    /// an error squiggle.
    Unnecessary,
    /// Deprecated or obsolete code.
    ///
    /// Clients are allowed to rendered diagnostics with this tag strike through.
    Deprecated,
}
impl From<DiagnosticTag> for u32 {
    fn from(e: DiagnosticTag) -> Self {
        match e {
            DiagnosticTag::Unnecessary => 1u32,
            DiagnosticTag::Deprecated => 2u32,
        }
    }
}
impl TryFrom<u32> for DiagnosticTag {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(DiagnosticTag::Unnecessary),
            2u32 => Ok(DiagnosticTag::Deprecated),
            _ => Err(format!("Invalid DiagnosticTag: {v}")),
        }
    }
}

/// How a completion was triggered
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum CompletionTriggerKind {
    /// Completion was triggered by typing an identifier (24x7 code
    /// complete), manual invocation (e.g Ctrl+Space) or via API.
    Invoked,
    /// Completion was triggered by a trigger character specified by
    /// the `triggerCharacters` properties of the `CompletionRegistrationOptions`.
    TriggerCharacter,
    /// Completion was re-triggered as current completion list is incomplete
    TriggerForIncompleteCompletions,
}
impl From<CompletionTriggerKind> for u32 {
    fn from(e: CompletionTriggerKind) -> Self {
        match e {
            CompletionTriggerKind::Invoked => 1u32,
            CompletionTriggerKind::TriggerCharacter => 2u32,
            CompletionTriggerKind::TriggerForIncompleteCompletions => 3u32,
        }
    }
}
impl TryFrom<u32> for CompletionTriggerKind {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(CompletionTriggerKind::Invoked),
            2u32 => Ok(CompletionTriggerKind::TriggerCharacter),
            3u32 => Ok(CompletionTriggerKind::TriggerForIncompleteCompletions),
            _ => Err(format!("Invalid CompletionTriggerKind: {v}")),
        }
    }
}

/// Defines how values from a set of defaults and an individual item will be
/// merged.
///
/// @since 3.18.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum ApplyKind {
    /// The value from the individual item (if provided and not `null`) will be
    /// used instead of the default.
    Replace,
    /// The value from the item will be merged with the default.
    ///
    /// The specific rules for mergeing values are defined against each field
    /// that supports merging.
    Merge,
}
impl From<ApplyKind> for u32 {
    fn from(e: ApplyKind) -> Self {
        match e {
            ApplyKind::Replace => 1u32,
            ApplyKind::Merge => 2u32,
        }
    }
}
impl TryFrom<u32> for ApplyKind {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(ApplyKind::Replace),
            2u32 => Ok(ApplyKind::Merge),
            _ => Err(format!("Invalid ApplyKind: {v}")),
        }
    }
}

/// How a signature help was triggered.
///
/// @since 3.15.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum SignatureHelpTriggerKind {
    /// Signature help was invoked manually by the user or by a command.
    Invoked,
    /// Signature help was triggered by a trigger character.
    TriggerCharacter,
    /// Signature help was triggered by the cursor moving or by the document content changing.
    ContentChange,
}
impl From<SignatureHelpTriggerKind> for u32 {
    fn from(e: SignatureHelpTriggerKind) -> Self {
        match e {
            SignatureHelpTriggerKind::Invoked => 1u32,
            SignatureHelpTriggerKind::TriggerCharacter => 2u32,
            SignatureHelpTriggerKind::ContentChange => 3u32,
        }
    }
}
impl TryFrom<u32> for SignatureHelpTriggerKind {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(SignatureHelpTriggerKind::Invoked),
            2u32 => Ok(SignatureHelpTriggerKind::TriggerCharacter),
            3u32 => Ok(SignatureHelpTriggerKind::ContentChange),
            _ => Err(format!("Invalid SignatureHelpTriggerKind: {v}")),
        }
    }
}

/// The reason why code actions were requested.
///
/// @since 3.17.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum CodeActionTriggerKind {
    /// Code actions were explicitly requested by the user or by an extension.
    Invoked,
    /// 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,
}
impl From<CodeActionTriggerKind> for u32 {
    fn from(e: CodeActionTriggerKind) -> Self {
        match e {
            CodeActionTriggerKind::Invoked => 1u32,
            CodeActionTriggerKind::Automatic => 2u32,
        }
    }
}
impl TryFrom<u32> for CodeActionTriggerKind {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(CodeActionTriggerKind::Invoked),
            2u32 => Ok(CodeActionTriggerKind::Automatic),
            _ => Err(format!("Invalid CodeActionTriggerKind: {v}")),
        }
    }
}

/// A pattern kind describing if a glob pattern matches a file a folder or
/// both.
///
/// @since 3.16.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "String", try_from = "String")]
pub enum FileOperationPatternKind {
    /// The pattern matches a file only.
    File,
    /// The pattern matches a folder only.
    Folder,
}
impl From<FileOperationPatternKind> for String {
    fn from(e: FileOperationPatternKind) -> Self {
        match e {
            FileOperationPatternKind::File => "file".to_string(),
            FileOperationPatternKind::Folder => "folder".to_string(),
        }
    }
}
impl TryFrom<String> for FileOperationPatternKind {
    type Error = String;
    fn try_from(v: String) -> Result<Self, <Self as TryFrom<String>>::Error> {
        match v.as_str() {
            "file" => Ok(FileOperationPatternKind::File),
            "folder" => Ok(FileOperationPatternKind::Folder),
            _ => Err(format!("Invalid FileOperationPatternKind: {v}")),
        }
    }
}
impl fmt::Display for FileOperationPatternKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = (*self).into();
        write!(f, "{s}")
    }
}

/// A notebook cell kind.
///
/// @since 3.17.0
#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum NotebookCellKind {
    /// A markup-cell is formatted source that is used for display.
    Markup,
    /// A code-cell is source code.
    Code,
}
impl From<NotebookCellKind> for u32 {
    fn from(e: NotebookCellKind) -> Self {
        match e {
            NotebookCellKind::Markup => 1u32,
            NotebookCellKind::Code => 2u32,
        }
    }
}
impl TryFrom<u32> for NotebookCellKind {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(NotebookCellKind::Markup),
            2u32 => Ok(NotebookCellKind::Code),
            _ => Err(format!("Invalid NotebookCellKind: {v}")),
        }
    }
}

#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "String", try_from = "String")]
pub enum ResourceOperationKind {
    /// Supports creating new files and folders.
    Create,
    /// Supports renaming existing files and folders.
    Rename,
    /// Supports deleting existing files and folders.
    Delete,
}
impl From<ResourceOperationKind> for String {
    fn from(e: ResourceOperationKind) -> Self {
        match e {
            ResourceOperationKind::Create => "create".to_string(),
            ResourceOperationKind::Rename => "rename".to_string(),
            ResourceOperationKind::Delete => "delete".to_string(),
        }
    }
}
impl TryFrom<String> for ResourceOperationKind {
    type Error = String;
    fn try_from(v: String) -> Result<Self, <Self as TryFrom<String>>::Error> {
        match v.as_str() {
            "create" => Ok(ResourceOperationKind::Create),
            "rename" => Ok(ResourceOperationKind::Rename),
            "delete" => Ok(ResourceOperationKind::Delete),
            _ => Err(format!("Invalid ResourceOperationKind: {v}")),
        }
    }
}
impl fmt::Display for ResourceOperationKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = (*self).into();
        write!(f, "{s}")
    }
}

#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "String", try_from = "String")]
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.
    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 From<FailureHandlingKind> for String {
    fn from(e: FailureHandlingKind) -> Self {
        match e {
            FailureHandlingKind::Abort => "abort".to_string(),
            FailureHandlingKind::Transactional => "transactional".to_string(),
            FailureHandlingKind::TextOnlyTransactional => {
                "textOnlyTransactional".to_string()
            }
            FailureHandlingKind::Undo => "undo".to_string(),
        }
    }
}
impl TryFrom<String> for FailureHandlingKind {
    type Error = String;
    fn try_from(v: String) -> Result<Self, <Self as TryFrom<String>>::Error> {
        match v.as_str() {
            "abort" => Ok(FailureHandlingKind::Abort),
            "transactional" => Ok(FailureHandlingKind::Transactional),
            "textOnlyTransactional" => Ok(FailureHandlingKind::TextOnlyTransactional),
            "undo" => Ok(FailureHandlingKind::Undo),
            _ => Err(format!("Invalid FailureHandlingKind: {v}")),
        }
    }
}
impl fmt::Display for FailureHandlingKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = (*self).into();
        write!(f, "{s}")
    }
}

#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "u32", try_from = "u32")]
pub enum PrepareSupportDefaultBehavior {
    /// The client's default behavior is to select the identifier
    /// according the to language's syntax rule.
    Identifier,
}
impl From<PrepareSupportDefaultBehavior> for u32 {
    fn from(e: PrepareSupportDefaultBehavior) -> Self {
        match e {
            PrepareSupportDefaultBehavior::Identifier => 1u32,
        }
    }
}
impl TryFrom<u32> for PrepareSupportDefaultBehavior {
    type Error = String;
    fn try_from(v: u32) -> Result<Self, <Self as TryFrom<u32>>::Error> {
        match v {
            1u32 => Ok(PrepareSupportDefaultBehavior::Identifier),
            _ => Err(format!("Invalid PrepareSupportDefaultBehavior: {v}")),
        }
    }
}

#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize, Copy)]
#[serde(into = "String", try_from = "String")]
pub enum TokenFormat {
    Relative,
}
impl From<TokenFormat> for String {
    fn from(e: TokenFormat) -> Self {
        match e {
            TokenFormat::Relative => "relative".to_string(),
        }
    }
}
impl TryFrom<String> for TokenFormat {
    type Error = String;
    fn try_from(v: String) -> Result<Self, <Self as TryFrom<String>>::Error> {
        match v.as_str() {
            "relative" => Ok(TokenFormat::Relative),
            _ => Err(format!("Invalid TokenFormat: {v}")),
        }
    }
}
impl fmt::Display for TokenFormat {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = (*self).into();
        write!(f, "{s}")
    }
}

#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize)]
#[serde(into = "String", from = "String")]
pub enum LspRequestMethods {
    TextDocumentImplementation,
    TextDocumentTypeDefinition,
    WorkspaceWorkspaceFolders,
    WorkspaceConfiguration,
    TextDocumentDocumentColor,
    TextDocumentColorPresentation,
    TextDocumentFoldingRange,
    WorkspaceFoldingRangeRefresh,
    TextDocumentDeclaration,
    TextDocumentSelectionRange,
    WindowWorkDoneProgressCreate,
    TextDocumentPrepareCallHierarchy,
    CallHierarchyIncomingCalls,
    CallHierarchyOutgoingCalls,
    TextDocumentSemanticTokensFull,
    TextDocumentSemanticTokensFullDelta,
    TextDocumentSemanticTokensRange,
    WorkspaceSemanticTokensRefresh,
    WindowShowDocument,
    TextDocumentLinkedEditingRange,
    WorkspaceWillCreateFiles,
    WorkspaceWillRenameFiles,
    WorkspaceWillDeleteFiles,
    TextDocumentMoniker,
    TextDocumentPrepareTypeHierarchy,
    TypeHierarchySupertypes,
    TypeHierarchySubtypes,
    TextDocumentInlineValue,
    WorkspaceInlineValueRefresh,
    TextDocumentInlayHint,
    InlayHintResolve,
    WorkspaceInlayHintRefresh,
    TextDocumentDiagnostic,
    WorkspaceDiagnostic,
    WorkspaceDiagnosticRefresh,
    TextDocumentInlineCompletion,
    WorkspaceTextDocumentContent,
    WorkspaceTextDocumentContentRefresh,
    ClientRegisterCapability,
    ClientUnregisterCapability,
    Initialize,
    Shutdown,
    WindowShowMessageRequest,
    TextDocumentWillSaveWaitUntil,
    TextDocumentCompletion,
    CompletionItemResolve,
    TextDocumentHover,
    TextDocumentSignatureHelp,
    TextDocumentDefinition,
    TextDocumentReferences,
    TextDocumentDocumentHighlight,
    TextDocumentDocumentSymbol,
    TextDocumentCodeAction,
    CodeActionResolve,
    WorkspaceSymbol,
    WorkspaceSymbolResolve,
    TextDocumentCodeLens,
    CodeLensResolve,
    WorkspaceCodeLensRefresh,
    TextDocumentDocumentLink,
    DocumentLinkResolve,
    TextDocumentFormatting,
    TextDocumentRangeFormatting,
    TextDocumentRangesFormatting,
    TextDocumentOnTypeFormatting,
    TextDocumentRename,
    TextDocumentPrepareRename,
    WorkspaceExecuteCommand,
    WorkspaceApplyEdit,
    /// A custom value.
    #[serde(untagged)]
    Custom(String),
}
impl From<LspRequestMethods> for String {
    fn from(e: LspRequestMethods) -> Self {
        match e {
            LspRequestMethods::TextDocumentImplementation => {
                "textDocument/implementation".to_string()
            }
            LspRequestMethods::TextDocumentTypeDefinition => {
                "textDocument/typeDefinition".to_string()
            }
            LspRequestMethods::WorkspaceWorkspaceFolders => {
                "workspace/workspaceFolders".to_string()
            }
            LspRequestMethods::WorkspaceConfiguration => {
                "workspace/configuration".to_string()
            }
            LspRequestMethods::TextDocumentDocumentColor => {
                "textDocument/documentColor".to_string()
            }
            LspRequestMethods::TextDocumentColorPresentation => {
                "textDocument/colorPresentation".to_string()
            }
            LspRequestMethods::TextDocumentFoldingRange => {
                "textDocument/foldingRange".to_string()
            }
            LspRequestMethods::WorkspaceFoldingRangeRefresh => {
                "workspace/foldingRange/refresh".to_string()
            }
            LspRequestMethods::TextDocumentDeclaration => {
                "textDocument/declaration".to_string()
            }
            LspRequestMethods::TextDocumentSelectionRange => {
                "textDocument/selectionRange".to_string()
            }
            LspRequestMethods::WindowWorkDoneProgressCreate => {
                "window/workDoneProgress/create".to_string()
            }
            LspRequestMethods::TextDocumentPrepareCallHierarchy => {
                "textDocument/prepareCallHierarchy".to_string()
            }
            LspRequestMethods::CallHierarchyIncomingCalls => {
                "callHierarchy/incomingCalls".to_string()
            }
            LspRequestMethods::CallHierarchyOutgoingCalls => {
                "callHierarchy/outgoingCalls".to_string()
            }
            LspRequestMethods::TextDocumentSemanticTokensFull => {
                "textDocument/semanticTokens/full".to_string()
            }
            LspRequestMethods::TextDocumentSemanticTokensFullDelta => {
                "textDocument/semanticTokens/full/delta".to_string()
            }
            LspRequestMethods::TextDocumentSemanticTokensRange => {
                "textDocument/semanticTokens/range".to_string()
            }
            LspRequestMethods::WorkspaceSemanticTokensRefresh => {
                "workspace/semanticTokens/refresh".to_string()
            }
            LspRequestMethods::WindowShowDocument => "window/showDocument".to_string(),
            LspRequestMethods::TextDocumentLinkedEditingRange => {
                "textDocument/linkedEditingRange".to_string()
            }
            LspRequestMethods::WorkspaceWillCreateFiles => {
                "workspace/willCreateFiles".to_string()
            }
            LspRequestMethods::WorkspaceWillRenameFiles => {
                "workspace/willRenameFiles".to_string()
            }
            LspRequestMethods::WorkspaceWillDeleteFiles => {
                "workspace/willDeleteFiles".to_string()
            }
            LspRequestMethods::TextDocumentMoniker => "textDocument/moniker".to_string(),
            LspRequestMethods::TextDocumentPrepareTypeHierarchy => {
                "textDocument/prepareTypeHierarchy".to_string()
            }
            LspRequestMethods::TypeHierarchySupertypes => {
                "typeHierarchy/supertypes".to_string()
            }
            LspRequestMethods::TypeHierarchySubtypes => {
                "typeHierarchy/subtypes".to_string()
            }
            LspRequestMethods::TextDocumentInlineValue => {
                "textDocument/inlineValue".to_string()
            }
            LspRequestMethods::WorkspaceInlineValueRefresh => {
                "workspace/inlineValue/refresh".to_string()
            }
            LspRequestMethods::TextDocumentInlayHint => {
                "textDocument/inlayHint".to_string()
            }
            LspRequestMethods::InlayHintResolve => "inlayHint/resolve".to_string(),
            LspRequestMethods::WorkspaceInlayHintRefresh => {
                "workspace/inlayHint/refresh".to_string()
            }
            LspRequestMethods::TextDocumentDiagnostic => {
                "textDocument/diagnostic".to_string()
            }
            LspRequestMethods::WorkspaceDiagnostic => "workspace/diagnostic".to_string(),
            LspRequestMethods::WorkspaceDiagnosticRefresh => {
                "workspace/diagnostic/refresh".to_string()
            }
            LspRequestMethods::TextDocumentInlineCompletion => {
                "textDocument/inlineCompletion".to_string()
            }
            LspRequestMethods::WorkspaceTextDocumentContent => {
                "workspace/textDocumentContent".to_string()
            }
            LspRequestMethods::WorkspaceTextDocumentContentRefresh => {
                "workspace/textDocumentContent/refresh".to_string()
            }
            LspRequestMethods::ClientRegisterCapability => {
                "client/registerCapability".to_string()
            }
            LspRequestMethods::ClientUnregisterCapability => {
                "client/unregisterCapability".to_string()
            }
            LspRequestMethods::Initialize => "initialize".to_string(),
            LspRequestMethods::Shutdown => "shutdown".to_string(),
            LspRequestMethods::WindowShowMessageRequest => {
                "window/showMessageRequest".to_string()
            }
            LspRequestMethods::TextDocumentWillSaveWaitUntil => {
                "textDocument/willSaveWaitUntil".to_string()
            }
            LspRequestMethods::TextDocumentCompletion => {
                "textDocument/completion".to_string()
            }
            LspRequestMethods::CompletionItemResolve => {
                "completionItem/resolve".to_string()
            }
            LspRequestMethods::TextDocumentHover => "textDocument/hover".to_string(),
            LspRequestMethods::TextDocumentSignatureHelp => {
                "textDocument/signatureHelp".to_string()
            }
            LspRequestMethods::TextDocumentDefinition => {
                "textDocument/definition".to_string()
            }
            LspRequestMethods::TextDocumentReferences => {
                "textDocument/references".to_string()
            }
            LspRequestMethods::TextDocumentDocumentHighlight => {
                "textDocument/documentHighlight".to_string()
            }
            LspRequestMethods::TextDocumentDocumentSymbol => {
                "textDocument/documentSymbol".to_string()
            }
            LspRequestMethods::TextDocumentCodeAction => {
                "textDocument/codeAction".to_string()
            }
            LspRequestMethods::CodeActionResolve => "codeAction/resolve".to_string(),
            LspRequestMethods::WorkspaceSymbol => "workspace/symbol".to_string(),
            LspRequestMethods::WorkspaceSymbolResolve => {
                "workspaceSymbol/resolve".to_string()
            }
            LspRequestMethods::TextDocumentCodeLens => {
                "textDocument/codeLens".to_string()
            }
            LspRequestMethods::CodeLensResolve => "codeLens/resolve".to_string(),
            LspRequestMethods::WorkspaceCodeLensRefresh => {
                "workspace/codeLens/refresh".to_string()
            }
            LspRequestMethods::TextDocumentDocumentLink => {
                "textDocument/documentLink".to_string()
            }
            LspRequestMethods::DocumentLinkResolve => "documentLink/resolve".to_string(),
            LspRequestMethods::TextDocumentFormatting => {
                "textDocument/formatting".to_string()
            }
            LspRequestMethods::TextDocumentRangeFormatting => {
                "textDocument/rangeFormatting".to_string()
            }
            LspRequestMethods::TextDocumentRangesFormatting => {
                "textDocument/rangesFormatting".to_string()
            }
            LspRequestMethods::TextDocumentOnTypeFormatting => {
                "textDocument/onTypeFormatting".to_string()
            }
            LspRequestMethods::TextDocumentRename => "textDocument/rename".to_string(),
            LspRequestMethods::TextDocumentPrepareRename => {
                "textDocument/prepareRename".to_string()
            }
            LspRequestMethods::WorkspaceExecuteCommand => {
                "workspace/executeCommand".to_string()
            }
            LspRequestMethods::WorkspaceApplyEdit => "workspace/applyEdit".to_string(),
            LspRequestMethods::Custom(any) => any,
        }
    }
}
impl From<String> for LspRequestMethods {
    fn from(v: String) -> Self {
        match v.as_str() {
            "textDocument/implementation" => {
                LspRequestMethods::TextDocumentImplementation
            }
            "textDocument/typeDefinition" => {
                LspRequestMethods::TextDocumentTypeDefinition
            }
            "workspace/workspaceFolders" => LspRequestMethods::WorkspaceWorkspaceFolders,
            "workspace/configuration" => LspRequestMethods::WorkspaceConfiguration,
            "textDocument/documentColor" => LspRequestMethods::TextDocumentDocumentColor,
            "textDocument/colorPresentation" => {
                LspRequestMethods::TextDocumentColorPresentation
            }
            "textDocument/foldingRange" => LspRequestMethods::TextDocumentFoldingRange,
            "workspace/foldingRange/refresh" => {
                LspRequestMethods::WorkspaceFoldingRangeRefresh
            }
            "textDocument/declaration" => LspRequestMethods::TextDocumentDeclaration,
            "textDocument/selectionRange" => {
                LspRequestMethods::TextDocumentSelectionRange
            }
            "window/workDoneProgress/create" => {
                LspRequestMethods::WindowWorkDoneProgressCreate
            }
            "textDocument/prepareCallHierarchy" => {
                LspRequestMethods::TextDocumentPrepareCallHierarchy
            }
            "callHierarchy/incomingCalls" => {
                LspRequestMethods::CallHierarchyIncomingCalls
            }
            "callHierarchy/outgoingCalls" => {
                LspRequestMethods::CallHierarchyOutgoingCalls
            }
            "textDocument/semanticTokens/full" => {
                LspRequestMethods::TextDocumentSemanticTokensFull
            }
            "textDocument/semanticTokens/full/delta" => {
                LspRequestMethods::TextDocumentSemanticTokensFullDelta
            }
            "textDocument/semanticTokens/range" => {
                LspRequestMethods::TextDocumentSemanticTokensRange
            }
            "workspace/semanticTokens/refresh" => {
                LspRequestMethods::WorkspaceSemanticTokensRefresh
            }
            "window/showDocument" => LspRequestMethods::WindowShowDocument,
            "textDocument/linkedEditingRange" => {
                LspRequestMethods::TextDocumentLinkedEditingRange
            }
            "workspace/willCreateFiles" => LspRequestMethods::WorkspaceWillCreateFiles,
            "workspace/willRenameFiles" => LspRequestMethods::WorkspaceWillRenameFiles,
            "workspace/willDeleteFiles" => LspRequestMethods::WorkspaceWillDeleteFiles,
            "textDocument/moniker" => LspRequestMethods::TextDocumentMoniker,
            "textDocument/prepareTypeHierarchy" => {
                LspRequestMethods::TextDocumentPrepareTypeHierarchy
            }
            "typeHierarchy/supertypes" => LspRequestMethods::TypeHierarchySupertypes,
            "typeHierarchy/subtypes" => LspRequestMethods::TypeHierarchySubtypes,
            "textDocument/inlineValue" => LspRequestMethods::TextDocumentInlineValue,
            "workspace/inlineValue/refresh" => {
                LspRequestMethods::WorkspaceInlineValueRefresh
            }
            "textDocument/inlayHint" => LspRequestMethods::TextDocumentInlayHint,
            "inlayHint/resolve" => LspRequestMethods::InlayHintResolve,
            "workspace/inlayHint/refresh" => LspRequestMethods::WorkspaceInlayHintRefresh,
            "textDocument/diagnostic" => LspRequestMethods::TextDocumentDiagnostic,
            "workspace/diagnostic" => LspRequestMethods::WorkspaceDiagnostic,
            "workspace/diagnostic/refresh" => {
                LspRequestMethods::WorkspaceDiagnosticRefresh
            }
            "textDocument/inlineCompletion" => {
                LspRequestMethods::TextDocumentInlineCompletion
            }
            "workspace/textDocumentContent" => {
                LspRequestMethods::WorkspaceTextDocumentContent
            }
            "workspace/textDocumentContent/refresh" => {
                LspRequestMethods::WorkspaceTextDocumentContentRefresh
            }
            "client/registerCapability" => LspRequestMethods::ClientRegisterCapability,
            "client/unregisterCapability" => {
                LspRequestMethods::ClientUnregisterCapability
            }
            "initialize" => LspRequestMethods::Initialize,
            "shutdown" => LspRequestMethods::Shutdown,
            "window/showMessageRequest" => LspRequestMethods::WindowShowMessageRequest,
            "textDocument/willSaveWaitUntil" => {
                LspRequestMethods::TextDocumentWillSaveWaitUntil
            }
            "textDocument/completion" => LspRequestMethods::TextDocumentCompletion,
            "completionItem/resolve" => LspRequestMethods::CompletionItemResolve,
            "textDocument/hover" => LspRequestMethods::TextDocumentHover,
            "textDocument/signatureHelp" => LspRequestMethods::TextDocumentSignatureHelp,
            "textDocument/definition" => LspRequestMethods::TextDocumentDefinition,
            "textDocument/references" => LspRequestMethods::TextDocumentReferences,
            "textDocument/documentHighlight" => {
                LspRequestMethods::TextDocumentDocumentHighlight
            }
            "textDocument/documentSymbol" => {
                LspRequestMethods::TextDocumentDocumentSymbol
            }
            "textDocument/codeAction" => LspRequestMethods::TextDocumentCodeAction,
            "codeAction/resolve" => LspRequestMethods::CodeActionResolve,
            "workspace/symbol" => LspRequestMethods::WorkspaceSymbol,
            "workspaceSymbol/resolve" => LspRequestMethods::WorkspaceSymbolResolve,
            "textDocument/codeLens" => LspRequestMethods::TextDocumentCodeLens,
            "codeLens/resolve" => LspRequestMethods::CodeLensResolve,
            "workspace/codeLens/refresh" => LspRequestMethods::WorkspaceCodeLensRefresh,
            "textDocument/documentLink" => LspRequestMethods::TextDocumentDocumentLink,
            "documentLink/resolve" => LspRequestMethods::DocumentLinkResolve,
            "textDocument/formatting" => LspRequestMethods::TextDocumentFormatting,
            "textDocument/rangeFormatting" => {
                LspRequestMethods::TextDocumentRangeFormatting
            }
            "textDocument/rangesFormatting" => {
                LspRequestMethods::TextDocumentRangesFormatting
            }
            "textDocument/onTypeFormatting" => {
                LspRequestMethods::TextDocumentOnTypeFormatting
            }
            "textDocument/rename" => LspRequestMethods::TextDocumentRename,
            "textDocument/prepareRename" => LspRequestMethods::TextDocumentPrepareRename,
            "workspace/executeCommand" => LspRequestMethods::WorkspaceExecuteCommand,
            "workspace/applyEdit" => LspRequestMethods::WorkspaceApplyEdit,
            _ => LspRequestMethods::Custom(v),
        }
    }
}
impl fmt::Display for LspRequestMethods {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = self.clone().into();
        write!(f, "{s}")
    }
}

#[derive(PartialEq, Eq, Hash, Debug, Clone, Serialize, Deserialize)]
#[serde(into = "String", from = "String")]
pub enum LspNotificationMethods {
    WorkspaceDidChangeWorkspaceFolders,
    WindowWorkDoneProgressCancel,
    WorkspaceDidCreateFiles,
    WorkspaceDidRenameFiles,
    WorkspaceDidDeleteFiles,
    NotebookDocumentDidOpen,
    NotebookDocumentDidChange,
    NotebookDocumentDidSave,
    NotebookDocumentDidClose,
    Initialized,
    Exit,
    WorkspaceDidChangeConfiguration,
    WindowShowMessage,
    WindowLogMessage,
    TelemetryEvent,
    TextDocumentDidOpen,
    TextDocumentDidChange,
    TextDocumentDidClose,
    TextDocumentDidSave,
    TextDocumentWillSave,
    WorkspaceDidChangeWatchedFiles,
    TextDocumentPublishDiagnostics,
    SetTrace,
    LogTrace,
    CancelRequest,
    Progress,
    /// A custom value.
    #[serde(untagged)]
    Custom(String),
}
impl From<LspNotificationMethods> for String {
    fn from(e: LspNotificationMethods) -> Self {
        match e {
            LspNotificationMethods::WorkspaceDidChangeWorkspaceFolders => {
                "workspace/didChangeWorkspaceFolders".to_string()
            }
            LspNotificationMethods::WindowWorkDoneProgressCancel => {
                "window/workDoneProgress/cancel".to_string()
            }
            LspNotificationMethods::WorkspaceDidCreateFiles => {
                "workspace/didCreateFiles".to_string()
            }
            LspNotificationMethods::WorkspaceDidRenameFiles => {
                "workspace/didRenameFiles".to_string()
            }
            LspNotificationMethods::WorkspaceDidDeleteFiles => {
                "workspace/didDeleteFiles".to_string()
            }
            LspNotificationMethods::NotebookDocumentDidOpen => {
                "notebookDocument/didOpen".to_string()
            }
            LspNotificationMethods::NotebookDocumentDidChange => {
                "notebookDocument/didChange".to_string()
            }
            LspNotificationMethods::NotebookDocumentDidSave => {
                "notebookDocument/didSave".to_string()
            }
            LspNotificationMethods::NotebookDocumentDidClose => {
                "notebookDocument/didClose".to_string()
            }
            LspNotificationMethods::Initialized => "initialized".to_string(),
            LspNotificationMethods::Exit => "exit".to_string(),
            LspNotificationMethods::WorkspaceDidChangeConfiguration => {
                "workspace/didChangeConfiguration".to_string()
            }
            LspNotificationMethods::WindowShowMessage => "window/showMessage".to_string(),
            LspNotificationMethods::WindowLogMessage => "window/logMessage".to_string(),
            LspNotificationMethods::TelemetryEvent => "telemetry/event".to_string(),
            LspNotificationMethods::TextDocumentDidOpen => {
                "textDocument/didOpen".to_string()
            }
            LspNotificationMethods::TextDocumentDidChange => {
                "textDocument/didChange".to_string()
            }
            LspNotificationMethods::TextDocumentDidClose => {
                "textDocument/didClose".to_string()
            }
            LspNotificationMethods::TextDocumentDidSave => {
                "textDocument/didSave".to_string()
            }
            LspNotificationMethods::TextDocumentWillSave => {
                "textDocument/willSave".to_string()
            }
            LspNotificationMethods::WorkspaceDidChangeWatchedFiles => {
                "workspace/didChangeWatchedFiles".to_string()
            }
            LspNotificationMethods::TextDocumentPublishDiagnostics => {
                "textDocument/publishDiagnostics".to_string()
            }
            LspNotificationMethods::SetTrace => "$/setTrace".to_string(),
            LspNotificationMethods::LogTrace => "$/logTrace".to_string(),
            LspNotificationMethods::CancelRequest => "$/cancelRequest".to_string(),
            LspNotificationMethods::Progress => "$/progress".to_string(),
            LspNotificationMethods::Custom(any) => any,
        }
    }
}
impl From<String> for LspNotificationMethods {
    fn from(v: String) -> Self {
        match v.as_str() {
            "workspace/didChangeWorkspaceFolders" => {
                LspNotificationMethods::WorkspaceDidChangeWorkspaceFolders
            }
            "window/workDoneProgress/cancel" => {
                LspNotificationMethods::WindowWorkDoneProgressCancel
            }
            "workspace/didCreateFiles" => LspNotificationMethods::WorkspaceDidCreateFiles,
            "workspace/didRenameFiles" => LspNotificationMethods::WorkspaceDidRenameFiles,
            "workspace/didDeleteFiles" => LspNotificationMethods::WorkspaceDidDeleteFiles,
            "notebookDocument/didOpen" => LspNotificationMethods::NotebookDocumentDidOpen,
            "notebookDocument/didChange" => {
                LspNotificationMethods::NotebookDocumentDidChange
            }
            "notebookDocument/didSave" => LspNotificationMethods::NotebookDocumentDidSave,
            "notebookDocument/didClose" => {
                LspNotificationMethods::NotebookDocumentDidClose
            }
            "initialized" => LspNotificationMethods::Initialized,
            "exit" => LspNotificationMethods::Exit,
            "workspace/didChangeConfiguration" => {
                LspNotificationMethods::WorkspaceDidChangeConfiguration
            }
            "window/showMessage" => LspNotificationMethods::WindowShowMessage,
            "window/logMessage" => LspNotificationMethods::WindowLogMessage,
            "telemetry/event" => LspNotificationMethods::TelemetryEvent,
            "textDocument/didOpen" => LspNotificationMethods::TextDocumentDidOpen,
            "textDocument/didChange" => LspNotificationMethods::TextDocumentDidChange,
            "textDocument/didClose" => LspNotificationMethods::TextDocumentDidClose,
            "textDocument/didSave" => LspNotificationMethods::TextDocumentDidSave,
            "textDocument/willSave" => LspNotificationMethods::TextDocumentWillSave,
            "workspace/didChangeWatchedFiles" => {
                LspNotificationMethods::WorkspaceDidChangeWatchedFiles
            }
            "textDocument/publishDiagnostics" => {
                LspNotificationMethods::TextDocumentPublishDiagnostics
            }
            "$/setTrace" => LspNotificationMethods::SetTrace,
            "$/logTrace" => LspNotificationMethods::LogTrace,
            "$/cancelRequest" => LspNotificationMethods::CancelRequest,
            "$/progress" => LspNotificationMethods::Progress,
            _ => LspNotificationMethods::Custom(v),
        }
    }
}
impl fmt::Display for LspNotificationMethods {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s: String = self.clone().into();
        write!(f, "{s}")
    }
}

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

/// LSP arrays.
/// @since 3.17.0
pub type LspArray = Vec<LspAny>;

/// The LSP any type.
/// Please note that strictly speaking a property with the value `undefined`
/// can't be converted into JSON preserving the property name. However for
/// convenience it is allowed and assumed that all these properties are
/// optional as well.
/// @since 3.17.0
pub type LspAny = serde_json::Value;

/// Information about where a symbol is declared.
///
/// Provides additional metadata over normal [location][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;

/// 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>;

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

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

/// The glob pattern to watch relative to the base path. Glob patterns can have the following syntax:
/// - `*` to match one or more characters in a path segment
/// - `?` to match on one character in a path segment
/// - `**` to match any number of path segments, including none
/// - `{}` to group conditions (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
/// - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
/// - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
///
/// @since 3.17.0
pub type Pattern = String;

pub type RegularExpressionEngineKind = String;

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum ActiveParameter {
    #[from]
    Int(u32),
    #[serde(rename = "null")]
    #[from(())]
    Null,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum BaseUri {
    #[from]
    WorkspaceFolder(WorkspaceFolder),
    #[from]
    Uri(Uri),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum CallHierarchyProvider {
    #[from]
    Bool(bool),
    #[from]
    CallHierarchyOptions(CallHierarchyOptions),
    #[from]
    CallHierarchyRegistrationOptions(CallHierarchyRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum ChangeNotifications {
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
    #[from]
    Bool(bool),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum ClientSemanticTokensRequestOptionsFull {
    #[from]
    Bool(bool),
    #[from]
    ClientSemanticTokensRequestFullDelta(ClientSemanticTokensRequestFullDelta),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq)]
#[serde(untagged)]
pub enum ClientSemanticTokensRequestOptionsRange {
    #[from]
    Bool(bool),
    #[from]
    Object(LspObject),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum Code {
    #[from]
    Int(i32),
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq)]
#[serde(untagged)]
pub enum CodeActionProvider {
    #[from]
    Bool(bool),
    #[from]
    CodeActionOptions(CodeActionOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq)]
#[serde(untagged)]
pub enum CodeActionRequestResponse {
    #[from]
    Command(Command),
    #[from]
    CodeAction(CodeAction),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum ColorProvider {
    #[from]
    Bool(bool),
    #[from]
    DocumentColorOptions(DocumentColorOptions),
    #[from]
    DocumentColorRegistrationOptions(DocumentColorRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum CompletionItemTextEdit {
    #[from]
    TextEdit(TextEdit),
    #[from]
    InsertReplaceEdit(InsertReplaceEdit),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq)]
#[serde(untagged)]
pub enum CompletionRequestResponse {
    #[from]
    CompletionItemList(Vec<CompletionItem>),
    #[from]
    CompletionList(CompletionList),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum Contents {
    #[from]
    MarkupContent(MarkupContent),
    #[from]
    MarkedString(MarkedString),
    #[from]
    MarkedStringList(Vec<MarkedString>),
}

/// The declaration of a symbol representation as one or many [locations][Location].
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum Declaration {
    #[from]
    Location(Location),
    #[from]
    LocationList(Vec<Location>),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum DeclarationProvider {
    #[from]
    Bool(bool),
    #[from]
    DeclarationOptions(DeclarationOptions),
    #[from]
    DeclarationRegistrationOptions(DeclarationRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum DeclarationRequestResponse {
    #[from]
    Declaration(Declaration),
    #[from]
    DeclarationLinkList(Vec<DeclarationLink>),
}

/// The definition of a symbol represented as one or many [locations][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(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum Definition {
    #[from]
    Location(Location),
    #[from]
    LocationList(Vec<Location>),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum DefinitionProvider {
    #[from]
    Bool(bool),
    #[from]
    DefinitionOptions(DefinitionOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum DefinitionRequestResponse {
    #[from]
    Definition(Definition),
    #[from]
    DefinitionLinkList(Vec<DefinitionLink>),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum DiagnosticProvider {
    #[from]
    DiagnosticOptions(DiagnosticOptions),
    #[from]
    DiagnosticRegistrationOptions(DiagnosticRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum DocumentChange {
    #[from]
    TextDocumentEdit(TextDocumentEdit),
    #[from]
    CreateFile(CreateFile),
    #[from]
    RenameFile(RenameFile),
    #[from]
    DeleteFile(DeleteFile),
}

/// 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(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq)]
#[serde(untagged)]
pub enum DocumentDiagnosticReport {
    #[from]
    RelatedFullDocumentDiagnosticReport(RelatedFullDocumentDiagnosticReport),
    #[from]
    RelatedUnchangedDocumentDiagnosticReport(RelatedUnchangedDocumentDiagnosticReport),
}

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum DocumentFormattingProvider {
    #[from]
    Bool(bool),
    #[from]
    DocumentFormattingOptions(DocumentFormattingOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum DocumentHighlightProvider {
    #[from]
    Bool(bool),
    #[from]
    DocumentHighlightOptions(DocumentHighlightOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum DocumentRangeFormattingProvider {
    #[from]
    Bool(bool),
    #[from]
    DocumentRangeFormattingOptions(DocumentRangeFormattingOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum DocumentSymbolProvider {
    #[from]
    Bool(bool),
    #[from]
    DocumentSymbolOptions(DocumentSymbolOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum DocumentSymbolRequestResponse {
    #[from]
    SymbolInformationList(Vec<SymbolInformation>),
    #[from]
    DocumentSymbolList(Vec<DocumentSymbol>),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum Documentation {
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
    #[from]
    MarkupContent(MarkupContent),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum Edit {
    #[from]
    TextEdit(TextEdit),
    #[from]
    AnnotatedTextEdit(AnnotatedTextEdit),
    #[from]
    SnippetTextEdit(SnippetTextEdit),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum EditRange {
    #[from]
    Range(Range),
    #[from]
    EditRangeWithInsertReplace(EditRangeWithInsertReplace),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum FoldingRangeProvider {
    #[from]
    Bool(bool),
    #[from]
    FoldingRangeOptions(FoldingRangeOptions),
    #[from]
    FoldingRangeRegistrationOptions(FoldingRangeRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum Full {
    #[from]
    Bool(bool),
    #[from]
    SemanticTokensFullDelta(SemanticTokensFullDelta),
}

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum HoverProvider {
    #[from]
    Bool(bool),
    #[from]
    HoverOptions(HoverOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum Id {
    #[from]
    Int(i32),
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum ImplementationProvider {
    #[from]
    Bool(bool),
    #[from]
    ImplementationOptions(ImplementationOptions),
    #[from]
    ImplementationRegistrationOptions(ImplementationRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum ImplementationRequestResponse {
    #[from]
    Definition(Definition),
    #[from]
    DefinitionLinkList(Vec<DefinitionLink>),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum InlayHintProvider {
    #[from]
    Bool(bool),
    #[from]
    InlayHintOptions(InlayHintOptions),
    #[from]
    InlayHintRegistrationOptions(InlayHintRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum InlineCompletionProvider {
    #[from]
    Bool(bool),
    #[from]
    InlineCompletionOptions(InlineCompletionOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq)]
#[serde(untagged)]
pub enum InlineCompletionRequestResponse {
    #[from]
    InlineCompletionList(InlineCompletionList),
    #[from]
    InlineCompletionItemList(Vec<InlineCompletionItem>),
}

/// 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(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum InlineValue {
    #[from]
    Text(InlineValueText),
    #[from]
    VariableLookup(InlineValueVariableLookup),
    #[from]
    EvaluatableExpression(InlineValueEvaluatableExpression),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum InlineValueProvider {
    #[from]
    Bool(bool),
    #[from]
    InlineValueOptions(InlineValueOptions),
    #[from]
    InlineValueRegistrationOptions(InlineValueRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum InsertText {
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
    #[from]
    StringValue(StringValue),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq)]
#[serde(untagged)]
pub enum Label {
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
    #[from]
    InlayHintLabelPartList(Vec<InlayHintLabelPart>),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum LinkedEditingRangeProvider {
    #[from]
    Bool(bool),
    #[from]
    LinkedEditingRangeOptions(LinkedEditingRangeOptions),
    #[from]
    LinkedEditingRangeRegistrationOptions(LinkedEditingRangeRegistrationOptions),
}

/// 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(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum MarkedString {
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
    #[from]
    MarkedStringWithLanguage(MarkedStringWithLanguage),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum MonikerProvider {
    #[from]
    Bool(bool),
    #[from]
    MonikerOptions(MonikerOptions),
    #[from]
    MonikerRegistrationOptions(MonikerRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum Notebook {
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
    #[from]
    NotebookDocumentFilter(NotebookDocumentFilter),
}

/// 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(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum NotebookDocumentFilter {
    #[from]
    NotebookType(NotebookDocumentFilterNotebookType),
    #[from]
    Scheme(NotebookDocumentFilterScheme),
    #[from]
    Pattern(NotebookDocumentFilterPattern),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum NotebookDocumentSync {
    #[from]
    Options(NotebookDocumentSyncOptions),
    #[from]
    RegistrationOptions(NotebookDocumentSyncRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum NotebookSelector {
    #[from]
    NotebookDocumentFilterWithNotebook(NotebookDocumentFilterWithNotebook),
    #[from]
    NotebookDocumentFilterWithCells(NotebookDocumentFilterWithCells),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum ParameterInformationLabel {
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
    #[from]
    Tuple((u32, u32)),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum PrepareRenameResult {
    #[from]
    Range(Range),
    #[from]
    PrepareRenamePlaceholder(PrepareRenamePlaceholder),
    #[from]
    PrepareRenameDefaultBehavior(PrepareRenameDefaultBehavior),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum ProgressToken {
    #[from]
    Int(i32),
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum ReferencesProvider {
    #[from]
    Bool(bool),
    #[from]
    ReferenceOptions(ReferenceOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq)]
#[serde(untagged)]
pub enum RelatedDocument {
    #[from]
    FullDocumentDiagnosticReport(FullDocumentDiagnosticReport),
    #[from]
    UnchangedDocumentDiagnosticReport(UnchangedDocumentDiagnosticReport),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum RenameProvider {
    #[from]
    Bool(bool),
    #[from]
    RenameOptions(RenameOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum RootPath {
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
    #[serde(rename = "null")]
    #[from(())]
    Null,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum Save {
    #[from]
    Bool(bool),
    #[from]
    SaveOptions(SaveOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum Section {
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
    #[from]
    StringList(Vec<String>),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum SelectionRangeProvider {
    #[from]
    Bool(bool),
    #[from]
    SelectionRangeOptions(SelectionRangeOptions),
    #[from]
    SelectionRangeRegistrationOptions(SelectionRangeRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum SemanticTokensDeltaRequestResponse {
    #[from]
    SemanticTokens(SemanticTokens),
    #[from]
    SemanticTokensDelta(SemanticTokensDelta),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq)]
#[serde(untagged)]
pub enum SemanticTokensOptionsRange {
    #[from]
    Bool(bool),
    #[from]
    Object(LspObject),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq)]
#[serde(untagged)]
pub enum SemanticTokensProvider {
    #[from]
    SemanticTokensOptions(SemanticTokensOptions),
    #[from]
    SemanticTokensRegistrationOptions(SemanticTokensRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum TextDocumentContent {
    #[from]
    Options(TextDocumentContentOptions),
    #[from]
    RegistrationOptions(TextDocumentContentRegistrationOptions),
}

/// 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(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum TextDocumentContentChangeEvent {
    #[from]
    TextDocumentContentChangePartial(TextDocumentContentChangePartial),
    #[from]
    TextDocumentContentChangeWholeDocument(TextDocumentContentChangeWholeDocument),
}

/// A document filter denotes a document by different properties like
/// the [language][`TextDocument::languageId`], the [scheme][`Uri::scheme`] of
/// its resource, or a glob-pattern that is applied to the [path][`TextDocument::fileName`].
///
/// Glob patterns can have the following syntax:
/// - `*` to match one or more characters in a path segment
/// - `?` to match on one character in a path segment
/// - `**` to match any number of path segments, including none
/// - `{}` to group sub patterns into an OR expression. (e.g. `**/*.{ts,js}` matches all TypeScript and JavaScript files)
/// - `[]` to declare a range of characters to match in a path segment (e.g., `example.[0-9]` to match on `example.0`, `example.1`, …)
/// - `[!...]` to negate a range of characters to match in a path segment (e.g., `example.[!0-9]` to match on `example.a`, `example.b`, but not `example.0`)
///
/// @sample A language filter that applies to typescript files on disk: `{ language: 'typescript', scheme: 'file' }`
/// @sample A language filter that applies to all package.json paths: `{ language: 'json', pattern: '**package.json' }`
///
/// @since 3.17.0
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum TextDocumentFilter {
    #[from]
    Language(TextDocumentFilterLanguage),
    #[from]
    Scheme(TextDocumentFilterScheme),
    #[from]
    Pattern(TextDocumentFilterPattern),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum TextDocumentSync {
    #[from]
    Options(TextDocumentSyncOptions),
    #[from]
    Kind(TextDocumentSyncKind),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum Tooltip {
    #[from(String, &str, Box<str>, Cow<'_, str>, char)]
    String(String),
    #[from]
    MarkupContent(MarkupContent),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum TypeDefinitionProvider {
    #[from]
    Bool(bool),
    #[from]
    TypeDefinitionOptions(TypeDefinitionOptions),
    #[from]
    TypeDefinitionRegistrationOptions(TypeDefinitionRegistrationOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum TypeDefinitionRequestResponse {
    #[from]
    Definition(Definition),
    #[from]
    DefinitionLinkList(Vec<DefinitionLink>),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum TypeHierarchyProvider {
    #[from]
    Bool(bool),
    #[from]
    TypeHierarchyOptions(TypeHierarchyOptions),
    #[from]
    TypeHierarchyRegistrationOptions(TypeHierarchyRegistrationOptions),
}

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

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum WorkspaceFolders {
    #[from]
    WorkspaceFolderList(Vec<WorkspaceFolder>),
    #[serde(rename = "null")]
    #[from(())]
    Null,
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash)]
#[serde(untagged)]
pub enum WorkspaceSymbolLocation {
    #[from]
    Location(Location),
    #[from]
    LocationUriOnly(LocationUriOnly),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq, Hash, Copy)]
#[serde(untagged)]
pub enum WorkspaceSymbolProvider {
    #[from]
    Bool(bool),
    #[from]
    WorkspaceSymbolOptions(WorkspaceSymbolOptions),
}

#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, From, Eq)]
#[serde(untagged)]
pub enum WorkspaceSymbolRequestResponse {
    #[from]
    SymbolInformationList(Vec<SymbolInformation>),
    #[from]
    WorkspaceSymbolList(Vec<WorkspaceSymbol>),
}

/// A request to resolve the implementation locations of a symbol at a given text
/// document position. The request's parameter is of type [TextDocumentPositionParams]
/// the response is of type [Definition] or a Thenable that resolves to such.
#[derive(Debug)]
pub struct ImplementationRequest;
impl Request for ImplementationRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentImplementation;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = ImplementationParams;
    type Result = Option<ImplementationRequestResponse>;
}

/// A request to resolve the type definition locations of a symbol at a given text
/// document position. The request's parameter is of type [TextDocumentPositionParams]
/// the response is of type [Definition] or a Thenable that resolves to such.
#[derive(Debug)]
pub struct TypeDefinitionRequest;
impl Request for TypeDefinitionRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentTypeDefinition;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = TypeDefinitionParams;
    type Result = Option<TypeDefinitionRequestResponse>;
}

/// The `workspace/workspaceFolders` is sent from the server to the client to fetch the open workspace folders.
#[derive(Debug)]
pub struct WorkspaceFoldersRequest;
impl Request for WorkspaceFoldersRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceWorkspaceFolders;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ();
    type Result = Option<Vec<WorkspaceFolder>>;
}

/// The 'workspace/configuration' request is sent from the server to the client to fetch a certain
/// configuration setting.
///
/// This pull model replaces the old push model were the client signaled configuration change via an
/// event. If the server still needs to react to configuration changes (since the server caches the
/// result of `workspace/configuration` requests) the server should register for an empty configuration
/// change event and empty the cache if such an event is received.
#[derive(Debug)]
pub struct ConfigurationRequest;
impl Request for ConfigurationRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceConfiguration;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ConfigurationParams;
    type Result = Vec<LspAny>;
}

/// A request to list all color symbols found in a given text document. The request's
/// parameter is of type [DocumentColorParams] the
/// response is of type [ColorInformation[]][ColorInformation] or a Thenable
/// that resolves to such.
#[derive(Debug)]
pub struct DocumentColorRequest;
impl Request for DocumentColorRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentDocumentColor;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DocumentColorParams;
    type Result = Option<Vec<ColorInformation>>;
}

/// A request to list all presentation for a color. The request's
/// parameter is of type [ColorPresentationParams] the
/// response is of type [ColorInformation[]][ColorInformation] or a Thenable
/// that resolves to such.
#[derive(Debug)]
pub struct ColorPresentationRequest;
impl Request for ColorPresentationRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentColorPresentation;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = ColorPresentationParams;
    type Result = Option<Vec<ColorPresentation>>;
}

/// A request to provide folding ranges in a document. The request's
/// parameter is of type [FoldingRangeParams], the
/// response is of type [FoldingRangeList] or a Thenable
/// that resolves to such.
#[derive(Debug)]
pub struct FoldingRangeRequest;
impl Request for FoldingRangeRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentFoldingRange;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = FoldingRangeParams;
    type Result = Option<Vec<FoldingRange>>;
}

/// @since 3.18.0
/// @proposed
#[derive(Debug)]
pub struct FoldingRangeRefreshRequest;
impl Request for FoldingRangeRefreshRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceFoldingRangeRefresh;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ();
    type Result = ();
}

/// A request to resolve the type definition locations of a symbol at a given text
/// document position. The request's parameter is of type [TextDocumentPositionParams]
/// the response is of type [Declaration] or a typed array of [DeclarationLink]
/// or a Thenable that resolves to such.
#[derive(Debug)]
pub struct DeclarationRequest;
impl Request for DeclarationRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentDeclaration;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DeclarationParams;
    type Result = Option<DeclarationRequestResponse>;
}

/// A request to provide selection ranges in a document. The request's
/// parameter is of type [SelectionRangeParams], the
/// response is of type [SelectionRange[]][SelectionRange] or a Thenable
/// that resolves to such.
#[derive(Debug)]
pub struct SelectionRangeRequest;
impl Request for SelectionRangeRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentSelectionRange;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = SelectionRangeParams;
    type Result = Option<Vec<SelectionRange>>;
}

/// The `window/workDoneProgress/create` request is sent from the server to the client to initiate progress
/// reporting from the server.
#[derive(Debug)]
pub struct WorkDoneProgressCreateRequest;
impl Request for WorkDoneProgressCreateRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WindowWorkDoneProgressCreate;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = WorkDoneProgressCreateParams;
    type Result = ();
}

/// A request to result a `CallHierarchyItem` in a document at a given position.
/// Can be used as an input to an incoming or outgoing call hierarchy.
///
/// @since 3.16.0
#[derive(Debug)]
pub struct CallHierarchyPrepareRequest;
impl Request for CallHierarchyPrepareRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentPrepareCallHierarchy;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = CallHierarchyPrepareParams;
    type Result = Option<Vec<CallHierarchyItem>>;
}

/// A request to resolve the incoming calls for a given `CallHierarchyItem`.
///
/// @since 3.16.0
#[derive(Debug)]
pub struct CallHierarchyIncomingCallsRequest;
impl Request for CallHierarchyIncomingCallsRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::CallHierarchyIncomingCalls;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = CallHierarchyIncomingCallsParams;
    type Result = Option<Vec<CallHierarchyIncomingCall>>;
}

/// A request to resolve the outgoing calls for a given `CallHierarchyItem`.
///
/// @since 3.16.0
#[derive(Debug)]
pub struct CallHierarchyOutgoingCallsRequest;
impl Request for CallHierarchyOutgoingCallsRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::CallHierarchyOutgoingCalls;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = CallHierarchyOutgoingCallsParams;
    type Result = Option<Vec<CallHierarchyOutgoingCall>>;
}

/// @since 3.16.0
#[derive(Debug)]
pub struct SemanticTokensRequest;
impl Request for SemanticTokensRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentSemanticTokensFull;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = SemanticTokensParams;
    type Result = Option<SemanticTokens>;
}

/// @since 3.16.0
#[derive(Debug)]
pub struct SemanticTokensDeltaRequest;
impl Request for SemanticTokensDeltaRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentSemanticTokensFullDelta;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = SemanticTokensDeltaParams;
    type Result = Option<SemanticTokensDeltaRequestResponse>;
}

/// @since 3.16.0
#[derive(Debug)]
pub struct SemanticTokensRangeRequest;
impl Request for SemanticTokensRangeRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentSemanticTokensRange;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = SemanticTokensRangeParams;
    type Result = Option<SemanticTokens>;
}

/// @since 3.16.0
#[derive(Debug)]
pub struct SemanticTokensRefreshRequest;
impl Request for SemanticTokensRefreshRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceSemanticTokensRefresh;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ();
    type Result = ();
}

/// A request to show a document. This request might open an
/// external program depending on the value of the URI to open.
/// For example a request to open `https://code.visualstudio.com/`
/// will very likely open the URI in a WEB browser.
///
/// @since 3.16.0
#[derive(Debug)]
pub struct ShowDocumentRequest;
impl Request for ShowDocumentRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WindowShowDocument;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ShowDocumentParams;
    type Result = ShowDocumentResult;
}

/// A request to provide ranges that can be edited together.
///
/// @since 3.16.0
#[derive(Debug)]
pub struct LinkedEditingRangeRequest;
impl Request for LinkedEditingRangeRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentLinkedEditingRange;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = LinkedEditingRangeParams;
    type Result = Option<LinkedEditingRanges>;
}

/// The will create files request is sent from the client to the server before files are actually
/// created as long as the creation is triggered from within the client.
///
/// The request can return a `WorkspaceEdit` which will be applied to workspace before the
/// files are created. Hence the `WorkspaceEdit` can not manipulate the content of the file
/// to be created.
///
/// @since 3.16.0
#[derive(Debug)]
pub struct WillCreateFilesRequest;
impl Request for WillCreateFilesRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceWillCreateFiles;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = CreateFilesParams;
    type Result = Option<WorkspaceEdit>;
}

/// The will rename files request is sent from the client to the server before files are actually
/// renamed as long as the rename is triggered from within the client.
///
/// @since 3.16.0
#[derive(Debug)]
pub struct WillRenameFilesRequest;
impl Request for WillRenameFilesRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceWillRenameFiles;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = RenameFilesParams;
    type Result = Option<WorkspaceEdit>;
}

/// The did delete files notification is sent from the client to the server when
/// files were deleted from within the client.
///
/// @since 3.16.0
#[derive(Debug)]
pub struct WillDeleteFilesRequest;
impl Request for WillDeleteFilesRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceWillDeleteFiles;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DeleteFilesParams;
    type Result = Option<WorkspaceEdit>;
}

/// A request to get the moniker of a symbol at a given text document position.
/// The request parameter is of type [TextDocumentPositionParams].
/// The response is of type [Moniker[]][Moniker] or `null`.
#[derive(Debug)]
pub struct MonikerRequest;
impl Request for MonikerRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentMoniker;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = MonikerParams;
    type Result = Option<Vec<Moniker>>;
}

/// A request to result a `TypeHierarchyItem` in a document at a given position.
/// Can be used as an input to a subtypes or supertypes type hierarchy.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct TypeHierarchyPrepareRequest;
impl Request for TypeHierarchyPrepareRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentPrepareTypeHierarchy;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = TypeHierarchyPrepareParams;
    type Result = Option<Vec<TypeHierarchyItem>>;
}

/// A request to resolve the supertypes for a given `TypeHierarchyItem`.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct TypeHierarchySupertypesRequest;
impl Request for TypeHierarchySupertypesRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TypeHierarchySupertypes;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = TypeHierarchySupertypesParams;
    type Result = Option<Vec<TypeHierarchyItem>>;
}

/// A request to resolve the subtypes for a given `TypeHierarchyItem`.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct TypeHierarchySubtypesRequest;
impl Request for TypeHierarchySubtypesRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TypeHierarchySubtypes;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = TypeHierarchySubtypesParams;
    type Result = Option<Vec<TypeHierarchyItem>>;
}

/// A request to provide inline values in a document. The request's parameter is of
/// type [InlineValueParams], the response is of type
/// [InlineValue[]][InlineValue] or a Thenable that resolves to such.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct InlineValueRequest;
impl Request for InlineValueRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentInlineValue;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = InlineValueParams;
    type Result = Option<Vec<InlineValue>>;
}

/// @since 3.17.0
#[derive(Debug)]
pub struct InlineValueRefreshRequest;
impl Request for InlineValueRefreshRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceInlineValueRefresh;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ();
    type Result = ();
}

/// A request to provide inlay hints in a document. The request's parameter is of
/// type [InlayHintsParams], the response is of type
/// [InlayHint[]][InlayHint] or a Thenable that resolves to such.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct InlayHintRequest;
impl Request for InlayHintRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentInlayHint;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = InlayHintParams;
    type Result = Option<Vec<InlayHint>>;
}

/// A request to resolve additional properties for an inlay hint.
/// The request's parameter is of type [InlayHint], the response is
/// of type [InlayHint] or a Thenable that resolves to such.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct InlayHintResolveRequest;
impl Request for InlayHintResolveRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::InlayHintResolve;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = InlayHint;
    type Result = InlayHint;
}

/// @since 3.17.0
#[derive(Debug)]
pub struct InlayHintRefreshRequest;
impl Request for InlayHintRefreshRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceInlayHintRefresh;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ();
    type Result = ();
}

/// The document diagnostic request definition.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct DocumentDiagnosticRequest;
impl Request for DocumentDiagnosticRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentDiagnostic;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DocumentDiagnosticParams;
    type Result = DocumentDiagnosticReport;
}

/// The workspace diagnostic request definition.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct WorkspaceDiagnosticRequest;
impl Request for WorkspaceDiagnosticRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceDiagnostic;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = WorkspaceDiagnosticParams;
    type Result = WorkspaceDiagnosticReport;
}

/// The diagnostic refresh request definition.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct DiagnosticRefreshRequest;
impl Request for DiagnosticRefreshRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceDiagnosticRefresh;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ();
    type Result = ();
}

/// A request to provide inline completions in a document. The request's parameter is of
/// type [InlineCompletionParams], the response is of type
/// [InlineCompletion[]][InlineCompletion] or a Thenable that resolves to such.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug)]
pub struct InlineCompletionRequest;
impl Request for InlineCompletionRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentInlineCompletion;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = InlineCompletionParams;
    type Result = Option<InlineCompletionRequestResponse>;
}

/// The `workspace/textDocumentContent` request is sent from the client to the
/// server to request the content of a text document.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug)]
pub struct TextDocumentContentRequest;
impl Request for TextDocumentContentRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceTextDocumentContent;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = TextDocumentContentParams;
    type Result = TextDocumentContentResult;
}

/// The `workspace/textDocumentContent` request is sent from the server to the client to refresh
/// the content of a specific text document.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug)]
pub struct TextDocumentContentRefreshRequest;
impl Request for TextDocumentContentRefreshRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceTextDocumentContentRefresh;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = TextDocumentContentRefreshParams;
    type Result = ();
}

/// The `client/registerCapability` request is sent from the server to the client to register a new capability
/// handler on the client side.
#[derive(Debug)]
pub struct RegistrationRequest;
impl Request for RegistrationRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::ClientRegisterCapability;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = RegistrationParams;
    type Result = ();
}

/// The `client/unregisterCapability` request is sent from the server to the client to unregister a previously registered capability
/// handler on the client side.
#[derive(Debug)]
pub struct UnregistrationRequest;
impl Request for UnregistrationRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::ClientUnregisterCapability;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = UnregistrationParams;
    type Result = ();
}

/// The initialize request is sent from the client to the server.
/// It is sent once as the request after starting up the server.
/// The requests parameter is of type [InitializeParams]
/// the response if of type [InitializeResult] of a Thenable that
/// resolves to such.
#[derive(Debug)]
pub struct InitializeRequest;
impl Request for InitializeRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::Initialize;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = InitializeParams;
    type Result = InitializeResult;
}

/// A shutdown request is sent from the client to the server.
/// It is sent once when the client decides to shutdown the
/// server. The only notification that is sent after a shutdown request
/// is the exit event.
#[derive(Debug)]
pub struct ShutdownRequest;
impl Request for ShutdownRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::Shutdown;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = ();
    type Result = ();
}

/// The show message request is sent from the server to the client to show a message
/// and a set of options actions to the user.
#[derive(Debug)]
pub struct ShowMessageRequest;
impl Request for ShowMessageRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WindowShowMessageRequest;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ShowMessageRequestParams;
    type Result = Option<MessageActionItem>;
}

/// A document will save request is sent from the client to the server before
/// the document is actually saved. The request can return an array of TextEdits
/// which will be applied to the text document before it is saved. Please note that
/// clients might drop results if computing the text edits took too long or if a
/// server constantly fails on this request. This is done to keep the save fast and
/// reliable.
#[derive(Debug)]
pub struct WillSaveTextDocumentWaitUntilRequest;
impl Request for WillSaveTextDocumentWaitUntilRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentWillSaveWaitUntil;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = WillSaveTextDocumentParams;
    type Result = Option<Vec<TextEdit>>;
}

/// Request to request completion at a given text document position. The request's
/// parameter is of type [TextDocumentPosition] the response
/// is of type [CompletionItem[]][CompletionItem] or [CompletionList]
/// or a Thenable that resolves to such.
///
/// The request can delay the computation of the [`detail`][`CompletionItem::detail`]
/// and [`documentation`][`CompletionItem::documentation`] properties to the `completionItem/resolve`
/// request. However, properties that are needed for the initial sorting and filtering, like `sortText`,
/// `filterText`, `insertText`, and `textEdit`, must not be changed during resolve.
#[derive(Debug)]
pub struct CompletionRequest;
impl Request for CompletionRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentCompletion;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = CompletionParams;
    type Result = Option<CompletionRequestResponse>;
}

/// Request to resolve additional information for a given completion item.The request's
/// parameter is of type [CompletionItem] the response
/// is of type [CompletionItem] or a Thenable that resolves to such.
#[derive(Debug)]
pub struct CompletionResolveRequest;
impl Request for CompletionResolveRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::CompletionItemResolve;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = CompletionItem;
    type Result = CompletionItem;
}

/// Request to request hover information at a given text document position. The request's
/// parameter is of type [TextDocumentPosition] the response is of
/// type [Hover] or a Thenable that resolves to such.
#[derive(Debug)]
pub struct HoverRequest;
impl Request for HoverRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentHover;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = HoverParams;
    type Result = Option<Hover>;
}

#[derive(Debug)]
pub struct SignatureHelpRequest;
impl Request for SignatureHelpRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentSignatureHelp;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = SignatureHelpParams;
    type Result = Option<SignatureHelp>;
}

/// A request to resolve the definition location of a symbol at a given text
/// document position. The request's parameter is of type [TextDocumentPosition]
/// the response is of either type [Definition] or a typed array of
/// [DefinitionLink] or a Thenable that resolves to such.
#[derive(Debug)]
pub struct DefinitionRequest;
impl Request for DefinitionRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentDefinition;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DefinitionParams;
    type Result = Option<DefinitionRequestResponse>;
}

/// A request to resolve project-wide references for the symbol denoted
/// by the given text document position. The request's parameter is of
/// type [ReferenceParams] the response is of type
/// [Location[]][Location] or a Thenable that resolves to such.
#[derive(Debug)]
pub struct ReferencesRequest;
impl Request for ReferencesRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentReferences;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = ReferenceParams;
    type Result = Option<Vec<Location>>;
}

/// Request to resolve a [DocumentHighlight] for a given
/// text document position. The request's parameter is of type [TextDocumentPosition]
/// the request response is an array of type [DocumentHighlight]
/// or a Thenable that resolves to such.
#[derive(Debug)]
pub struct DocumentHighlightRequest;
impl Request for DocumentHighlightRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentDocumentHighlight;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DocumentHighlightParams;
    type Result = Option<Vec<DocumentHighlight>>;
}

/// A request to list all symbols found in a given text document. The request's
/// parameter is of type [TextDocumentIdentifier] the
/// response is of type [SymbolInformation[]][SymbolInformation] or a Thenable
/// that resolves to such.
#[derive(Debug)]
pub struct DocumentSymbolRequest;
impl Request for DocumentSymbolRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentDocumentSymbol;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DocumentSymbolParams;
    type Result = Option<DocumentSymbolRequestResponse>;
}

/// A request to provide commands for the given text document and range.
#[derive(Debug)]
pub struct CodeActionRequest;
impl Request for CodeActionRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentCodeAction;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = CodeActionParams;
    type Result = Option<Vec<CodeActionRequestResponse>>;
}

/// Request to resolve additional information for a given code action.The request's
/// parameter is of type [CodeAction] the response
/// is of type [CodeAction] or a Thenable that resolves to such.
#[derive(Debug)]
pub struct CodeActionResolveRequest;
impl Request for CodeActionResolveRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::CodeActionResolve;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = CodeAction;
    type Result = CodeAction;
}

/// A request to list project-wide symbols matching the query string given
/// by the [WorkspaceSymbolParams]. The response is
/// of type [SymbolInformation[]][SymbolInformation] or a Thenable that
/// resolves to such.
///
/// @since 3.17.0 - support for WorkspaceSymbol in the returned data. Clients
///  need to advertise support for WorkspaceSymbols via the client capability
///  `workspace.symbol.resolveSupport`.
///
#[derive(Debug)]
pub struct WorkspaceSymbolRequest;
impl Request for WorkspaceSymbolRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceSymbol;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = WorkspaceSymbolParams;
    type Result = Option<WorkspaceSymbolRequestResponse>;
}

/// A request to resolve the range inside the workspace
/// symbol's location.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct WorkspaceSymbolResolveRequest;
impl Request for WorkspaceSymbolResolveRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceSymbolResolve;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = WorkspaceSymbol;
    type Result = WorkspaceSymbol;
}

/// A request to provide code lens for the given text document.
#[derive(Debug)]
pub struct CodeLensRequest;
impl Request for CodeLensRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentCodeLens;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = CodeLensParams;
    type Result = Option<Vec<CodeLens>>;
}

/// A request to resolve a command for a given code lens.
#[derive(Debug)]
pub struct CodeLensResolveRequest;
impl Request for CodeLensResolveRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::CodeLensResolve;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = CodeLens;
    type Result = CodeLens;
}

/// A request to refresh all code actions
///
/// @since 3.16.0
#[derive(Debug)]
pub struct CodeLensRefreshRequest;
impl Request for CodeLensRefreshRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceCodeLensRefresh;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ();
    type Result = ();
}

/// A request to provide document links
#[derive(Debug)]
pub struct DocumentLinkRequest;
impl Request for DocumentLinkRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentDocumentLink;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DocumentLinkParams;
    type Result = Option<Vec<DocumentLink>>;
}

/// Request to resolve additional information for a given document link. The request's
/// parameter is of type [DocumentLink] the response
/// is of type [DocumentLink] or a Thenable that resolves to such.
#[derive(Debug)]
pub struct DocumentLinkResolveRequest;
impl Request for DocumentLinkResolveRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::DocumentLinkResolve;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DocumentLink;
    type Result = DocumentLink;
}

/// A request to format a whole document.
#[derive(Debug)]
pub struct DocumentFormattingRequest;
impl Request for DocumentFormattingRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentFormatting;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DocumentFormattingParams;
    type Result = Option<Vec<TextEdit>>;
}

/// A request to format a range in a document.
#[derive(Debug)]
pub struct DocumentRangeFormattingRequest;
impl Request for DocumentRangeFormattingRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentRangeFormatting;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DocumentRangeFormattingParams;
    type Result = Option<Vec<TextEdit>>;
}

/// A request to format ranges in a document.
///
/// @since 3.18.0
/// @proposed
#[derive(Debug)]
pub struct DocumentRangesFormattingRequest;
impl Request for DocumentRangesFormattingRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentRangesFormatting;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DocumentRangesFormattingParams;
    type Result = Option<Vec<TextEdit>>;
}

/// A request to format a document on type.
#[derive(Debug)]
pub struct DocumentOnTypeFormattingRequest;
impl Request for DocumentOnTypeFormattingRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentOnTypeFormatting;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DocumentOnTypeFormattingParams;
    type Result = Option<Vec<TextEdit>>;
}

/// A request to rename a symbol.
#[derive(Debug)]
pub struct RenameRequest;
impl Request for RenameRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentRename;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = RenameParams;
    type Result = Option<WorkspaceEdit>;
}

/// A request to test and perform the setup necessary for a rename.
///
/// @since 3.16 - support for default behavior
#[derive(Debug)]
pub struct PrepareRenameRequest;
impl Request for PrepareRenameRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::TextDocumentPrepareRename;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = PrepareRenameParams;
    type Result = Option<PrepareRenameResult>;
}

/// A request send from the client to the server to execute a command. The request might return
/// a workspace edit which the client will apply to the workspace.
#[derive(Debug)]
pub struct ExecuteCommandRequest;
impl Request for ExecuteCommandRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceExecuteCommand;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = ExecuteCommandParams;
    type Result = Option<LspAny>;
}

/// A request sent from the server to the client to modified certain resources.
#[derive(Debug)]
pub struct ApplyWorkspaceEditRequest;
impl Request for ApplyWorkspaceEditRequest {
    const METHOD: LspRequestMethods = LspRequestMethods::WorkspaceApplyEdit;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ApplyWorkspaceEditParams;
    type Result = ApplyWorkspaceEditResult;
}

/// The `workspace/didChangeWorkspaceFolders` notification is sent from the client to the server when the workspace
/// folder configuration changes.
#[derive(Debug)]
pub struct DidChangeWorkspaceFoldersNotification;
impl Notification for DidChangeWorkspaceFoldersNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::WorkspaceDidChangeWorkspaceFolders;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DidChangeWorkspaceFoldersParams;
}

/// The `window/workDoneProgress/cancel` notification is sent from  the client to the server to cancel a progress
/// initiated on the server side.
#[derive(Debug)]
pub struct WorkDoneProgressCancelNotification;
impl Notification for WorkDoneProgressCancelNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::WindowWorkDoneProgressCancel;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = WorkDoneProgressCancelParams;
}

/// The did create files notification is sent from the client to the server when
/// files were created from within the client.
///
/// @since 3.16.0
#[derive(Debug)]
pub struct DidCreateFilesNotification;
impl Notification for DidCreateFilesNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::WorkspaceDidCreateFiles;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = CreateFilesParams;
}

/// The did rename files notification is sent from the client to the server when
/// files were renamed from within the client.
///
/// @since 3.16.0
#[derive(Debug)]
pub struct DidRenameFilesNotification;
impl Notification for DidRenameFilesNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::WorkspaceDidRenameFiles;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = RenameFilesParams;
}

/// The will delete files request is sent from the client to the server before files are actually
/// deleted as long as the deletion is triggered from within the client.
///
/// @since 3.16.0
#[derive(Debug)]
pub struct DidDeleteFilesNotification;
impl Notification for DidDeleteFilesNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::WorkspaceDidDeleteFiles;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DeleteFilesParams;
}

/// A notification sent when a notebook opens.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct DidOpenNotebookDocumentNotification;
impl Notification for DidOpenNotebookDocumentNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::NotebookDocumentDidOpen;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DidOpenNotebookDocumentParams;
}

#[derive(Debug)]
pub struct DidChangeNotebookDocumentNotification;
impl Notification for DidChangeNotebookDocumentNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::NotebookDocumentDidChange;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DidChangeNotebookDocumentParams;
}

/// A notification sent when a notebook document is saved.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct DidSaveNotebookDocumentNotification;
impl Notification for DidSaveNotebookDocumentNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::NotebookDocumentDidSave;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DidSaveNotebookDocumentParams;
}

/// A notification sent when a notebook closes.
///
/// @since 3.17.0
#[derive(Debug)]
pub struct DidCloseNotebookDocumentNotification;
impl Notification for DidCloseNotebookDocumentNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::NotebookDocumentDidClose;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DidCloseNotebookDocumentParams;
}

/// The initialized notification is sent from the client to the
/// server after the client is fully initialized and the server
/// is allowed to send requests from the server to the client.
#[derive(Debug)]
pub struct InitializedNotification;
impl Notification for InitializedNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::Initialized;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = InitializedParams;
}

/// The exit event is sent from the client to the server to
/// ask the server to exit its process.
#[derive(Debug)]
pub struct ExitNotification;
impl Notification for ExitNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::Exit;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = ();
}

/// The configuration change notification is sent from the client to the server
/// when the client's configuration has changed. The notification contains
/// the changed configuration as defined by the language client.
#[derive(Debug)]
pub struct DidChangeConfigurationNotification;
impl Notification for DidChangeConfigurationNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::WorkspaceDidChangeConfiguration;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DidChangeConfigurationParams;
}

/// The show message notification is sent from a server to a client to ask
/// the client to display a particular message in the user interface.
#[derive(Debug)]
pub struct ShowMessageNotification;
impl Notification for ShowMessageNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::WindowShowMessage;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = ShowMessageParams;
}

/// The log message notification is sent from the server to the client to ask
/// the client to log a particular message.
#[derive(Debug)]
pub struct LogMessageNotification;
impl Notification for LogMessageNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::WindowLogMessage;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = LogMessageParams;
}

/// The telemetry event notification is sent from the server to the client to ask
/// the client to log telemetry data.
#[derive(Debug)]
pub struct TelemetryEventNotification;
impl Notification for TelemetryEventNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::TelemetryEvent;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = LspAny;
}

/// The document open notification is sent from the client to the server to signal
/// newly opened text documents. The document's truth is now managed by the client
/// and the server must not try to read the document's truth using the document's
/// uri. Open in this sense means it is managed by the client. It doesn't necessarily
/// mean that its content is presented in an editor. An open notification must not
/// be sent more than once without a corresponding close notification send before.
/// This means open and close notification must be balanced and the max open count
/// is one.
#[derive(Debug)]
pub struct DidOpenTextDocumentNotification;
impl Notification for DidOpenTextDocumentNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::TextDocumentDidOpen;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DidOpenTextDocumentParams;
}

/// The document change notification is sent from the client to the server to signal
/// changes to a text document.
#[derive(Debug)]
pub struct DidChangeTextDocumentNotification;
impl Notification for DidChangeTextDocumentNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::TextDocumentDidChange;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DidChangeTextDocumentParams;
}

/// The document close notification is sent from the client to the server when
/// the document got closed in the client. The document's truth now exists where
/// the document's uri points to (e.g. if the document's uri is a file uri the
/// truth now exists on disk). As with the open notification the close notification
/// is about managing the document's content. Receiving a close notification
/// doesn't mean that the document was open in an editor before. A close
/// notification requires a previous open notification to be sent.
#[derive(Debug)]
pub struct DidCloseTextDocumentNotification;
impl Notification for DidCloseTextDocumentNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::TextDocumentDidClose;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DidCloseTextDocumentParams;
}

/// The document save notification is sent from the client to the server when
/// the document got saved in the client.
#[derive(Debug)]
pub struct DidSaveTextDocumentNotification;
impl Notification for DidSaveTextDocumentNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::TextDocumentDidSave;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DidSaveTextDocumentParams;
}

/// A document will save notification is sent from the client to the server before
/// the document is actually saved.
#[derive(Debug)]
pub struct WillSaveTextDocumentNotification;
impl Notification for WillSaveTextDocumentNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::TextDocumentWillSave;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = WillSaveTextDocumentParams;
}

/// The watched files notification is sent from the client to the server when
/// the client detects changes to file watched by the language client.
#[derive(Debug)]
pub struct DidChangeWatchedFilesNotification;
impl Notification for DidChangeWatchedFilesNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::WorkspaceDidChangeWatchedFiles;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = DidChangeWatchedFilesParams;
}

/// Diagnostics notification are sent from the server to the client to signal
/// results of validation runs.
#[derive(Debug)]
pub struct PublishDiagnosticsNotification;
impl Notification for PublishDiagnosticsNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::TextDocumentPublishDiagnostics;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = PublishDiagnosticsParams;
}

#[derive(Debug)]
pub struct SetTraceNotification;
impl Notification for SetTraceNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::SetTrace;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ClientToServer;
    type Params = SetTraceParams;
}

#[derive(Debug)]
pub struct LogTraceNotification;
impl Notification for LogTraceNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::LogTrace;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::ServerToClient;
    type Params = LogTraceParams;
}

#[derive(Debug)]
pub struct CancelNotification;
impl Notification for CancelNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::CancelRequest;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::Both;
    type Params = CancelParams;
}

#[derive(Debug)]
pub struct ProgressNotification;
impl Notification for ProgressNotification {
    const METHOD: LspNotificationMethods = LspNotificationMethods::Progress;
    const MESSAGE_DIRECTION: MessageDirection = MessageDirection::Both;
    type Params = ProgressParams;
}