From 0ba90f42156f2d85dc2a9c8cc2ffe3f69f886e00 Mon Sep 17 00:00:00 2001 From: Roberto Raggi Date: Sat, 26 Oct 2024 18:51:50 +0200 Subject: [PATCH 1/2] chore: Initial work on LSP requests --- packages/cxx-gen-lsp/src/MetaModel.ts | 13 +- packages/cxx-gen-lsp/src/gen_fwd_h.ts | 18 + packages/cxx-gen-lsp/src/gen_requests_cc.ts | 168 + packages/cxx-gen-lsp/src/gen_requests_h.ts | 95 + packages/cxx-gen-lsp/src/main.ts | 4 + src/lsp/cxx/lsp/fwd.h | 150 + src/lsp/cxx/lsp/requests.cc | 3690 +++++++++++++++++++ src/lsp/cxx/lsp/requests.h | 2046 ++++++++++ 8 files changed, 6183 insertions(+), 1 deletion(-) create mode 100644 packages/cxx-gen-lsp/src/gen_requests_cc.ts create mode 100644 packages/cxx-gen-lsp/src/gen_requests_h.ts create mode 100644 src/lsp/cxx/lsp/requests.cc create mode 100644 src/lsp/cxx/lsp/requests.h diff --git a/packages/cxx-gen-lsp/src/MetaModel.ts b/packages/cxx-gen-lsp/src/MetaModel.ts index e6954d50..f2f7cb02 100644 --- a/packages/cxx-gen-lsp/src/MetaModel.ts +++ b/packages/cxx-gen-lsp/src/MetaModel.ts @@ -97,7 +97,18 @@ export type Enumeration = { export type Notification = {}; -export type Request = {}; +type MessageDirection = "clientToServer" | "serverToClient" | "both"; + +export type Request = { + documentation?: string; + messageDirection: MessageDirection; + method: string; + params: ReferenceType; + partialResult?: ReferenceType | ArrayType | OrType; + registrationOptions?: ReferenceType | AndType; + result?: BaseType | ReferenceType | ArrayType | OrType; + typeName: string; +}; export type Property = { documentation?: string; diff --git a/packages/cxx-gen-lsp/src/gen_fwd_h.ts b/packages/cxx-gen-lsp/src/gen_fwd_h.ts index c19ff3f9..1d7aba19 100644 --- a/packages/cxx-gen-lsp/src/gen_fwd_h.ts +++ b/packages/cxx-gen-lsp/src/gen_fwd_h.ts @@ -42,6 +42,16 @@ class LSPObject { json* repr_{nullptr}; }; +class LSPRequest : public LSPObject { + public: + using LSPObject::LSPObject; +}; + +class LSPResponse : public LSPObject { + public: + using LSPObject::LSPObject; +}; + template class Vector final : public LSPObject { public: @@ -314,9 +324,17 @@ export function gen_fwd_h({ model, outputDirectory }: { model: MetaModel; output emit(`enum class ${enumeration.name}${enumBaseType};`); }); emit(); + emit(`// structures`); model.structures.forEach((structure) => { emit(`class ${structure.name};`); }); + emit(`// requests`); + model.requests.forEach((request) => { + emit(`class ${request.typeName};`); + if (request.result) { + emit(`class ${request.typeName.replace(/Request$/, "Response")};`); + } + }); emit(); const knownTypes = new Set(); diff --git a/packages/cxx-gen-lsp/src/gen_requests_cc.ts b/packages/cxx-gen-lsp/src/gen_requests_cc.ts new file mode 100644 index 00000000..cb80331f --- /dev/null +++ b/packages/cxx-gen-lsp/src/gen_requests_cc.ts @@ -0,0 +1,168 @@ +// Copyright (c) 2024 Roberto Raggi +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import * as path from "node:path"; +import { Enumeration, MetaModel, Structure, toCppType, Type, TypeAlias } from "./MetaModel.js"; +import { writeFileSync } from "node:fs"; +import { copyrightHeader } from "./copyrightHeader.js"; + +class RequestGenerator { + readonly structByName: Map; + readonly enumByName: Map; + readonly typeAliasByName: Map; + readonly model: MetaModel; + readonly outputDirectory: string; + out: string = ""; + + constructor({ model, outputDirectory }: { model: MetaModel; outputDirectory: string }) { + this.model = model; + this.outputDirectory = outputDirectory; + this.structByName = new Map(model.structures.map((s) => [s.name, s])); + this.enumByName = new Map(model.enumerations.map((e) => [e.name, e])); + this.typeAliasByName = new Map(model.typeAliases.map((t) => [t.name, t])); + } + + genTypes() { + this.begin(); + + this.model.requests.forEach((request) => { + const { typeName } = request; + this.emit(); + this.emit(`auto ${typeName}::method() const -> std::string {`); + this.emit(` return repr_->at("method");`); + this.emit(`}`); + this.emit(); + this.emit(`auto ${typeName}::method(std::string method) -> ${typeName}& {`); + this.emit(` (*repr_)["method"] = std::move(method);`); + this.emit(` return *this;`); + this.emit(`}`); + this.emit(); + this.emit(`auto ${typeName}::id() const -> std::variant {`); + this.emit(` const auto& id = repr_->at("id");`); + this.emit(` if (id.is_string()) return id.get();`); + this.emit(` return id.get();`); + this.emit(`}`); + this.emit(); + this.emit(`auto ${typeName}::id(long id) -> ${typeName}& {`); + this.emit(` (*repr_)["id"] = id;`); + this.emit(` return *this;`); + this.emit(`}`); + this.emit(); + this.emit(`auto ${typeName}::id(std::string id) -> ${typeName}& {`); + this.emit(` (*repr_)["id"] = std::move(id);`); + this.emit(` return *this;`); + this.emit(`}`); + + if (request.params) { + const paramsTypeName = toCppType(request.params); + + this.emit(); + this.emit(`auto ${typeName}::params() const -> ${paramsTypeName} {`); + this.emit(` if (!repr_->contains("params")) repr_->emplace("params", json::object());`); + this.emit(` return ${paramsTypeName}(repr_->at("params"));`); + this.emit(`}`); + this.emit(); + this.emit(`auto ${typeName}::params(${paramsTypeName} params) -> ${typeName}& {`); + this.emit(` (*repr_)["params"] = std::move(params);`); + this.emit(` return *this;`); + this.emit(`}`); + } + + if (request.result) { + const resultTypeName = typeName.replace(/Request$/, "Response"); + this.emit(); + this.emit(`auto ${resultTypeName}::id() const -> std::variant {`); + this.emit(` const auto& id = repr_->at("id");`); + this.emit(` if (id.is_string()) return id.get();`); + this.emit(` return id.get();`); + this.emit(`}`); + this.emit(); + this.emit(`auto ${resultTypeName}::id(long id) -> ${resultTypeName}& {`); + this.emit(` (*repr_)["id"] = id;`); + this.emit(` return *this;`); + this.emit(`}`); + this.emit(); + this.emit(`auto ${resultTypeName}::id(std::string id) -> ${resultTypeName}& {`); + this.emit(` (*repr_)["id"] = std::move(id);`); + this.emit(` return *this;`); + this.emit(`}`); + } + }); + + this.end(); + } + + emit(s: string = "") { + this.out += `${s}\n`; + } + + getPropertyType({ type, optional }: { type: Type; optional?: boolean }): string { + let propertyType = toCppType(type); + + if (optional) { + propertyType = `std::optional<${propertyType}>`; + } + + return propertyType; + } + + isStringLike(type: Type): boolean { + switch (type.kind) { + case "base": + return type.name === "string"; + + case "reference": { + if (this.typeAliasByName.has(type.name)) { + return this.isStringLike(this.typeAliasByName.get(type.name)!.type); + } + return false; + } + + case "stringLiteral": + return true; + + default: + return false; + } // switch + } + + begin() { + this.emit(copyrightHeader); + this.emit(); + this.emit(`#include `); + this.emit(`#include `); + this.emit(`#include `); + this.emit(); + this.emit(`namespace cxx::lsp {`); + this.emit(); + } + + end() { + this.emit(`} // namespace cxx::lsp`); + + const outputFile = path.join(this.outputDirectory, "requests.cc"); + writeFileSync(outputFile, this.out); + } +} + +export function gen_requests_cc({ model, outputDirectory }: { model: MetaModel; outputDirectory: string }) { + const generator = new RequestGenerator({ model, outputDirectory }); + generator.genTypes(); +} diff --git a/packages/cxx-gen-lsp/src/gen_requests_h.ts b/packages/cxx-gen-lsp/src/gen_requests_h.ts new file mode 100644 index 00000000..6c9c68e0 --- /dev/null +++ b/packages/cxx-gen-lsp/src/gen_requests_h.ts @@ -0,0 +1,95 @@ +// Copyright (c) 2024 Roberto Raggi +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +import * as path from "node:path"; +import { MetaModel, toCppType } from "./MetaModel.js"; +import { writeFileSync } from "node:fs"; +import { copyrightHeader } from "./copyrightHeader.js"; + +const beginHeaderFragment = ` +#pragma once + +#include + +namespace cxx::lsp { + +`; + +export function gen_requests_h({ model, outputDirectory }: { model: MetaModel; outputDirectory: string }) { + let out = ""; + + const emit = (s: string = "") => { + out += `${s}\n`; + }; + + emit(copyrightHeader); + emit(beginHeaderFragment); + + model.requests.forEach((request) => { + const typeName = request.typeName; + emit(); + emit(`class ${typeName} final : public LSPRequest {`); + emit(`public:`); + emit(` using LSPRequest::LSPRequest;`); + emit(); + emit(` [[nodiscard]] auto method() const -> std::string;`); + emit(` auto method(std::string method) -> ${typeName}&;`); + emit(); + emit(` [[nodiscard]] auto id() const -> std::variant;`); + emit(` auto id(long id) -> ${typeName}&;`); + emit(` auto id(std::string id) -> ${typeName}&;`); + + if (request.params) { + const paramsType = toCppType(request.params); + emit(); + emit(` [[nodiscard]] auto params() const -> ${paramsType};`); + emit(` auto params(${paramsType} result) -> ${typeName}&;`); + } + + emit(`};`); + + // generate the respose type if the request has a result + if (request.result) { + const responseTypeName = typeName.replace(/Request$/, "Response"); + const resultType = toCppType(request.result); + + emit(); + + emit(`class ${responseTypeName} final : public LSPResponse {`); + emit(`public:`); + emit(` using LSPResponse::LSPResponse;`); + emit(); + emit(` [[nodiscard]] auto id() const -> std::variant;`); + emit(` auto id(long id) -> ${responseTypeName}&;`); + emit(` auto id(std::string id) -> ${responseTypeName}&;`); + emit(); + emit(` [[nodiscard]] auto result() const -> ${resultType};`); + emit(); + emit(` auto result(${resultType} result) -> ${responseTypeName}&;`); + emit(`};`); + } + }); + + emit(); + emit(`}`); + + const outputFile = path.join(outputDirectory, "requests.h"); + writeFileSync(outputFile, out); +} diff --git a/packages/cxx-gen-lsp/src/main.ts b/packages/cxx-gen-lsp/src/main.ts index 0c5564c4..33d0dfd8 100644 --- a/packages/cxx-gen-lsp/src/main.ts +++ b/packages/cxx-gen-lsp/src/main.ts @@ -28,6 +28,8 @@ import { gen_enums_cc } from "./gen_enums_cc.js"; import { gen_fwd_h } from "./gen_fwd_h.js"; import { gen_types_h } from "./gen_types_h.js"; import { gen_types_cc } from "./gen_types_cc.js"; +import { gen_requests_h } from "./gen_requests_h.js"; +import { gen_requests_cc } from "./gen_requests_cc.js"; async function main() { try { @@ -66,6 +68,8 @@ async function main() { gen_enums_cc({ outputDirectory, model }); gen_types_h({ outputDirectory, model }); gen_types_cc({ outputDirectory, model }); + gen_requests_h({ outputDirectory, model }); + gen_requests_cc({ outputDirectory, model }); console.log( child_process diff --git a/src/lsp/cxx/lsp/fwd.h b/src/lsp/cxx/lsp/fwd.h index 6d8e207e..ba038ad6 100644 --- a/src/lsp/cxx/lsp/fwd.h +++ b/src/lsp/cxx/lsp/fwd.h @@ -69,6 +69,7 @@ enum class FailureHandlingKind; enum class PrepareSupportDefaultBehavior : long; enum class TokenFormat; +// structures class ImplementationParams; class Location; class ImplementationRegistrationOptions; @@ -456,6 +457,145 @@ class ClientSignatureParameterInformationOptions; class ClientCodeActionKindOptions; class ClientDiagnosticsTagOptions; class ClientSemanticTokensRequestFullDelta; +// requests +class ImplementationRequest; +class ImplementationResponse; +class TypeDefinitionRequest; +class TypeDefinitionResponse; +class WorkspaceFoldersRequest; +class WorkspaceFoldersResponse; +class ConfigurationRequest; +class ConfigurationResponse; +class DocumentColorRequest; +class DocumentColorResponse; +class ColorPresentationRequest; +class ColorPresentationResponse; +class FoldingRangeRequest; +class FoldingRangeResponse; +class FoldingRangeRefreshRequest; +class FoldingRangeRefreshResponse; +class DeclarationRequest; +class DeclarationResponse; +class SelectionRangeRequest; +class SelectionRangeResponse; +class WorkDoneProgressCreateRequest; +class WorkDoneProgressCreateResponse; +class CallHierarchyPrepareRequest; +class CallHierarchyPrepareResponse; +class CallHierarchyIncomingCallsRequest; +class CallHierarchyIncomingCallsResponse; +class CallHierarchyOutgoingCallsRequest; +class CallHierarchyOutgoingCallsResponse; +class SemanticTokensRequest; +class SemanticTokensResponse; +class SemanticTokensDeltaRequest; +class SemanticTokensDeltaResponse; +class SemanticTokensRangeRequest; +class SemanticTokensRangeResponse; +class SemanticTokensRefreshRequest; +class SemanticTokensRefreshResponse; +class ShowDocumentRequest; +class ShowDocumentResponse; +class LinkedEditingRangeRequest; +class LinkedEditingRangeResponse; +class WillCreateFilesRequest; +class WillCreateFilesResponse; +class WillRenameFilesRequest; +class WillRenameFilesResponse; +class WillDeleteFilesRequest; +class WillDeleteFilesResponse; +class MonikerRequest; +class MonikerResponse; +class TypeHierarchyPrepareRequest; +class TypeHierarchyPrepareResponse; +class TypeHierarchySupertypesRequest; +class TypeHierarchySupertypesResponse; +class TypeHierarchySubtypesRequest; +class TypeHierarchySubtypesResponse; +class InlineValueRequest; +class InlineValueResponse; +class InlineValueRefreshRequest; +class InlineValueRefreshResponse; +class InlayHintRequest; +class InlayHintResponse; +class InlayHintResolveRequest; +class InlayHintResolveResponse; +class InlayHintRefreshRequest; +class InlayHintRefreshResponse; +class DocumentDiagnosticRequest; +class DocumentDiagnosticResponse; +class WorkspaceDiagnosticRequest; +class WorkspaceDiagnosticResponse; +class DiagnosticRefreshRequest; +class DiagnosticRefreshResponse; +class InlineCompletionRequest; +class InlineCompletionResponse; +class TextDocumentContentRequest; +class TextDocumentContentResponse; +class TextDocumentContentRefreshRequest; +class TextDocumentContentRefreshResponse; +class RegistrationRequest; +class RegistrationResponse; +class UnregistrationRequest; +class UnregistrationResponse; +class InitializeRequest; +class InitializeResponse; +class ShutdownRequest; +class ShutdownResponse; +class ShowMessageRequest; +class ShowMessageResponse; +class WillSaveTextDocumentWaitUntilRequest; +class WillSaveTextDocumentWaitUntilResponse; +class CompletionRequest; +class CompletionResponse; +class CompletionResolveRequest; +class CompletionResolveResponse; +class HoverRequest; +class HoverResponse; +class SignatureHelpRequest; +class SignatureHelpResponse; +class DefinitionRequest; +class DefinitionResponse; +class ReferencesRequest; +class ReferencesResponse; +class DocumentHighlightRequest; +class DocumentHighlightResponse; +class DocumentSymbolRequest; +class DocumentSymbolResponse; +class CodeActionRequest; +class CodeActionResponse; +class CodeActionResolveRequest; +class CodeActionResolveResponse; +class WorkspaceSymbolRequest; +class WorkspaceSymbolResponse; +class WorkspaceSymbolResolveRequest; +class WorkspaceSymbolResolveResponse; +class CodeLensRequest; +class CodeLensResponse; +class CodeLensResolveRequest; +class CodeLensResolveResponse; +class CodeLensRefreshRequest; +class CodeLensRefreshResponse; +class DocumentLinkRequest; +class DocumentLinkResponse; +class DocumentLinkResolveRequest; +class DocumentLinkResolveResponse; +class DocumentFormattingRequest; +class DocumentFormattingResponse; +class DocumentRangeFormattingRequest; +class DocumentRangeFormattingResponse; +class DocumentRangesFormattingRequest; +class DocumentRangesFormattingResponse; +class DocumentOnTypeFormattingRequest; +class DocumentOnTypeFormattingResponse; +class RenameRequest; +class RenameResponse; +class PrepareRenameRequest; +class PrepareRenameResponse; +class ExecuteCommandRequest; +class ExecuteCommandResponse; +class ApplyWorkspaceEditRequest; +class ApplyWorkspaceEditResponse; [[noreturn]] void lsp_runtime_error(const std::string& msg); @@ -475,6 +615,16 @@ class LSPObject { json* repr_{nullptr}; }; +class LSPRequest : public LSPObject { + public: + using LSPObject::LSPObject; +}; + +class LSPResponse : public LSPObject { + public: + using LSPObject::LSPObject; +}; + template class Vector final : public LSPObject { public: diff --git a/src/lsp/cxx/lsp/requests.cc b/src/lsp/cxx/lsp/requests.cc new file mode 100644 index 00000000..07f88dd1 --- /dev/null +++ b/src/lsp/cxx/lsp/requests.cc @@ -0,0 +1,3690 @@ +// Copyright (c) 2024 Roberto Raggi +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +#include +#include +#include + +namespace cxx::lsp { + +auto ImplementationRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto ImplementationRequest::method(std::string method) + -> ImplementationRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ImplementationRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ImplementationRequest::id(long id) -> ImplementationRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto ImplementationRequest::id(std::string id) -> ImplementationRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ImplementationRequest::params() const -> ImplementationParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return ImplementationParams(repr_->at("params")); +} + +auto ImplementationRequest::params(ImplementationParams params) + -> ImplementationRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto ImplementationResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ImplementationResponse::id(long id) -> ImplementationResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto ImplementationResponse::id(std::string id) -> ImplementationResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TypeDefinitionRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto TypeDefinitionRequest::method(std::string method) + -> TypeDefinitionRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto TypeDefinitionRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TypeDefinitionRequest::id(long id) -> TypeDefinitionRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto TypeDefinitionRequest::id(std::string id) -> TypeDefinitionRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TypeDefinitionRequest::params() const -> TypeDefinitionParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return TypeDefinitionParams(repr_->at("params")); +} + +auto TypeDefinitionRequest::params(TypeDefinitionParams params) + -> TypeDefinitionRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto TypeDefinitionResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TypeDefinitionResponse::id(long id) -> TypeDefinitionResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto TypeDefinitionResponse::id(std::string id) -> TypeDefinitionResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WorkspaceFoldersRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto WorkspaceFoldersRequest::method(std::string method) + -> WorkspaceFoldersRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto WorkspaceFoldersRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WorkspaceFoldersRequest::id(long id) -> WorkspaceFoldersRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto WorkspaceFoldersRequest::id(std::string id) -> WorkspaceFoldersRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WorkspaceFoldersResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WorkspaceFoldersResponse::id(long id) -> WorkspaceFoldersResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto WorkspaceFoldersResponse::id(std::string id) -> WorkspaceFoldersResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ConfigurationRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto ConfigurationRequest::method(std::string method) -> ConfigurationRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ConfigurationRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ConfigurationRequest::id(long id) -> ConfigurationRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto ConfigurationRequest::id(std::string id) -> ConfigurationRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ConfigurationRequest::params() const -> ConfigurationParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return ConfigurationParams(repr_->at("params")); +} + +auto ConfigurationRequest::params(ConfigurationParams params) + -> ConfigurationRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto ConfigurationResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ConfigurationResponse::id(long id) -> ConfigurationResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto ConfigurationResponse::id(std::string id) -> ConfigurationResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentColorRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DocumentColorRequest::method(std::string method) -> DocumentColorRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DocumentColorRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentColorRequest::id(long id) -> DocumentColorRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentColorRequest::id(std::string id) -> DocumentColorRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentColorRequest::params() const -> DocumentColorParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DocumentColorParams(repr_->at("params")); +} + +auto DocumentColorRequest::params(DocumentColorParams params) + -> DocumentColorRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DocumentColorResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentColorResponse::id(long id) -> DocumentColorResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentColorResponse::id(std::string id) -> DocumentColorResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ColorPresentationRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto ColorPresentationRequest::method(std::string method) + -> ColorPresentationRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ColorPresentationRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ColorPresentationRequest::id(long id) -> ColorPresentationRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto ColorPresentationRequest::id(std::string id) -> ColorPresentationRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ColorPresentationRequest::params() const -> ColorPresentationParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return ColorPresentationParams(repr_->at("params")); +} + +auto ColorPresentationRequest::params(ColorPresentationParams params) + -> ColorPresentationRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto ColorPresentationResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ColorPresentationResponse::id(long id) -> ColorPresentationResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto ColorPresentationResponse::id(std::string id) + -> ColorPresentationResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto FoldingRangeRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto FoldingRangeRequest::method(std::string method) -> FoldingRangeRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto FoldingRangeRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto FoldingRangeRequest::id(long id) -> FoldingRangeRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto FoldingRangeRequest::id(std::string id) -> FoldingRangeRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto FoldingRangeRequest::params() const -> FoldingRangeParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return FoldingRangeParams(repr_->at("params")); +} + +auto FoldingRangeRequest::params(FoldingRangeParams params) + -> FoldingRangeRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto FoldingRangeResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto FoldingRangeResponse::id(long id) -> FoldingRangeResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto FoldingRangeResponse::id(std::string id) -> FoldingRangeResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto FoldingRangeRefreshRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto FoldingRangeRefreshRequest::method(std::string method) + -> FoldingRangeRefreshRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto FoldingRangeRefreshRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto FoldingRangeRefreshRequest::id(long id) -> FoldingRangeRefreshRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto FoldingRangeRefreshRequest::id(std::string id) + -> FoldingRangeRefreshRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto FoldingRangeRefreshResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto FoldingRangeRefreshResponse::id(long id) -> FoldingRangeRefreshResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto FoldingRangeRefreshResponse::id(std::string id) + -> FoldingRangeRefreshResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DeclarationRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DeclarationRequest::method(std::string method) -> DeclarationRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DeclarationRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DeclarationRequest::id(long id) -> DeclarationRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DeclarationRequest::id(std::string id) -> DeclarationRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DeclarationRequest::params() const -> DeclarationParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DeclarationParams(repr_->at("params")); +} + +auto DeclarationRequest::params(DeclarationParams params) + -> DeclarationRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DeclarationResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DeclarationResponse::id(long id) -> DeclarationResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DeclarationResponse::id(std::string id) -> DeclarationResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SelectionRangeRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto SelectionRangeRequest::method(std::string method) + -> SelectionRangeRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto SelectionRangeRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SelectionRangeRequest::id(long id) -> SelectionRangeRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto SelectionRangeRequest::id(std::string id) -> SelectionRangeRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SelectionRangeRequest::params() const -> SelectionRangeParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return SelectionRangeParams(repr_->at("params")); +} + +auto SelectionRangeRequest::params(SelectionRangeParams params) + -> SelectionRangeRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto SelectionRangeResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SelectionRangeResponse::id(long id) -> SelectionRangeResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto SelectionRangeResponse::id(std::string id) -> SelectionRangeResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WorkDoneProgressCreateRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto WorkDoneProgressCreateRequest::method(std::string method) + -> WorkDoneProgressCreateRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto WorkDoneProgressCreateRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WorkDoneProgressCreateRequest::id(long id) + -> WorkDoneProgressCreateRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto WorkDoneProgressCreateRequest::id(std::string id) + -> WorkDoneProgressCreateRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WorkDoneProgressCreateRequest::params() const + -> WorkDoneProgressCreateParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return WorkDoneProgressCreateParams(repr_->at("params")); +} + +auto WorkDoneProgressCreateRequest::params(WorkDoneProgressCreateParams params) + -> WorkDoneProgressCreateRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto WorkDoneProgressCreateResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WorkDoneProgressCreateResponse::id(long id) + -> WorkDoneProgressCreateResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto WorkDoneProgressCreateResponse::id(std::string id) + -> WorkDoneProgressCreateResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CallHierarchyPrepareRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto CallHierarchyPrepareRequest::method(std::string method) + -> CallHierarchyPrepareRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto CallHierarchyPrepareRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CallHierarchyPrepareRequest::id(long id) -> CallHierarchyPrepareRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto CallHierarchyPrepareRequest::id(std::string id) + -> CallHierarchyPrepareRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CallHierarchyPrepareRequest::params() const -> CallHierarchyPrepareParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CallHierarchyPrepareParams(repr_->at("params")); +} + +auto CallHierarchyPrepareRequest::params(CallHierarchyPrepareParams params) + -> CallHierarchyPrepareRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto CallHierarchyPrepareResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CallHierarchyPrepareResponse::id(long id) + -> CallHierarchyPrepareResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto CallHierarchyPrepareResponse::id(std::string id) + -> CallHierarchyPrepareResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CallHierarchyIncomingCallsRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto CallHierarchyIncomingCallsRequest::method(std::string method) + -> CallHierarchyIncomingCallsRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto CallHierarchyIncomingCallsRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CallHierarchyIncomingCallsRequest::id(long id) + -> CallHierarchyIncomingCallsRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto CallHierarchyIncomingCallsRequest::id(std::string id) + -> CallHierarchyIncomingCallsRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CallHierarchyIncomingCallsRequest::params() const + -> CallHierarchyIncomingCallsParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CallHierarchyIncomingCallsParams(repr_->at("params")); +} + +auto CallHierarchyIncomingCallsRequest::params( + CallHierarchyIncomingCallsParams params) + -> CallHierarchyIncomingCallsRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto CallHierarchyIncomingCallsResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CallHierarchyIncomingCallsResponse::id(long id) + -> CallHierarchyIncomingCallsResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto CallHierarchyIncomingCallsResponse::id(std::string id) + -> CallHierarchyIncomingCallsResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CallHierarchyOutgoingCallsRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto CallHierarchyOutgoingCallsRequest::method(std::string method) + -> CallHierarchyOutgoingCallsRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto CallHierarchyOutgoingCallsRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CallHierarchyOutgoingCallsRequest::id(long id) + -> CallHierarchyOutgoingCallsRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto CallHierarchyOutgoingCallsRequest::id(std::string id) + -> CallHierarchyOutgoingCallsRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CallHierarchyOutgoingCallsRequest::params() const + -> CallHierarchyOutgoingCallsParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CallHierarchyOutgoingCallsParams(repr_->at("params")); +} + +auto CallHierarchyOutgoingCallsRequest::params( + CallHierarchyOutgoingCallsParams params) + -> CallHierarchyOutgoingCallsRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto CallHierarchyOutgoingCallsResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CallHierarchyOutgoingCallsResponse::id(long id) + -> CallHierarchyOutgoingCallsResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto CallHierarchyOutgoingCallsResponse::id(std::string id) + -> CallHierarchyOutgoingCallsResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SemanticTokensRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto SemanticTokensRequest::method(std::string method) + -> SemanticTokensRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto SemanticTokensRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SemanticTokensRequest::id(long id) -> SemanticTokensRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto SemanticTokensRequest::id(std::string id) -> SemanticTokensRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SemanticTokensRequest::params() const -> SemanticTokensParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return SemanticTokensParams(repr_->at("params")); +} + +auto SemanticTokensRequest::params(SemanticTokensParams params) + -> SemanticTokensRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto SemanticTokensResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SemanticTokensResponse::id(long id) -> SemanticTokensResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto SemanticTokensResponse::id(std::string id) -> SemanticTokensResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SemanticTokensDeltaRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto SemanticTokensDeltaRequest::method(std::string method) + -> SemanticTokensDeltaRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto SemanticTokensDeltaRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SemanticTokensDeltaRequest::id(long id) -> SemanticTokensDeltaRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto SemanticTokensDeltaRequest::id(std::string id) + -> SemanticTokensDeltaRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SemanticTokensDeltaRequest::params() const -> SemanticTokensDeltaParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return SemanticTokensDeltaParams(repr_->at("params")); +} + +auto SemanticTokensDeltaRequest::params(SemanticTokensDeltaParams params) + -> SemanticTokensDeltaRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto SemanticTokensDeltaResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SemanticTokensDeltaResponse::id(long id) -> SemanticTokensDeltaResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto SemanticTokensDeltaResponse::id(std::string id) + -> SemanticTokensDeltaResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SemanticTokensRangeRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto SemanticTokensRangeRequest::method(std::string method) + -> SemanticTokensRangeRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto SemanticTokensRangeRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SemanticTokensRangeRequest::id(long id) -> SemanticTokensRangeRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto SemanticTokensRangeRequest::id(std::string id) + -> SemanticTokensRangeRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SemanticTokensRangeRequest::params() const -> SemanticTokensRangeParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return SemanticTokensRangeParams(repr_->at("params")); +} + +auto SemanticTokensRangeRequest::params(SemanticTokensRangeParams params) + -> SemanticTokensRangeRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto SemanticTokensRangeResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SemanticTokensRangeResponse::id(long id) -> SemanticTokensRangeResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto SemanticTokensRangeResponse::id(std::string id) + -> SemanticTokensRangeResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SemanticTokensRefreshRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto SemanticTokensRefreshRequest::method(std::string method) + -> SemanticTokensRefreshRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto SemanticTokensRefreshRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SemanticTokensRefreshRequest::id(long id) + -> SemanticTokensRefreshRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto SemanticTokensRefreshRequest::id(std::string id) + -> SemanticTokensRefreshRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SemanticTokensRefreshResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SemanticTokensRefreshResponse::id(long id) + -> SemanticTokensRefreshResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto SemanticTokensRefreshResponse::id(std::string id) + -> SemanticTokensRefreshResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ShowDocumentRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto ShowDocumentRequest::method(std::string method) -> ShowDocumentRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ShowDocumentRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ShowDocumentRequest::id(long id) -> ShowDocumentRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto ShowDocumentRequest::id(std::string id) -> ShowDocumentRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ShowDocumentRequest::params() const -> ShowDocumentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return ShowDocumentParams(repr_->at("params")); +} + +auto ShowDocumentRequest::params(ShowDocumentParams params) + -> ShowDocumentRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto ShowDocumentResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ShowDocumentResponse::id(long id) -> ShowDocumentResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto ShowDocumentResponse::id(std::string id) -> ShowDocumentResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto LinkedEditingRangeRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto LinkedEditingRangeRequest::method(std::string method) + -> LinkedEditingRangeRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto LinkedEditingRangeRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto LinkedEditingRangeRequest::id(long id) -> LinkedEditingRangeRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto LinkedEditingRangeRequest::id(std::string id) + -> LinkedEditingRangeRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto LinkedEditingRangeRequest::params() const -> LinkedEditingRangeParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return LinkedEditingRangeParams(repr_->at("params")); +} + +auto LinkedEditingRangeRequest::params(LinkedEditingRangeParams params) + -> LinkedEditingRangeRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto LinkedEditingRangeResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto LinkedEditingRangeResponse::id(long id) -> LinkedEditingRangeResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto LinkedEditingRangeResponse::id(std::string id) + -> LinkedEditingRangeResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WillCreateFilesRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto WillCreateFilesRequest::method(std::string method) + -> WillCreateFilesRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto WillCreateFilesRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WillCreateFilesRequest::id(long id) -> WillCreateFilesRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto WillCreateFilesRequest::id(std::string id) -> WillCreateFilesRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WillCreateFilesRequest::params() const -> CreateFilesParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CreateFilesParams(repr_->at("params")); +} + +auto WillCreateFilesRequest::params(CreateFilesParams params) + -> WillCreateFilesRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto WillCreateFilesResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WillCreateFilesResponse::id(long id) -> WillCreateFilesResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto WillCreateFilesResponse::id(std::string id) -> WillCreateFilesResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WillRenameFilesRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto WillRenameFilesRequest::method(std::string method) + -> WillRenameFilesRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto WillRenameFilesRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WillRenameFilesRequest::id(long id) -> WillRenameFilesRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto WillRenameFilesRequest::id(std::string id) -> WillRenameFilesRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WillRenameFilesRequest::params() const -> RenameFilesParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return RenameFilesParams(repr_->at("params")); +} + +auto WillRenameFilesRequest::params(RenameFilesParams params) + -> WillRenameFilesRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto WillRenameFilesResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WillRenameFilesResponse::id(long id) -> WillRenameFilesResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto WillRenameFilesResponse::id(std::string id) -> WillRenameFilesResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WillDeleteFilesRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto WillDeleteFilesRequest::method(std::string method) + -> WillDeleteFilesRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto WillDeleteFilesRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WillDeleteFilesRequest::id(long id) -> WillDeleteFilesRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto WillDeleteFilesRequest::id(std::string id) -> WillDeleteFilesRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WillDeleteFilesRequest::params() const -> DeleteFilesParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DeleteFilesParams(repr_->at("params")); +} + +auto WillDeleteFilesRequest::params(DeleteFilesParams params) + -> WillDeleteFilesRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto WillDeleteFilesResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WillDeleteFilesResponse::id(long id) -> WillDeleteFilesResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto WillDeleteFilesResponse::id(std::string id) -> WillDeleteFilesResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto MonikerRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto MonikerRequest::method(std::string method) -> MonikerRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto MonikerRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto MonikerRequest::id(long id) -> MonikerRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto MonikerRequest::id(std::string id) -> MonikerRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto MonikerRequest::params() const -> MonikerParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return MonikerParams(repr_->at("params")); +} + +auto MonikerRequest::params(MonikerParams params) -> MonikerRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto MonikerResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto MonikerResponse::id(long id) -> MonikerResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto MonikerResponse::id(std::string id) -> MonikerResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TypeHierarchyPrepareRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto TypeHierarchyPrepareRequest::method(std::string method) + -> TypeHierarchyPrepareRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto TypeHierarchyPrepareRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TypeHierarchyPrepareRequest::id(long id) -> TypeHierarchyPrepareRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto TypeHierarchyPrepareRequest::id(std::string id) + -> TypeHierarchyPrepareRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TypeHierarchyPrepareRequest::params() const -> TypeHierarchyPrepareParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return TypeHierarchyPrepareParams(repr_->at("params")); +} + +auto TypeHierarchyPrepareRequest::params(TypeHierarchyPrepareParams params) + -> TypeHierarchyPrepareRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto TypeHierarchyPrepareResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TypeHierarchyPrepareResponse::id(long id) + -> TypeHierarchyPrepareResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto TypeHierarchyPrepareResponse::id(std::string id) + -> TypeHierarchyPrepareResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TypeHierarchySupertypesRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto TypeHierarchySupertypesRequest::method(std::string method) + -> TypeHierarchySupertypesRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto TypeHierarchySupertypesRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TypeHierarchySupertypesRequest::id(long id) + -> TypeHierarchySupertypesRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto TypeHierarchySupertypesRequest::id(std::string id) + -> TypeHierarchySupertypesRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TypeHierarchySupertypesRequest::params() const + -> TypeHierarchySupertypesParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return TypeHierarchySupertypesParams(repr_->at("params")); +} + +auto TypeHierarchySupertypesRequest::params( + TypeHierarchySupertypesParams params) -> TypeHierarchySupertypesRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto TypeHierarchySupertypesResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TypeHierarchySupertypesResponse::id(long id) + -> TypeHierarchySupertypesResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto TypeHierarchySupertypesResponse::id(std::string id) + -> TypeHierarchySupertypesResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TypeHierarchySubtypesRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto TypeHierarchySubtypesRequest::method(std::string method) + -> TypeHierarchySubtypesRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto TypeHierarchySubtypesRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TypeHierarchySubtypesRequest::id(long id) + -> TypeHierarchySubtypesRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto TypeHierarchySubtypesRequest::id(std::string id) + -> TypeHierarchySubtypesRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TypeHierarchySubtypesRequest::params() const + -> TypeHierarchySubtypesParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return TypeHierarchySubtypesParams(repr_->at("params")); +} + +auto TypeHierarchySubtypesRequest::params(TypeHierarchySubtypesParams params) + -> TypeHierarchySubtypesRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto TypeHierarchySubtypesResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TypeHierarchySubtypesResponse::id(long id) + -> TypeHierarchySubtypesResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto TypeHierarchySubtypesResponse::id(std::string id) + -> TypeHierarchySubtypesResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlineValueRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto InlineValueRequest::method(std::string method) -> InlineValueRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto InlineValueRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlineValueRequest::id(long id) -> InlineValueRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto InlineValueRequest::id(std::string id) -> InlineValueRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlineValueRequest::params() const -> InlineValueParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return InlineValueParams(repr_->at("params")); +} + +auto InlineValueRequest::params(InlineValueParams params) + -> InlineValueRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto InlineValueResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlineValueResponse::id(long id) -> InlineValueResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto InlineValueResponse::id(std::string id) -> InlineValueResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlineValueRefreshRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto InlineValueRefreshRequest::method(std::string method) + -> InlineValueRefreshRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto InlineValueRefreshRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlineValueRefreshRequest::id(long id) -> InlineValueRefreshRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto InlineValueRefreshRequest::id(std::string id) + -> InlineValueRefreshRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlineValueRefreshResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlineValueRefreshResponse::id(long id) -> InlineValueRefreshResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto InlineValueRefreshResponse::id(std::string id) + -> InlineValueRefreshResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlayHintRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto InlayHintRequest::method(std::string method) -> InlayHintRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto InlayHintRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlayHintRequest::id(long id) -> InlayHintRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto InlayHintRequest::id(std::string id) -> InlayHintRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlayHintRequest::params() const -> InlayHintParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return InlayHintParams(repr_->at("params")); +} + +auto InlayHintRequest::params(InlayHintParams params) -> InlayHintRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto InlayHintResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlayHintResponse::id(long id) -> InlayHintResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto InlayHintResponse::id(std::string id) -> InlayHintResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlayHintResolveRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto InlayHintResolveRequest::method(std::string method) + -> InlayHintResolveRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto InlayHintResolveRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlayHintResolveRequest::id(long id) -> InlayHintResolveRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto InlayHintResolveRequest::id(std::string id) -> InlayHintResolveRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlayHintResolveRequest::params() const -> InlayHint { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return InlayHint(repr_->at("params")); +} + +auto InlayHintResolveRequest::params(InlayHint params) + -> InlayHintResolveRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto InlayHintResolveResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlayHintResolveResponse::id(long id) -> InlayHintResolveResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto InlayHintResolveResponse::id(std::string id) -> InlayHintResolveResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlayHintRefreshRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto InlayHintRefreshRequest::method(std::string method) + -> InlayHintRefreshRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto InlayHintRefreshRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlayHintRefreshRequest::id(long id) -> InlayHintRefreshRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto InlayHintRefreshRequest::id(std::string id) -> InlayHintRefreshRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlayHintRefreshResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlayHintRefreshResponse::id(long id) -> InlayHintRefreshResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto InlayHintRefreshResponse::id(std::string id) -> InlayHintRefreshResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentDiagnosticRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DocumentDiagnosticRequest::method(std::string method) + -> DocumentDiagnosticRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DocumentDiagnosticRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentDiagnosticRequest::id(long id) -> DocumentDiagnosticRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentDiagnosticRequest::id(std::string id) + -> DocumentDiagnosticRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentDiagnosticRequest::params() const -> DocumentDiagnosticParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DocumentDiagnosticParams(repr_->at("params")); +} + +auto DocumentDiagnosticRequest::params(DocumentDiagnosticParams params) + -> DocumentDiagnosticRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DocumentDiagnosticResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentDiagnosticResponse::id(long id) -> DocumentDiagnosticResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentDiagnosticResponse::id(std::string id) + -> DocumentDiagnosticResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WorkspaceDiagnosticRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto WorkspaceDiagnosticRequest::method(std::string method) + -> WorkspaceDiagnosticRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto WorkspaceDiagnosticRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WorkspaceDiagnosticRequest::id(long id) -> WorkspaceDiagnosticRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto WorkspaceDiagnosticRequest::id(std::string id) + -> WorkspaceDiagnosticRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WorkspaceDiagnosticRequest::params() const -> WorkspaceDiagnosticParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return WorkspaceDiagnosticParams(repr_->at("params")); +} + +auto WorkspaceDiagnosticRequest::params(WorkspaceDiagnosticParams params) + -> WorkspaceDiagnosticRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto WorkspaceDiagnosticResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WorkspaceDiagnosticResponse::id(long id) -> WorkspaceDiagnosticResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto WorkspaceDiagnosticResponse::id(std::string id) + -> WorkspaceDiagnosticResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DiagnosticRefreshRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DiagnosticRefreshRequest::method(std::string method) + -> DiagnosticRefreshRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DiagnosticRefreshRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DiagnosticRefreshRequest::id(long id) -> DiagnosticRefreshRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DiagnosticRefreshRequest::id(std::string id) -> DiagnosticRefreshRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DiagnosticRefreshResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DiagnosticRefreshResponse::id(long id) -> DiagnosticRefreshResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DiagnosticRefreshResponse::id(std::string id) + -> DiagnosticRefreshResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlineCompletionRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto InlineCompletionRequest::method(std::string method) + -> InlineCompletionRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto InlineCompletionRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlineCompletionRequest::id(long id) -> InlineCompletionRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto InlineCompletionRequest::id(std::string id) -> InlineCompletionRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InlineCompletionRequest::params() const -> InlineCompletionParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return InlineCompletionParams(repr_->at("params")); +} + +auto InlineCompletionRequest::params(InlineCompletionParams params) + -> InlineCompletionRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto InlineCompletionResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InlineCompletionResponse::id(long id) -> InlineCompletionResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto InlineCompletionResponse::id(std::string id) -> InlineCompletionResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TextDocumentContentRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto TextDocumentContentRequest::method(std::string method) + -> TextDocumentContentRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto TextDocumentContentRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TextDocumentContentRequest::id(long id) -> TextDocumentContentRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto TextDocumentContentRequest::id(std::string id) + -> TextDocumentContentRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TextDocumentContentRequest::params() const -> TextDocumentContentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return TextDocumentContentParams(repr_->at("params")); +} + +auto TextDocumentContentRequest::params(TextDocumentContentParams params) + -> TextDocumentContentRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto TextDocumentContentResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TextDocumentContentResponse::id(long id) -> TextDocumentContentResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto TextDocumentContentResponse::id(std::string id) + -> TextDocumentContentResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TextDocumentContentRefreshRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto TextDocumentContentRefreshRequest::method(std::string method) + -> TextDocumentContentRefreshRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto TextDocumentContentRefreshRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TextDocumentContentRefreshRequest::id(long id) + -> TextDocumentContentRefreshRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto TextDocumentContentRefreshRequest::id(std::string id) + -> TextDocumentContentRefreshRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TextDocumentContentRefreshRequest::params() const + -> TextDocumentContentRefreshParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return TextDocumentContentRefreshParams(repr_->at("params")); +} + +auto TextDocumentContentRefreshRequest::params( + TextDocumentContentRefreshParams params) + -> TextDocumentContentRefreshRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto TextDocumentContentRefreshResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TextDocumentContentRefreshResponse::id(long id) + -> TextDocumentContentRefreshResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto TextDocumentContentRefreshResponse::id(std::string id) + -> TextDocumentContentRefreshResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto RegistrationRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto RegistrationRequest::method(std::string method) -> RegistrationRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto RegistrationRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto RegistrationRequest::id(long id) -> RegistrationRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto RegistrationRequest::id(std::string id) -> RegistrationRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto RegistrationRequest::params() const -> RegistrationParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return RegistrationParams(repr_->at("params")); +} + +auto RegistrationRequest::params(RegistrationParams params) + -> RegistrationRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto RegistrationResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto RegistrationResponse::id(long id) -> RegistrationResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto RegistrationResponse::id(std::string id) -> RegistrationResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto UnregistrationRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto UnregistrationRequest::method(std::string method) + -> UnregistrationRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto UnregistrationRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto UnregistrationRequest::id(long id) -> UnregistrationRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto UnregistrationRequest::id(std::string id) -> UnregistrationRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto UnregistrationRequest::params() const -> UnregistrationParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return UnregistrationParams(repr_->at("params")); +} + +auto UnregistrationRequest::params(UnregistrationParams params) + -> UnregistrationRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto UnregistrationResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto UnregistrationResponse::id(long id) -> UnregistrationResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto UnregistrationResponse::id(std::string id) -> UnregistrationResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InitializeRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto InitializeRequest::method(std::string method) -> InitializeRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto InitializeRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InitializeRequest::id(long id) -> InitializeRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto InitializeRequest::id(std::string id) -> InitializeRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InitializeRequest::params() const -> InitializeParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return InitializeParams(repr_->at("params")); +} + +auto InitializeRequest::params(InitializeParams params) -> InitializeRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto InitializeResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InitializeResponse::id(long id) -> InitializeResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto InitializeResponse::id(std::string id) -> InitializeResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ShutdownRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto ShutdownRequest::method(std::string method) -> ShutdownRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ShutdownRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ShutdownRequest::id(long id) -> ShutdownRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto ShutdownRequest::id(std::string id) -> ShutdownRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ShutdownResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ShutdownResponse::id(long id) -> ShutdownResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto ShutdownResponse::id(std::string id) -> ShutdownResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ShowMessageRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto ShowMessageRequest::method(std::string method) -> ShowMessageRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ShowMessageRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ShowMessageRequest::id(long id) -> ShowMessageRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto ShowMessageRequest::id(std::string id) -> ShowMessageRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ShowMessageRequest::params() const -> ShowMessageRequestParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return ShowMessageRequestParams(repr_->at("params")); +} + +auto ShowMessageRequest::params(ShowMessageRequestParams params) + -> ShowMessageRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto ShowMessageResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ShowMessageResponse::id(long id) -> ShowMessageResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto ShowMessageResponse::id(std::string id) -> ShowMessageResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WillSaveTextDocumentWaitUntilRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto WillSaveTextDocumentWaitUntilRequest::method(std::string method) + -> WillSaveTextDocumentWaitUntilRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto WillSaveTextDocumentWaitUntilRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WillSaveTextDocumentWaitUntilRequest::id(long id) + -> WillSaveTextDocumentWaitUntilRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto WillSaveTextDocumentWaitUntilRequest::id(std::string id) + -> WillSaveTextDocumentWaitUntilRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WillSaveTextDocumentWaitUntilRequest::params() const + -> WillSaveTextDocumentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return WillSaveTextDocumentParams(repr_->at("params")); +} + +auto WillSaveTextDocumentWaitUntilRequest::params( + WillSaveTextDocumentParams params) + -> WillSaveTextDocumentWaitUntilRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto WillSaveTextDocumentWaitUntilResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WillSaveTextDocumentWaitUntilResponse::id(long id) + -> WillSaveTextDocumentWaitUntilResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto WillSaveTextDocumentWaitUntilResponse::id(std::string id) + -> WillSaveTextDocumentWaitUntilResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CompletionRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto CompletionRequest::method(std::string method) -> CompletionRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto CompletionRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CompletionRequest::id(long id) -> CompletionRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto CompletionRequest::id(std::string id) -> CompletionRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CompletionRequest::params() const -> CompletionParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CompletionParams(repr_->at("params")); +} + +auto CompletionRequest::params(CompletionParams params) -> CompletionRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto CompletionResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CompletionResponse::id(long id) -> CompletionResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto CompletionResponse::id(std::string id) -> CompletionResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CompletionResolveRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto CompletionResolveRequest::method(std::string method) + -> CompletionResolveRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto CompletionResolveRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CompletionResolveRequest::id(long id) -> CompletionResolveRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto CompletionResolveRequest::id(std::string id) -> CompletionResolveRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CompletionResolveRequest::params() const -> CompletionItem { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CompletionItem(repr_->at("params")); +} + +auto CompletionResolveRequest::params(CompletionItem params) + -> CompletionResolveRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto CompletionResolveResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CompletionResolveResponse::id(long id) -> CompletionResolveResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto CompletionResolveResponse::id(std::string id) + -> CompletionResolveResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto HoverRequest::method() const -> std::string { return repr_->at("method"); } + +auto HoverRequest::method(std::string method) -> HoverRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto HoverRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto HoverRequest::id(long id) -> HoverRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto HoverRequest::id(std::string id) -> HoverRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto HoverRequest::params() const -> HoverParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return HoverParams(repr_->at("params")); +} + +auto HoverRequest::params(HoverParams params) -> HoverRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto HoverResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto HoverResponse::id(long id) -> HoverResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto HoverResponse::id(std::string id) -> HoverResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SignatureHelpRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto SignatureHelpRequest::method(std::string method) -> SignatureHelpRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto SignatureHelpRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SignatureHelpRequest::id(long id) -> SignatureHelpRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto SignatureHelpRequest::id(std::string id) -> SignatureHelpRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SignatureHelpRequest::params() const -> SignatureHelpParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return SignatureHelpParams(repr_->at("params")); +} + +auto SignatureHelpRequest::params(SignatureHelpParams params) + -> SignatureHelpRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto SignatureHelpResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SignatureHelpResponse::id(long id) -> SignatureHelpResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto SignatureHelpResponse::id(std::string id) -> SignatureHelpResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DefinitionRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DefinitionRequest::method(std::string method) -> DefinitionRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DefinitionRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DefinitionRequest::id(long id) -> DefinitionRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DefinitionRequest::id(std::string id) -> DefinitionRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DefinitionRequest::params() const -> DefinitionParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DefinitionParams(repr_->at("params")); +} + +auto DefinitionRequest::params(DefinitionParams params) -> DefinitionRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DefinitionResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DefinitionResponse::id(long id) -> DefinitionResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DefinitionResponse::id(std::string id) -> DefinitionResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ReferencesRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto ReferencesRequest::method(std::string method) -> ReferencesRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ReferencesRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ReferencesRequest::id(long id) -> ReferencesRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto ReferencesRequest::id(std::string id) -> ReferencesRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ReferencesRequest::params() const -> ReferenceParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return ReferenceParams(repr_->at("params")); +} + +auto ReferencesRequest::params(ReferenceParams params) -> ReferencesRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto ReferencesResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ReferencesResponse::id(long id) -> ReferencesResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto ReferencesResponse::id(std::string id) -> ReferencesResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentHighlightRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DocumentHighlightRequest::method(std::string method) + -> DocumentHighlightRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DocumentHighlightRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentHighlightRequest::id(long id) -> DocumentHighlightRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentHighlightRequest::id(std::string id) -> DocumentHighlightRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentHighlightRequest::params() const -> DocumentHighlightParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DocumentHighlightParams(repr_->at("params")); +} + +auto DocumentHighlightRequest::params(DocumentHighlightParams params) + -> DocumentHighlightRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DocumentHighlightResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentHighlightResponse::id(long id) -> DocumentHighlightResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentHighlightResponse::id(std::string id) + -> DocumentHighlightResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentSymbolRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DocumentSymbolRequest::method(std::string method) + -> DocumentSymbolRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DocumentSymbolRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentSymbolRequest::id(long id) -> DocumentSymbolRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentSymbolRequest::id(std::string id) -> DocumentSymbolRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentSymbolRequest::params() const -> DocumentSymbolParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DocumentSymbolParams(repr_->at("params")); +} + +auto DocumentSymbolRequest::params(DocumentSymbolParams params) + -> DocumentSymbolRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DocumentSymbolResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentSymbolResponse::id(long id) -> DocumentSymbolResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentSymbolResponse::id(std::string id) -> DocumentSymbolResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CodeActionRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto CodeActionRequest::method(std::string method) -> CodeActionRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto CodeActionRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CodeActionRequest::id(long id) -> CodeActionRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto CodeActionRequest::id(std::string id) -> CodeActionRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CodeActionRequest::params() const -> CodeActionParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CodeActionParams(repr_->at("params")); +} + +auto CodeActionRequest::params(CodeActionParams params) -> CodeActionRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto CodeActionResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CodeActionResponse::id(long id) -> CodeActionResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto CodeActionResponse::id(std::string id) -> CodeActionResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CodeActionResolveRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto CodeActionResolveRequest::method(std::string method) + -> CodeActionResolveRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto CodeActionResolveRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CodeActionResolveRequest::id(long id) -> CodeActionResolveRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto CodeActionResolveRequest::id(std::string id) -> CodeActionResolveRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CodeActionResolveRequest::params() const -> CodeAction { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CodeAction(repr_->at("params")); +} + +auto CodeActionResolveRequest::params(CodeAction params) + -> CodeActionResolveRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto CodeActionResolveResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CodeActionResolveResponse::id(long id) -> CodeActionResolveResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto CodeActionResolveResponse::id(std::string id) + -> CodeActionResolveResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WorkspaceSymbolRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto WorkspaceSymbolRequest::method(std::string method) + -> WorkspaceSymbolRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto WorkspaceSymbolRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WorkspaceSymbolRequest::id(long id) -> WorkspaceSymbolRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto WorkspaceSymbolRequest::id(std::string id) -> WorkspaceSymbolRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WorkspaceSymbolRequest::params() const -> WorkspaceSymbolParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return WorkspaceSymbolParams(repr_->at("params")); +} + +auto WorkspaceSymbolRequest::params(WorkspaceSymbolParams params) + -> WorkspaceSymbolRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto WorkspaceSymbolResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WorkspaceSymbolResponse::id(long id) -> WorkspaceSymbolResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto WorkspaceSymbolResponse::id(std::string id) -> WorkspaceSymbolResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WorkspaceSymbolResolveRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto WorkspaceSymbolResolveRequest::method(std::string method) + -> WorkspaceSymbolResolveRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto WorkspaceSymbolResolveRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WorkspaceSymbolResolveRequest::id(long id) + -> WorkspaceSymbolResolveRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto WorkspaceSymbolResolveRequest::id(std::string id) + -> WorkspaceSymbolResolveRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WorkspaceSymbolResolveRequest::params() const -> WorkspaceSymbol { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return WorkspaceSymbol(repr_->at("params")); +} + +auto WorkspaceSymbolResolveRequest::params(WorkspaceSymbol params) + -> WorkspaceSymbolResolveRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto WorkspaceSymbolResolveResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WorkspaceSymbolResolveResponse::id(long id) + -> WorkspaceSymbolResolveResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto WorkspaceSymbolResolveResponse::id(std::string id) + -> WorkspaceSymbolResolveResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CodeLensRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto CodeLensRequest::method(std::string method) -> CodeLensRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto CodeLensRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CodeLensRequest::id(long id) -> CodeLensRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto CodeLensRequest::id(std::string id) -> CodeLensRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CodeLensRequest::params() const -> CodeLensParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CodeLensParams(repr_->at("params")); +} + +auto CodeLensRequest::params(CodeLensParams params) -> CodeLensRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto CodeLensResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CodeLensResponse::id(long id) -> CodeLensResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto CodeLensResponse::id(std::string id) -> CodeLensResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CodeLensResolveRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto CodeLensResolveRequest::method(std::string method) + -> CodeLensResolveRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto CodeLensResolveRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CodeLensResolveRequest::id(long id) -> CodeLensResolveRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto CodeLensResolveRequest::id(std::string id) -> CodeLensResolveRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CodeLensResolveRequest::params() const -> CodeLens { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CodeLens(repr_->at("params")); +} + +auto CodeLensResolveRequest::params(CodeLens params) + -> CodeLensResolveRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto CodeLensResolveResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CodeLensResolveResponse::id(long id) -> CodeLensResolveResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto CodeLensResolveResponse::id(std::string id) -> CodeLensResolveResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CodeLensRefreshRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto CodeLensRefreshRequest::method(std::string method) + -> CodeLensRefreshRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto CodeLensRefreshRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CodeLensRefreshRequest::id(long id) -> CodeLensRefreshRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto CodeLensRefreshRequest::id(std::string id) -> CodeLensRefreshRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CodeLensRefreshResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CodeLensRefreshResponse::id(long id) -> CodeLensRefreshResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto CodeLensRefreshResponse::id(std::string id) -> CodeLensRefreshResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentLinkRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DocumentLinkRequest::method(std::string method) -> DocumentLinkRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DocumentLinkRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentLinkRequest::id(long id) -> DocumentLinkRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentLinkRequest::id(std::string id) -> DocumentLinkRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentLinkRequest::params() const -> DocumentLinkParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DocumentLinkParams(repr_->at("params")); +} + +auto DocumentLinkRequest::params(DocumentLinkParams params) + -> DocumentLinkRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DocumentLinkResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentLinkResponse::id(long id) -> DocumentLinkResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentLinkResponse::id(std::string id) -> DocumentLinkResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentLinkResolveRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DocumentLinkResolveRequest::method(std::string method) + -> DocumentLinkResolveRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DocumentLinkResolveRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentLinkResolveRequest::id(long id) -> DocumentLinkResolveRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentLinkResolveRequest::id(std::string id) + -> DocumentLinkResolveRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentLinkResolveRequest::params() const -> DocumentLink { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DocumentLink(repr_->at("params")); +} + +auto DocumentLinkResolveRequest::params(DocumentLink params) + -> DocumentLinkResolveRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DocumentLinkResolveResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentLinkResolveResponse::id(long id) -> DocumentLinkResolveResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentLinkResolveResponse::id(std::string id) + -> DocumentLinkResolveResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentFormattingRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DocumentFormattingRequest::method(std::string method) + -> DocumentFormattingRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DocumentFormattingRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentFormattingRequest::id(long id) -> DocumentFormattingRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentFormattingRequest::id(std::string id) + -> DocumentFormattingRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentFormattingRequest::params() const -> DocumentFormattingParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DocumentFormattingParams(repr_->at("params")); +} + +auto DocumentFormattingRequest::params(DocumentFormattingParams params) + -> DocumentFormattingRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DocumentFormattingResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentFormattingResponse::id(long id) -> DocumentFormattingResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentFormattingResponse::id(std::string id) + -> DocumentFormattingResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentRangeFormattingRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DocumentRangeFormattingRequest::method(std::string method) + -> DocumentRangeFormattingRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DocumentRangeFormattingRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentRangeFormattingRequest::id(long id) + -> DocumentRangeFormattingRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentRangeFormattingRequest::id(std::string id) + -> DocumentRangeFormattingRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentRangeFormattingRequest::params() const + -> DocumentRangeFormattingParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DocumentRangeFormattingParams(repr_->at("params")); +} + +auto DocumentRangeFormattingRequest::params( + DocumentRangeFormattingParams params) -> DocumentRangeFormattingRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DocumentRangeFormattingResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentRangeFormattingResponse::id(long id) + -> DocumentRangeFormattingResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentRangeFormattingResponse::id(std::string id) + -> DocumentRangeFormattingResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentRangesFormattingRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DocumentRangesFormattingRequest::method(std::string method) + -> DocumentRangesFormattingRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DocumentRangesFormattingRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentRangesFormattingRequest::id(long id) + -> DocumentRangesFormattingRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentRangesFormattingRequest::id(std::string id) + -> DocumentRangesFormattingRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentRangesFormattingRequest::params() const + -> DocumentRangesFormattingParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DocumentRangesFormattingParams(repr_->at("params")); +} + +auto DocumentRangesFormattingRequest::params( + DocumentRangesFormattingParams params) -> DocumentRangesFormattingRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DocumentRangesFormattingResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentRangesFormattingResponse::id(long id) + -> DocumentRangesFormattingResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentRangesFormattingResponse::id(std::string id) + -> DocumentRangesFormattingResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentOnTypeFormattingRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto DocumentOnTypeFormattingRequest::method(std::string method) + -> DocumentOnTypeFormattingRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DocumentOnTypeFormattingRequest::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentOnTypeFormattingRequest::id(long id) + -> DocumentOnTypeFormattingRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentOnTypeFormattingRequest::id(std::string id) + -> DocumentOnTypeFormattingRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DocumentOnTypeFormattingRequest::params() const + -> DocumentOnTypeFormattingParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DocumentOnTypeFormattingParams(repr_->at("params")); +} + +auto DocumentOnTypeFormattingRequest::params( + DocumentOnTypeFormattingParams params) -> DocumentOnTypeFormattingRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DocumentOnTypeFormattingResponse::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DocumentOnTypeFormattingResponse::id(long id) + -> DocumentOnTypeFormattingResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto DocumentOnTypeFormattingResponse::id(std::string id) + -> DocumentOnTypeFormattingResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto RenameRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto RenameRequest::method(std::string method) -> RenameRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto RenameRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto RenameRequest::id(long id) -> RenameRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto RenameRequest::id(std::string id) -> RenameRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto RenameRequest::params() const -> RenameParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return RenameParams(repr_->at("params")); +} + +auto RenameRequest::params(RenameParams params) -> RenameRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto RenameResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto RenameResponse::id(long id) -> RenameResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto RenameResponse::id(std::string id) -> RenameResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto PrepareRenameRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto PrepareRenameRequest::method(std::string method) -> PrepareRenameRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto PrepareRenameRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto PrepareRenameRequest::id(long id) -> PrepareRenameRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto PrepareRenameRequest::id(std::string id) -> PrepareRenameRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto PrepareRenameRequest::params() const -> PrepareRenameParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return PrepareRenameParams(repr_->at("params")); +} + +auto PrepareRenameRequest::params(PrepareRenameParams params) + -> PrepareRenameRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto PrepareRenameResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto PrepareRenameResponse::id(long id) -> PrepareRenameResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto PrepareRenameResponse::id(std::string id) -> PrepareRenameResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ExecuteCommandRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto ExecuteCommandRequest::method(std::string method) + -> ExecuteCommandRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ExecuteCommandRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ExecuteCommandRequest::id(long id) -> ExecuteCommandRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto ExecuteCommandRequest::id(std::string id) -> ExecuteCommandRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ExecuteCommandRequest::params() const -> ExecuteCommandParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return ExecuteCommandParams(repr_->at("params")); +} + +auto ExecuteCommandRequest::params(ExecuteCommandParams params) + -> ExecuteCommandRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto ExecuteCommandResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ExecuteCommandResponse::id(long id) -> ExecuteCommandResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto ExecuteCommandResponse::id(std::string id) -> ExecuteCommandResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ApplyWorkspaceEditRequest::method() const -> std::string { + return repr_->at("method"); +} + +auto ApplyWorkspaceEditRequest::method(std::string method) + -> ApplyWorkspaceEditRequest& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ApplyWorkspaceEditRequest::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ApplyWorkspaceEditRequest::id(long id) -> ApplyWorkspaceEditRequest& { + (*repr_)["id"] = id; + return *this; +} + +auto ApplyWorkspaceEditRequest::id(std::string id) + -> ApplyWorkspaceEditRequest& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ApplyWorkspaceEditRequest::params() const -> ApplyWorkspaceEditParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return ApplyWorkspaceEditParams(repr_->at("params")); +} + +auto ApplyWorkspaceEditRequest::params(ApplyWorkspaceEditParams params) + -> ApplyWorkspaceEditRequest& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto ApplyWorkspaceEditResponse::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ApplyWorkspaceEditResponse::id(long id) -> ApplyWorkspaceEditResponse& { + (*repr_)["id"] = id; + return *this; +} + +auto ApplyWorkspaceEditResponse::id(std::string id) + -> ApplyWorkspaceEditResponse& { + (*repr_)["id"] = std::move(id); + return *this; +} +} // namespace cxx::lsp diff --git a/src/lsp/cxx/lsp/requests.h b/src/lsp/cxx/lsp/requests.h new file mode 100644 index 00000000..9cc34588 --- /dev/null +++ b/src/lsp/cxx/lsp/requests.h @@ -0,0 +1,2046 @@ +// Copyright (c) 2024 Roberto Raggi +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +#pragma once + +#include + +namespace cxx::lsp { + +class ImplementationRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ImplementationRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ImplementationRequest&; + auto id(std::string id) -> ImplementationRequest&; + + [[nodiscard]] auto params() const -> ImplementationParams; + auto params(ImplementationParams result) -> ImplementationRequest&; +}; + +class ImplementationResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ImplementationResponse&; + auto id(std::string id) -> ImplementationResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result( + std::variant, std::nullptr_t> result) + -> ImplementationResponse&; +}; + +class TypeDefinitionRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> TypeDefinitionRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TypeDefinitionRequest&; + auto id(std::string id) -> TypeDefinitionRequest&; + + [[nodiscard]] auto params() const -> TypeDefinitionParams; + auto params(TypeDefinitionParams result) -> TypeDefinitionRequest&; +}; + +class TypeDefinitionResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TypeDefinitionResponse&; + auto id(std::string id) -> TypeDefinitionResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result( + std::variant, std::nullptr_t> result) + -> TypeDefinitionResponse&; +}; + +class WorkspaceFoldersRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> WorkspaceFoldersRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WorkspaceFoldersRequest&; + auto id(std::string id) -> WorkspaceFoldersRequest&; +}; + +class WorkspaceFoldersResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WorkspaceFoldersResponse&; + auto id(std::string id) -> WorkspaceFoldersResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> WorkspaceFoldersResponse&; +}; + +class ConfigurationRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ConfigurationRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ConfigurationRequest&; + auto id(std::string id) -> ConfigurationRequest&; + + [[nodiscard]] auto params() const -> ConfigurationParams; + auto params(ConfigurationParams result) -> ConfigurationRequest&; +}; + +class ConfigurationResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ConfigurationResponse&; + auto id(std::string id) -> ConfigurationResponse&; + + [[nodiscard]] auto result() const -> Vector; + + auto result(Vector result) -> ConfigurationResponse&; +}; + +class DocumentColorRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DocumentColorRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentColorRequest&; + auto id(std::string id) -> DocumentColorRequest&; + + [[nodiscard]] auto params() const -> DocumentColorParams; + auto params(DocumentColorParams result) -> DocumentColorRequest&; +}; + +class DocumentColorResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentColorResponse&; + auto id(std::string id) -> DocumentColorResponse&; + + [[nodiscard]] auto result() const -> Vector; + + auto result(Vector result) -> DocumentColorResponse&; +}; + +class ColorPresentationRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ColorPresentationRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ColorPresentationRequest&; + auto id(std::string id) -> ColorPresentationRequest&; + + [[nodiscard]] auto params() const -> ColorPresentationParams; + auto params(ColorPresentationParams result) -> ColorPresentationRequest&; +}; + +class ColorPresentationResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ColorPresentationResponse&; + auto id(std::string id) -> ColorPresentationResponse&; + + [[nodiscard]] auto result() const -> Vector; + + auto result(Vector result) -> ColorPresentationResponse&; +}; + +class FoldingRangeRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> FoldingRangeRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> FoldingRangeRequest&; + auto id(std::string id) -> FoldingRangeRequest&; + + [[nodiscard]] auto params() const -> FoldingRangeParams; + auto params(FoldingRangeParams result) -> FoldingRangeRequest&; +}; + +class FoldingRangeResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> FoldingRangeResponse&; + auto id(std::string id) -> FoldingRangeResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> FoldingRangeResponse&; +}; + +class FoldingRangeRefreshRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> FoldingRangeRefreshRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> FoldingRangeRefreshRequest&; + auto id(std::string id) -> FoldingRangeRefreshRequest&; +}; + +class FoldingRangeRefreshResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> FoldingRangeRefreshResponse&; + auto id(std::string id) -> FoldingRangeRefreshResponse&; + + [[nodiscard]] auto result() const -> std::nullptr_t; + + auto result(std::nullptr_t result) -> FoldingRangeRefreshResponse&; +}; + +class DeclarationRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DeclarationRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DeclarationRequest&; + auto id(std::string id) -> DeclarationRequest&; + + [[nodiscard]] auto params() const -> DeclarationParams; + auto params(DeclarationParams result) -> DeclarationRequest&; +}; + +class DeclarationResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DeclarationResponse&; + auto id(std::string id) -> DeclarationResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result( + std::variant, std::nullptr_t> result) + -> DeclarationResponse&; +}; + +class SelectionRangeRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> SelectionRangeRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SelectionRangeRequest&; + auto id(std::string id) -> SelectionRangeRequest&; + + [[nodiscard]] auto params() const -> SelectionRangeParams; + auto params(SelectionRangeParams result) -> SelectionRangeRequest&; +}; + +class SelectionRangeResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SelectionRangeResponse&; + auto id(std::string id) -> SelectionRangeResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> SelectionRangeResponse&; +}; + +class WorkDoneProgressCreateRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> WorkDoneProgressCreateRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WorkDoneProgressCreateRequest&; + auto id(std::string id) -> WorkDoneProgressCreateRequest&; + + [[nodiscard]] auto params() const -> WorkDoneProgressCreateParams; + auto params(WorkDoneProgressCreateParams result) + -> WorkDoneProgressCreateRequest&; +}; + +class WorkDoneProgressCreateResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WorkDoneProgressCreateResponse&; + auto id(std::string id) -> WorkDoneProgressCreateResponse&; + + [[nodiscard]] auto result() const -> std::nullptr_t; + + auto result(std::nullptr_t result) -> WorkDoneProgressCreateResponse&; +}; + +class CallHierarchyPrepareRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> CallHierarchyPrepareRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CallHierarchyPrepareRequest&; + auto id(std::string id) -> CallHierarchyPrepareRequest&; + + [[nodiscard]] auto params() const -> CallHierarchyPrepareParams; + auto params(CallHierarchyPrepareParams result) + -> CallHierarchyPrepareRequest&; +}; + +class CallHierarchyPrepareResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CallHierarchyPrepareResponse&; + auto id(std::string id) -> CallHierarchyPrepareResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> CallHierarchyPrepareResponse&; +}; + +class CallHierarchyIncomingCallsRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> CallHierarchyIncomingCallsRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CallHierarchyIncomingCallsRequest&; + auto id(std::string id) -> CallHierarchyIncomingCallsRequest&; + + [[nodiscard]] auto params() const -> CallHierarchyIncomingCallsParams; + auto params(CallHierarchyIncomingCallsParams result) + -> CallHierarchyIncomingCallsRequest&; +}; + +class CallHierarchyIncomingCallsResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CallHierarchyIncomingCallsResponse&; + auto id(std::string id) -> CallHierarchyIncomingCallsResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result( + std::variant, std::nullptr_t> result) + -> CallHierarchyIncomingCallsResponse&; +}; + +class CallHierarchyOutgoingCallsRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> CallHierarchyOutgoingCallsRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CallHierarchyOutgoingCallsRequest&; + auto id(std::string id) -> CallHierarchyOutgoingCallsRequest&; + + [[nodiscard]] auto params() const -> CallHierarchyOutgoingCallsParams; + auto params(CallHierarchyOutgoingCallsParams result) + -> CallHierarchyOutgoingCallsRequest&; +}; + +class CallHierarchyOutgoingCallsResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CallHierarchyOutgoingCallsResponse&; + auto id(std::string id) -> CallHierarchyOutgoingCallsResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result( + std::variant, std::nullptr_t> result) + -> CallHierarchyOutgoingCallsResponse&; +}; + +class SemanticTokensRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> SemanticTokensRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SemanticTokensRequest&; + auto id(std::string id) -> SemanticTokensRequest&; + + [[nodiscard]] auto params() const -> SemanticTokensParams; + auto params(SemanticTokensParams result) -> SemanticTokensRequest&; +}; + +class SemanticTokensResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SemanticTokensResponse&; + auto id(std::string id) -> SemanticTokensResponse&; + + [[nodiscard]] auto result() const + -> std::variant; + + auto result(std::variant result) + -> SemanticTokensResponse&; +}; + +class SemanticTokensDeltaRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> SemanticTokensDeltaRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SemanticTokensDeltaRequest&; + auto id(std::string id) -> SemanticTokensDeltaRequest&; + + [[nodiscard]] auto params() const -> SemanticTokensDeltaParams; + auto params(SemanticTokensDeltaParams result) -> SemanticTokensDeltaRequest&; +}; + +class SemanticTokensDeltaResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SemanticTokensDeltaResponse&; + auto id(std::string id) -> SemanticTokensDeltaResponse&; + + [[nodiscard]] auto result() const + -> std::variant; + + auto result( + std::variant result) + -> SemanticTokensDeltaResponse&; +}; + +class SemanticTokensRangeRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> SemanticTokensRangeRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SemanticTokensRangeRequest&; + auto id(std::string id) -> SemanticTokensRangeRequest&; + + [[nodiscard]] auto params() const -> SemanticTokensRangeParams; + auto params(SemanticTokensRangeParams result) -> SemanticTokensRangeRequest&; +}; + +class SemanticTokensRangeResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SemanticTokensRangeResponse&; + auto id(std::string id) -> SemanticTokensRangeResponse&; + + [[nodiscard]] auto result() const + -> std::variant; + + auto result(std::variant result) + -> SemanticTokensRangeResponse&; +}; + +class SemanticTokensRefreshRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> SemanticTokensRefreshRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SemanticTokensRefreshRequest&; + auto id(std::string id) -> SemanticTokensRefreshRequest&; +}; + +class SemanticTokensRefreshResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SemanticTokensRefreshResponse&; + auto id(std::string id) -> SemanticTokensRefreshResponse&; + + [[nodiscard]] auto result() const -> std::nullptr_t; + + auto result(std::nullptr_t result) -> SemanticTokensRefreshResponse&; +}; + +class ShowDocumentRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ShowDocumentRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ShowDocumentRequest&; + auto id(std::string id) -> ShowDocumentRequest&; + + [[nodiscard]] auto params() const -> ShowDocumentParams; + auto params(ShowDocumentParams result) -> ShowDocumentRequest&; +}; + +class ShowDocumentResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ShowDocumentResponse&; + auto id(std::string id) -> ShowDocumentResponse&; + + [[nodiscard]] auto result() const -> ShowDocumentResult; + + auto result(ShowDocumentResult result) -> ShowDocumentResponse&; +}; + +class LinkedEditingRangeRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> LinkedEditingRangeRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> LinkedEditingRangeRequest&; + auto id(std::string id) -> LinkedEditingRangeRequest&; + + [[nodiscard]] auto params() const -> LinkedEditingRangeParams; + auto params(LinkedEditingRangeParams result) -> LinkedEditingRangeRequest&; +}; + +class LinkedEditingRangeResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> LinkedEditingRangeResponse&; + auto id(std::string id) -> LinkedEditingRangeResponse&; + + [[nodiscard]] auto result() const + -> std::variant; + + auto result(std::variant result) + -> LinkedEditingRangeResponse&; +}; + +class WillCreateFilesRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> WillCreateFilesRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WillCreateFilesRequest&; + auto id(std::string id) -> WillCreateFilesRequest&; + + [[nodiscard]] auto params() const -> CreateFilesParams; + auto params(CreateFilesParams result) -> WillCreateFilesRequest&; +}; + +class WillCreateFilesResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WillCreateFilesResponse&; + auto id(std::string id) -> WillCreateFilesResponse&; + + [[nodiscard]] auto result() const + -> std::variant; + + auto result(std::variant result) + -> WillCreateFilesResponse&; +}; + +class WillRenameFilesRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> WillRenameFilesRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WillRenameFilesRequest&; + auto id(std::string id) -> WillRenameFilesRequest&; + + [[nodiscard]] auto params() const -> RenameFilesParams; + auto params(RenameFilesParams result) -> WillRenameFilesRequest&; +}; + +class WillRenameFilesResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WillRenameFilesResponse&; + auto id(std::string id) -> WillRenameFilesResponse&; + + [[nodiscard]] auto result() const + -> std::variant; + + auto result(std::variant result) + -> WillRenameFilesResponse&; +}; + +class WillDeleteFilesRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> WillDeleteFilesRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WillDeleteFilesRequest&; + auto id(std::string id) -> WillDeleteFilesRequest&; + + [[nodiscard]] auto params() const -> DeleteFilesParams; + auto params(DeleteFilesParams result) -> WillDeleteFilesRequest&; +}; + +class WillDeleteFilesResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WillDeleteFilesResponse&; + auto id(std::string id) -> WillDeleteFilesResponse&; + + [[nodiscard]] auto result() const + -> std::variant; + + auto result(std::variant result) + -> WillDeleteFilesResponse&; +}; + +class MonikerRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> MonikerRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> MonikerRequest&; + auto id(std::string id) -> MonikerRequest&; + + [[nodiscard]] auto params() const -> MonikerParams; + auto params(MonikerParams result) -> MonikerRequest&; +}; + +class MonikerResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> MonikerResponse&; + auto id(std::string id) -> MonikerResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> MonikerResponse&; +}; + +class TypeHierarchyPrepareRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> TypeHierarchyPrepareRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TypeHierarchyPrepareRequest&; + auto id(std::string id) -> TypeHierarchyPrepareRequest&; + + [[nodiscard]] auto params() const -> TypeHierarchyPrepareParams; + auto params(TypeHierarchyPrepareParams result) + -> TypeHierarchyPrepareRequest&; +}; + +class TypeHierarchyPrepareResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TypeHierarchyPrepareResponse&; + auto id(std::string id) -> TypeHierarchyPrepareResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> TypeHierarchyPrepareResponse&; +}; + +class TypeHierarchySupertypesRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> TypeHierarchySupertypesRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TypeHierarchySupertypesRequest&; + auto id(std::string id) -> TypeHierarchySupertypesRequest&; + + [[nodiscard]] auto params() const -> TypeHierarchySupertypesParams; + auto params(TypeHierarchySupertypesParams result) + -> TypeHierarchySupertypesRequest&; +}; + +class TypeHierarchySupertypesResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TypeHierarchySupertypesResponse&; + auto id(std::string id) -> TypeHierarchySupertypesResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> TypeHierarchySupertypesResponse&; +}; + +class TypeHierarchySubtypesRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> TypeHierarchySubtypesRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TypeHierarchySubtypesRequest&; + auto id(std::string id) -> TypeHierarchySubtypesRequest&; + + [[nodiscard]] auto params() const -> TypeHierarchySubtypesParams; + auto params(TypeHierarchySubtypesParams result) + -> TypeHierarchySubtypesRequest&; +}; + +class TypeHierarchySubtypesResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TypeHierarchySubtypesResponse&; + auto id(std::string id) -> TypeHierarchySubtypesResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> TypeHierarchySubtypesResponse&; +}; + +class InlineValueRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> InlineValueRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlineValueRequest&; + auto id(std::string id) -> InlineValueRequest&; + + [[nodiscard]] auto params() const -> InlineValueParams; + auto params(InlineValueParams result) -> InlineValueRequest&; +}; + +class InlineValueResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlineValueResponse&; + auto id(std::string id) -> InlineValueResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> InlineValueResponse&; +}; + +class InlineValueRefreshRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> InlineValueRefreshRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlineValueRefreshRequest&; + auto id(std::string id) -> InlineValueRefreshRequest&; +}; + +class InlineValueRefreshResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlineValueRefreshResponse&; + auto id(std::string id) -> InlineValueRefreshResponse&; + + [[nodiscard]] auto result() const -> std::nullptr_t; + + auto result(std::nullptr_t result) -> InlineValueRefreshResponse&; +}; + +class InlayHintRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> InlayHintRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlayHintRequest&; + auto id(std::string id) -> InlayHintRequest&; + + [[nodiscard]] auto params() const -> InlayHintParams; + auto params(InlayHintParams result) -> InlayHintRequest&; +}; + +class InlayHintResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlayHintResponse&; + auto id(std::string id) -> InlayHintResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> InlayHintResponse&; +}; + +class InlayHintResolveRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> InlayHintResolveRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlayHintResolveRequest&; + auto id(std::string id) -> InlayHintResolveRequest&; + + [[nodiscard]] auto params() const -> InlayHint; + auto params(InlayHint result) -> InlayHintResolveRequest&; +}; + +class InlayHintResolveResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlayHintResolveResponse&; + auto id(std::string id) -> InlayHintResolveResponse&; + + [[nodiscard]] auto result() const -> InlayHint; + + auto result(InlayHint result) -> InlayHintResolveResponse&; +}; + +class InlayHintRefreshRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> InlayHintRefreshRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlayHintRefreshRequest&; + auto id(std::string id) -> InlayHintRefreshRequest&; +}; + +class InlayHintRefreshResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlayHintRefreshResponse&; + auto id(std::string id) -> InlayHintRefreshResponse&; + + [[nodiscard]] auto result() const -> std::nullptr_t; + + auto result(std::nullptr_t result) -> InlayHintRefreshResponse&; +}; + +class DocumentDiagnosticRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DocumentDiagnosticRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentDiagnosticRequest&; + auto id(std::string id) -> DocumentDiagnosticRequest&; + + [[nodiscard]] auto params() const -> DocumentDiagnosticParams; + auto params(DocumentDiagnosticParams result) -> DocumentDiagnosticRequest&; +}; + +class DocumentDiagnosticResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentDiagnosticResponse&; + auto id(std::string id) -> DocumentDiagnosticResponse&; + + [[nodiscard]] auto result() const -> DocumentDiagnosticReport; + + auto result(DocumentDiagnosticReport result) -> DocumentDiagnosticResponse&; +}; + +class WorkspaceDiagnosticRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> WorkspaceDiagnosticRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WorkspaceDiagnosticRequest&; + auto id(std::string id) -> WorkspaceDiagnosticRequest&; + + [[nodiscard]] auto params() const -> WorkspaceDiagnosticParams; + auto params(WorkspaceDiagnosticParams result) -> WorkspaceDiagnosticRequest&; +}; + +class WorkspaceDiagnosticResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WorkspaceDiagnosticResponse&; + auto id(std::string id) -> WorkspaceDiagnosticResponse&; + + [[nodiscard]] auto result() const -> WorkspaceDiagnosticReport; + + auto result(WorkspaceDiagnosticReport result) -> WorkspaceDiagnosticResponse&; +}; + +class DiagnosticRefreshRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DiagnosticRefreshRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DiagnosticRefreshRequest&; + auto id(std::string id) -> DiagnosticRefreshRequest&; +}; + +class DiagnosticRefreshResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DiagnosticRefreshResponse&; + auto id(std::string id) -> DiagnosticRefreshResponse&; + + [[nodiscard]] auto result() const -> std::nullptr_t; + + auto result(std::nullptr_t result) -> DiagnosticRefreshResponse&; +}; + +class InlineCompletionRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> InlineCompletionRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlineCompletionRequest&; + auto id(std::string id) -> InlineCompletionRequest&; + + [[nodiscard]] auto params() const -> InlineCompletionParams; + auto params(InlineCompletionParams result) -> InlineCompletionRequest&; +}; + +class InlineCompletionResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InlineCompletionResponse&; + auto id(std::string id) -> InlineCompletionResponse&; + + [[nodiscard]] auto result() const + -> std::variant, + std::nullptr_t>; + + auto result(std::variant, + std::nullptr_t> + result) -> InlineCompletionResponse&; +}; + +class TextDocumentContentRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> TextDocumentContentRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TextDocumentContentRequest&; + auto id(std::string id) -> TextDocumentContentRequest&; + + [[nodiscard]] auto params() const -> TextDocumentContentParams; + auto params(TextDocumentContentParams result) -> TextDocumentContentRequest&; +}; + +class TextDocumentContentResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TextDocumentContentResponse&; + auto id(std::string id) -> TextDocumentContentResponse&; + + [[nodiscard]] auto result() const -> TextDocumentContentResult; + + auto result(TextDocumentContentResult result) -> TextDocumentContentResponse&; +}; + +class TextDocumentContentRefreshRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> TextDocumentContentRefreshRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TextDocumentContentRefreshRequest&; + auto id(std::string id) -> TextDocumentContentRefreshRequest&; + + [[nodiscard]] auto params() const -> TextDocumentContentRefreshParams; + auto params(TextDocumentContentRefreshParams result) + -> TextDocumentContentRefreshRequest&; +}; + +class TextDocumentContentRefreshResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TextDocumentContentRefreshResponse&; + auto id(std::string id) -> TextDocumentContentRefreshResponse&; + + [[nodiscard]] auto result() const -> std::nullptr_t; + + auto result(std::nullptr_t result) -> TextDocumentContentRefreshResponse&; +}; + +class RegistrationRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> RegistrationRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> RegistrationRequest&; + auto id(std::string id) -> RegistrationRequest&; + + [[nodiscard]] auto params() const -> RegistrationParams; + auto params(RegistrationParams result) -> RegistrationRequest&; +}; + +class RegistrationResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> RegistrationResponse&; + auto id(std::string id) -> RegistrationResponse&; + + [[nodiscard]] auto result() const -> std::nullptr_t; + + auto result(std::nullptr_t result) -> RegistrationResponse&; +}; + +class UnregistrationRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> UnregistrationRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> UnregistrationRequest&; + auto id(std::string id) -> UnregistrationRequest&; + + [[nodiscard]] auto params() const -> UnregistrationParams; + auto params(UnregistrationParams result) -> UnregistrationRequest&; +}; + +class UnregistrationResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> UnregistrationResponse&; + auto id(std::string id) -> UnregistrationResponse&; + + [[nodiscard]] auto result() const -> std::nullptr_t; + + auto result(std::nullptr_t result) -> UnregistrationResponse&; +}; + +class InitializeRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> InitializeRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InitializeRequest&; + auto id(std::string id) -> InitializeRequest&; + + [[nodiscard]] auto params() const -> InitializeParams; + auto params(InitializeParams result) -> InitializeRequest&; +}; + +class InitializeResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InitializeResponse&; + auto id(std::string id) -> InitializeResponse&; + + [[nodiscard]] auto result() const -> InitializeResult; + + auto result(InitializeResult result) -> InitializeResponse&; +}; + +class ShutdownRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ShutdownRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ShutdownRequest&; + auto id(std::string id) -> ShutdownRequest&; +}; + +class ShutdownResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ShutdownResponse&; + auto id(std::string id) -> ShutdownResponse&; + + [[nodiscard]] auto result() const -> std::nullptr_t; + + auto result(std::nullptr_t result) -> ShutdownResponse&; +}; + +class ShowMessageRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ShowMessageRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ShowMessageRequest&; + auto id(std::string id) -> ShowMessageRequest&; + + [[nodiscard]] auto params() const -> ShowMessageRequestParams; + auto params(ShowMessageRequestParams result) -> ShowMessageRequest&; +}; + +class ShowMessageResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ShowMessageResponse&; + auto id(std::string id) -> ShowMessageResponse&; + + [[nodiscard]] auto result() const + -> std::variant; + + auto result(std::variant result) + -> ShowMessageResponse&; +}; + +class WillSaveTextDocumentWaitUntilRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> WillSaveTextDocumentWaitUntilRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WillSaveTextDocumentWaitUntilRequest&; + auto id(std::string id) -> WillSaveTextDocumentWaitUntilRequest&; + + [[nodiscard]] auto params() const -> WillSaveTextDocumentParams; + auto params(WillSaveTextDocumentParams result) + -> WillSaveTextDocumentWaitUntilRequest&; +}; + +class WillSaveTextDocumentWaitUntilResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WillSaveTextDocumentWaitUntilResponse&; + auto id(std::string id) -> WillSaveTextDocumentWaitUntilResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> WillSaveTextDocumentWaitUntilResponse&; +}; + +class CompletionRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> CompletionRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CompletionRequest&; + auto id(std::string id) -> CompletionRequest&; + + [[nodiscard]] auto params() const -> CompletionParams; + auto params(CompletionParams result) -> CompletionRequest&; +}; + +class CompletionResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CompletionResponse&; + auto id(std::string id) -> CompletionResponse&; + + [[nodiscard]] auto result() const + -> std::variant, CompletionList, std::nullptr_t>; + + auto result( + std::variant, CompletionList, std::nullptr_t> + result) -> CompletionResponse&; +}; + +class CompletionResolveRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> CompletionResolveRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CompletionResolveRequest&; + auto id(std::string id) -> CompletionResolveRequest&; + + [[nodiscard]] auto params() const -> CompletionItem; + auto params(CompletionItem result) -> CompletionResolveRequest&; +}; + +class CompletionResolveResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CompletionResolveResponse&; + auto id(std::string id) -> CompletionResolveResponse&; + + [[nodiscard]] auto result() const -> CompletionItem; + + auto result(CompletionItem result) -> CompletionResolveResponse&; +}; + +class HoverRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> HoverRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> HoverRequest&; + auto id(std::string id) -> HoverRequest&; + + [[nodiscard]] auto params() const -> HoverParams; + auto params(HoverParams result) -> HoverRequest&; +}; + +class HoverResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> HoverResponse&; + auto id(std::string id) -> HoverResponse&; + + [[nodiscard]] auto result() const -> std::variant; + + auto result(std::variant result) -> HoverResponse&; +}; + +class SignatureHelpRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> SignatureHelpRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SignatureHelpRequest&; + auto id(std::string id) -> SignatureHelpRequest&; + + [[nodiscard]] auto params() const -> SignatureHelpParams; + auto params(SignatureHelpParams result) -> SignatureHelpRequest&; +}; + +class SignatureHelpResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SignatureHelpResponse&; + auto id(std::string id) -> SignatureHelpResponse&; + + [[nodiscard]] auto result() const + -> std::variant; + + auto result(std::variant result) + -> SignatureHelpResponse&; +}; + +class DefinitionRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DefinitionRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DefinitionRequest&; + auto id(std::string id) -> DefinitionRequest&; + + [[nodiscard]] auto params() const -> DefinitionParams; + auto params(DefinitionParams result) -> DefinitionRequest&; +}; + +class DefinitionResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DefinitionResponse&; + auto id(std::string id) -> DefinitionResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result( + std::variant, std::nullptr_t> result) + -> DefinitionResponse&; +}; + +class ReferencesRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ReferencesRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ReferencesRequest&; + auto id(std::string id) -> ReferencesRequest&; + + [[nodiscard]] auto params() const -> ReferenceParams; + auto params(ReferenceParams result) -> ReferencesRequest&; +}; + +class ReferencesResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ReferencesResponse&; + auto id(std::string id) -> ReferencesResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> ReferencesResponse&; +}; + +class DocumentHighlightRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DocumentHighlightRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentHighlightRequest&; + auto id(std::string id) -> DocumentHighlightRequest&; + + [[nodiscard]] auto params() const -> DocumentHighlightParams; + auto params(DocumentHighlightParams result) -> DocumentHighlightRequest&; +}; + +class DocumentHighlightResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentHighlightResponse&; + auto id(std::string id) -> DocumentHighlightResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> DocumentHighlightResponse&; +}; + +class DocumentSymbolRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DocumentSymbolRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentSymbolRequest&; + auto id(std::string id) -> DocumentSymbolRequest&; + + [[nodiscard]] auto params() const -> DocumentSymbolParams; + auto params(DocumentSymbolParams result) -> DocumentSymbolRequest&; +}; + +class DocumentSymbolResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentSymbolResponse&; + auto id(std::string id) -> DocumentSymbolResponse&; + + [[nodiscard]] auto result() const + -> std::variant, Vector, + std::nullptr_t>; + + auto result(std::variant, Vector, + std::nullptr_t> + result) -> DocumentSymbolResponse&; +}; + +class CodeActionRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> CodeActionRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CodeActionRequest&; + auto id(std::string id) -> CodeActionRequest&; + + [[nodiscard]] auto params() const -> CodeActionParams; + auto params(CodeActionParams result) -> CodeActionRequest&; +}; + +class CodeActionResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CodeActionResponse&; + auto id(std::string id) -> CodeActionResponse&; + + [[nodiscard]] auto result() const + -> std::variant>, + std::nullptr_t>; + + auto result( + std::variant>, std::nullptr_t> + result) -> CodeActionResponse&; +}; + +class CodeActionResolveRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> CodeActionResolveRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CodeActionResolveRequest&; + auto id(std::string id) -> CodeActionResolveRequest&; + + [[nodiscard]] auto params() const -> CodeAction; + auto params(CodeAction result) -> CodeActionResolveRequest&; +}; + +class CodeActionResolveResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CodeActionResolveResponse&; + auto id(std::string id) -> CodeActionResolveResponse&; + + [[nodiscard]] auto result() const -> CodeAction; + + auto result(CodeAction result) -> CodeActionResolveResponse&; +}; + +class WorkspaceSymbolRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> WorkspaceSymbolRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WorkspaceSymbolRequest&; + auto id(std::string id) -> WorkspaceSymbolRequest&; + + [[nodiscard]] auto params() const -> WorkspaceSymbolParams; + auto params(WorkspaceSymbolParams result) -> WorkspaceSymbolRequest&; +}; + +class WorkspaceSymbolResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WorkspaceSymbolResponse&; + auto id(std::string id) -> WorkspaceSymbolResponse&; + + [[nodiscard]] auto result() const + -> std::variant, Vector, + std::nullptr_t>; + + auto result(std::variant, Vector, + std::nullptr_t> + result) -> WorkspaceSymbolResponse&; +}; + +class WorkspaceSymbolResolveRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> WorkspaceSymbolResolveRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WorkspaceSymbolResolveRequest&; + auto id(std::string id) -> WorkspaceSymbolResolveRequest&; + + [[nodiscard]] auto params() const -> WorkspaceSymbol; + auto params(WorkspaceSymbol result) -> WorkspaceSymbolResolveRequest&; +}; + +class WorkspaceSymbolResolveResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WorkspaceSymbolResolveResponse&; + auto id(std::string id) -> WorkspaceSymbolResolveResponse&; + + [[nodiscard]] auto result() const -> WorkspaceSymbol; + + auto result(WorkspaceSymbol result) -> WorkspaceSymbolResolveResponse&; +}; + +class CodeLensRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> CodeLensRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CodeLensRequest&; + auto id(std::string id) -> CodeLensRequest&; + + [[nodiscard]] auto params() const -> CodeLensParams; + auto params(CodeLensParams result) -> CodeLensRequest&; +}; + +class CodeLensResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CodeLensResponse&; + auto id(std::string id) -> CodeLensResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> CodeLensResponse&; +}; + +class CodeLensResolveRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> CodeLensResolveRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CodeLensResolveRequest&; + auto id(std::string id) -> CodeLensResolveRequest&; + + [[nodiscard]] auto params() const -> CodeLens; + auto params(CodeLens result) -> CodeLensResolveRequest&; +}; + +class CodeLensResolveResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CodeLensResolveResponse&; + auto id(std::string id) -> CodeLensResolveResponse&; + + [[nodiscard]] auto result() const -> CodeLens; + + auto result(CodeLens result) -> CodeLensResolveResponse&; +}; + +class CodeLensRefreshRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> CodeLensRefreshRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CodeLensRefreshRequest&; + auto id(std::string id) -> CodeLensRefreshRequest&; +}; + +class CodeLensRefreshResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CodeLensRefreshResponse&; + auto id(std::string id) -> CodeLensRefreshResponse&; + + [[nodiscard]] auto result() const -> std::nullptr_t; + + auto result(std::nullptr_t result) -> CodeLensRefreshResponse&; +}; + +class DocumentLinkRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DocumentLinkRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentLinkRequest&; + auto id(std::string id) -> DocumentLinkRequest&; + + [[nodiscard]] auto params() const -> DocumentLinkParams; + auto params(DocumentLinkParams result) -> DocumentLinkRequest&; +}; + +class DocumentLinkResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentLinkResponse&; + auto id(std::string id) -> DocumentLinkResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> DocumentLinkResponse&; +}; + +class DocumentLinkResolveRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DocumentLinkResolveRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentLinkResolveRequest&; + auto id(std::string id) -> DocumentLinkResolveRequest&; + + [[nodiscard]] auto params() const -> DocumentLink; + auto params(DocumentLink result) -> DocumentLinkResolveRequest&; +}; + +class DocumentLinkResolveResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentLinkResolveResponse&; + auto id(std::string id) -> DocumentLinkResolveResponse&; + + [[nodiscard]] auto result() const -> DocumentLink; + + auto result(DocumentLink result) -> DocumentLinkResolveResponse&; +}; + +class DocumentFormattingRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DocumentFormattingRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentFormattingRequest&; + auto id(std::string id) -> DocumentFormattingRequest&; + + [[nodiscard]] auto params() const -> DocumentFormattingParams; + auto params(DocumentFormattingParams result) -> DocumentFormattingRequest&; +}; + +class DocumentFormattingResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentFormattingResponse&; + auto id(std::string id) -> DocumentFormattingResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> DocumentFormattingResponse&; +}; + +class DocumentRangeFormattingRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DocumentRangeFormattingRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentRangeFormattingRequest&; + auto id(std::string id) -> DocumentRangeFormattingRequest&; + + [[nodiscard]] auto params() const -> DocumentRangeFormattingParams; + auto params(DocumentRangeFormattingParams result) + -> DocumentRangeFormattingRequest&; +}; + +class DocumentRangeFormattingResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentRangeFormattingResponse&; + auto id(std::string id) -> DocumentRangeFormattingResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> DocumentRangeFormattingResponse&; +}; + +class DocumentRangesFormattingRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DocumentRangesFormattingRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentRangesFormattingRequest&; + auto id(std::string id) -> DocumentRangesFormattingRequest&; + + [[nodiscard]] auto params() const -> DocumentRangesFormattingParams; + auto params(DocumentRangesFormattingParams result) + -> DocumentRangesFormattingRequest&; +}; + +class DocumentRangesFormattingResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentRangesFormattingResponse&; + auto id(std::string id) -> DocumentRangesFormattingResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> DocumentRangesFormattingResponse&; +}; + +class DocumentOnTypeFormattingRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DocumentOnTypeFormattingRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentOnTypeFormattingRequest&; + auto id(std::string id) -> DocumentOnTypeFormattingRequest&; + + [[nodiscard]] auto params() const -> DocumentOnTypeFormattingParams; + auto params(DocumentOnTypeFormattingParams result) + -> DocumentOnTypeFormattingRequest&; +}; + +class DocumentOnTypeFormattingResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DocumentOnTypeFormattingResponse&; + auto id(std::string id) -> DocumentOnTypeFormattingResponse&; + + [[nodiscard]] auto result() const + -> std::variant, std::nullptr_t>; + + auto result(std::variant, std::nullptr_t> result) + -> DocumentOnTypeFormattingResponse&; +}; + +class RenameRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> RenameRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> RenameRequest&; + auto id(std::string id) -> RenameRequest&; + + [[nodiscard]] auto params() const -> RenameParams; + auto params(RenameParams result) -> RenameRequest&; +}; + +class RenameResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> RenameResponse&; + auto id(std::string id) -> RenameResponse&; + + [[nodiscard]] auto result() const + -> std::variant; + + auto result(std::variant result) + -> RenameResponse&; +}; + +class PrepareRenameRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> PrepareRenameRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> PrepareRenameRequest&; + auto id(std::string id) -> PrepareRenameRequest&; + + [[nodiscard]] auto params() const -> PrepareRenameParams; + auto params(PrepareRenameParams result) -> PrepareRenameRequest&; +}; + +class PrepareRenameResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> PrepareRenameResponse&; + auto id(std::string id) -> PrepareRenameResponse&; + + [[nodiscard]] auto result() const + -> std::variant; + + auto result(std::variant result) + -> PrepareRenameResponse&; +}; + +class ExecuteCommandRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ExecuteCommandRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ExecuteCommandRequest&; + auto id(std::string id) -> ExecuteCommandRequest&; + + [[nodiscard]] auto params() const -> ExecuteCommandParams; + auto params(ExecuteCommandParams result) -> ExecuteCommandRequest&; +}; + +class ExecuteCommandResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ExecuteCommandResponse&; + auto id(std::string id) -> ExecuteCommandResponse&; + + [[nodiscard]] auto result() const -> std::variant; + + auto result(std::variant result) + -> ExecuteCommandResponse&; +}; + +class ApplyWorkspaceEditRequest final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ApplyWorkspaceEditRequest&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ApplyWorkspaceEditRequest&; + auto id(std::string id) -> ApplyWorkspaceEditRequest&; + + [[nodiscard]] auto params() const -> ApplyWorkspaceEditParams; + auto params(ApplyWorkspaceEditParams result) -> ApplyWorkspaceEditRequest&; +}; + +class ApplyWorkspaceEditResponse final : public LSPResponse { + public: + using LSPResponse::LSPResponse; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ApplyWorkspaceEditResponse&; + auto id(std::string id) -> ApplyWorkspaceEditResponse&; + + [[nodiscard]] auto result() const -> ApplyWorkspaceEditResult; + + auto result(ApplyWorkspaceEditResult result) -> ApplyWorkspaceEditResponse&; +}; + +} // namespace cxx::lsp From 81a5801bb60ddc0e18b1e41e2f38712ad2b9fdcb Mon Sep 17 00:00:00 2001 From: Roberto Raggi Date: Sat, 26 Oct 2024 19:08:23 +0200 Subject: [PATCH 2/2] chore: Add code for LSP notifications --- packages/cxx-gen-lsp/src/MetaModel.ts | 6 +- packages/cxx-gen-lsp/src/gen_fwd_h.ts | 7 +- packages/cxx-gen-lsp/src/gen_requests_cc.ts | 8 +- packages/cxx-gen-lsp/src/gen_requests_h.ts | 8 +- src/lsp/cxx/lsp/fwd.h | 26 + src/lsp/cxx/lsp/requests.cc | 1012 +++++++++++++++++++ src/lsp/cxx/lsp/requests.h | 401 ++++++++ 7 files changed, 1458 insertions(+), 10 deletions(-) diff --git a/packages/cxx-gen-lsp/src/MetaModel.ts b/packages/cxx-gen-lsp/src/MetaModel.ts index f2f7cb02..422b1e23 100644 --- a/packages/cxx-gen-lsp/src/MetaModel.ts +++ b/packages/cxx-gen-lsp/src/MetaModel.ts @@ -95,7 +95,7 @@ export type Enumeration = { values: EnumerationValue[]; }; -export type Notification = {}; +export type Notification = Omit; type MessageDirection = "clientToServer" | "serverToClient" | "both"; @@ -139,6 +139,10 @@ export type MetaModel = { typeAliases: TypeAlias[]; }; +export function isRequest(request: Request | Notification): request is Request { + return "result" in request; +} + export function getEnumBaseType(enumeration: Enumeration) { switch (enumeration.type.name) { case "integer": diff --git a/packages/cxx-gen-lsp/src/gen_fwd_h.ts b/packages/cxx-gen-lsp/src/gen_fwd_h.ts index 1d7aba19..e9fc295f 100644 --- a/packages/cxx-gen-lsp/src/gen_fwd_h.ts +++ b/packages/cxx-gen-lsp/src/gen_fwd_h.ts @@ -19,7 +19,7 @@ // SOFTWARE. import * as path from "node:path"; -import { getEnumBaseType, MetaModel, toCppType, Type } from "./MetaModel.js"; +import { getEnumBaseType, MetaModel, toCppType, Type, Request, Notification, isRequest } from "./MetaModel.js"; import { writeFileSync } from "node:fs"; import { copyrightHeader } from "./copyrightHeader.js"; @@ -329,9 +329,10 @@ export function gen_fwd_h({ model, outputDirectory }: { model: MetaModel; output emit(`class ${structure.name};`); }); emit(`// requests`); - model.requests.forEach((request) => { + const requestsAndNotifications: Array = [...model.requests, ...model.notifications]; + requestsAndNotifications.forEach((request) => { emit(`class ${request.typeName};`); - if (request.result) { + if (isRequest(request) && request.result) { emit(`class ${request.typeName.replace(/Request$/, "Response")};`); } }); diff --git a/packages/cxx-gen-lsp/src/gen_requests_cc.ts b/packages/cxx-gen-lsp/src/gen_requests_cc.ts index cb80331f..7ecf2e6e 100644 --- a/packages/cxx-gen-lsp/src/gen_requests_cc.ts +++ b/packages/cxx-gen-lsp/src/gen_requests_cc.ts @@ -19,7 +19,7 @@ // SOFTWARE. import * as path from "node:path"; -import { Enumeration, MetaModel, Structure, toCppType, Type, TypeAlias } from "./MetaModel.js"; +import { Enumeration, isRequest, MetaModel, Structure, toCppType, Type, TypeAlias } from "./MetaModel.js"; import { writeFileSync } from "node:fs"; import { copyrightHeader } from "./copyrightHeader.js"; @@ -42,7 +42,9 @@ class RequestGenerator { genTypes() { this.begin(); - this.model.requests.forEach((request) => { + const requestsAndNotifications = [...this.model.requests, ...this.model.notifications]; + + requestsAndNotifications.forEach((request) => { const { typeName } = request; this.emit(); this.emit(`auto ${typeName}::method() const -> std::string {`); @@ -85,7 +87,7 @@ class RequestGenerator { this.emit(`}`); } - if (request.result) { + if (isRequest(request) && request.result) { const resultTypeName = typeName.replace(/Request$/, "Response"); this.emit(); this.emit(`auto ${resultTypeName}::id() const -> std::variant {`); diff --git a/packages/cxx-gen-lsp/src/gen_requests_h.ts b/packages/cxx-gen-lsp/src/gen_requests_h.ts index 6c9c68e0..824cdff4 100644 --- a/packages/cxx-gen-lsp/src/gen_requests_h.ts +++ b/packages/cxx-gen-lsp/src/gen_requests_h.ts @@ -19,7 +19,7 @@ // SOFTWARE. import * as path from "node:path"; -import { MetaModel, toCppType } from "./MetaModel.js"; +import { MetaModel, toCppType, Request, Notification, isRequest } from "./MetaModel.js"; import { writeFileSync } from "node:fs"; import { copyrightHeader } from "./copyrightHeader.js"; @@ -42,7 +42,9 @@ export function gen_requests_h({ model, outputDirectory }: { model: MetaModel; o emit(copyrightHeader); emit(beginHeaderFragment); - model.requests.forEach((request) => { + const requestsAndNotifications: Array = [...model.requests, ...model.notifications]; + + requestsAndNotifications.forEach((request) => { const typeName = request.typeName; emit(); emit(`class ${typeName} final : public LSPRequest {`); @@ -66,7 +68,7 @@ export function gen_requests_h({ model, outputDirectory }: { model: MetaModel; o emit(`};`); // generate the respose type if the request has a result - if (request.result) { + if (isRequest(request) && request.result) { const responseTypeName = typeName.replace(/Request$/, "Response"); const resultType = toCppType(request.result); diff --git a/src/lsp/cxx/lsp/fwd.h b/src/lsp/cxx/lsp/fwd.h index ba038ad6..80a46492 100644 --- a/src/lsp/cxx/lsp/fwd.h +++ b/src/lsp/cxx/lsp/fwd.h @@ -596,6 +596,32 @@ class ExecuteCommandRequest; class ExecuteCommandResponse; class ApplyWorkspaceEditRequest; class ApplyWorkspaceEditResponse; +class DidChangeWorkspaceFoldersNotification; +class WorkDoneProgressCancelNotification; +class DidCreateFilesNotification; +class DidRenameFilesNotification; +class DidDeleteFilesNotification; +class DidOpenNotebookDocumentNotification; +class DidChangeNotebookDocumentNotification; +class DidSaveNotebookDocumentNotification; +class DidCloseNotebookDocumentNotification; +class InitializedNotification; +class ExitNotification; +class DidChangeConfigurationNotification; +class ShowMessageNotification; +class LogMessageNotification; +class TelemetryEventNotification; +class DidOpenTextDocumentNotification; +class DidChangeTextDocumentNotification; +class DidCloseTextDocumentNotification; +class DidSaveTextDocumentNotification; +class WillSaveTextDocumentNotification; +class DidChangeWatchedFilesNotification; +class PublishDiagnosticsNotification; +class SetTraceNotification; +class LogTraceNotification; +class CancelNotification; +class ProgressNotification; [[noreturn]] void lsp_runtime_error(const std::string& msg); diff --git a/src/lsp/cxx/lsp/requests.cc b/src/lsp/cxx/lsp/requests.cc index 07f88dd1..7371a020 100644 --- a/src/lsp/cxx/lsp/requests.cc +++ b/src/lsp/cxx/lsp/requests.cc @@ -3687,4 +3687,1016 @@ auto ApplyWorkspaceEditResponse::id(std::string id) (*repr_)["id"] = std::move(id); return *this; } + +auto DidChangeWorkspaceFoldersNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidChangeWorkspaceFoldersNotification::method(std::string method) + -> DidChangeWorkspaceFoldersNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidChangeWorkspaceFoldersNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidChangeWorkspaceFoldersNotification::id(long id) + -> DidChangeWorkspaceFoldersNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidChangeWorkspaceFoldersNotification::id(std::string id) + -> DidChangeWorkspaceFoldersNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidChangeWorkspaceFoldersNotification::params() const + -> DidChangeWorkspaceFoldersParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DidChangeWorkspaceFoldersParams(repr_->at("params")); +} + +auto DidChangeWorkspaceFoldersNotification::params( + DidChangeWorkspaceFoldersParams params) + -> DidChangeWorkspaceFoldersNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto WorkDoneProgressCancelNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto WorkDoneProgressCancelNotification::method(std::string method) + -> WorkDoneProgressCancelNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto WorkDoneProgressCancelNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WorkDoneProgressCancelNotification::id(long id) + -> WorkDoneProgressCancelNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto WorkDoneProgressCancelNotification::id(std::string id) + -> WorkDoneProgressCancelNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WorkDoneProgressCancelNotification::params() const + -> WorkDoneProgressCancelParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return WorkDoneProgressCancelParams(repr_->at("params")); +} + +auto WorkDoneProgressCancelNotification::params( + WorkDoneProgressCancelParams params) + -> WorkDoneProgressCancelNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidCreateFilesNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidCreateFilesNotification::method(std::string method) + -> DidCreateFilesNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidCreateFilesNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidCreateFilesNotification::id(long id) -> DidCreateFilesNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidCreateFilesNotification::id(std::string id) + -> DidCreateFilesNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidCreateFilesNotification::params() const -> CreateFilesParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CreateFilesParams(repr_->at("params")); +} + +auto DidCreateFilesNotification::params(CreateFilesParams params) + -> DidCreateFilesNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidRenameFilesNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidRenameFilesNotification::method(std::string method) + -> DidRenameFilesNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidRenameFilesNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidRenameFilesNotification::id(long id) -> DidRenameFilesNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidRenameFilesNotification::id(std::string id) + -> DidRenameFilesNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidRenameFilesNotification::params() const -> RenameFilesParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return RenameFilesParams(repr_->at("params")); +} + +auto DidRenameFilesNotification::params(RenameFilesParams params) + -> DidRenameFilesNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidDeleteFilesNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidDeleteFilesNotification::method(std::string method) + -> DidDeleteFilesNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidDeleteFilesNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidDeleteFilesNotification::id(long id) -> DidDeleteFilesNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidDeleteFilesNotification::id(std::string id) + -> DidDeleteFilesNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidDeleteFilesNotification::params() const -> DeleteFilesParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DeleteFilesParams(repr_->at("params")); +} + +auto DidDeleteFilesNotification::params(DeleteFilesParams params) + -> DidDeleteFilesNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidOpenNotebookDocumentNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidOpenNotebookDocumentNotification::method(std::string method) + -> DidOpenNotebookDocumentNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidOpenNotebookDocumentNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidOpenNotebookDocumentNotification::id(long id) + -> DidOpenNotebookDocumentNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidOpenNotebookDocumentNotification::id(std::string id) + -> DidOpenNotebookDocumentNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidOpenNotebookDocumentNotification::params() const + -> DidOpenNotebookDocumentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DidOpenNotebookDocumentParams(repr_->at("params")); +} + +auto DidOpenNotebookDocumentNotification::params( + DidOpenNotebookDocumentParams params) + -> DidOpenNotebookDocumentNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidChangeNotebookDocumentNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidChangeNotebookDocumentNotification::method(std::string method) + -> DidChangeNotebookDocumentNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidChangeNotebookDocumentNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidChangeNotebookDocumentNotification::id(long id) + -> DidChangeNotebookDocumentNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidChangeNotebookDocumentNotification::id(std::string id) + -> DidChangeNotebookDocumentNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidChangeNotebookDocumentNotification::params() const + -> DidChangeNotebookDocumentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DidChangeNotebookDocumentParams(repr_->at("params")); +} + +auto DidChangeNotebookDocumentNotification::params( + DidChangeNotebookDocumentParams params) + -> DidChangeNotebookDocumentNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidSaveNotebookDocumentNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidSaveNotebookDocumentNotification::method(std::string method) + -> DidSaveNotebookDocumentNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidSaveNotebookDocumentNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidSaveNotebookDocumentNotification::id(long id) + -> DidSaveNotebookDocumentNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidSaveNotebookDocumentNotification::id(std::string id) + -> DidSaveNotebookDocumentNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidSaveNotebookDocumentNotification::params() const + -> DidSaveNotebookDocumentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DidSaveNotebookDocumentParams(repr_->at("params")); +} + +auto DidSaveNotebookDocumentNotification::params( + DidSaveNotebookDocumentParams params) + -> DidSaveNotebookDocumentNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidCloseNotebookDocumentNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidCloseNotebookDocumentNotification::method(std::string method) + -> DidCloseNotebookDocumentNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidCloseNotebookDocumentNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidCloseNotebookDocumentNotification::id(long id) + -> DidCloseNotebookDocumentNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidCloseNotebookDocumentNotification::id(std::string id) + -> DidCloseNotebookDocumentNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidCloseNotebookDocumentNotification::params() const + -> DidCloseNotebookDocumentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DidCloseNotebookDocumentParams(repr_->at("params")); +} + +auto DidCloseNotebookDocumentNotification::params( + DidCloseNotebookDocumentParams params) + -> DidCloseNotebookDocumentNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto InitializedNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto InitializedNotification::method(std::string method) + -> InitializedNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto InitializedNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto InitializedNotification::id(long id) -> InitializedNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto InitializedNotification::id(std::string id) -> InitializedNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto InitializedNotification::params() const -> InitializedParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return InitializedParams(repr_->at("params")); +} + +auto InitializedNotification::params(InitializedParams params) + -> InitializedNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto ExitNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto ExitNotification::method(std::string method) -> ExitNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ExitNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ExitNotification::id(long id) -> ExitNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto ExitNotification::id(std::string id) -> ExitNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidChangeConfigurationNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidChangeConfigurationNotification::method(std::string method) + -> DidChangeConfigurationNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidChangeConfigurationNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidChangeConfigurationNotification::id(long id) + -> DidChangeConfigurationNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidChangeConfigurationNotification::id(std::string id) + -> DidChangeConfigurationNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidChangeConfigurationNotification::params() const + -> DidChangeConfigurationParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DidChangeConfigurationParams(repr_->at("params")); +} + +auto DidChangeConfigurationNotification::params( + DidChangeConfigurationParams params) + -> DidChangeConfigurationNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto ShowMessageNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto ShowMessageNotification::method(std::string method) + -> ShowMessageNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ShowMessageNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ShowMessageNotification::id(long id) -> ShowMessageNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto ShowMessageNotification::id(std::string id) -> ShowMessageNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ShowMessageNotification::params() const -> ShowMessageParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return ShowMessageParams(repr_->at("params")); +} + +auto ShowMessageNotification::params(ShowMessageParams params) + -> ShowMessageNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto LogMessageNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto LogMessageNotification::method(std::string method) + -> LogMessageNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto LogMessageNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto LogMessageNotification::id(long id) -> LogMessageNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto LogMessageNotification::id(std::string id) -> LogMessageNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto LogMessageNotification::params() const -> LogMessageParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return LogMessageParams(repr_->at("params")); +} + +auto LogMessageNotification::params(LogMessageParams params) + -> LogMessageNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto TelemetryEventNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto TelemetryEventNotification::method(std::string method) + -> TelemetryEventNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto TelemetryEventNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto TelemetryEventNotification::id(long id) -> TelemetryEventNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto TelemetryEventNotification::id(std::string id) + -> TelemetryEventNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto TelemetryEventNotification::params() const -> LSPAny { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return LSPAny(repr_->at("params")); +} + +auto TelemetryEventNotification::params(LSPAny params) + -> TelemetryEventNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidOpenTextDocumentNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidOpenTextDocumentNotification::method(std::string method) + -> DidOpenTextDocumentNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidOpenTextDocumentNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidOpenTextDocumentNotification::id(long id) + -> DidOpenTextDocumentNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidOpenTextDocumentNotification::id(std::string id) + -> DidOpenTextDocumentNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidOpenTextDocumentNotification::params() const + -> DidOpenTextDocumentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DidOpenTextDocumentParams(repr_->at("params")); +} + +auto DidOpenTextDocumentNotification::params(DidOpenTextDocumentParams params) + -> DidOpenTextDocumentNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidChangeTextDocumentNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidChangeTextDocumentNotification::method(std::string method) + -> DidChangeTextDocumentNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidChangeTextDocumentNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidChangeTextDocumentNotification::id(long id) + -> DidChangeTextDocumentNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidChangeTextDocumentNotification::id(std::string id) + -> DidChangeTextDocumentNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidChangeTextDocumentNotification::params() const + -> DidChangeTextDocumentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DidChangeTextDocumentParams(repr_->at("params")); +} + +auto DidChangeTextDocumentNotification::params( + DidChangeTextDocumentParams params) -> DidChangeTextDocumentNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidCloseTextDocumentNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidCloseTextDocumentNotification::method(std::string method) + -> DidCloseTextDocumentNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidCloseTextDocumentNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidCloseTextDocumentNotification::id(long id) + -> DidCloseTextDocumentNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidCloseTextDocumentNotification::id(std::string id) + -> DidCloseTextDocumentNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidCloseTextDocumentNotification::params() const + -> DidCloseTextDocumentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DidCloseTextDocumentParams(repr_->at("params")); +} + +auto DidCloseTextDocumentNotification::params(DidCloseTextDocumentParams params) + -> DidCloseTextDocumentNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidSaveTextDocumentNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidSaveTextDocumentNotification::method(std::string method) + -> DidSaveTextDocumentNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidSaveTextDocumentNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidSaveTextDocumentNotification::id(long id) + -> DidSaveTextDocumentNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidSaveTextDocumentNotification::id(std::string id) + -> DidSaveTextDocumentNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidSaveTextDocumentNotification::params() const + -> DidSaveTextDocumentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DidSaveTextDocumentParams(repr_->at("params")); +} + +auto DidSaveTextDocumentNotification::params(DidSaveTextDocumentParams params) + -> DidSaveTextDocumentNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto WillSaveTextDocumentNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto WillSaveTextDocumentNotification::method(std::string method) + -> WillSaveTextDocumentNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto WillSaveTextDocumentNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto WillSaveTextDocumentNotification::id(long id) + -> WillSaveTextDocumentNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto WillSaveTextDocumentNotification::id(std::string id) + -> WillSaveTextDocumentNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto WillSaveTextDocumentNotification::params() const + -> WillSaveTextDocumentParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return WillSaveTextDocumentParams(repr_->at("params")); +} + +auto WillSaveTextDocumentNotification::params(WillSaveTextDocumentParams params) + -> WillSaveTextDocumentNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto DidChangeWatchedFilesNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto DidChangeWatchedFilesNotification::method(std::string method) + -> DidChangeWatchedFilesNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto DidChangeWatchedFilesNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto DidChangeWatchedFilesNotification::id(long id) + -> DidChangeWatchedFilesNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto DidChangeWatchedFilesNotification::id(std::string id) + -> DidChangeWatchedFilesNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto DidChangeWatchedFilesNotification::params() const + -> DidChangeWatchedFilesParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return DidChangeWatchedFilesParams(repr_->at("params")); +} + +auto DidChangeWatchedFilesNotification::params( + DidChangeWatchedFilesParams params) -> DidChangeWatchedFilesNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto PublishDiagnosticsNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto PublishDiagnosticsNotification::method(std::string method) + -> PublishDiagnosticsNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto PublishDiagnosticsNotification::id() const + -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto PublishDiagnosticsNotification::id(long id) + -> PublishDiagnosticsNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto PublishDiagnosticsNotification::id(std::string id) + -> PublishDiagnosticsNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto PublishDiagnosticsNotification::params() const + -> PublishDiagnosticsParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return PublishDiagnosticsParams(repr_->at("params")); +} + +auto PublishDiagnosticsNotification::params(PublishDiagnosticsParams params) + -> PublishDiagnosticsNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto SetTraceNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto SetTraceNotification::method(std::string method) -> SetTraceNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto SetTraceNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto SetTraceNotification::id(long id) -> SetTraceNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto SetTraceNotification::id(std::string id) -> SetTraceNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto SetTraceNotification::params() const -> SetTraceParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return SetTraceParams(repr_->at("params")); +} + +auto SetTraceNotification::params(SetTraceParams params) + -> SetTraceNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto LogTraceNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto LogTraceNotification::method(std::string method) -> LogTraceNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto LogTraceNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto LogTraceNotification::id(long id) -> LogTraceNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto LogTraceNotification::id(std::string id) -> LogTraceNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto LogTraceNotification::params() const -> LogTraceParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return LogTraceParams(repr_->at("params")); +} + +auto LogTraceNotification::params(LogTraceParams params) + -> LogTraceNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto CancelNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto CancelNotification::method(std::string method) -> CancelNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto CancelNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto CancelNotification::id(long id) -> CancelNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto CancelNotification::id(std::string id) -> CancelNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto CancelNotification::params() const -> CancelParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return CancelParams(repr_->at("params")); +} + +auto CancelNotification::params(CancelParams params) -> CancelNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} + +auto ProgressNotification::method() const -> std::string { + return repr_->at("method"); +} + +auto ProgressNotification::method(std::string method) -> ProgressNotification& { + (*repr_)["method"] = std::move(method); + return *this; +} + +auto ProgressNotification::id() const -> std::variant { + const auto& id = repr_->at("id"); + if (id.is_string()) return id.get(); + return id.get(); +} + +auto ProgressNotification::id(long id) -> ProgressNotification& { + (*repr_)["id"] = id; + return *this; +} + +auto ProgressNotification::id(std::string id) -> ProgressNotification& { + (*repr_)["id"] = std::move(id); + return *this; +} + +auto ProgressNotification::params() const -> ProgressParams { + if (!repr_->contains("params")) repr_->emplace("params", json::object()); + return ProgressParams(repr_->at("params")); +} + +auto ProgressNotification::params(ProgressParams params) + -> ProgressNotification& { + (*repr_)["params"] = std::move(params); + return *this; +} } // namespace cxx::lsp diff --git a/src/lsp/cxx/lsp/requests.h b/src/lsp/cxx/lsp/requests.h index 9cc34588..d8cbc053 100644 --- a/src/lsp/cxx/lsp/requests.h +++ b/src/lsp/cxx/lsp/requests.h @@ -2043,4 +2043,405 @@ class ApplyWorkspaceEditResponse final : public LSPResponse { auto result(ApplyWorkspaceEditResult result) -> ApplyWorkspaceEditResponse&; }; +class DidChangeWorkspaceFoldersNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidChangeWorkspaceFoldersNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidChangeWorkspaceFoldersNotification&; + auto id(std::string id) -> DidChangeWorkspaceFoldersNotification&; + + [[nodiscard]] auto params() const -> DidChangeWorkspaceFoldersParams; + auto params(DidChangeWorkspaceFoldersParams result) + -> DidChangeWorkspaceFoldersNotification&; +}; + +class WorkDoneProgressCancelNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> WorkDoneProgressCancelNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WorkDoneProgressCancelNotification&; + auto id(std::string id) -> WorkDoneProgressCancelNotification&; + + [[nodiscard]] auto params() const -> WorkDoneProgressCancelParams; + auto params(WorkDoneProgressCancelParams result) + -> WorkDoneProgressCancelNotification&; +}; + +class DidCreateFilesNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidCreateFilesNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidCreateFilesNotification&; + auto id(std::string id) -> DidCreateFilesNotification&; + + [[nodiscard]] auto params() const -> CreateFilesParams; + auto params(CreateFilesParams result) -> DidCreateFilesNotification&; +}; + +class DidRenameFilesNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidRenameFilesNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidRenameFilesNotification&; + auto id(std::string id) -> DidRenameFilesNotification&; + + [[nodiscard]] auto params() const -> RenameFilesParams; + auto params(RenameFilesParams result) -> DidRenameFilesNotification&; +}; + +class DidDeleteFilesNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidDeleteFilesNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidDeleteFilesNotification&; + auto id(std::string id) -> DidDeleteFilesNotification&; + + [[nodiscard]] auto params() const -> DeleteFilesParams; + auto params(DeleteFilesParams result) -> DidDeleteFilesNotification&; +}; + +class DidOpenNotebookDocumentNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidOpenNotebookDocumentNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidOpenNotebookDocumentNotification&; + auto id(std::string id) -> DidOpenNotebookDocumentNotification&; + + [[nodiscard]] auto params() const -> DidOpenNotebookDocumentParams; + auto params(DidOpenNotebookDocumentParams result) + -> DidOpenNotebookDocumentNotification&; +}; + +class DidChangeNotebookDocumentNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidChangeNotebookDocumentNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidChangeNotebookDocumentNotification&; + auto id(std::string id) -> DidChangeNotebookDocumentNotification&; + + [[nodiscard]] auto params() const -> DidChangeNotebookDocumentParams; + auto params(DidChangeNotebookDocumentParams result) + -> DidChangeNotebookDocumentNotification&; +}; + +class DidSaveNotebookDocumentNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidSaveNotebookDocumentNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidSaveNotebookDocumentNotification&; + auto id(std::string id) -> DidSaveNotebookDocumentNotification&; + + [[nodiscard]] auto params() const -> DidSaveNotebookDocumentParams; + auto params(DidSaveNotebookDocumentParams result) + -> DidSaveNotebookDocumentNotification&; +}; + +class DidCloseNotebookDocumentNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidCloseNotebookDocumentNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidCloseNotebookDocumentNotification&; + auto id(std::string id) -> DidCloseNotebookDocumentNotification&; + + [[nodiscard]] auto params() const -> DidCloseNotebookDocumentParams; + auto params(DidCloseNotebookDocumentParams result) + -> DidCloseNotebookDocumentNotification&; +}; + +class InitializedNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> InitializedNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> InitializedNotification&; + auto id(std::string id) -> InitializedNotification&; + + [[nodiscard]] auto params() const -> InitializedParams; + auto params(InitializedParams result) -> InitializedNotification&; +}; + +class ExitNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ExitNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ExitNotification&; + auto id(std::string id) -> ExitNotification&; +}; + +class DidChangeConfigurationNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidChangeConfigurationNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidChangeConfigurationNotification&; + auto id(std::string id) -> DidChangeConfigurationNotification&; + + [[nodiscard]] auto params() const -> DidChangeConfigurationParams; + auto params(DidChangeConfigurationParams result) + -> DidChangeConfigurationNotification&; +}; + +class ShowMessageNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ShowMessageNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ShowMessageNotification&; + auto id(std::string id) -> ShowMessageNotification&; + + [[nodiscard]] auto params() const -> ShowMessageParams; + auto params(ShowMessageParams result) -> ShowMessageNotification&; +}; + +class LogMessageNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> LogMessageNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> LogMessageNotification&; + auto id(std::string id) -> LogMessageNotification&; + + [[nodiscard]] auto params() const -> LogMessageParams; + auto params(LogMessageParams result) -> LogMessageNotification&; +}; + +class TelemetryEventNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> TelemetryEventNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> TelemetryEventNotification&; + auto id(std::string id) -> TelemetryEventNotification&; + + [[nodiscard]] auto params() const -> LSPAny; + auto params(LSPAny result) -> TelemetryEventNotification&; +}; + +class DidOpenTextDocumentNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidOpenTextDocumentNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidOpenTextDocumentNotification&; + auto id(std::string id) -> DidOpenTextDocumentNotification&; + + [[nodiscard]] auto params() const -> DidOpenTextDocumentParams; + auto params(DidOpenTextDocumentParams result) + -> DidOpenTextDocumentNotification&; +}; + +class DidChangeTextDocumentNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidChangeTextDocumentNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidChangeTextDocumentNotification&; + auto id(std::string id) -> DidChangeTextDocumentNotification&; + + [[nodiscard]] auto params() const -> DidChangeTextDocumentParams; + auto params(DidChangeTextDocumentParams result) + -> DidChangeTextDocumentNotification&; +}; + +class DidCloseTextDocumentNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidCloseTextDocumentNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidCloseTextDocumentNotification&; + auto id(std::string id) -> DidCloseTextDocumentNotification&; + + [[nodiscard]] auto params() const -> DidCloseTextDocumentParams; + auto params(DidCloseTextDocumentParams result) + -> DidCloseTextDocumentNotification&; +}; + +class DidSaveTextDocumentNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidSaveTextDocumentNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidSaveTextDocumentNotification&; + auto id(std::string id) -> DidSaveTextDocumentNotification&; + + [[nodiscard]] auto params() const -> DidSaveTextDocumentParams; + auto params(DidSaveTextDocumentParams result) + -> DidSaveTextDocumentNotification&; +}; + +class WillSaveTextDocumentNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> WillSaveTextDocumentNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> WillSaveTextDocumentNotification&; + auto id(std::string id) -> WillSaveTextDocumentNotification&; + + [[nodiscard]] auto params() const -> WillSaveTextDocumentParams; + auto params(WillSaveTextDocumentParams result) + -> WillSaveTextDocumentNotification&; +}; + +class DidChangeWatchedFilesNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> DidChangeWatchedFilesNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> DidChangeWatchedFilesNotification&; + auto id(std::string id) -> DidChangeWatchedFilesNotification&; + + [[nodiscard]] auto params() const -> DidChangeWatchedFilesParams; + auto params(DidChangeWatchedFilesParams result) + -> DidChangeWatchedFilesNotification&; +}; + +class PublishDiagnosticsNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> PublishDiagnosticsNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> PublishDiagnosticsNotification&; + auto id(std::string id) -> PublishDiagnosticsNotification&; + + [[nodiscard]] auto params() const -> PublishDiagnosticsParams; + auto params(PublishDiagnosticsParams result) + -> PublishDiagnosticsNotification&; +}; + +class SetTraceNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> SetTraceNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> SetTraceNotification&; + auto id(std::string id) -> SetTraceNotification&; + + [[nodiscard]] auto params() const -> SetTraceParams; + auto params(SetTraceParams result) -> SetTraceNotification&; +}; + +class LogTraceNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> LogTraceNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> LogTraceNotification&; + auto id(std::string id) -> LogTraceNotification&; + + [[nodiscard]] auto params() const -> LogTraceParams; + auto params(LogTraceParams result) -> LogTraceNotification&; +}; + +class CancelNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> CancelNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> CancelNotification&; + auto id(std::string id) -> CancelNotification&; + + [[nodiscard]] auto params() const -> CancelParams; + auto params(CancelParams result) -> CancelNotification&; +}; + +class ProgressNotification final : public LSPRequest { + public: + using LSPRequest::LSPRequest; + + [[nodiscard]] auto method() const -> std::string; + auto method(std::string method) -> ProgressNotification&; + + [[nodiscard]] auto id() const -> std::variant; + auto id(long id) -> ProgressNotification&; + auto id(std::string id) -> ProgressNotification&; + + [[nodiscard]] auto params() const -> ProgressParams; + auto params(ProgressParams result) -> ProgressNotification&; +}; + } // namespace cxx::lsp