lspf 1.0.0

//! Standard LSP feature descriptors (ADR 0017).
//!
//! Each `features::*` constructor returns a descriptor implementing one of the
//! sealed traits [`FeatureSpec`] (request features) or
//! [`NotificationFeatureSpec`] (notification features). A descriptor fixes
//! three things at once: the `gen_lsp_types` request or notification marker that
//! names the wire method and its typed parameters (and result, for requests),
//! the descriptor's public options, and the single deterministic contribution
//! the feature makes to the capability catalog.
//!
//! Both traits are sealed: downstream crates use these descriptors but cannot
//! implement either trait, so they cannot present a pseudo-standard feature
//! whose capability fragment lspf does not know how to merge. Custom methods
//! use [`request`](crate::ServerBuilder::request) and
//! [`notification`](crate::ServerBuilder::notification) instead and advertise
//! no capability.

use gen_lsp_types::{
    CallHierarchyIncomingCallsRequest as CallHierarchyIncomingCalls, CallHierarchyOptions,
    CallHierarchyOutgoingCallsRequest as CallHierarchyOutgoingCalls,
    CallHierarchyPrepareRequest as CallHierarchyPrepare, CodeActionOptions, CodeActionRequest,
    CodeActionResolveRequest, CodeLensOptions, CodeLensRequest,
    CodeLensResolveRequest as CodeLensResolve, ColorPresentationRequest, CompletionOptions,
    CompletionRequest as Completion, CompletionResolveRequest as ResolveCompletionItem,
    DeclarationOptions, DeclarationRequest as GotoDeclaration, DefinitionOptions,
    DefinitionRequest as GotoDefinition, DiagnosticOptions,
    DidChangeWatchedFilesNotification as DidChangeWatchedFiles,
    DidCreateFilesNotification as DidCreateFiles, DidDeleteFilesNotification as DidDeleteFiles,
    DidRenameFilesNotification as DidRenameFiles, DocumentColorOptions as ColorProviderOptions,
    DocumentColorRequest as DocumentColor, DocumentDiagnosticRequest, DocumentFormattingOptions,
    DocumentFormattingRequest as Formatting, DocumentHighlightOptions, DocumentHighlightRequest,
    DocumentLinkOptions, DocumentLinkRequest, DocumentLinkResolveRequest as DocumentLinkResolve,
    DocumentOnTypeFormattingOptions, DocumentOnTypeFormattingRequest as OnTypeFormatting,
    DocumentRangeFormattingOptions, DocumentRangeFormattingRequest as RangeFormatting,
    DocumentRangesFormattingRequest, DocumentSymbolOptions, DocumentSymbolRequest,
    FileOperationRegistrationOptions, FoldingRangeOptions as FoldingProviderOptions,
    FoldingRangeRequest, HoverRequest, ImplementationRegistrationOptions,
    ImplementationRequest as GotoImplementation, InlayHintOptions, InlayHintRequest,
    InlayHintResolveRequest, InlineCompletionOptions, InlineCompletionRequest, InlineValueOptions,
    InlineValueRequest, LinkedEditingRangeOptions, LinkedEditingRangeRequest as LinkedEditingRange,
    MonikerOptions, MonikerRequest, PrepareRenameRequest, ReferenceOptions as ReferencesOptions,
    ReferencesRequest as References, RenameOptions, RenameRequest as Rename, SelectionRangeOptions,
    SelectionRangeRequest, SemanticTokensDeltaRequest as SemanticTokensFullDeltaRequest,
    SemanticTokensOptions, SemanticTokensRangeRequest,
    SemanticTokensRequest as SemanticTokensFullRequest, SignatureHelpOptions, SignatureHelpRequest,
    TextDocumentContentOptions, TextDocumentContentRequest, TypeDefinitionRegistrationOptions,
    TypeDefinitionRequest as GotoTypeDefinition, TypeHierarchyOptions,
    TypeHierarchyPrepareRequest as TypeHierarchyPrepare,
    TypeHierarchySubtypesRequest as TypeHierarchySubtypes,
    TypeHierarchySupertypesRequest as TypeHierarchySupertypes,
    WillCreateFilesRequest as WillCreateFiles, WillDeleteFilesRequest as WillDeleteFiles,
    WillRenameFilesRequest as WillRenameFiles,
    WillSaveTextDocumentWaitUntilRequest as WillSaveWaitUntil, WorkspaceDiagnosticRequest,
    WorkspaceSymbolOptions, WorkspaceSymbolRequest,
    WorkspaceSymbolResolveRequest as WorkspaceSymbolResolve,
};

use crate::capability::CapabilityBuilder;
use crate::error::BuildError;
use crate::types::notification::Notification;
use crate::types::request::Request;

pub(crate) mod sealed {
    use crate::capability::CapabilityBuilder;
    use crate::error::BuildError;

    /// The in-crate half of [`FeatureSpec`](super::FeatureSpec). Being only
    /// `pub(crate)` it both seals the public trait against downstream
    /// implementations and keeps the internal [`CapabilityBuilder`] out of the
    /// public API.
    ///
    /// `contribute` names the crate-private `CapabilityBuilder`, which the
    /// public `FeatureSpec` supertrait bound technically makes reachable. The
    /// leak is inert — `Sealed` cannot be implemented and `CapabilityBuilder`
    /// cannot be named or constructed outside the crate — so the lint is
    /// silenced deliberately.
    #[allow(private_interfaces)]
    pub trait Sealed {
        /// Record this feature's contribution to the capability catalog, or
        /// return a [`BuildError`] if it conflicts with an existing one.
        fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError>;

        /// Classify a second registration of this descriptor's request method.
        fn duplicate_error(&self, method: String) -> BuildError {
            BuildError::DuplicateMethod(method)
        }
    }
}

/// The sealed descriptor contract for a standard LSP feature (ADR 0017).
///
/// [`Marker`](Self::Marker) is the `gen_lsp_types` request marker fixing the wire
/// method and the typed parameter and result types dispatch uses. The
/// capability contribution lives on the sealed in-crate supertrait, so this
/// trait is usable but not implementable downstream. Implemented only by the
/// descriptors returned from this module.
pub trait FeatureSpec: sealed::Sealed {
    /// The request marker this feature dispatches, fixing its method and its
    /// parameter and result types.
    type Marker: Request;
}

/// The sealed descriptor contract for a standard LSP notification feature
/// (ADR 0017).
///
/// The notification counterpart of [`FeatureSpec`]: [`Marker`](Self::Marker)
/// is the `gen_lsp_types` notification marker fixing the wire method and the typed
/// parameter type dispatch uses. Registered through
/// [`ServerBuilder::feature_notification`](crate::ServerBuilder::feature_notification).
/// Implemented only by the descriptors returned from this module.
pub trait NotificationFeatureSpec: sealed::Sealed {
    /// The notification marker this feature dispatches, fixing its method and
    /// its parameter type.
    type Marker: Notification;
}

/// The `textDocument/willSaveWaitUntil` request feature descriptor.
pub struct WillSaveWaitUntilFeature(());

/// Describe the typed pre-save edit request. Its registration contributes
/// `willSaveWaitUntil: true` to the effective text-document sync options.
pub fn will_save_wait_until() -> WillSaveWaitUntilFeature {
    WillSaveWaitUntilFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for WillSaveWaitUntilFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_will_save_wait_until();
        Ok(())
    }
}
impl FeatureSpec for WillSaveWaitUntilFeature {
    type Marker = WillSaveWaitUntil;
}

/// The `textDocument/hover` feature descriptor. Construct it with [`hover`].
pub struct HoverFeature(());

/// Describe the standard hover feature: it dispatches
/// [`HoverParams`](gen_lsp_types::HoverParams), returns
/// [`Option<Hover>`](gen_lsp_types::Hover), and advertises `hoverProvider`.
pub fn hover() -> HoverFeature {
    HoverFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for HoverFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_hover()
    }
}
impl FeatureSpec for HoverFeature {
    type Marker = HoverRequest;
}

/// The `textDocument/signatureHelp` feature descriptor. Construct it with
/// [`signature_help`].
pub struct SignatureHelpFeature {
    options: SignatureHelpOptions,
}

/// Describe the standard signature-help feature: it dispatches the lsp-types
/// [`SignatureHelpRequest`] marker — typed
/// [`SignatureHelpParams`](gen_lsp_types::SignatureHelpParams) in, optional
/// [`SignatureHelp`](gen_lsp_types::SignatureHelp) out — and advertises the
/// supplied [`SignatureHelpOptions`] as `signatureHelpProvider`.
pub fn signature_help(options: SignatureHelpOptions) -> SignatureHelpFeature {
    SignatureHelpFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for SignatureHelpFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_signature_help(self.options.clone())
    }
}
impl FeatureSpec for SignatureHelpFeature {
    type Marker = SignatureHelpRequest;
}

/// The `textDocument/declaration` feature descriptor. Construct it with
/// [`declaration`].
pub struct DeclarationFeature {
    options: DeclarationOptions,
}

/// Describe the standard declaration feature: it dispatches the lsp-types
/// [`GotoDeclaration`] marker and advertises the supplied [`DeclarationOptions`]
/// as the singular `declarationProvider` capability.
pub fn declaration(options: DeclarationOptions) -> DeclarationFeature {
    DeclarationFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for DeclarationFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_declaration(self.options)
    }
}
impl FeatureSpec for DeclarationFeature {
    type Marker = GotoDeclaration;
}

/// The `textDocument/definition` feature descriptor. Construct it with
/// [`definition`].
pub struct DefinitionFeature {
    options: DefinitionOptions,
}

/// Describe the standard definition feature: it dispatches the lsp-types
/// [`GotoDefinition`] marker and advertises the supplied [`DefinitionOptions`]
/// as the singular `definitionProvider` capability.
pub fn definition(options: DefinitionOptions) -> DefinitionFeature {
    DefinitionFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for DefinitionFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_definition(self.options)
    }
}
impl FeatureSpec for DefinitionFeature {
    type Marker = GotoDefinition;
}

/// The `textDocument/typeDefinition` feature descriptor. Construct it with
/// [`type_definition`].
pub struct TypeDefinitionFeature {
    options: TypeDefinitionRegistrationOptions,
}

/// Describe the standard type-definition feature: it dispatches the lsp-types
/// [`GotoTypeDefinition`] marker and advertises the supplied
/// [`TypeDefinitionRegistrationOptions`] as the singular
/// `typeDefinitionProvider` capability.
pub fn type_definition(options: TypeDefinitionRegistrationOptions) -> TypeDefinitionFeature {
    TypeDefinitionFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for TypeDefinitionFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_type_definition(self.options.clone())
    }
}
impl FeatureSpec for TypeDefinitionFeature {
    type Marker = GotoTypeDefinition;
}

