#pragma once

// 包含所有 LSP 协议定义
#include <glaze/glaze.hpp>
#include "./detail/basic_types.hpp"
#include "./detail/capabilities.hpp"
#include "./detail/code_actions.hpp"
#include "./detail/completion.hpp"
#include "./detail/configuration.hpp"
#include "./detail/diagnostics.hpp"
#include "./detail/document_features.hpp"
#include "./detail/document_sync.hpp"
#include "./detail/file_operations.hpp"
#include "./detail/formatting.hpp"
#include "./detail/inline_features.hpp"
#include "./detail/message.hpp"
#include "./detail/navigation.hpp"
#include "./detail/notebook.hpp"
#include "./detail/progress.hpp"
#include "./detail/registration.hpp"
#include "./detail/rename.hpp"
#include "./detail/semantic_tokens.hpp"
#include "./detail/signature_help.hpp"
#include "./detail/symbols.hpp"
#include "./detail/workspace.hpp"

namespace glz
{
    using namespace lsp;
    // 为 LSPAny 提供 glaze 支持
    template<>
    struct meta<protocol::LSPAny>
    {
        static constexpr std::string_view name = "LSPAny";
        using T = protocol::LSPAny;
        static constexpr auto value = &T::value;
    };

    template<>
    struct meta<protocol::RequestMessage>
    {
        using T = protocol::RequestMessage;
        static constexpr auto value = glz::object(
            &T::jsonrpc,
            &T::id,
            &T::method,
            &T::params
        );
    };

    template<>
    struct meta<protocol::ResponseError>
    {
        using T = protocol::ResponseError;
        static constexpr auto value = glz::object(
            &T::jsonrpc,
            &T::code,
            &T::message,
            &T::data
        );
    };

    template<>
    struct meta<protocol::ResponseMessage>
    {
        using T = protocol::ResponseMessage;
        static constexpr auto value = glz::object(
            &T::jsonrpc,
            &T::id,
            &T::result,
            &T::error
        );
    };

    template<>
    struct meta<protocol::NotificationMessage>
    {
        using T = protocol::NotificationMessage;
        static constexpr auto value = glz::object(
            &T::jsonrpc,
            &T::method,
            &T::params
        );
    };

    template<>
    struct meta<protocol::AnnotatedTextEdit>
    {
        using T = protocol::AnnotatedTextEdit;
        static constexpr auto value = glz::object(
            &T::range,
            &T::newText,
            &T::annotationId
        );
    };