/// The `textDocument/implementation` feature descriptor. Construct it with
/// [`implementation`].
pub struct ImplementationFeature {
    options: ImplementationRegistrationOptions,
}

/// Describe the standard implementation feature: it dispatches the lsp-types
/// [`GotoImplementation`] marker and advertises the supplied
/// [`ImplementationRegistrationOptions`] as the singular
/// `implementationProvider` capability.
pub fn implementation(options: ImplementationRegistrationOptions) -> ImplementationFeature {
    ImplementationFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for ImplementationFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_implementation(self.options.clone())
    }
}
impl FeatureSpec for ImplementationFeature {
    type Marker = GotoImplementation;
}

/// The `textDocument/references` feature descriptor. Construct it with
/// [`references`].
pub struct ReferencesFeature {
    options: ReferencesOptions,
}

/// Describe the standard references feature: it dispatches the lsp-types
/// [`References`] marker and advertises the supplied [`ReferencesOptions`] as
/// the singular `referencesProvider` capability.
pub fn references(options: ReferencesOptions) -> ReferencesFeature {
    ReferencesFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for ReferencesFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_references(self.options)
    }
}
impl FeatureSpec for ReferencesFeature {
    type Marker = References;
}

/// The `textDocument/documentHighlight` feature descriptor. Construct it with
/// [`document_highlight`].
pub struct DocumentHighlightFeature {
    options: DocumentHighlightOptions,
}

/// Describe the standard document-highlight feature: it dispatches the
/// lsp-types [`DocumentHighlightRequest`] marker and advertises the supplied
/// [`DocumentHighlightOptions`] as the singular `documentHighlightProvider`
/// capability.
pub fn document_highlight(options: DocumentHighlightOptions) -> DocumentHighlightFeature {
    DocumentHighlightFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for DocumentHighlightFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_document_highlight(self.options)
    }
}
impl FeatureSpec for DocumentHighlightFeature {
    type Marker = DocumentHighlightRequest;
}

/// The `textDocument/documentSymbol` feature descriptor. Construct it with
/// [`document_symbol`].
pub struct DocumentSymbolFeature {
    options: DocumentSymbolOptions,
}

/// Describe the standard document-symbol feature: it dispatches the lsp-types
/// [`DocumentSymbolRequest`] marker and advertises the supplied
/// [`DocumentSymbolOptions`] as the singular `documentSymbolProvider`
/// capability.
pub fn document_symbol(options: DocumentSymbolOptions) -> DocumentSymbolFeature {
    DocumentSymbolFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for DocumentSymbolFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_document_symbol(self.options.clone())
    }
}
impl FeatureSpec for DocumentSymbolFeature {
    type Marker = DocumentSymbolRequest;
}

/// The `textDocument/linkedEditingRange` feature descriptor. Construct it with
/// [`linked_editing_range`].
pub struct LinkedEditingRangeFeature {
    options: LinkedEditingRangeOptions,
}

/// Describe the standard linked-editing-range feature: it dispatches the
/// lsp-types [`LinkedEditingRange`] marker and advertises the supplied
/// [`LinkedEditingRangeOptions`] as the singular `linkedEditingRangeProvider`
/// capability.
pub fn linked_editing_range(options: LinkedEditingRangeOptions) -> LinkedEditingRangeFeature {
    LinkedEditingRangeFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for LinkedEditingRangeFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_linked_editing_range(self.options)
    }
}
impl FeatureSpec for LinkedEditingRangeFeature {
    type Marker = LinkedEditingRange;
}

/// The `textDocument/moniker` feature descriptor. Construct it with
/// [`moniker`].
pub struct MonikerFeature {
    options: MonikerOptions,
}

/// Describe the standard moniker feature: it dispatches the lsp-types
/// [`MonikerRequest`] marker and advertises the supplied [`MonikerOptions`] as
/// the singular `monikerProvider` capability.
pub fn moniker(options: MonikerOptions) -> MonikerFeature {
    MonikerFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for MonikerFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_moniker(self.options)
    }
}
impl FeatureSpec for MonikerFeature {
    type Marker = MonikerRequest;
}

/// The `textDocument/formatting` feature descriptor.
pub struct DocumentFormattingFeature {
    options: DocumentFormattingOptions,
}

/// Describe whole-document formatting and its provider options.
pub fn document_formatting(options: DocumentFormattingOptions) -> DocumentFormattingFeature {
    DocumentFormattingFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for DocumentFormattingFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_document_formatting(self.options)
    }
}
impl FeatureSpec for DocumentFormattingFeature {
    type Marker = Formatting;
}

/// The `textDocument/rangeFormatting` feature descriptor.
pub struct RangeFormattingFeature {
    options: DocumentRangeFormattingOptions,
}

/// Describe range formatting and its provider options.
pub fn range_formatting(options: DocumentRangeFormattingOptions) -> RangeFormattingFeature {
    RangeFormattingFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for RangeFormattingFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_range_formatting(self.options)
    }
}
impl FeatureSpec for RangeFormattingFeature {
    type Marker = RangeFormatting;
}

/// The `textDocument/rangesFormatting` feature descriptor.
pub struct RangesFormattingFeature {
    options: DocumentRangeFormattingOptions,
}

/// Describe multiple-ranges formatting and its shared range provider options.
pub fn ranges_formatting(options: DocumentRangeFormattingOptions) -> RangesFormattingFeature {
    RangesFormattingFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for RangesFormattingFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_ranges_formatting(self.options)
    }

    fn duplicate_error(&self, _method: String) -> BuildError {
        BuildError::ConflictingCapability {
            field: "documentRangeFormattingProvider",
        }
    }
}
impl FeatureSpec for RangesFormattingFeature {
    type Marker = DocumentRangesFormattingRequest;
}

/// The `textDocument/inlineCompletion` feature descriptor.
pub struct InlineCompletionFeature {
    options: InlineCompletionOptions,
}

/// Describe inline completion and its provider options.
pub fn inline_completion(options: InlineCompletionOptions) -> InlineCompletionFeature {
    InlineCompletionFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for InlineCompletionFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_inline_completion(self.options)
    }

    fn duplicate_error(&self, _method: String) -> BuildError {
        BuildError::ConflictingCapability {
            field: "inlineCompletionProvider",
        }
    }
}
impl FeatureSpec for InlineCompletionFeature {
    type Marker = InlineCompletionRequest;
}

/// The `workspace/textDocumentContent` feature descriptor.
pub struct TextDocumentContentFeature {
    options: TextDocumentContentOptions,
}

/// Describe virtual text-document content and the URI schemes it serves.
pub fn text_document_content(options: TextDocumentContentOptions) -> TextDocumentContentFeature {
    TextDocumentContentFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for TextDocumentContentFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_text_document_content(self.options.clone())
    }

    fn duplicate_error(&self, _method: String) -> BuildError {
        BuildError::ConflictingCapability {
            field: "workspace.textDocumentContent",
        }
    }
}
impl FeatureSpec for TextDocumentContentFeature {
    type Marker = TextDocumentContentRequest;
}

/// The `textDocument/onTypeFormatting` feature descriptor.
pub struct OnTypeFormattingFeature {
    options: DocumentOnTypeFormattingOptions,
}

/// Describe on-type formatting and its trigger-character options.
pub fn on_type_formatting(options: DocumentOnTypeFormattingOptions) -> OnTypeFormattingFeature {
    OnTypeFormattingFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for OnTypeFormattingFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_on_type_formatting(self.options.clone())
    }
}
impl FeatureSpec for OnTypeFormattingFeature {
    type Marker = OnTypeFormatting;
}

/// The `textDocument/documentColor` feature descriptor.
pub struct DocumentColorFeature {
    options: ColorProviderOptions,
}

/// Describe document-color discovery and the shared color provider.
pub fn document_color(options: ColorProviderOptions) -> DocumentColorFeature {
    DocumentColorFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for DocumentColorFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_document_color(self.options)
    }
}
impl FeatureSpec for DocumentColorFeature {
    type Marker = DocumentColor;
}

/// The `textDocument/colorPresentation` feature descriptor.
pub struct ColorPresentationFeature(());

/// Describe color presentation, the subordinate route of `colorProvider`.
pub fn color_presentation() -> ColorPresentationFeature {
    ColorPresentationFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for ColorPresentationFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_color_presentation();
        Ok(())
    }
}
impl FeatureSpec for ColorPresentationFeature {
    type Marker = ColorPresentationRequest;
}

/// The `textDocument/foldingRange` feature descriptor.
pub struct FoldingRangeFeature {
    options: FoldingProviderOptions,
}

/// Describe folding-range discovery and its provider options.
pub fn folding_range(options: FoldingProviderOptions) -> FoldingRangeFeature {
    FoldingRangeFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for FoldingRangeFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_folding_range(self.options)
    }
}
impl FeatureSpec for FoldingRangeFeature {
    type Marker = FoldingRangeRequest;
}

/// The `textDocument/selectionRange` feature descriptor.
pub struct SelectionRangeFeature {
    options: SelectionRangeOptions,
}

/// Describe selection-range discovery and its provider options.
pub fn selection_range(options: SelectionRangeOptions) -> SelectionRangeFeature {
    SelectionRangeFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for SelectionRangeFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_selection_range(self.options)
    }
}
impl FeatureSpec for SelectionRangeFeature {
    type Marker = SelectionRangeRequest;
}

/// The `textDocument/inlineValue` feature descriptor.
pub struct InlineValueFeature {
    options: InlineValueOptions,
}

/// Describe inline-value calculation and its provider options.
pub fn inline_value(options: InlineValueOptions) -> InlineValueFeature {
    InlineValueFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for InlineValueFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_inline_value(self.options)
    }
}
impl FeatureSpec for InlineValueFeature {
    type Marker = InlineValueRequest;
}

/// The `textDocument/prepareCallHierarchy` feature descriptor.
pub struct CallHierarchyPrepareFeature {
    options: CallHierarchyOptions,
}

/// Describe the call-hierarchy prepare feature and its single provider
/// capability. Incoming and outgoing call routes depend on this feature.
pub fn call_hierarchy_prepare(options: CallHierarchyOptions) -> CallHierarchyPrepareFeature {
    CallHierarchyPrepareFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for CallHierarchyPrepareFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_call_hierarchy(self.options)
    }
}
impl FeatureSpec for CallHierarchyPrepareFeature {
    type Marker = CallHierarchyPrepare;
}

/// The `callHierarchy/incomingCalls` feature descriptor.
pub struct CallHierarchyIncomingCallsFeature(());

/// Describe the incoming-call route. It contributes membership to the
/// call-hierarchy family without emitting a second provider capability.
pub fn call_hierarchy_incoming_calls() -> CallHierarchyIncomingCallsFeature {
    CallHierarchyIncomingCallsFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for CallHierarchyIncomingCallsFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_call_hierarchy_incoming_calls();
        Ok(())
    }
}
impl FeatureSpec for CallHierarchyIncomingCallsFeature {
    type Marker = CallHierarchyIncomingCalls;
}

/// The `callHierarchy/outgoingCalls` feature descriptor.
pub struct CallHierarchyOutgoingCallsFeature(());

/// Describe the outgoing-call route. It contributes membership to the
/// call-hierarchy family without emitting a second provider capability.
pub fn call_hierarchy_outgoing_calls() -> CallHierarchyOutgoingCallsFeature {
    CallHierarchyOutgoingCallsFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for CallHierarchyOutgoingCallsFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_call_hierarchy_outgoing_calls();
        Ok(())
    }
}
impl FeatureSpec for CallHierarchyOutgoingCallsFeature {
    type Marker = CallHierarchyOutgoingCalls;
}

/// The `textDocument/prepareTypeHierarchy` feature descriptor.
pub struct TypeHierarchyPrepareFeature {
    options: TypeHierarchyOptions,
}

/// Describe the type-hierarchy prepare feature and its single provider
/// capability. Supertype and subtype routes depend on this feature.
pub fn type_hierarchy_prepare(options: TypeHierarchyOptions) -> TypeHierarchyPrepareFeature {
    TypeHierarchyPrepareFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for TypeHierarchyPrepareFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_type_hierarchy(self.options)
    }
}
impl FeatureSpec for TypeHierarchyPrepareFeature {
    type Marker = TypeHierarchyPrepare;
}

/// The `typeHierarchy/supertypes` feature descriptor.
pub struct TypeHierarchySupertypesFeature(());

/// Describe the supertype route without emitting another prepare capability.
pub fn type_hierarchy_supertypes() -> TypeHierarchySupertypesFeature {
    TypeHierarchySupertypesFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for TypeHierarchySupertypesFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_type_hierarchy_supertypes();
        Ok(())
    }
}
impl FeatureSpec for TypeHierarchySupertypesFeature {
    type Marker = TypeHierarchySupertypes;
}

/// The `typeHierarchy/subtypes` feature descriptor.
pub struct TypeHierarchySubtypesFeature(());

/// Describe the subtype route without emitting another prepare capability.
pub fn type_hierarchy_subtypes() -> TypeHierarchySubtypesFeature {
    TypeHierarchySubtypesFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for TypeHierarchySubtypesFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_type_hierarchy_subtypes();
        Ok(())
    }
}
impl FeatureSpec for TypeHierarchySubtypesFeature {
    type Marker = TypeHierarchySubtypes;
}

/// The `textDocument/semanticTokens/full` feature descriptor.
pub struct SemanticTokensFullFeature {
    options: SemanticTokensOptions,
}

/// Describe full-document semantic tokens. All semantic-token descriptors in
/// one family must agree on their legend and shared options.
pub fn semantic_tokens_full(options: SemanticTokensOptions) -> SemanticTokensFullFeature {
    SemanticTokensFullFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for SemanticTokensFullFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_semantic_tokens_full(self.options.clone())
    }
}
impl FeatureSpec for SemanticTokensFullFeature {
    type Marker = SemanticTokensFullRequest;
}

/// The `textDocument/semanticTokens/full/delta` feature descriptor.
pub struct SemanticTokensFullDeltaFeature {
    options: SemanticTokensOptions,
}

/// Describe semantic-token deltas, which depend on the full-document route.
pub fn semantic_tokens_full_delta(
    options: SemanticTokensOptions,
) -> SemanticTokensFullDeltaFeature {
    SemanticTokensFullDeltaFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for SemanticTokensFullDeltaFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_semantic_tokens_full_delta(self.options.clone())
    }
}
impl FeatureSpec for SemanticTokensFullDeltaFeature {
    type Marker = SemanticTokensFullDeltaRequest;
}

/// The `textDocument/semanticTokens/range` feature descriptor.
pub struct SemanticTokensRangeFeature {
    options: SemanticTokensOptions,
}

/// Describe range semantic tokens and merge them into the family's one
/// provider capability.
pub fn semantic_tokens_range(options: SemanticTokensOptions) -> SemanticTokensRangeFeature {
    SemanticTokensRangeFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for SemanticTokensRangeFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_semantic_tokens_range(self.options.clone())
    }
}
impl FeatureSpec for SemanticTokensRangeFeature {
    type Marker = SemanticTokensRangeRequest;
}

/// The `textDocument/completion` feature descriptor. Construct it with
/// [`completion`].
pub struct CompletionFeature {
    options: CompletionOptions,
}

/// Describe the standard completion feature: it dispatches the lsp-types
/// [`Completion`] marker and advertises the supplied [`CompletionOptions`] as
/// `completionProvider`.
pub fn completion(options: CompletionOptions) -> CompletionFeature {
    CompletionFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for CompletionFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_completion(self.options.clone())
    }
}
impl FeatureSpec for CompletionFeature {
    type Marker = Completion;
}

/// The `completionItem/resolve` feature descriptor. Construct it with
/// [`completion_resolve`].
pub struct CompletionResolveFeature(());

/// Describe the standard completion-item resolve feature: it dispatches the
/// lsp-types [`ResolveCompletionItem`] marker — a typed
/// [`CompletionItem`](gen_lsp_types::CompletionItem) in and out — and augments
/// the completion family's capability with `resolveProvider`.
///
/// Resolve is a dependent feature: registering it without the base
/// [`completion`] feature fails validation with
/// [`BuildError::ConflictingCapability`]
/// rather than advertising a dangling `resolveProvider`.
pub fn completion_resolve() -> CompletionResolveFeature {
    CompletionResolveFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for CompletionResolveFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_completion_resolve();
        Ok(())
    }
}
impl FeatureSpec for CompletionResolveFeature {
    type Marker = ResolveCompletionItem;
}

/// The `textDocument/diagnostic` feature descriptor. Construct it with
/// [`document_diagnostic`].
pub struct DocumentDiagnosticFeature {
    options: DiagnosticOptions,
}

/// Describe document diagnostics with the shared pull-diagnostics provider
/// options and the exact [`DocumentDiagnosticRequest`] wire contract.
pub fn document_diagnostic(options: DiagnosticOptions) -> DocumentDiagnosticFeature {
    DocumentDiagnosticFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for DocumentDiagnosticFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_diagnostics(self.options.clone())
    }
}
impl FeatureSpec for DocumentDiagnosticFeature {
    type Marker = DocumentDiagnosticRequest;
}

/// The `workspace/diagnostic` feature descriptor. Construct it with
/// [`workspace_diagnostic`].
pub struct WorkspaceDiagnosticFeature {
    options: DiagnosticOptions,
}

/// Describe workspace diagnostics with the shared pull-diagnostics provider
/// options and the exact [`WorkspaceDiagnosticRequest`] wire contract.
pub fn workspace_diagnostic(options: DiagnosticOptions) -> WorkspaceDiagnosticFeature {
    WorkspaceDiagnosticFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for WorkspaceDiagnosticFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_diagnostics(self.options.clone())
    }
}
impl FeatureSpec for WorkspaceDiagnosticFeature {
    type Marker = WorkspaceDiagnosticRequest;
}

/// The `workspace/symbol` feature descriptor. Construct it with
/// [`workspace_symbol`].
pub struct WorkspaceSymbolFeature {
    options: WorkspaceSymbolOptions,
}

/// Describe the standard workspace-symbol feature: it dispatches the
/// lsp-types [`WorkspaceSymbolRequest`] marker and advertises the supplied
/// [`WorkspaceSymbolOptions`] as the base of the `workspaceSymbolProvider`
/// capability family.
pub fn workspace_symbol(options: WorkspaceSymbolOptions) -> WorkspaceSymbolFeature {
    WorkspaceSymbolFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for WorkspaceSymbolFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_workspace_symbol(self.options)
    }
}
impl FeatureSpec for WorkspaceSymbolFeature {
    type Marker = WorkspaceSymbolRequest;
}

/// The `workspaceSymbol/resolve` feature descriptor. Construct it with
/// [`workspace_symbol_resolve`].
pub struct WorkspaceSymbolResolveFeature(());

/// Describe the standard workspace-symbol resolve feature: it dispatches the
/// lsp-types [`WorkspaceSymbolResolve`] marker — a typed
/// [`WorkspaceSymbol`](gen_lsp_types::WorkspaceSymbol) in and out — and augments
/// the workspace-symbol family's capability with `resolveProvider`.
///
/// Resolve is a dependent feature: registering it without the base
/// [`workspace_symbol`] feature fails validation with
/// [`BuildError::ConflictingCapability`]
/// rather than advertising a dangling `resolveProvider`.
pub fn workspace_symbol_resolve() -> WorkspaceSymbolResolveFeature {
    WorkspaceSymbolResolveFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for WorkspaceSymbolResolveFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_workspace_symbol_resolve();
        Ok(())
    }
}
impl FeatureSpec for WorkspaceSymbolResolveFeature {
    type Marker = WorkspaceSymbolResolve;
}

/// The `textDocument/rename` feature descriptor. Construct it with [`rename`].
pub struct RenameFeature {
    options: RenameOptions,
}

/// Describe the standard rename feature: it dispatches the lsp-types
/// [`Rename`] marker and advertises the supplied [`RenameOptions`] as the base
/// of the `renameProvider` capability family.
pub fn rename(options: RenameOptions) -> RenameFeature {
    RenameFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for RenameFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_rename(self.options)
    }
}
impl FeatureSpec for RenameFeature {
    type Marker = Rename;
}

/// The `textDocument/prepareRename` feature descriptor. Construct it with
/// [`prepare_rename`].
pub struct PrepareRenameFeature(());