    template<>
    struct meta<protocol::InitializeParams>
    {
        using T = protocol::InitializeParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::processId,
            &T::clientInfo,
            &T::locale,
            &T::rootPath,
            &T::rootUri,
            &T::initializationOptions,
            &T::capabilities,
            &T::trace,
            &T::workspaceFolders
        );
    };

    template<>
    struct meta<protocol::CodeActionOptions>
    {
        using T = protocol::CodeActionOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::codeActionKinds,
            &T::resolveProvider
        );
    };

    template<>
    struct meta<protocol::CodeActionRegistrationOptions>
    {
        using T = protocol::CodeActionRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::codeActionKinds,
            &T::resolveProvider
        );
    };

    template<>
    struct meta<protocol::CodeActionParams>
    {
        using T = protocol::CodeActionParams;
        static constexpr auto value = glz::object(
            &T::textDocument,
            &T::position,
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::range,
            &T::context
        );
    };

    template<>
    struct meta<protocol::DocumentColorOptions>
    {
        using T = protocol::DocumentColorOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::DocumentColorRegistrationOptions>
    {
        using T = protocol::DocumentColorRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::id);
    };

    template<>
    struct meta<protocol::DocumentColorParams>
    {
        using T = protocol::DocumentColorParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument);
    };

    template<>
    struct meta<protocol::ColorPresentationParams>
    {
        using T = protocol::ColorPresentationParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::color,
            &T::range);
    };

    template<>
    struct meta<protocol::CompletionOptions>
    {
        using T = protocol::CompletionOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::triggerCharacters,
            &T::allCommitCharacters,
            &T::resolveProvider,
            &T::completionItem
        );
    };

    template<>
    struct meta<protocol::CompletionRegistrationOptions>
    {
        using T = protocol::CompletionRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::triggerCharacters,
            &T::allCommitCharacters,
            &T::resolveProvider,
            &T::completionItem
        );
    };

    template<>
    struct meta<protocol::CompletionParams>
    {
        using T = protocol::CompletionParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::position,
            &T::context
        );
    };

    template<>
    struct meta<protocol::ExecuteCommandOptions>
    {
        using T = protocol::ExecuteCommandOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::commands
        );
    };

    template<>
    struct meta<protocol::ExecuteCommandRegistrationOptions>
    {
        using T = protocol::ExecuteCommandRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::commands
        );
    };

    template<>
    struct meta<protocol::ExecuteCommandParams>
    {
        using T = protocol::ExecuteCommandParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::arguments
        );
    };

    template<>
    struct meta<protocol::DiagnosticOptions>
    {
        using T = protocol::DiagnosticOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::interFileDependencies,
            &T::workspaceDiagnostics
        );
    };

    template<>
    struct meta<protocol::DiagnosticRegistrationOptions>
    {
        using T = protocol::DiagnosticRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::id,
            &T::workDoneProgress,
            &T::interFileDependencies,
            &T::workspaceDiagnostics
        );
    };

    template<>
    struct meta<protocol::DiagnosticParams>
    {
        using T = protocol::DiagnosticParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::identifier,
            &T::previousResultId
        );
    };

    template<>
    struct meta<protocol::RelatedFullDocumentDiagnosticReport>
    {
        using T = protocol::RelatedFullDocumentDiagnosticReport;
        static constexpr auto value = glz::object(
            &T::kind,
            &T::resultId,
            &T::items,
            &T::relatedDocuments
        );
    };

    template<>
    struct meta<protocol::RelatedUnchangedDocumentDiagnosticReport>
    {
        using T = protocol::RelatedUnchangedDocumentDiagnosticReport;
        static constexpr auto value = glz::object(
            &T::kind,
            &T::resultId,
            &T::relatedDocuments
        );
    };

    template<>
    struct meta<protocol::WorkspaceDiagnosticParams>
    {
        using T = protocol::WorkspaceDiagnosticParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::identifier,
            &T::previousResultIds
        );
    };

    template<>
    struct meta<protocol::WorkspaceFullDocumentDiagnosticReport>
    {
        using T = protocol::WorkspaceFullDocumentDiagnosticReport;
        static constexpr auto value = glz::object(
            &T::kind,
            &T::resultId,
            &T::items,
            &T::uri,
            &T::version
        );
    };

    template<>
    struct meta<protocol::WorkspaceUnchangedDocumentDiagnosticReport>
    {
        using T = protocol::WorkspaceUnchangedDocumentDiagnosticReport;
        static constexpr auto value = glz::object(
            &T::kind,
            &T::resultId,
            &T::uri,
            &T::version
        );
    };

    template<>
    struct meta<protocol::DocumentHighlightOptions>
    {
        using T = protocol::DocumentHighlightOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::DocumentHighlightRegistrationOptions>
    {
        using T = protocol::DocumentHighlightRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::DocumentHighlightParams>
    {
        using T = protocol::DocumentHighlightParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::position
        );
    };

    template<>
    struct meta<protocol::DocumentLinkOptions>
    {
        using T = protocol::DocumentLinkOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::resolveProvider
        );
    };

    template<>
    struct meta<protocol::DocumentLinkRegistrationOptions>
    {
        using T = protocol::DocumentLinkRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::resolveProvider
        );
    };

    template<>
    struct meta<protocol::DocumentLinkParams>
    {
        using T = protocol::DocumentLinkParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument
        );
    };

    template<>
    struct meta<protocol::HoverOptions>
    {
        using T = protocol::HoverOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::HoverRegistrationOptions>
    {
        using T = protocol::HoverRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::HoverParams>
    {
        using T = protocol::HoverParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::position
        );
    };

    template<>
    struct meta<protocol::CodeLensOptions>
    {
        using T = protocol::CodeLensOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::resolveProvider
        );
    };

    template<>
    struct meta<protocol::CodeLensRegistrationOptions>
    {
        using T = protocol::CodeLensRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::resolveProvider
        );
    };

    template<>
    struct meta<protocol::CodeLensParams>
    {
        using T = protocol::CodeLensParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument
        );
    };

    template<>
    struct meta<protocol::FoldingRangeOptions>
    {
        using T = protocol::FoldingRangeOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::FoldingRangeRegistrationOptions>
    {
        using T = protocol::FoldingRangeRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::id
        );
    };

    template<>
    struct meta<protocol::FoldingRangeParams>
    {
        using T = protocol::FoldingRangeParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument
        );
    };

    template<>
    struct meta<protocol::SelectionRangeOptions>
    {
        using T = protocol::SelectionRangeOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::SelectionRangeRegistrationOptions>
    {
        using T = protocol::SelectionRangeRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::id
        );
    };

    template<>
    struct meta<protocol::SelectionRangeParams>
    {
        using T = protocol::SelectionRangeParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::positions
        );
    };

    template<>
    struct meta<protocol::VersionedTextDocumentIdentifier>
    {
        using T = protocol::VersionedTextDocumentIdentifier;
        static constexpr auto value = glz::object(
            &T::uri,
            &T::version
        );
    };

    template<>
    struct meta<protocol::OptionalVersionedTextDocumentIdentifier>
    {
        using T = protocol::OptionalVersionedTextDocumentIdentifier;
        static constexpr auto value = glz::object(
            &T::uri,
            &T::version
        );
    };

    template<>
    struct meta<protocol::TextDocumentChangeRegistrationOptions>
    {
        using T = protocol::TextDocumentChangeRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::syncKind
        );
    };

    template<>
    struct meta<protocol::TextDocumentSaveRegistrationOptions>
    {
        using T = protocol::TextDocumentSaveRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::includeText
        );
    };

    template<>
    struct meta<protocol::DocumentFormattingOptions>
    {
        using T = protocol::DocumentFormattingOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::DocumentFormattingRegistrationOptions>
    {
        using T = protocol::DocumentFormattingRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::DocumentFormattingParams>
    {
        using T = protocol::DocumentFormattingParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::options
        );
    };

    template<>
    struct meta<protocol::DocumentRangeFormattingOptions>
    {
        using T = protocol::DocumentRangeFormattingOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::DocumentRangeFormattingRegistrationOptions>
    {
        using T = protocol::DocumentRangeFormattingRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::DocumentRangeFormattingParams>
    {
        using T = protocol::DocumentRangeFormattingParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::range,
            &T::options
        );
    };

    template<>
    struct meta<protocol::DocumentOnTypeFormattingOptions>
    {
        using T = protocol::DocumentOnTypeFormattingOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::firstTriggerCharacter,
            &T::moreTriggerCharacter
        );
    };

    template<>
    struct meta<protocol::DocumentOnTypeFormattingRegistrationOptions>
    {
        using T = protocol::DocumentOnTypeFormattingRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::firstTriggerCharacter,
            &T::moreTriggerCharacter
        );
    };

    template<>
    struct meta<protocol::InlayHintOptions>
    {
        using T = protocol::InlayHintOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::resolveProvider
        );
    };

    template<>
    struct meta<protocol::InlayHintRegistrationOptions>
    {
        using T = protocol::InlayHintRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::resolveProvider,
            &T::id
        );
    };

    template<>
    struct meta<protocol::InlayHintParams>
    {
        using T = protocol::InlayHintParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::range
        );
    };

    template<>
    struct meta<protocol::InlineValueOptions>
    {
        using T = protocol::InlineValueOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::InlineValueRegistrationOptions>
    {
        using T = protocol::InlineValueRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::id
        );
    };

    template<>
    struct meta<protocol::InlineValueParams>
    {
        using T = protocol::InlineValueParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::range,
            &T::context
        );
    };

    template<>
    struct meta<protocol::MonikerOptions>
    {
        using T = protocol::MonikerOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::MonikerRegistrationOptions>
    {
        using T = protocol::MonikerRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::MonikerParams>
    {
        using T = protocol::MonikerParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::position
        );
    };

    template<>
    struct meta<protocol::DeclarationOptions>
    {
        using T = protocol::DeclarationOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::DeclarationRegistrationOptions>
    {
        using T = protocol::DeclarationRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::id
        );
    };

    template<>
    struct meta<protocol::DeclarationParams>
    {
        using T = protocol::DeclarationParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::position
        );
    };

    template<>
    struct meta<protocol::DefinitionOptions>
    {
        using T = protocol::DefinitionOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::DefinitionRegistrationOptions>
    {
        using T = protocol::DefinitionRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::DefinitionParams>
    {
        using T = protocol::DefinitionParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::position
        );
    };

    template<>
    struct meta<protocol::TypeDefinitionOptions>
    {
        using T = protocol::TypeDefinitionOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::TypeDefinitionRegistrationOptions>
    {
        using T = protocol::TypeDefinitionRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::id
        );
    };

    template<>
    struct meta<protocol::TypeDefinitionParams>
    {
        using T = protocol::TypeDefinitionParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::position
        );
    };

    template<>
    struct meta<protocol::ImplementationOptions>
    {
        using T = protocol::ImplementationOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::ImplementationRegistrationOptions>
    {
        using T = protocol::ImplementationRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::id
        );
    };

    template<>
    struct meta<protocol::ImplementationParams>
    {
        using T = protocol::ImplementationParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken
        );
    };

    template<>
    struct meta<protocol::ReferenceOptions>
    {
        using T = protocol::ReferenceOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::ReferenceRegistrationOptions>
    {
        using T = protocol::ReferenceRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::ReferenceParams>
    {
        using T = protocol::ReferenceParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::position,
            &T::context
        );
    };

    template<>
    struct meta<protocol::CallHierarchyOptions>
    {
        using T = protocol::CallHierarchyOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::CallHierarchyRegistrationOptions>
    {
        using T = protocol::CallHierarchyRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::id
        );
    };

    template<>
    struct meta<protocol::CallHierarchyParams>
    {
        using T = protocol::CallHierarchyParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::position
        );
    };

    template<>
    struct meta<protocol::CallHierarchyIncomingCallsParams>
    {
        using T = protocol::CallHierarchyIncomingCallsParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::item
        );
    };

    template<>
    struct meta<protocol::CallHierarchyOutgoingCallsParams>
    {
        using T = protocol::CallHierarchyIncomingCallsParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::item
        );
    };

    template<>
    struct meta<protocol::TypeHierarchyOptions>
    {
        using T = protocol::TypeHierarchyOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::TypeHierarchyRegistrationOptions>
    {
        using T = protocol::TypeHierarchyRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::id
        );
    };

    template<>
    struct meta<protocol::TypeHierarchyParams>
    {
        using T = protocol::TypeHierarchyParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::position
        );
    };

    template<>
    struct meta<protocol::TypeHierarchyPrepareParams>
    {
        using T = protocol::TypeHierarchyPrepareParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::position
        );
    };

    template<>
    struct meta<protocol::TypeHierarchySubtypesParams>
    {
        using T = protocol::TypeHierarchySubtypesParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::item
        );
    };

    template<>
    struct meta<protocol::TypeHierarchySupertypesParams>
    {
        using T = protocol::TypeHierarchySupertypesParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::item
        );
    };

    template<>
    struct meta<protocol::NotebookDocumentSyncRegistrationOptions>
    {
        using T = protocol::NotebookDocumentSyncRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::notebookSelector,
            &T::save,
            &T::id
        );
    };

    template<>
    struct meta<protocol::RenameOptions>
    {
        using T = protocol::RenameOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::prepareProvider
        );
    };

    template<>
    struct meta<protocol::RenameRegistrationOptions>
    {
        using T = protocol::RenameRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::prepareProvider
        );
    };

    template<>
    struct meta<protocol::RenameParams>
    {
        using T = protocol::RenameParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::position,
            &T::newName
        );
    };

    template<>
    struct meta<protocol::PrepareRenameParams>
    {
        using T = protocol::PrepareRenameParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::position
        );
    };

    template<>
    struct meta<protocol::LinkedEditingRangeOptions>
    {
        using T = protocol::LinkedEditingRangeOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress
        );
    };

    template<>
    struct meta<protocol::LinkedEditingRangeRegistrationOptions>
    {
        using T = protocol::LinkedEditingRangeRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::id);
    };

    template<>
    struct meta<protocol::LinkedEditingRangeParams>
    {
        using T = protocol::LinkedEditingRangeParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::position);
    };

    template<>
    struct meta<protocol::SemanticTokensOptions>
    {
        using T = protocol::SemanticTokensOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::legend,
            &T::range,
            &T::full);
    };

    template<>
    struct meta<protocol::SemanticTokensRegistrationOptions>
    {
        using T = protocol::SemanticTokensRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::legend,
            &T::range,
            &T::full,
            &T::id);
    };

    template<>
    struct meta<protocol::SemanticTokensParams>
    {
        using T = protocol::SemanticTokensParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument);
    };

    template<>
    struct meta<protocol::SemanticTokensDeltaParams>
    {
        using T = protocol::SemanticTokensDeltaParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::previousResultId);
    };

    template<>
    struct meta<protocol::SemanticTokensRangeParams>
    {
        using T = protocol::SemanticTokensRangeParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument,
            &T::range);
    };

    template<>
    struct meta<protocol::SignatureHelpOptions>
    {
        using T = protocol::SignatureHelpOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::triggerCharacters,
            &T::retriggerCharacters);
    };

    template<>
    struct meta<protocol::SignatureHelpRegistrationOptions>
    {
        using T = protocol::SignatureHelpRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::triggerCharacters,
            &T::retriggerCharacters);
    };

    template<>
    struct meta<protocol::SignatureHelpParams>
    {
        using T = protocol::SignatureHelpParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::textDocument,
            &T::position,
            &T::contextSupport);
    };

    template<>
    struct meta<protocol::DocumentSymbolOptions>
    {
        using T = protocol::DocumentSymbolOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::label);
    };

    template<>
    struct meta<protocol::DocumentSymbolRegistrationOptions>
    {
        using T = protocol::DocumentSymbolRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::documentSelector,
            &T::workDoneProgress,
            &T::label);
    };

    template<>
    struct meta<protocol::DocumentSymbolParams>
    {
        using T = protocol::DocumentSymbolParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::textDocument);
    };

    template<>
    struct meta<protocol::WorkspaceSymbolOptions>
    {
        using T = protocol::WorkspaceSymbolOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::resolveProvider);
    };

    template<>
    struct meta<protocol::WorkspaceSymbolRegistrationOptions>
    {
        using T = protocol::WorkspaceSymbolRegistrationOptions;
        static constexpr auto value = glz::object(
            &T::workDoneProgress,
            &T::resolveProvider);
    };

    template<>
    struct meta<protocol::WorkspaceSymbolParams>
    {
        using T = protocol::WorkspaceSymbolParams;
        static constexpr auto value = glz::object(
            &T::workDoneToken,
            &T::partialResultToken,
            &T::query);
    };

}