/// Describe the standard prepare-rename feature: it dispatches the lsp-types
/// [`PrepareRenameRequest`] marker and augments the rename family's capability
/// with `prepareProvider`.
///
/// Prepare rename is a dependent feature: registering it without the base
/// [`rename`] feature fails validation with
/// [`BuildError::ConflictingCapability`]
/// rather than advertising a dangling `prepareProvider`.
pub fn prepare_rename() -> PrepareRenameFeature {
    PrepareRenameFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for PrepareRenameFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_prepare_rename();
        Ok(())
    }
}
impl FeatureSpec for PrepareRenameFeature {
    type Marker = PrepareRenameRequest;
}

/// The `textDocument/codeAction` feature descriptor. Construct it with
/// [`code_action`].
pub struct CodeActionFeature {
    options: CodeActionOptions,
}

/// Describe the standard code-action feature: it dispatches the lsp-types
/// [`CodeActionRequest`] marker and advertises the supplied
/// [`CodeActionOptions`] as the base of the `codeActionProvider` capability
/// family.
pub fn code_action(options: CodeActionOptions) -> CodeActionFeature {
    CodeActionFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for CodeActionFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_code_action(self.options.clone())
    }
}
impl FeatureSpec for CodeActionFeature {
    type Marker = CodeActionRequest;
}

/// The `codeAction/resolve` feature descriptor. Construct it with
/// [`code_action_resolve`].
pub struct CodeActionResolveFeature(());

/// Describe the standard code-action resolve feature: it dispatches the
/// lsp-types [`CodeActionResolveRequest`] marker — a typed
/// [`CodeAction`](gen_lsp_types::CodeAction) in and out — and augments the
/// code-action family's capability with `resolveProvider`.
///
/// Resolve is a dependent feature: registering it without the base
/// [`code_action`] feature fails validation with
/// [`BuildError::ConflictingCapability`]
/// rather than advertising a dangling `resolveProvider`.
pub fn code_action_resolve() -> CodeActionResolveFeature {
    CodeActionResolveFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for CodeActionResolveFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_code_action_resolve();
        Ok(())
    }
}
impl FeatureSpec for CodeActionResolveFeature {
    type Marker = CodeActionResolveRequest;
}

/// The `textDocument/codeLens` feature descriptor. Construct it with
/// [`code_lens`].
pub struct CodeLensFeature {
    options: CodeLensOptions,
}

/// Describe the standard code-lens feature: it dispatches the lsp-types
/// [`CodeLensRequest`] marker and advertises the supplied [`CodeLensOptions`]
/// as the base of the `codeLensProvider` capability family.
pub fn code_lens(options: CodeLensOptions) -> CodeLensFeature {
    CodeLensFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for CodeLensFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_code_lens(self.options)
    }
}
impl FeatureSpec for CodeLensFeature {
    type Marker = CodeLensRequest;
}

/// The `codeLens/resolve` feature descriptor. Construct it with
/// [`code_lens_resolve`].
pub struct CodeLensResolveFeature(());

/// Describe the standard code-lens resolve feature: it dispatches the
/// lsp-types [`CodeLensResolve`] marker — a typed
/// [`CodeLens`](gen_lsp_types::CodeLens) in and out — and augments the code-lens
/// family's capability with `resolveProvider`.
///
/// Resolve is a dependent feature: registering it without the base
/// [`code_lens`] feature fails validation with
/// [`BuildError::ConflictingCapability`]
/// rather than advertising a dangling `resolveProvider`.
pub fn code_lens_resolve() -> CodeLensResolveFeature {
    CodeLensResolveFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for CodeLensResolveFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_code_lens_resolve();
        Ok(())
    }
}
impl FeatureSpec for CodeLensResolveFeature {
    type Marker = CodeLensResolve;
}

/// The `textDocument/documentLink` feature descriptor. Construct it with
/// [`document_link`].
pub struct DocumentLinkFeature {
    options: DocumentLinkOptions,
}

/// Describe the standard document-link feature: it dispatches the lsp-types
/// [`DocumentLinkRequest`] marker and advertises the supplied
/// [`DocumentLinkOptions`] as the base of the `documentLinkProvider`
/// capability family.
pub fn document_link(options: DocumentLinkOptions) -> DocumentLinkFeature {
    DocumentLinkFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for DocumentLinkFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_document_link(self.options)
    }
}
impl FeatureSpec for DocumentLinkFeature {
    type Marker = DocumentLinkRequest;
}

/// The `documentLink/resolve` feature descriptor. Construct it with
/// [`document_link_resolve`].
pub struct DocumentLinkResolveFeature(());

/// Describe the standard document-link resolve feature: it dispatches the
/// lsp-types [`DocumentLinkResolve`] marker — a typed
/// [`DocumentLink`](gen_lsp_types::DocumentLink) in and out — and augments the
/// document-link family's capability with `resolveProvider`.
///
/// Resolve is a dependent feature: registering it without the base
/// [`document_link`] feature fails validation with
/// [`BuildError::ConflictingCapability`]
/// rather than advertising a dangling `resolveProvider`.
pub fn document_link_resolve() -> DocumentLinkResolveFeature {
    DocumentLinkResolveFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for DocumentLinkResolveFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_document_link_resolve();
        Ok(())
    }
}
impl FeatureSpec for DocumentLinkResolveFeature {
    type Marker = DocumentLinkResolve;
}

/// The `textDocument/inlayHint` feature descriptor. Construct it with
/// [`inlay_hint`].
pub struct InlayHintFeature {
    options: InlayHintOptions,
}

/// Describe the standard inlay-hint feature: it dispatches the lsp-types
/// [`InlayHintRequest`] marker and advertises the supplied [`InlayHintOptions`]
/// as the base of the `inlayHintProvider` capability family.
pub fn inlay_hint(options: InlayHintOptions) -> InlayHintFeature {
    InlayHintFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for InlayHintFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_inlay_hint(self.options)
    }
}
impl FeatureSpec for InlayHintFeature {
    type Marker = InlayHintRequest;
}

/// The `inlayHint/resolve` feature descriptor. Construct it with
/// [`inlay_hint_resolve`].
pub struct InlayHintResolveFeature(());

/// Describe the standard inlay-hint resolve feature: it dispatches the
/// lsp-types [`InlayHintResolveRequest`] marker — a typed
/// [`InlayHint`](gen_lsp_types::InlayHint) in and out — and augments the
/// inlay-hint family's capability with `resolveProvider`.
///
/// Resolve is a dependent feature: registering it without the base
/// [`inlay_hint`] feature fails validation with
/// [`BuildError::ConflictingCapability`]
/// rather than advertising a dangling `resolveProvider`.
pub fn inlay_hint_resolve() -> InlayHintResolveFeature {
    InlayHintResolveFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for InlayHintResolveFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_inlay_hint_resolve();
        Ok(())
    }
}
impl FeatureSpec for InlayHintResolveFeature {
    type Marker = InlayHintResolveRequest;
}

/// The `workspace/willCreateFiles` feature descriptor. Construct it with
/// [`will_create_files`].
pub struct WillCreateFilesFeature {
    options: FileOperationRegistrationOptions,
}

/// Describe the standard will-create-files request: it dispatches the
/// lsp-types [`WillCreateFiles`] marker and contributes the supplied
/// [`FileOperationRegistrationOptions`] to the create file-operation family,
/// whose shared filters the family's capability advertises.
///
/// The create family is shared with [`did_create_files`]: both sides must
/// contribute identical filters, or the build fails with
/// [`BuildError::ConflictingCapability`].
pub fn will_create_files(options: FileOperationRegistrationOptions) -> WillCreateFilesFeature {
    WillCreateFilesFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for WillCreateFilesFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_will_create(self.options.clone())
    }
}
impl FeatureSpec for WillCreateFilesFeature {
    type Marker = WillCreateFiles;
}

/// The `workspace/willRenameFiles` feature descriptor. Construct it with
/// [`will_rename_files`].
pub struct WillRenameFilesFeature {
    options: FileOperationRegistrationOptions,
}

/// Describe the standard will-rename-files request: it dispatches the
/// lsp-types [`WillRenameFiles`] marker and contributes the supplied
/// [`FileOperationRegistrationOptions`] to the rename file-operation family,
/// whose shared filters the family's capability advertises.
///
/// The rename family is shared with [`did_rename_files`]: both sides must
/// contribute identical filters, or the build fails with
/// [`BuildError::ConflictingCapability`].
pub fn will_rename_files(options: FileOperationRegistrationOptions) -> WillRenameFilesFeature {
    WillRenameFilesFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for WillRenameFilesFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_will_rename(self.options.clone())
    }
}
impl FeatureSpec for WillRenameFilesFeature {
    type Marker = WillRenameFiles;
}

/// The `workspace/willDeleteFiles` feature descriptor. Construct it with
/// [`will_delete_files`].
pub struct WillDeleteFilesFeature {
    options: FileOperationRegistrationOptions,
}

/// Describe the standard will-delete-files request: it dispatches the
/// lsp-types [`WillDeleteFiles`] marker and contributes the supplied
/// [`FileOperationRegistrationOptions`] to the delete file-operation family,
/// whose shared filters the family's capability advertises.
///
/// The delete family is shared with [`did_delete_files`]: both sides must
/// contribute identical filters, or the build fails with
/// [`BuildError::ConflictingCapability`].
pub fn will_delete_files(options: FileOperationRegistrationOptions) -> WillDeleteFilesFeature {
    WillDeleteFilesFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for WillDeleteFilesFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_will_delete(self.options.clone())
    }
}
impl FeatureSpec for WillDeleteFilesFeature {
    type Marker = WillDeleteFiles;
}

/// The `workspace/didChangeWatchedFiles` notification feature descriptor.
/// Construct it with [`did_change_watched_files`].
pub struct DidChangeWatchedFilesFeature(());

/// Describe the standard watched-files notification feature: it dispatches
/// the lsp-types [`DidChangeWatchedFiles`] marker with typed
/// [`DidChangeWatchedFilesParams`](gen_lsp_types::DidChangeWatchedFilesParams).
///
/// LSP 3.17 has no server capability field for watched files — a server
/// subscribes through dynamic registration — so this descriptor contributes
/// nothing to the capability catalog. Registering through the descriptor
/// rather than [`notification`](crate::ServerBuilder::notification) keeps the
/// registration inside the sealed catalog.
pub fn did_change_watched_files() -> DidChangeWatchedFilesFeature {
    DidChangeWatchedFilesFeature(())
}

#[allow(private_interfaces)]
impl sealed::Sealed for DidChangeWatchedFilesFeature {
    fn contribute(&self, _caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        Ok(())
    }
}
impl NotificationFeatureSpec for DidChangeWatchedFilesFeature {
    type Marker = DidChangeWatchedFiles;
}

/// The `workspace/didCreateFiles` notification feature descriptor. Construct
/// it with [`did_create_files`].
pub struct DidCreateFilesFeature {
    options: FileOperationRegistrationOptions,
}

/// Describe the standard did-create-files notification feature: it dispatches
/// the lsp-types [`DidCreateFiles`] marker and contributes the supplied
/// [`FileOperationRegistrationOptions`] to the create file-operation family,
/// whose shared filters the family's capability advertises.
///
/// The create family is shared with [`will_create_files`]: both sides must
/// contribute identical filters, or the build fails with
/// [`BuildError::ConflictingCapability`].
pub fn did_create_files(options: FileOperationRegistrationOptions) -> DidCreateFilesFeature {
    DidCreateFilesFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for DidCreateFilesFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_did_create(self.options.clone())
    }
}
impl NotificationFeatureSpec for DidCreateFilesFeature {
    type Marker = DidCreateFiles;
}

/// The `workspace/didRenameFiles` notification feature descriptor. Construct
/// it with [`did_rename_files`].
pub struct DidRenameFilesFeature {
    options: FileOperationRegistrationOptions,
}

/// Describe the standard did-rename-files notification feature: it dispatches
/// the lsp-types [`DidRenameFiles`] marker and contributes the supplied
/// [`FileOperationRegistrationOptions`] to the rename file-operation family,
/// whose shared filters the family's capability advertises.
///
/// The rename family is shared with [`will_rename_files`]: both sides must
/// contribute identical filters, or the build fails with
/// [`BuildError::ConflictingCapability`].
pub fn did_rename_files(options: FileOperationRegistrationOptions) -> DidRenameFilesFeature {
    DidRenameFilesFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for DidRenameFilesFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_did_rename(self.options.clone())
    }
}
impl NotificationFeatureSpec for DidRenameFilesFeature {
    type Marker = DidRenameFiles;
}

/// The `workspace/didDeleteFiles` notification feature descriptor. Construct
/// it with [`did_delete_files`].
pub struct DidDeleteFilesFeature {
    options: FileOperationRegistrationOptions,
}

/// Describe the standard did-delete-files notification feature: it dispatches
/// the lsp-types [`DidDeleteFiles`] marker and contributes the supplied
/// [`FileOperationRegistrationOptions`] to the delete file-operation family,
/// whose shared filters the family's capability advertises.
///
/// The delete family is shared with [`will_delete_files`]: both sides must
/// contribute identical filters, or the build fails with
/// [`BuildError::ConflictingCapability`].
pub fn did_delete_files(options: FileOperationRegistrationOptions) -> DidDeleteFilesFeature {
    DidDeleteFilesFeature { options }
}

#[allow(private_interfaces)]
impl sealed::Sealed for DidDeleteFilesFeature {
    fn contribute(&self, caps: &mut CapabilityBuilder) -> Result<(), BuildError> {
        caps.set_did_delete(self.options.clone())
    }
}
impl NotificationFeatureSpec for DidDeleteFilesFeature {
    type Marker = DidDeleteFiles;
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::notification::{DidChangeWatchedFiles, DidCreateFiles};
    use crate::types::request::{
        CallHierarchyIncomingCalls, CallHierarchyOutgoingCalls, CallHierarchyPrepare,
        CodeActionRequest, CodeActionResolveRequest, CodeLensRequest, CodeLensResolve,
        ColorPresentationRequest, DocumentColor, DocumentDiagnosticRequest,
        DocumentHighlightRequest, DocumentLinkRequest, DocumentLinkResolve, DocumentSymbolRequest,
        FoldingRangeRequest, Formatting, GotoDeclaration, GotoDefinition, GotoImplementation,
        GotoTypeDefinition, InlayHintRequest, InlayHintResolveRequest, InlineValueRequest,
        LinkedEditingRange, MonikerRequest, OnTypeFormatting, PrepareRenameRequest,
        RangeFormatting, References, Rename, SelectionRangeRequest, SemanticTokensFullDeltaRequest,
        SemanticTokensFullRequest, SemanticTokensRangeRequest, SignatureHelpRequest,
        TypeHierarchyPrepare, TypeHierarchySubtypes, TypeHierarchySupertypes,
        WorkspaceDiagnosticRequest,
    };
    use gen_lsp_types::{
        CallHierarchyIncomingCall, CallHierarchyIncomingCallsParams, CallHierarchyItem,
        CallHierarchyOutgoingCall, CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams,
        CodeAction, CodeActionOptions, CodeActionParams, CodeActionResponse, CodeLens,
        CodeLensOptions, CodeLensParams, ColorInformation, ColorPresentation,
        ColorPresentationParams, CreateFilesParams, DeclarationOptions,
        DeclarationParams as GotoDeclarationParams, DeclarationResponse as GotoDeclarationResponse,
        DefinitionOptions, DefinitionParams as GotoDefinitionParams,
        DefinitionResponse as GotoDefinitionResponse, DeleteFilesParams, DiagnosticOptions,
        DidChangeWatchedFilesParams, DocumentColorOptions as ColorProviderOptions,
        DocumentColorParams, DocumentDiagnosticParams,
        DocumentDiagnosticReport as DocumentDiagnosticReportResult, DocumentFormattingOptions,
        DocumentFormattingParams, DocumentHighlight, DocumentHighlightOptions,
        DocumentHighlightParams, DocumentLink, DocumentLinkOptions, DocumentLinkParams,
        DocumentOnTypeFormattingOptions, DocumentOnTypeFormattingParams,
        DocumentRangeFormattingOptions, DocumentRangeFormattingParams, DocumentSymbolOptions,
        DocumentSymbolParams, DocumentSymbolResponse, FoldingRange,
        FoldingRangeOptions as FoldingProviderOptions, FoldingRangeParams,
        ImplementationParams as GotoImplementationParams, ImplementationRegistrationOptions,
        ImplementationResponse as GotoImplementationResponse, InlayHint, InlayHintOptions,
        InlayHintParams, InlineValue, InlineValueOptions, InlineValueParams,
        LinkedEditingRangeOptions, LinkedEditingRangeParams, LinkedEditingRanges, Location,
        Moniker, MonikerOptions, MonikerParams, PrepareRenameParams,
        PrepareRenameResult as PrepareRenameResponse, ReferenceOptions as ReferencesOptions,
        ReferenceParams, RenameFilesParams, RenameOptions, RenameParams, SelectionRange,
        SelectionRangeOptions, SelectionRangeParams, SemanticTokens, SemanticTokensDeltaParams,
        SemanticTokensDeltaResponse, SemanticTokensParams, SemanticTokensRangeParams,
        SignatureHelp, SignatureHelpOptions, SignatureHelpParams, TextEdit,
        TypeDefinitionParams as GotoTypeDefinitionParams, TypeDefinitionRegistrationOptions,
        TypeDefinitionResponse as GotoTypeDefinitionResponse, TypeHierarchyItem,
        TypeHierarchyPrepareParams, TypeHierarchySubtypesParams, TypeHierarchySupertypesParams,
        WorkspaceDiagnosticParams, WorkspaceDiagnosticReport as WorkspaceDiagnosticReportResult,
        WorkspaceEdit, WorkspaceSymbol, WorkspaceSymbolParams, WorkspaceSymbolResponse,
    };

    fn assert_formatting_descriptor<F: FeatureSpec<Marker = Formatting>>(_: F) {}
    fn assert_range_formatting_descriptor<F: FeatureSpec<Marker = RangeFormatting>>(_: F) {}
    fn assert_on_type_formatting_descriptor<F: FeatureSpec<Marker = OnTypeFormatting>>(_: F) {}

    fn assert_formatting_contract<R>()
    where
        R: Request<Params = DocumentFormattingParams, Result = Option<Vec<TextEdit>>>,
    {
    }

    fn assert_range_formatting_contract<R>()
    where
        R: Request<Params = DocumentRangeFormattingParams, Result = Option<Vec<TextEdit>>>,
    {
    }

    fn assert_on_type_formatting_contract<R>()
    where
        R: Request<Params = DocumentOnTypeFormattingParams, Result = Option<Vec<TextEdit>>>,
    {
    }

    #[test]
    fn formatting_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_formatting_descriptor(document_formatting(DocumentFormattingOptions::default()));
        assert_range_formatting_descriptor(range_formatting(DocumentRangeFormattingOptions {
            work_done_progress_options: Default::default(),
            ..Default::default()
        }));
        assert_on_type_formatting_descriptor(on_type_formatting(
            DocumentOnTypeFormattingOptions::default(),
        ));
        assert_formatting_contract::<Formatting>();
        assert_range_formatting_contract::<RangeFormatting>();
        assert_on_type_formatting_contract::<OnTypeFormatting>();
        assert_eq!(<Formatting as Request>::METHOD, "textDocument/formatting");
        assert_eq!(
            <RangeFormatting as Request>::METHOD,
            "textDocument/rangeFormatting"
        );
        assert_eq!(
            <OnTypeFormatting as Request>::METHOD,
            "textDocument/onTypeFormatting"
        );
    }

    fn assert_document_color_descriptor<F: FeatureSpec<Marker = DocumentColor>>(_: F) {}
    fn assert_color_presentation_descriptor<F: FeatureSpec<Marker = ColorPresentationRequest>>(
        _: F,
    ) {
    }
    fn assert_folding_range_descriptor<F: FeatureSpec<Marker = FoldingRangeRequest>>(_: F) {}
    fn assert_selection_range_descriptor<F: FeatureSpec<Marker = SelectionRangeRequest>>(_: F) {}
    fn assert_inline_value_descriptor<F: FeatureSpec<Marker = InlineValueRequest>>(_: F) {}

    fn assert_document_color_contract<R>()
    where
        R: Request<Params = DocumentColorParams, Result = Vec<ColorInformation>>,
    {
    }

    fn assert_color_presentation_contract<R>()
    where
        R: Request<Params = ColorPresentationParams, Result = Vec<ColorPresentation>>,
    {
    }

    fn assert_folding_range_contract<R>()
    where
        R: Request<Params = FoldingRangeParams, Result = Option<Vec<FoldingRange>>>,
    {
    }

    fn assert_selection_range_contract<R>()
    where
        R: Request<Params = SelectionRangeParams, Result = Option<Vec<SelectionRange>>>,
    {
    }

    fn assert_inline_value_contract<R>()
    where
        R: Request<Params = InlineValueParams, Result = Option<Vec<InlineValue>>>,
    {
    }

    #[test]
    fn presentation_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_document_color_descriptor(document_color(ColorProviderOptions::default()));
        assert_color_presentation_descriptor(color_presentation());
        assert_folding_range_descriptor(folding_range(FoldingProviderOptions::default()));
        assert_selection_range_descriptor(selection_range(SelectionRangeOptions::default()));
        assert_inline_value_descriptor(inline_value(InlineValueOptions::default()));
        assert_document_color_contract::<DocumentColor>();
        assert_color_presentation_contract::<ColorPresentationRequest>();
        assert_folding_range_contract::<FoldingRangeRequest>();
        assert_selection_range_contract::<SelectionRangeRequest>();
        assert_inline_value_contract::<InlineValueRequest>();
        assert_eq!(
            <DocumentColor as Request>::METHOD,
            "textDocument/documentColor"
        );
        assert_eq!(
            <ColorPresentationRequest as Request>::METHOD,
            "textDocument/colorPresentation"
        );
        assert_eq!(
            <FoldingRangeRequest as Request>::METHOD,
            "textDocument/foldingRange"
        );
        assert_eq!(
            <SelectionRangeRequest as Request>::METHOD,
            "textDocument/selectionRange"
        );
        assert_eq!(
            <InlineValueRequest as Request>::METHOD,
            "textDocument/inlineValue"
        );
    }

    #[test]
    fn editing_and_presentation_descriptors_contribute_only_their_capabilities() {
        let formatting = DocumentFormattingOptions::default();
        let range = DocumentRangeFormattingOptions {
            work_done_progress_options: Default::default(),
            ..Default::default()
        };
        let on_type = DocumentOnTypeFormattingOptions {
            first_trigger_character: "}".to_string(),
            more_trigger_character: Some(vec![";".to_string()]),
        };
        let selection = SelectionRangeOptions::default();
        let inline = InlineValueOptions::default();
        let mut caps = CapabilityBuilder::default();

        sealed::Sealed::contribute(&document_formatting(formatting), &mut caps).unwrap();
        sealed::Sealed::contribute(&range_formatting(range), &mut caps).unwrap();
        sealed::Sealed::contribute(&on_type_formatting(on_type.clone()), &mut caps).unwrap();
        sealed::Sealed::contribute(&document_color(ColorProviderOptions::default()), &mut caps)
            .unwrap();
        sealed::Sealed::contribute(&color_presentation(), &mut caps).unwrap();
        sealed::Sealed::contribute(&folding_range(FoldingProviderOptions::default()), &mut caps)
            .unwrap();
        sealed::Sealed::contribute(&selection_range(selection), &mut caps).unwrap();
        sealed::Sealed::contribute(&inline_value(inline), &mut caps).unwrap();
        caps.validate().unwrap();

        assert_eq!(
            caps.finish(),
            gen_lsp_types::ServerCapabilities {
                document_formatting_provider: Some(formatting.into()),
                document_range_formatting_provider: Some(range.into()),
                document_on_type_formatting_provider: Some(on_type),
                color_provider: Some(ColorProviderOptions::default().into()),
                folding_range_provider: Some(FoldingProviderOptions::default().into()),
                selection_range_provider: Some(selection.into()),
                inline_value_provider: Some(inline.into()),
                ..gen_lsp_types::ServerCapabilities::default()
            }
        );
    }

    fn assert_call_prepare_descriptor<F: FeatureSpec<Marker = CallHierarchyPrepare>>(_: F) {}
    fn assert_call_incoming_descriptor<F: FeatureSpec<Marker = CallHierarchyIncomingCalls>>(_: F) {}
    fn assert_call_outgoing_descriptor<F: FeatureSpec<Marker = CallHierarchyOutgoingCalls>>(_: F) {}

    fn assert_call_prepare_contract<R>()
    where
        R: Request<Params = CallHierarchyPrepareParams, Result = Option<Vec<CallHierarchyItem>>>,
    {
    }

    fn assert_call_incoming_contract<R>()
    where
        R: Request<
                Params = CallHierarchyIncomingCallsParams,
                Result = Option<Vec<CallHierarchyIncomingCall>>,
            >,
    {
    }

    fn assert_call_outgoing_contract<R>()
    where
        R: Request<
                Params = CallHierarchyOutgoingCallsParams,
                Result = Option<Vec<CallHierarchyOutgoingCall>>,
            >,
    {
    }

    #[test]
    fn call_hierarchy_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_call_prepare_descriptor(call_hierarchy_prepare(CallHierarchyOptions::default()));
        assert_call_incoming_descriptor(call_hierarchy_incoming_calls());
        assert_call_outgoing_descriptor(call_hierarchy_outgoing_calls());
        assert_call_prepare_contract::<CallHierarchyPrepare>();
        assert_call_incoming_contract::<CallHierarchyIncomingCalls>();
        assert_call_outgoing_contract::<CallHierarchyOutgoingCalls>();
        assert_eq!(
            <CallHierarchyPrepare as Request>::METHOD,
            "textDocument/prepareCallHierarchy"
        );
        assert_eq!(
            <CallHierarchyIncomingCalls as Request>::METHOD,
            "callHierarchy/incomingCalls"
        );
        assert_eq!(
            <CallHierarchyOutgoingCalls as Request>::METHOD,
            "callHierarchy/outgoingCalls"
        );
    }

    fn assert_type_prepare_descriptor<F: FeatureSpec<Marker = TypeHierarchyPrepare>>(_: F) {}
    fn assert_type_supertypes_descriptor<F: FeatureSpec<Marker = TypeHierarchySupertypes>>(_: F) {}
    fn assert_type_subtypes_descriptor<F: FeatureSpec<Marker = TypeHierarchySubtypes>>(_: F) {}

    fn assert_type_prepare_contract<R>()
    where
        R: Request<Params = TypeHierarchyPrepareParams, Result = Option<Vec<TypeHierarchyItem>>>,
    {
    }

    fn assert_type_supertypes_contract<R>()
    where
        R: Request<Params = TypeHierarchySupertypesParams, Result = Option<Vec<TypeHierarchyItem>>>,
    {
    }

    fn assert_type_subtypes_contract<R>()
    where
        R: Request<Params = TypeHierarchySubtypesParams, Result = Option<Vec<TypeHierarchyItem>>>,
    {
    }

    #[test]
    fn type_hierarchy_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_type_prepare_descriptor(type_hierarchy_prepare(TypeHierarchyOptions::default()));
        assert_type_supertypes_descriptor(type_hierarchy_supertypes());
        assert_type_subtypes_descriptor(type_hierarchy_subtypes());
        assert_type_prepare_contract::<TypeHierarchyPrepare>();
        assert_type_supertypes_contract::<TypeHierarchySupertypes>();
        assert_type_subtypes_contract::<TypeHierarchySubtypes>();
        assert_eq!(
            <TypeHierarchyPrepare as Request>::METHOD,
            "textDocument/prepareTypeHierarchy"
        );
        assert_eq!(
            <TypeHierarchySupertypes as Request>::METHOD,
            "typeHierarchy/supertypes"
        );
        assert_eq!(
            <TypeHierarchySubtypes as Request>::METHOD,
            "typeHierarchy/subtypes"
        );
    }

    fn assert_semantic_full_descriptor<F: FeatureSpec<Marker = SemanticTokensFullRequest>>(_: F) {}
    fn assert_semantic_delta_descriptor<F: FeatureSpec<Marker = SemanticTokensFullDeltaRequest>>(
        _: F,
    ) {
    }
    fn assert_semantic_range_descriptor<F: FeatureSpec<Marker = SemanticTokensRangeRequest>>(_: F) {
    }

    fn assert_semantic_full_contract<R>()
    where
        R: Request<Params = SemanticTokensParams, Result = Option<SemanticTokens>>,
    {
    }

    fn assert_semantic_delta_contract<R>()
    where
        R: Request<
                Params = SemanticTokensDeltaParams,
                Result = Option<SemanticTokensDeltaResponse>,
            >,
    {
    }

    fn assert_semantic_range_contract<R>()
    where
        R: Request<Params = SemanticTokensRangeParams, Result = Option<SemanticTokens>>,
    {
    }

    #[test]
    fn semantic_token_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        let options = SemanticTokensOptions::default();
        assert_semantic_full_descriptor(semantic_tokens_full(options.clone()));
        assert_semantic_delta_descriptor(semantic_tokens_full_delta(options.clone()));
        assert_semantic_range_descriptor(semantic_tokens_range(options));
        assert_semantic_full_contract::<SemanticTokensFullRequest>();
        assert_semantic_delta_contract::<SemanticTokensFullDeltaRequest>();
        assert_semantic_range_contract::<SemanticTokensRangeRequest>();
        assert_eq!(
            <SemanticTokensFullRequest as Request>::METHOD,
            "textDocument/semanticTokens/full"
        );
        assert_eq!(
            <SemanticTokensFullDeltaRequest as Request>::METHOD,
            "textDocument/semanticTokens/full/delta"
        );
        assert_eq!(
            <SemanticTokensRangeRequest as Request>::METHOD,
            "textDocument/semanticTokens/range"
        );
    }

    fn assert_document_descriptor<F: FeatureSpec<Marker = DocumentDiagnosticRequest>>(_: F) {}

    fn assert_will_save_wait_until_descriptor<F: FeatureSpec<Marker = WillSaveWaitUntil>>(_: F) {}

    #[test]
    fn will_save_wait_until_descriptor_fixes_the_typed_request_contract() {
        assert_will_save_wait_until_descriptor(will_save_wait_until());
        assert_eq!(
            <WillSaveWaitUntil as Request>::METHOD,
            "textDocument/willSaveWaitUntil"
        );
    }
    fn assert_workspace_descriptor<F: FeatureSpec<Marker = WorkspaceDiagnosticRequest>>(_: F) {}

    fn assert_document_contract<R>()
    where
        R: Request<Params = DocumentDiagnosticParams, Result = DocumentDiagnosticReportResult>,
    {
    }

    fn assert_workspace_contract<R>()
    where
        R: Request<Params = WorkspaceDiagnosticParams, Result = WorkspaceDiagnosticReportResult>,
    {
    }

    #[test]
    fn diagnostic_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_document_descriptor(document_diagnostic(DiagnosticOptions::default()));
        assert_workspace_descriptor(workspace_diagnostic(DiagnosticOptions::default()));
        assert_document_contract::<DocumentDiagnosticRequest>();
        assert_workspace_contract::<WorkspaceDiagnosticRequest>();
        assert_eq!(
            <DocumentDiagnosticRequest as Request>::METHOD,
            "textDocument/diagnostic"
        );
        assert_eq!(
            <WorkspaceDiagnosticRequest as Request>::METHOD,
            "workspace/diagnostic"
        );
    }

    fn assert_workspace_symbol_descriptor<F: FeatureSpec<Marker = WorkspaceSymbolRequest>>(_: F) {}
    fn assert_workspace_symbol_resolve_descriptor<
        F: FeatureSpec<Marker = WorkspaceSymbolResolve>,
    >(
        _: F,
    ) {
    }
    fn assert_will_create_descriptor<F: FeatureSpec<Marker = WillCreateFiles>>(_: F) {}
    fn assert_will_rename_descriptor<F: FeatureSpec<Marker = WillRenameFiles>>(_: F) {}
    fn assert_will_delete_descriptor<F: FeatureSpec<Marker = WillDeleteFiles>>(_: F) {}
    fn assert_did_change_watched_descriptor<
        F: NotificationFeatureSpec<Marker = DidChangeWatchedFiles>,
    >(
        _: F,
    ) {
    }
    fn assert_did_create_descriptor<F: NotificationFeatureSpec<Marker = DidCreateFiles>>(_: F) {}

    fn assert_workspace_symbol_contract<R>()
    where
        R: Request<Params = WorkspaceSymbolParams, Result = Option<WorkspaceSymbolResponse>>,
    {
    }

    fn assert_workspace_symbol_resolve_contract<R>()
    where
        R: Request<Params = WorkspaceSymbol, Result = WorkspaceSymbol>,
    {
    }

    fn assert_will_create_contract<R>()
    where
        R: Request<Params = CreateFilesParams, Result = Option<WorkspaceEdit>>,
    {
    }

    fn assert_will_rename_contract<R>()
    where
        R: Request<Params = RenameFilesParams, Result = Option<WorkspaceEdit>>,
    {
    }

    fn assert_will_delete_contract<R>()
    where
        R: Request<Params = DeleteFilesParams, Result = Option<WorkspaceEdit>>,
    {
    }

    fn assert_did_change_watched_contract<N>()
    where
        N: Notification<Params = DidChangeWatchedFilesParams>,
    {
    }

    fn assert_did_create_contract<N>()
    where
        N: Notification<Params = CreateFilesParams>,
    {
    }

    fn workspace_symbol_options() -> WorkspaceSymbolOptions {
        WorkspaceSymbolOptions {
            work_done_progress_options: Default::default(),
            resolve_provider: None,
        }
    }

    #[test]
    fn workspace_symbol_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_workspace_symbol_descriptor(workspace_symbol(workspace_symbol_options()));
        assert_workspace_symbol_resolve_descriptor(workspace_symbol_resolve());
        assert_workspace_symbol_contract::<WorkspaceSymbolRequest>();
        assert_workspace_symbol_resolve_contract::<WorkspaceSymbolResolve>();
        assert_eq!(
            <WorkspaceSymbolRequest as Request>::METHOD,
            "workspace/symbol"
        );
        assert_eq!(
            <WorkspaceSymbolResolve as Request>::METHOD,
            "workspaceSymbol/resolve"
        );
    }

    #[test]
    fn file_operation_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        let options = || FileOperationRegistrationOptions::default();
        assert_will_create_descriptor(will_create_files(options()));
        assert_will_rename_descriptor(will_rename_files(options()));
        assert_will_delete_descriptor(will_delete_files(options()));
        assert_did_change_watched_descriptor(did_change_watched_files());
        assert_did_create_descriptor(did_create_files(options()));
        assert_will_create_contract::<WillCreateFiles>();
        assert_will_rename_contract::<WillRenameFiles>();
        assert_will_delete_contract::<WillDeleteFiles>();
        assert_did_change_watched_contract::<DidChangeWatchedFiles>();
        assert_did_create_contract::<DidCreateFiles>();
        assert_eq!(
            <WillCreateFiles as Request>::METHOD,
            "workspace/willCreateFiles"
        );
        assert_eq!(
            <WillRenameFiles as Request>::METHOD,
            "workspace/willRenameFiles"
        );
        assert_eq!(
            <WillDeleteFiles as Request>::METHOD,
            "workspace/willDeleteFiles"
        );
        assert_eq!(
            <DidChangeWatchedFiles as Notification>::METHOD,
            "workspace/didChangeWatchedFiles"
        );
        assert_eq!(
            <DidCreateFiles as Notification>::METHOD,
            "workspace/didCreateFiles"
        );
        assert_eq!(
            <DidRenameFiles as Notification>::METHOD,
            "workspace/didRenameFiles"
        );
        assert_eq!(
            <DidDeleteFiles as Notification>::METHOD,
            "workspace/didDeleteFiles"
        );
    }

    fn assert_rename_descriptor<F: FeatureSpec<Marker = Rename>>(_: F) {}
    fn assert_prepare_rename_descriptor<F: FeatureSpec<Marker = PrepareRenameRequest>>(_: F) {}

    fn assert_rename_contract<R>()
    where
        R: Request<Params = RenameParams, Result = Option<WorkspaceEdit>>,
    {
    }

    fn assert_prepare_rename_contract<R>()
    where
        R: Request<Params = PrepareRenameParams, Result = Option<PrepareRenameResponse>>,
    {
    }

    #[test]
    fn rename_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_rename_descriptor(rename(RenameOptions {
            prepare_provider: None,
            work_done_progress_options: Default::default(),
        }));
        assert_prepare_rename_descriptor(prepare_rename());
        assert_rename_contract::<Rename>();
        assert_prepare_rename_contract::<PrepareRenameRequest>();
        assert_eq!(<Rename as Request>::METHOD, "textDocument/rename");
        assert_eq!(
            <PrepareRenameRequest as Request>::METHOD,
            "textDocument/prepareRename"
        );
    }

    fn assert_code_action_descriptor<F: FeatureSpec<Marker = CodeActionRequest>>(_: F) {}
    fn assert_code_action_resolve_descriptor<F: FeatureSpec<Marker = CodeActionResolveRequest>>(
        _: F,
    ) {
    }

    fn assert_code_action_contract<R>()
    where
        R: Request<Params = CodeActionParams, Result = Option<Vec<CodeActionResponse>>>,
    {
    }

    fn assert_code_action_resolve_contract<R>()
    where
        R: Request<Params = CodeAction, Result = CodeAction>,
    {
    }

    #[test]
    fn code_action_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_code_action_descriptor(code_action(CodeActionOptions::default()));
        assert_code_action_resolve_descriptor(code_action_resolve());
        assert_code_action_contract::<CodeActionRequest>();
        assert_code_action_resolve_contract::<CodeActionResolveRequest>();
        assert_eq!(
            <CodeActionRequest as Request>::METHOD,
            "textDocument/codeAction"
        );
        assert_eq!(
            <CodeActionResolveRequest as Request>::METHOD,
            "codeAction/resolve"
        );
    }

    fn assert_code_lens_descriptor<F: FeatureSpec<Marker = CodeLensRequest>>(_: F) {}
    fn assert_code_lens_resolve_descriptor<F: FeatureSpec<Marker = CodeLensResolve>>(_: F) {}

    fn assert_code_lens_contract<R>()
    where
        R: Request<Params = CodeLensParams, Result = Option<Vec<CodeLens>>>,
    {
    }

    fn assert_code_lens_resolve_contract<R>()
    where
        R: Request<Params = CodeLens, Result = CodeLens>,
    {
    }

    #[test]
    fn code_lens_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_code_lens_descriptor(code_lens(CodeLensOptions {
            resolve_provider: None,
            ..Default::default()
        }));
        assert_code_lens_resolve_descriptor(code_lens_resolve());
        assert_code_lens_contract::<CodeLensRequest>();
        assert_code_lens_resolve_contract::<CodeLensResolve>();
        assert_eq!(
            <CodeLensRequest as Request>::METHOD,
            "textDocument/codeLens"
        );
        assert_eq!(<CodeLensResolve as Request>::METHOD, "codeLens/resolve");
    }

    fn assert_document_link_descriptor<F: FeatureSpec<Marker = DocumentLinkRequest>>(_: F) {}
    fn assert_document_link_resolve_descriptor<F: FeatureSpec<Marker = DocumentLinkResolve>>(_: F) {
    }

    fn assert_document_link_contract<R>()
    where
        R: Request<Params = DocumentLinkParams, Result = Option<Vec<DocumentLink>>>,
    {
    }

    fn assert_document_link_resolve_contract<R>()
    where
        R: Request<Params = DocumentLink, Result = DocumentLink>,
    {
    }

    #[test]
    fn document_link_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_document_link_descriptor(document_link(DocumentLinkOptions {
            resolve_provider: None,
            work_done_progress_options: Default::default(),
        }));
        assert_document_link_resolve_descriptor(document_link_resolve());
        assert_document_link_contract::<DocumentLinkRequest>();
        assert_document_link_resolve_contract::<DocumentLinkResolve>();
        assert_eq!(
            <DocumentLinkRequest as Request>::METHOD,
            "textDocument/documentLink"
        );
        assert_eq!(
            <DocumentLinkResolve as Request>::METHOD,
            "documentLink/resolve"
        );
    }

    fn assert_inlay_hint_descriptor<F: FeatureSpec<Marker = InlayHintRequest>>(_: F) {}
    fn assert_inlay_hint_resolve_descriptor<F: FeatureSpec<Marker = InlayHintResolveRequest>>(
        _: F,
    ) {
    }

    fn assert_inlay_hint_contract<R>()
    where
        R: Request<Params = InlayHintParams, Result = Option<Vec<InlayHint>>>,
    {
    }

    fn assert_inlay_hint_resolve_contract<R>()
    where
        R: Request<Params = InlayHint, Result = InlayHint>,
    {
    }

    #[test]
    fn inlay_hint_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_inlay_hint_descriptor(inlay_hint(InlayHintOptions::default()));
        assert_inlay_hint_resolve_descriptor(inlay_hint_resolve());
        assert_inlay_hint_contract::<InlayHintRequest>();
        assert_inlay_hint_resolve_contract::<InlayHintResolveRequest>();
        assert_eq!(
            <InlayHintRequest as Request>::METHOD,
            "textDocument/inlayHint"
        );
        assert_eq!(
            <InlayHintResolveRequest as Request>::METHOD,
            "inlayHint/resolve"
        );
    }

    fn assert_signature_help_descriptor<F: FeatureSpec<Marker = SignatureHelpRequest>>(_: F) {}
    fn assert_declaration_descriptor<F: FeatureSpec<Marker = GotoDeclaration>>(_: F) {}
    fn assert_definition_descriptor<F: FeatureSpec<Marker = GotoDefinition>>(_: F) {}
    fn assert_type_definition_descriptor<F: FeatureSpec<Marker = GotoTypeDefinition>>(_: F) {}
    fn assert_implementation_descriptor<F: FeatureSpec<Marker = GotoImplementation>>(_: F) {}
    fn assert_references_descriptor<F: FeatureSpec<Marker = References>>(_: F) {}
    fn assert_document_highlight_descriptor<F: FeatureSpec<Marker = DocumentHighlightRequest>>(
        _: F,
    ) {
    }
    fn assert_document_symbol_descriptor<F: FeatureSpec<Marker = DocumentSymbolRequest>>(_: F) {}
    fn assert_linked_editing_range_descriptor<F: FeatureSpec<Marker = LinkedEditingRange>>(_: F) {}
    fn assert_moniker_descriptor<F: FeatureSpec<Marker = MonikerRequest>>(_: F) {}

    fn assert_signature_help_contract<R>()
    where
        R: Request<Params = SignatureHelpParams, Result = Option<SignatureHelp>>,
    {
    }

    fn assert_declaration_contract<R>()
    where
        R: Request<Params = GotoDeclarationParams, Result = Option<GotoDeclarationResponse>>,
    {
    }

    fn assert_definition_contract<R>()
    where
        R: Request<Params = GotoDefinitionParams, Result = Option<GotoDefinitionResponse>>,
    {
    }

    fn assert_type_definition_contract<R>()
    where
        R: Request<Params = GotoTypeDefinitionParams, Result = Option<GotoTypeDefinitionResponse>>,
    {
    }

    fn assert_implementation_contract<R>()
    where
        R: Request<Params = GotoImplementationParams, Result = Option<GotoImplementationResponse>>,
    {
    }

    fn assert_references_contract<R>()
    where
        R: Request<Params = ReferenceParams, Result = Option<Vec<Location>>>,
    {
    }

    fn assert_document_highlight_contract<R>()
    where
        R: Request<Params = DocumentHighlightParams, Result = Option<Vec<DocumentHighlight>>>,
    {
    }

    fn assert_document_symbol_contract<R>()
    where
        R: Request<Params = DocumentSymbolParams, Result = Option<DocumentSymbolResponse>>,
    {
    }

    fn assert_linked_editing_range_contract<R>()
    where
        R: Request<Params = LinkedEditingRangeParams, Result = Option<LinkedEditingRanges>>,
    {
    }

    fn assert_moniker_contract<R>()
    where
        R: Request<Params = MonikerParams, Result = Option<Vec<Moniker>>>,
    {
    }

    fn progress(value: Option<bool>) -> gen_lsp_types::WorkDoneProgressOptions {
        gen_lsp_types::WorkDoneProgressOptions {
            work_done_progress: value,
        }
    }

    fn type_definition_registration_options() -> TypeDefinitionRegistrationOptions {
        TypeDefinitionRegistrationOptions::default()
    }

    fn implementation_registration_options() -> ImplementationRegistrationOptions {
        ImplementationRegistrationOptions::default()
    }

    #[test]
    fn navigation_and_lookup_descriptors_fix_the_exact_gen_lsp_types_contracts() {
        assert_signature_help_descriptor(signature_help(SignatureHelpOptions::default()));
        assert_declaration_descriptor(declaration(DeclarationOptions {
            work_done_progress_options: progress(Some(true)),
        }));
        assert_definition_descriptor(definition(DefinitionOptions {
            work_done_progress_options: progress(Some(true)),
        }));
        assert_type_definition_descriptor(type_definition(type_definition_registration_options()));
        assert_implementation_descriptor(implementation(implementation_registration_options()));
        assert_references_descriptor(references(ReferencesOptions {
            work_done_progress_options: progress(Some(true)),
        }));
        assert_document_highlight_descriptor(document_highlight(DocumentHighlightOptions {
            work_done_progress_options: progress(Some(true)),
        }));
        assert_document_symbol_descriptor(document_symbol(DocumentSymbolOptions {
            label: Some("outline".to_string()),
            work_done_progress_options: progress(Some(true)),
        }));
        assert_linked_editing_range_descriptor(linked_editing_range(LinkedEditingRangeOptions {
            work_done_progress_options: progress(Some(true)),
        }));
        assert_moniker_descriptor(moniker(MonikerOptions {
            work_done_progress_options: progress(Some(true)),
        }));
        assert_signature_help_contract::<SignatureHelpRequest>();
        assert_declaration_contract::<GotoDeclaration>();
        assert_definition_contract::<GotoDefinition>();
        assert_type_definition_contract::<GotoTypeDefinition>();
        assert_implementation_contract::<GotoImplementation>();
        assert_references_contract::<References>();
        assert_document_highlight_contract::<DocumentHighlightRequest>();
        assert_document_symbol_contract::<DocumentSymbolRequest>();
        assert_linked_editing_range_contract::<LinkedEditingRange>();
        assert_moniker_contract::<MonikerRequest>();
        assert_eq!(
            <SignatureHelpRequest as Request>::METHOD,
            "textDocument/signatureHelp"
        );
        assert_eq!(
            <GotoDeclaration as Request>::METHOD,
            "textDocument/declaration"
        );
        assert_eq!(
            <GotoDefinition as Request>::METHOD,
            "textDocument/definition"
        );
        assert_eq!(
            <GotoTypeDefinition as Request>::METHOD,
            "textDocument/typeDefinition"
        );
        assert_eq!(
            <GotoImplementation as Request>::METHOD,
            "textDocument/implementation"
        );
        assert_eq!(<References as Request>::METHOD, "textDocument/references");
        assert_eq!(
            <DocumentHighlightRequest as Request>::METHOD,
            "textDocument/documentHighlight"
        );
        assert_eq!(
            <DocumentSymbolRequest as Request>::METHOD,
            "textDocument/documentSymbol"
        );
        assert_eq!(
            <LinkedEditingRange as Request>::METHOD,
            "textDocument/linkedEditingRange"
        );
        assert_eq!(<MonikerRequest as Request>::METHOD, "textDocument/moniker");
    }

    #[test]
    fn navigation_and_lookup_descriptors_contribute_only_their_capabilities() {
        let signature_options = SignatureHelpOptions {
            trigger_characters: Some(vec!["(".to_string()]),
            retrigger_characters: None,
            work_done_progress_options: Default::default(),
        };
        let declaration_options = DeclarationOptions {
            work_done_progress_options: progress(Some(true)),
        };
        let definition_options = DefinitionOptions {
            work_done_progress_options: progress(Some(true)),
        };
        let type_definition_options = type_definition_registration_options();
        let implementation_options = implementation_registration_options();
        let references_options = ReferencesOptions {
            work_done_progress_options: progress(Some(true)),
        };
        let highlight_options = DocumentHighlightOptions {
            work_done_progress_options: progress(Some(true)),
        };
        let symbols_options = DocumentSymbolOptions {
            label: Some("outline".to_string()),
            work_done_progress_options: progress(Some(true)),
        };
        let linked_options = LinkedEditingRangeOptions {
            work_done_progress_options: progress(Some(true)),
        };
        let moniker_options = MonikerOptions {
            work_done_progress_options: progress(Some(true)),
        };
        let mut caps = CapabilityBuilder::default();

        sealed::Sealed::contribute(&signature_help(signature_options.clone()), &mut caps).unwrap();
        sealed::Sealed::contribute(&declaration(declaration_options), &mut caps).unwrap();
        sealed::Sealed::contribute(&definition(definition_options), &mut caps).unwrap();
        sealed::Sealed::contribute(&type_definition(type_definition_options.clone()), &mut caps)
            .unwrap();
        sealed::Sealed::contribute(&implementation(implementation_options.clone()), &mut caps)
            .unwrap();
        sealed::Sealed::contribute(&references(references_options), &mut caps).unwrap();
        sealed::Sealed::contribute(&document_highlight(highlight_options), &mut caps).unwrap();
        sealed::Sealed::contribute(&document_symbol(symbols_options.clone()), &mut caps).unwrap();
        sealed::Sealed::contribute(&linked_editing_range(linked_options), &mut caps).unwrap();
        sealed::Sealed::contribute(&moniker(moniker_options), &mut caps).unwrap();
        caps.validate().unwrap();

        assert_eq!(
            caps.finish(),
            gen_lsp_types::ServerCapabilities {
                signature_help_provider: Some(signature_options),
                declaration_provider: Some(declaration_options.into()),
                definition_provider: Some(definition_options.into()),
                type_definition_provider: Some(type_definition_options.into()),
                implementation_provider: Some(implementation_options.into()),
                references_provider: Some(references_options.into()),
                document_highlight_provider: Some(highlight_options.into()),
                document_symbol_provider: Some(symbols_options.into()),
                linked_editing_range_provider: Some(linked_options.into()),
                moniker_provider: Some(moniker_options.into()),
                ..gen_lsp_types::ServerCapabilities::default()
            }
        );
    }

    #[test]
    fn no_request_descriptor_fixes_the_execute_command_method() {
        // `workspace/executeCommand` is reserved for the Command registry
        // (ADR 0022). The enforcement is structural — `FeatureSpec` is sealed,
        // so no descriptor for it can ever be added downstream — and this pins
        // the in-crate catalog to that rule.
        for method in [
            <HoverRequest as Request>::METHOD,
            <Completion as Request>::METHOD,
            <ResolveCompletionItem as Request>::METHOD,
            <DocumentDiagnosticRequest as Request>::METHOD,
            <WorkspaceDiagnosticRequest as Request>::METHOD,
            <WorkspaceSymbolRequest as Request>::METHOD,
            <WorkspaceSymbolResolve as Request>::METHOD,
            <Rename as Request>::METHOD,
            <PrepareRenameRequest as Request>::METHOD,
            <CodeActionRequest as Request>::METHOD,
            <CodeActionResolveRequest as Request>::METHOD,
            <CodeLensRequest as Request>::METHOD,
            <CodeLensResolve as Request>::METHOD,
            <DocumentLinkRequest as Request>::METHOD,
            <DocumentLinkResolve as Request>::METHOD,
            <InlayHintRequest as Request>::METHOD,
            <InlayHintResolveRequest as Request>::METHOD,
            <WillCreateFiles as Request>::METHOD,
            <WillRenameFiles as Request>::METHOD,
            <WillDeleteFiles as Request>::METHOD,
        ] {
            assert_ne!(method, "workspace/executeCommand");
        }
    }
}