diff --git a/CMakeLists.txt b/CMakeLists.txt index 2e42e7d7..d0f9a177 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -48,13 +48,38 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CXX_LIBCXX_WITH_CLANG) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++") endif() -# if CMAKE_SYSTEM_NAME is WASI disable the exceptions +# if CMAKE_SYSTEM_NAME is WASI disable the exceptions, and the tests if(CMAKE_SYSTEM_NAME STREQUAL "WASI") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions") + set(CXX_BUILD_TESTS OFF) + + # set the executable suffix to .wasm + set(CMAKE_EXECUTABLE_SUFFIX ".wasm") endif() -set(CMAKE_CXX_SCAN_FOR_MODULES OFF) +# +# google test +# +if(CXX_BUILD_TESTS) + + set(CMAKE_CXX_SCAN_FOR_MODULES OFF) + + set(INSTALL_GTEST OFF CACHE BOOL "" FORCE) + FetchContent_Declare( + googletest + URL https://github.com/google/googletest/archive/refs/tags/v1.15.2.tar.gz + ) + + FetchContent_MakeAvailable(googletest) + + include(GoogleTest) + +endif() + +# +# utfcpp +# FetchContent_Declare( utfcpp URL https://github.com/nemtrif/utfcpp/archive/refs/tags/v4.0.5.tar.gz @@ -64,6 +89,21 @@ FetchContent_Declare( FetchContent_MakeAvailable(utfcpp) FetchContent_GetProperties(utfcpp) +# +# nlohmann_json +# +FetchContent_Declare( + nlohmann_json + URL https://github.com/nlohmann/json/releases/download/v3.11.3/include.zip + URL_HASH SHA256=a22461d13119ac5c78f205d3df1db13403e58ce1bb1794edc9313677313f4a9d +) + +FetchContent_MakeAvailable(nlohmann_json) + +add_library(nlohmann_json::nlohmann_json INTERFACE IMPORTED) +set_target_properties(nlohmann_json::nlohmann_json PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${nlohmann_json_SOURCE_DIR}/single_include") + FetchContent_Declare( wasi_sysroot URL https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-22/wasi-sysroot-22.0.tar.gz diff --git a/packages/cxx-gen-lsp/.prettierrc b/packages/cxx-gen-lsp/.prettierrc new file mode 100644 index 00000000..963354f2 --- /dev/null +++ b/packages/cxx-gen-lsp/.prettierrc @@ -0,0 +1,3 @@ +{ + "printWidth": 120 +} diff --git a/packages/cxx-gen-lsp/package.json b/packages/cxx-gen-lsp/package.json index 29c53613..82eb1e44 100644 --- a/packages/cxx-gen-lsp/package.json +++ b/packages/cxx-gen-lsp/package.json @@ -33,4 +33,4 @@ "dependencies": { "prettier": "^3.3.3" } -} \ No newline at end of file +} diff --git a/packages/cxx-gen-lsp/src/MetaModel.ts b/packages/cxx-gen-lsp/src/MetaModel.ts index 2941d350..d8bb8730 100644 --- a/packages/cxx-gen-lsp/src/MetaModel.ts +++ b/packages/cxx-gen-lsp/src/MetaModel.ts @@ -18,15 +18,67 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. -export type Type = BaseType; +export type Type = + | BaseType + | TupleType + | OrType + | AndType + | ReferenceType + | ArrayType + | MapType + | StringLiteralType + | LiteralType; -export type BaseTypeName = "string" | "integer" | "uinteger"; +export type BaseTypeName = "null" | "string" | "integer" | "uinteger" | "decimal" | "boolean" | "DocumentUri" | "URI"; export type BaseType = { kind: "base"; name: BaseTypeName; }; +export type TupleType = { + kind: "tuple"; + items: Type[]; +}; + +export type OrType = { + kind: "or"; + items: Type[]; +}; + +export type AndType = { + kind: "and"; + items: Type[]; +}; + +export type ReferenceType = { + kind: "reference"; + name: string; +}; + +export type ArrayType = { + kind: "array"; + element: Type; +}; + +export type MapType = { + kind: "map"; + key: Type; + value: Type; +}; + +export type StringLiteralType = { + kind: "stringLiteral"; + value: string; +}; + +export type LiteralType = { + kind: "literal"; + value: { + properties: unknown[]; + }; +}; + export type EnumerationValue = { name: string; value: string; @@ -47,9 +99,25 @@ export type Notification = {}; export type Request = {}; -export type Structure = {}; +export type Property = { + documentation?: string; + name: string; + type: Type; + optional?: boolean; +}; + +export type Structure = { + extends?: ReferenceType[]; + mixins?: ReferenceType[]; + name: string; + properties: Property[]; +}; -export type TypeAlias = {}; +export type TypeAlias = { + documentation?: string; + name: string; + type: Type; +}; export type MetaModel = { metaData: MetaData; @@ -65,7 +133,7 @@ export function getEnumBaseType(enumeration: Enumeration) { case "integer": return " : int"; case "uinteger": - return " : unsigned int"; + return " : long"; default: return ""; } @@ -80,12 +148,117 @@ export function getEnumeratorName(enumerator: EnumerationValue) { return `k${name}`; } -export function getEnumeratorInitializer( - enumeration: Enumeration, - enumerator: EnumerationValue -) { +export function getEnumeratorInitializer(enumeration: Enumeration, enumerator: EnumerationValue) { if (enumeration.type.name === "string") { return ""; } return ` = ${enumerator.value}`; } + +export function toCppType(type: Type): string { + switch (type.kind) { + case "base": { + switch (type.name) { + case "null": + return "std::nullptr_t"; + case "string": + return "std::string"; + case "integer": + return "int"; + case "uinteger": + return "long"; + case "decimal": + return "double"; + case "boolean": + return "bool"; + case "DocumentUri": + return "std::string"; + case "URI": + return "std::string"; + default: + throw new Error(`Unknown base type: ${JSON.stringify(type)}`); + } // switch type.name + } // case "base" + + case "stringLiteral": + return "std::string"; + + case "literal": + return "json"; + + case "reference": + return type.name; + + case "array": + return `Vector<${toCppType(type.element)}>`; + + case "map": + return `Map<${toCppType(type.key)}, ${toCppType(type.value)}>`; + + case "tuple": + return `std::tuple<${type.items.map(toCppType).join(", ")}>`; + + case "or": + return `std::variant`; + + case "and": + return `std::tuple<${type.items.map(toCppType).join(", ")}>`; + + default: + throw new Error(`Unknown type kind: ${JSON.stringify(type)}`); + } // switch +} + +export function getStructureProperties(model: MetaModel, structure: Structure): Property[] { + const structByName = new Map(model.structures.map((s) => [s.name, s])); + const added = new Set(); + return getStructurePropertiesHelper({ structure, added, structByName }); +} + +function getStructurePropertiesHelper({ + structure, + added, + structByName, +}: { + structure: Structure; + added: Set; + structByName: Map; +}): Property[] { + const properties: Property[] = []; + + for (const property of structure.properties) { + if (added.has(property.name)) { + continue; + } + added.add(property.name); + properties.push(property); + } + + structure.extends?.forEach((ref) => { + const extend = structByName.get(ref.name); + + if (!extend) { + throw new Error(`Unknown extends ${ref.name}`); + } + + properties.push( + ...getStructurePropertiesHelper({ + structure: extend, + added, + structByName, + }), + ); + }); + + structure.mixins?.forEach((ref) => { + const mixin = structByName.get(ref.name); + + if (!mixin) { + throw new Error(`Unknown mixin ${ref.name}`); + } + + properties.push(...getStructurePropertiesHelper({ structure: mixin, added, structByName })); + }); + + return properties; +} diff --git a/packages/cxx-gen-lsp/src/gen_enums_cc.ts b/packages/cxx-gen-lsp/src/gen_enums_cc.ts index b08f344d..3514fb27 100644 --- a/packages/cxx-gen-lsp/src/gen_enums_cc.ts +++ b/packages/cxx-gen-lsp/src/gen_enums_cc.ts @@ -21,24 +21,21 @@ import { getEnumeratorName, MetaModel } from "./MetaModel.js"; import path from "node:path"; -import { writeFile } from "node:fs/promises"; +import { writeFileSync } from "node:fs"; import { copyrightHeader } from "./copyrightHeader.js"; -export async function gen_enums_cc({ - model, - outputDirectory, -}: { - model: MetaModel; - outputDirectory: string; -}) { +export function gen_enums_cc({ model, outputDirectory }: { model: MetaModel; outputDirectory: string }) { let out = ""; const emit = (s: string = "") => { out += `${s}\n`; }; + emit(copyrightHeader); + emit(); emit(`#include `); emit(); + emit(`namespace cxx::lsp {`); model.enumerations.forEach((enumeration) => { @@ -49,14 +46,15 @@ export async function gen_enums_cc({ enumeration.values.forEach((enumerator) => { const enumeratorName = getEnumeratorName(enumerator); - const text = - enumeration.type.name === "string" ? enumerator.value : enumerator.name; + const text = enumeration.type.name === "string" ? enumerator.value : enumerator.name; emit(` case ${enumeration.name}::${enumeratorName}:`); emit(` return "${text}";`); }); emit(` }`); + emit(); + emit(` lsp_runtime_error("invalid enumerator value");`); emit(`}`); }); @@ -64,5 +62,5 @@ export async function gen_enums_cc({ emit(`} // namespace cxx::lsp`); const outputFile = path.join(outputDirectory, "enums.cc"); - await writeFile(outputFile, out); + writeFileSync(outputFile, out); } diff --git a/packages/cxx-gen-lsp/src/gen_enums_h.ts b/packages/cxx-gen-lsp/src/gen_enums_h.ts index 480be8c9..748e1578 100644 --- a/packages/cxx-gen-lsp/src/gen_enums_h.ts +++ b/packages/cxx-gen-lsp/src/gen_enums_h.ts @@ -18,33 +18,25 @@ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. -import { - getEnumBaseType, - getEnumeratorInitializer, - getEnumeratorName, - MetaModel, -} from "./MetaModel.js"; +import { getEnumBaseType, getEnumeratorInitializer, getEnumeratorName, MetaModel } from "./MetaModel.js"; import path from "node:path"; -import { writeFile } from "node:fs/promises"; +import { writeFileSync } from "node:fs"; +import { copyrightHeader } from "./copyrightHeader.js"; -export async function gen_enums_h({ - model, - outputDirectory, -}: { - model: MetaModel; - outputDirectory: string; -}) { +export function gen_enums_h({ model, outputDirectory }: { model: MetaModel; outputDirectory: string }) { let out = ""; const emit = (s: string = "") => { out += `${s}\n`; }; - emit(`#pragma once`); + emit(copyrightHeader); emit(); + emit(`#pragma once`); emit(); emit(`#include `); + emit(`#include `); emit(); emit(`namespace cxx::lsp {`); @@ -54,10 +46,7 @@ export async function gen_enums_h({ emit(`enum class ${enumeration.name}${enumBaseType} {`); enumeration.values.forEach((value) => { const enumeratorName = getEnumeratorName(value); - const enumeratorInitializer = getEnumeratorInitializer( - enumeration, - value - ); + const enumeratorInitializer = getEnumeratorInitializer(enumeration, value); emit(` ${enumeratorName}${enumeratorInitializer},`); }); emit(`};`); @@ -70,5 +59,5 @@ export async function gen_enums_h({ emit(`} // namespace cxx::lsp`); const outputFile = path.join(outputDirectory, "enums.h"); - await writeFile(outputFile, out); + writeFileSync(outputFile, out); } diff --git a/packages/cxx-gen-lsp/src/gen_fwd_h.ts b/packages/cxx-gen-lsp/src/gen_fwd_h.ts new file mode 100644 index 00000000..45ce5835 --- /dev/null +++ b/packages/cxx-gen-lsp/src/gen_fwd_h.ts @@ -0,0 +1,315 @@ +// 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 { getEnumBaseType, MetaModel, toCppType, Type } from "./MetaModel.js"; +import { writeFileSync } from "node:fs"; +import { copyrightHeader } from "./copyrightHeader.js"; + +const fragment = ` +[[noreturn]] void lsp_runtime_error(const std::string& msg); + +using LSPAny = json; +using Pattern = std::string; + +class LSPObject { + public: + explicit LSPObject(json repr): repr_(std::move(repr)) {} + + [[nodiscard]] operator const json&() const { return repr_; } + + protected: + json repr_; +}; + +template +class Vector final : public LSPObject { +public: + using LSPObject::LSPObject; + + [[nodiscard]] explicit operator bool() const { return repr_.is_array(); } + [[nodiscard]] auto size() const -> std::size_t { return repr_.size(); } + [[nodiscard]] auto empty() const -> bool { return repr_.empty(); } + [[nodiscard]] auto at(int index) const -> const T& { return repr_[index]; } +}; + +namespace details { + +template +struct TryEmplace; + +template T> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + auto obj = T{value}; + if (!obj) return false; + result.template emplace(std::move(obj)); + return true; + } +}; + +template +auto try_emplace(std::variant& result, const json& value) -> bool { + return (details::TryEmplace{}(result, value) || ...); +} + +template <> +struct TryEmplace { + auto operator()(auto&, const json&) const -> bool { return false; } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_null()) return false; + result.template emplace(nullptr); + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_boolean()) return false; + result.template emplace(value); + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_number_integer()) return false; + result.template emplace(value); + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_number_integer()) return false; + result.template emplace(value); + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_number_float()) return false; + result.template emplace(value); + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_string()) return false; + result.template emplace(value); + return true; + } +}; + +template +struct TryEmplace> { + auto operator()(auto& result, const json& value) const -> bool { + return try_emplace(result, value); + } +}; + +template +struct TryEmplace> { + auto operator()(auto& result, const json& value) const -> bool { + lsp_runtime_error("todo: TryEmplace>"); + return false; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + result = value; + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + lsp_runtime_error("todo: TextDocumentSyncKind"); + return true; + } +}; + +} // namespace details + +template +class Vector> final : public LSPObject { + public: + using LSPObject::LSPObject; + + [[nodiscard]] explicit operator bool() const { return repr_.is_array(); } + [[nodiscard]] auto size() const -> std::size_t { return repr_.size(); } + [[nodiscard]] auto empty() const -> bool { return repr_.empty(); } + [[nodiscard]] auto at(int index) const -> std::variant { + std::variant result; + details::try_emplace(result, repr_[index]); + return result; + } +}; + +template +class Map final : public LSPObject { +public: + using LSPObject::LSPObject; + + [[nodiscard]] explicit operator bool() const { return repr_.is_object(); } + [[nodiscard]] auto size() const -> std::size_t { return repr_.size(); } + [[nodiscard]] auto empty() const -> bool { return repr_.empty(); } + [[nodiscard]] auto at(const Key& key) const -> const Value& { return repr_[key]; } +}; + +template +class Map> final : public LSPObject { + public: + using LSPObject::LSPObject; + + [[nodiscard]] explicit operator bool() const { return repr_.is_object(); } + [[nodiscard]] auto size() const -> std::size_t { return repr_.size(); } + [[nodiscard]] auto empty() const -> bool { return repr_.empty(); } + + [[nodiscard]] auto at(const Key& key) const -> std::variant { + std::variant result; + details::try_emplace(result, repr_[key]); + return result; + } +}; +`; + +function dependenciesHelper(type: Type, deps: Set) { + switch (type.kind) { + case "base": + break; + case "reference": + deps.add(type.name); + break; + case "array": + dependenciesHelper(type.element, deps); + break; + case "map": + dependenciesHelper(type.key, deps); + dependenciesHelper(type.value, deps); + break; + case "tuple": + type.items.forEach((item) => dependenciesHelper(item, deps)); + break; + case "or": + type.items.forEach((item) => dependenciesHelper(item, deps)); + break; + case "and": + type.items.forEach((item) => dependenciesHelper(item, deps)); + break; + default: + throw new Error(`Unknown type kind: ${JSON.stringify(type)}`); + } // switch +} + +function dependencies(type: Type): Set { + const deps = new Set(); + dependenciesHelper(type, deps); + if (type.kind === "reference") { + deps.delete(type.name); + } + return deps; +} + +export function gen_fwd_h({ model, outputDirectory }: { model: MetaModel; outputDirectory: string }) { + let out = ""; + + const emit = (s: string = "") => { + out += `${s}\n`; + }; + + emit(copyrightHeader); + emit(); + emit(`#pragma once`); + emit(); + emit(`#include `); + emit(`#include `); + emit(); + emit(`namespace cxx::lsp {`); + emit(); + emit(`using json = nlohmann::json;`); + emit(); + model.enumerations.forEach((enumeration) => { + const enumBaseType = getEnumBaseType(enumeration); + emit(`enum class ${enumeration.name}${enumBaseType};`); + }); + emit(); + model.structures.forEach((structure) => { + emit(`class ${structure.name};`); + }); + emit(); + + const knownTypes = new Set(); + model.enumerations.forEach((enumeration) => knownTypes.add(enumeration.name)); + model.structures.forEach((structure) => knownTypes.add(structure.name)); + // add builtins + knownTypes.add("LSPAny"); + knownTypes.add("LSPObject"); + knownTypes.add("LSPArray"); + knownTypes.add("Pattern"); + knownTypes.add("DocumentFilter"); + knownTypes.add("TextDocumentFilter"); + + const todo = model.typeAliases.map((typeAlias) => typeAlias); + + const builtinTypes = new Set(["LSPAny", "LSPObject", "LSPArray", "Pattern"]); + + emit(fragment); + + while (todo.length > 0) { + const typeAlias = todo.pop()!; + const deps = Array.from(dependencies(typeAlias.type)); + const hasUnknownDeps = deps.some((dep) => !knownTypes.has(dep)); + if (hasUnknownDeps) { + const unknownDeps = deps.filter((dep) => !knownTypes.has(dep)); + console.log(`unknown ${unknownDeps} for type alias ${typeAlias.name}`); + todo.unshift(typeAlias); + continue; + } + + if (builtinTypes.has(typeAlias.name)) { + // skip builtins + continue; + } + + const cppType = toCppType(typeAlias.type); + emit(); + emit(`using ${typeAlias.name} = ${cppType};`); + } + emit(); + emit(`}`); + + const outputFile = path.join(outputDirectory, "fwd.h"); + writeFileSync(outputFile, out); +} diff --git a/packages/cxx-gen-lsp/src/gen_types_cc.ts b/packages/cxx-gen-lsp/src/gen_types_cc.ts new file mode 100644 index 00000000..2da1ced6 --- /dev/null +++ b/packages/cxx-gen-lsp/src/gen_types_cc.ts @@ -0,0 +1,338 @@ +// 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, + getStructureProperties, + MetaModel, + Property, + Structure, + toCppType, + Type, + TypeAlias, +} from "./MetaModel.js"; +import { writeFileSync } from "node:fs"; +import { copyrightHeader } from "./copyrightHeader.js"; + +class TypeGenerator { + 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.structures.forEach((structure) => { + const properties = getStructureProperties(this.model, structure); + + this.generateValidator({ structure, properties }); + this.generateGetters({ structure, properties }); + this.generateSetters({ structure, properties }); + }); + + 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(); + this.emit(`namespace cxx::lsp {`); + this.emit(); + } + + end() { + this.emit(`} // namespace cxx::lsp`); + + const outputFile = path.join(this.outputDirectory, "types.cc"); + writeFileSync(outputFile, this.out); + } + + generateGetters({ structure, properties }: { structure: Structure; properties: Property[] }) { + const typeName = structure.name; + + properties.forEach((property) => { + this.beginPropertyGetter({ structure, property }); + this.generatePropertyGetter({ structure, property }); + this.endPropertyGetter(); + }); + } + + generateValidator({ structure, properties }: { structure: Structure; properties: Property[] }) { + this.emit(); + this.emit(`${structure.name}::operator bool() const {`); + this.emit(`if (!repr_.is_object() || repr_.is_null()) return false;`); + + const requiredProperties = properties.filter((p) => !p.optional); + + requiredProperties.forEach(({ name, type }) => { + this.emit(`if (!repr_.contains("${name}")) return false;`); + + if (type.kind === "stringLiteral") { + this.emit(`if (repr_["${name}"] != "${type.value}")`); + this.emit(` return false;`); + } + }); + + this.emit(`return true;`); + this.emit(`}`); + } + + beginPropertyGetter({ structure, property }: { structure: Structure; property: Property }) { + const returnType = this.getPropertyType(property); + + this.emit(); + this.emit(`auto ${structure.name}::${property.name}() const -> ${returnType} {`); + + if (property.optional) { + this.emit(`if (!repr_.contains("${property.name}")) return std::nullopt;`); + this.emit(); + } + + this.emit(`const auto& value = repr_["${property.name}"];`); + this.emit(); + } + + endPropertyGetter() { + this.emit(`}`); + } + + generatePropertyGetter({ structure, property }: { structure: Structure; property: Property }): void { + const propertyType = toCppType(property.type); + + switch (property.type.kind) { + case "base": + if (!this.generatePropertyGetterBase({ structure, property })) break; + return; + + case "reference": + if (!this.generatePropertyGetterReference({ structure, property })) break; + return; + + case "tuple": { + throw new Error(`Unexpected tuple type`); + } + + case "or": + this.emit(`${propertyType} result;`); + this.emit(); + this.emit(`details::try_emplace(result, value);`); + this.emit(); + this.emit(`return result;`); + return; + + case "and": { + throw new Error(`Unexpected and type`); + } + + case "array": + this.emit(`assert(value.is_array());`); + this.emit(`return ${propertyType}(value);`); + return; + + case "map": + this.emit(`assert(value.is_object());`); + this.emit(`return ${propertyType}(value);`); + return; + + case "stringLiteral": + this.emit(`assert(value.is_string());`); + this.emit(`return value.get();`); + return; + + case "literal": { + throw new Error(`Unexpected literal type`); + } + + default: + throw new Error(`Unknown type kind: ${JSON.stringify(property.type)}`); + } // switch + + this.emit(); + this.emit(`lsp_runtime_error("${structure.name}::${property.name}: not implement yet");`); + } + + generatePropertyGetterBase({ structure, property }: { structure: Structure; property: Property }): boolean { + if (property.type.kind !== "base") return false; + + switch (property.type.name) { + case "null": + throw new Error(`Unexpected null type`); + + case "string": + this.emit(`assert(value.is_string());`); + this.emit(`return value.get();`); + return true; + + case "integer": + this.emit(`assert(value.is_number_integer());`); + this.emit(`return value.get();`); + return true; + + case "uinteger": + this.emit(`assert(value.is_number_integer());`); + this.emit(`return value.get();`); + return true; + + case "decimal": + this.emit(`assert(value.is_number());`); + this.emit(`return value.get();`); + return true; + + case "boolean": + this.emit(`assert(value.is_boolean());`); + this.emit(`return value.get();`); + return true; + + case "DocumentUri": + this.emit(`assert(value.is_string());`); + this.emit(`return value.get();`); + return true; + + case "URI": + this.emit(`assert(value.is_string());`); + this.emit(`return value.get();`); + return true; + + default: + throw new Error(`Unknown base type: ${JSON.stringify(property.type)}`); + } // switch type.name + } + + generatePropertyGetterReference({ structure, property }: { structure: Structure; property: Property }): boolean { + if (property.type.kind !== "reference") return false; + + const propertyType = toCppType(property.type); + + if (this.structByName.has(property.type.name)) { + this.emit(`return ${propertyType}(value);`); + return true; + } + + if (this.enumByName.has(property.type.name)) { + const enumeration = this.enumByName.get(property.type.name)!; + if (enumeration.type.name !== "string") { + this.emit(`return ${propertyType}(value);`); + return true; + } + + // todo: string-like enumeration + console.log(`string-like enumeration: ${property.type.name}`); + return false; + } + + if (this.typeAliasByName.has(property.type.name)) { + const typeAlias = this.typeAliasByName.get(property.type.name)!; + + if (property.type.name === "LSPObject") { + this.emit(`assert(value.is_object());`); + this.emit(`return ${propertyType}(value);`); + return true; + } + + if (property.type.name === "LSPAny") { + this.emit(`assert(value.is_object());`); + this.emit(`return ${propertyType}(value);`); + return true; + } + + switch (typeAlias.type.kind) { + case "base": + return this.generatePropertyGetterBase({ structure, property: { ...property, type: typeAlias.type } }); + + case "or": + this.emit(`${propertyType} result;`); + this.emit(); + this.emit(`details::try_emplace(result, value);`); + this.emit(); + this.emit(`return result;`); + return true; + + default: + throw new Error(`Unexpected reference to type alias`); + } // switch + } else { + throw new Error(`Unexpected reference type`); + } + } + + generateSetters({ structure, properties }: { structure: Structure; properties: Property[] }) { + const typeName = structure.name; + + properties.forEach(({ name, type, optional }) => { + const argumentType = this.getPropertyType({ type, optional }); + this.emit(); + this.emit(`auto ${typeName}::${name}(${argumentType} ${name})`); + this.emit(`-> ${typeName}& { return *this; }`); + }); + } +} + +export function gen_types_cc({ model, outputDirectory }: { model: MetaModel; outputDirectory: string }) { + const generator = new TypeGenerator({ model, outputDirectory }); + generator.genTypes(); +} diff --git a/packages/cxx-gen-lsp/src/gen_types_h.ts b/packages/cxx-gen-lsp/src/gen_types_h.ts new file mode 100644 index 00000000..e237c862 --- /dev/null +++ b/packages/cxx-gen-lsp/src/gen_types_h.ts @@ -0,0 +1,83 @@ +// 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 { getStructureProperties, MetaModel, Property, toCppType } from "./MetaModel.js"; +import { writeFileSync } from "node:fs"; +import { copyrightHeader } from "./copyrightHeader.js"; + +export function gen_types_h({ model, outputDirectory }: { model: MetaModel; outputDirectory: string }) { + let out = ""; + + const emit = (s: string = "") => { + out += `${s}\n`; + }; + + const getReturnType = (property: Property) => { + let propertyType = toCppType(property.type); + if (property.optional) { + propertyType = `std::optional<${propertyType}>`; + } + return propertyType; + }; + + emit(copyrightHeader); + emit(); + emit(`#pragma once`); + emit(); + emit(`#include `); + emit(); + emit(`namespace cxx::lsp {`); + emit(); + + model.structures.forEach((structure) => { + const typeName = structure.name; + emit(); + emit(`class ${typeName} final : public LSPObject {`); + emit(` public:`); + emit(` using LSPObject::LSPObject;`); + emit(); + emit(` explicit operator bool() const;`); + + const properties = getStructureProperties(model, structure); + + properties.forEach((property) => { + const propertyName = property.name; + const returnType = getReturnType(property); + emit(); + emit(` [[nodiscard ]]auto ${propertyName}() const -> ${returnType};`); + }); + + emit(); + properties.forEach((property) => { + const propertyName = property.name; + const argumentType = getReturnType(property); + emit(); + emit(` auto ${propertyName}(${argumentType} ${propertyName}) -> ${typeName}&;`); + }); + + emit(`};`); + }); + + emit(`}`); + + const outputFile = path.join(outputDirectory, "types.h"); + writeFileSync(outputFile, out); +} diff --git a/packages/cxx-gen-lsp/src/main.ts b/packages/cxx-gen-lsp/src/main.ts index e25b0679..0c5564c4 100644 --- a/packages/cxx-gen-lsp/src/main.ts +++ b/packages/cxx-gen-lsp/src/main.ts @@ -25,6 +25,9 @@ import { readFile, mkdir } from "node:fs/promises"; import { MetaModel } from "./MetaModel.js"; import { gen_enums_h } from "./gen_enums_h.js"; 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"; async function main() { try { @@ -58,24 +61,25 @@ async function main() { await mkdir(outputDirectory, { recursive: true }); - await gen_enums_h({ outputDirectory, model }); - await gen_enums_cc({ outputDirectory, model }); + gen_fwd_h({ outputDirectory, model }); + gen_enums_h({ outputDirectory, model }); + gen_enums_cc({ outputDirectory, model }); + gen_types_h({ outputDirectory, model }); + gen_types_cc({ outputDirectory, model }); console.log( child_process .execSync("clang-format --verbose -i *.h *.cc", { cwd: outputDirectory, }) - .toString() + .toString(), ); } catch (error) { if (error instanceof Error) { console.error(`${error.message}\n`); } - console.error( - "usage: cxx-gen-lsp --output output-directory " - ); + console.error("usage: cxx-gen-lsp --output output-directory "); process.exit(1); } diff --git a/src/lsp/CMakeLists.txt b/src/lsp/CMakeLists.txt index e78a41b2..15fe6605 100644 --- a/src/lsp/CMakeLists.txt +++ b/src/lsp/CMakeLists.txt @@ -31,6 +31,8 @@ target_include_directories(cxx-lsp $ ) +target_link_libraries(cxx-lsp PUBLIC nlohmann_json::nlohmann_json) + target_compile_features(cxx-lsp PUBLIC cxx_std_20) # disable exception when targeting emscripten @@ -38,12 +40,16 @@ if (EMSCRIPTEN) target_compile_options(cxx-lsp PUBLIC -fno-exceptions) endif() -install( - FILES ${CXX_LSP_INCLUDE_HEADER_FILES} - DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/cxx/lsp -) +if(CXX_INSTALL_LSP) -install( - TARGETS cxx-lsp - EXPORT cxxTargets -) + install( + FILES ${CXX_LSP_INCLUDE_HEADER_FILES} + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/cxx/lsp + ) + + install( + TARGETS cxx-lsp + EXPORT cxxTargets + ) + +endif() diff --git a/src/lsp/cxx/lsp/enums.cc b/src/lsp/cxx/lsp/enums.cc index fccde0e8..22358ec1 100644 --- a/src/lsp/cxx/lsp/enums.cc +++ b/src/lsp/cxx/lsp/enums.cc @@ -1,3 +1,23 @@ +// 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 namespace cxx::lsp { @@ -53,6 +73,8 @@ auto to_string(SemanticTokenTypes value) -> std::string { case SemanticTokenTypes::kLabel: return "label"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(SemanticTokenModifiers value) -> std::string { @@ -78,6 +100,8 @@ auto to_string(SemanticTokenModifiers value) -> std::string { case SemanticTokenModifiers::kDefaultLibrary: return "defaultLibrary"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(DocumentDiagnosticReportKind value) -> std::string { @@ -87,6 +111,8 @@ auto to_string(DocumentDiagnosticReportKind value) -> std::string { case DocumentDiagnosticReportKind::kUnchanged: return "unchanged"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(ErrorCodes value) -> std::string { @@ -106,6 +132,8 @@ auto to_string(ErrorCodes value) -> std::string { case ErrorCodes::kUnknownErrorCode: return "UnknownErrorCode"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(LSPErrorCodes value) -> std::string { @@ -119,6 +147,8 @@ auto to_string(LSPErrorCodes value) -> std::string { case LSPErrorCodes::kRequestCancelled: return "RequestCancelled"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(FoldingRangeKind value) -> std::string { @@ -130,6 +160,8 @@ auto to_string(FoldingRangeKind value) -> std::string { case FoldingRangeKind::kRegion: return "region"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(SymbolKind value) -> std::string { @@ -187,6 +219,8 @@ auto to_string(SymbolKind value) -> std::string { case SymbolKind::kTypeParameter: return "TypeParameter"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(SymbolTag value) -> std::string { @@ -194,6 +228,8 @@ auto to_string(SymbolTag value) -> std::string { case SymbolTag::kDeprecated: return "Deprecated"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(UniquenessLevel value) -> std::string { @@ -209,6 +245,8 @@ auto to_string(UniquenessLevel value) -> std::string { case UniquenessLevel::kGlobal: return "global"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(MonikerKind value) -> std::string { @@ -220,6 +258,8 @@ auto to_string(MonikerKind value) -> std::string { case MonikerKind::kLocal: return "local"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(InlayHintKind value) -> std::string { @@ -229,6 +269,8 @@ auto to_string(InlayHintKind value) -> std::string { case InlayHintKind::kParameter: return "Parameter"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(MessageType value) -> std::string { @@ -244,6 +286,8 @@ auto to_string(MessageType value) -> std::string { case MessageType::kDebug: return "Debug"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(TextDocumentSyncKind value) -> std::string { @@ -255,6 +299,8 @@ auto to_string(TextDocumentSyncKind value) -> std::string { case TextDocumentSyncKind::kIncremental: return "Incremental"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(TextDocumentSaveReason value) -> std::string { @@ -266,6 +312,8 @@ auto to_string(TextDocumentSaveReason value) -> std::string { case TextDocumentSaveReason::kFocusOut: return "FocusOut"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(CompletionItemKind value) -> std::string { @@ -321,6 +369,8 @@ auto to_string(CompletionItemKind value) -> std::string { case CompletionItemKind::kTypeParameter: return "TypeParameter"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(CompletionItemTag value) -> std::string { @@ -328,6 +378,8 @@ auto to_string(CompletionItemTag value) -> std::string { case CompletionItemTag::kDeprecated: return "Deprecated"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(InsertTextFormat value) -> std::string { @@ -337,6 +389,8 @@ auto to_string(InsertTextFormat value) -> std::string { case InsertTextFormat::kSnippet: return "Snippet"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(InsertTextMode value) -> std::string { @@ -346,6 +400,8 @@ auto to_string(InsertTextMode value) -> std::string { case InsertTextMode::kAdjustIndentation: return "adjustIndentation"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(DocumentHighlightKind value) -> std::string { @@ -357,6 +413,8 @@ auto to_string(DocumentHighlightKind value) -> std::string { case DocumentHighlightKind::kWrite: return "Write"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(CodeActionKind value) -> std::string { @@ -384,6 +442,8 @@ auto to_string(CodeActionKind value) -> std::string { case CodeActionKind::kNotebook: return "notebook"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(CodeActionTag value) -> std::string { @@ -391,6 +451,8 @@ auto to_string(CodeActionTag value) -> std::string { case CodeActionTag::kLLMGenerated: return "LLMGenerated"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(TraceValue value) -> std::string { @@ -402,6 +464,8 @@ auto to_string(TraceValue value) -> std::string { case TraceValue::kVerbose: return "verbose"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(MarkupKind value) -> std::string { @@ -411,6 +475,8 @@ auto to_string(MarkupKind value) -> std::string { case MarkupKind::kMarkdown: return "markdown"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(LanguageKind value) -> std::string { @@ -538,6 +604,8 @@ auto to_string(LanguageKind value) -> std::string { case LanguageKind::kYAML: return "yaml"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(InlineCompletionTriggerKind value) -> std::string { @@ -547,6 +615,8 @@ auto to_string(InlineCompletionTriggerKind value) -> std::string { case InlineCompletionTriggerKind::kAutomatic: return "Automatic"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(PositionEncodingKind value) -> std::string { @@ -558,6 +628,8 @@ auto to_string(PositionEncodingKind value) -> std::string { case PositionEncodingKind::kUTF32: return "utf-32"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(FileChangeType value) -> std::string { @@ -569,6 +641,8 @@ auto to_string(FileChangeType value) -> std::string { case FileChangeType::kDeleted: return "Deleted"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(WatchKind value) -> std::string { @@ -580,6 +654,8 @@ auto to_string(WatchKind value) -> std::string { case WatchKind::kDelete: return "Delete"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(DiagnosticSeverity value) -> std::string { @@ -593,6 +669,8 @@ auto to_string(DiagnosticSeverity value) -> std::string { case DiagnosticSeverity::kHint: return "Hint"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(DiagnosticTag value) -> std::string { @@ -602,6 +680,8 @@ auto to_string(DiagnosticTag value) -> std::string { case DiagnosticTag::kDeprecated: return "Deprecated"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(CompletionTriggerKind value) -> std::string { @@ -613,6 +693,8 @@ auto to_string(CompletionTriggerKind value) -> std::string { case CompletionTriggerKind::kTriggerForIncompleteCompletions: return "TriggerForIncompleteCompletions"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(ApplyKind value) -> std::string { @@ -622,6 +704,8 @@ auto to_string(ApplyKind value) -> std::string { case ApplyKind::kMerge: return "Merge"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(SignatureHelpTriggerKind value) -> std::string { @@ -633,6 +717,8 @@ auto to_string(SignatureHelpTriggerKind value) -> std::string { case SignatureHelpTriggerKind::kContentChange: return "ContentChange"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(CodeActionTriggerKind value) -> std::string { @@ -642,6 +728,8 @@ auto to_string(CodeActionTriggerKind value) -> std::string { case CodeActionTriggerKind::kAutomatic: return "Automatic"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(FileOperationPatternKind value) -> std::string { @@ -651,6 +739,8 @@ auto to_string(FileOperationPatternKind value) -> std::string { case FileOperationPatternKind::kFolder: return "folder"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(NotebookCellKind value) -> std::string { @@ -660,6 +750,8 @@ auto to_string(NotebookCellKind value) -> std::string { case NotebookCellKind::kCode: return "Code"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(ResourceOperationKind value) -> std::string { @@ -671,6 +763,8 @@ auto to_string(ResourceOperationKind value) -> std::string { case ResourceOperationKind::kDelete: return "delete"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(FailureHandlingKind value) -> std::string { @@ -684,6 +778,8 @@ auto to_string(FailureHandlingKind value) -> std::string { case FailureHandlingKind::kUndo: return "undo"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(PrepareSupportDefaultBehavior value) -> std::string { @@ -691,6 +787,8 @@ auto to_string(PrepareSupportDefaultBehavior value) -> std::string { case PrepareSupportDefaultBehavior::kIdentifier: return "Identifier"; } + + lsp_runtime_error("invalid enumerator value"); } auto to_string(TokenFormat value) -> std::string { @@ -698,6 +796,8 @@ auto to_string(TokenFormat value) -> std::string { case TokenFormat::kRelative: return "relative"; } + + lsp_runtime_error("invalid enumerator value"); } } // namespace cxx::lsp diff --git a/src/lsp/cxx/lsp/enums.h b/src/lsp/cxx/lsp/enums.h index fdeba3e7..2d09e8ee 100644 --- a/src/lsp/cxx/lsp/enums.h +++ b/src/lsp/cxx/lsp/enums.h @@ -1,5 +1,27 @@ +// 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 + #include namespace cxx::lsp { @@ -72,7 +94,7 @@ enum class FoldingRangeKind { kRegion, }; -enum class SymbolKind : unsigned int { +enum class SymbolKind : long { kFile = 1, kModule = 2, kNamespace = 3, @@ -101,7 +123,7 @@ enum class SymbolKind : unsigned int { kTypeParameter = 26, }; -enum class SymbolTag : unsigned int { +enum class SymbolTag : long { kDeprecated = 1, }; @@ -119,12 +141,12 @@ enum class MonikerKind { kLocal, }; -enum class InlayHintKind : unsigned int { +enum class InlayHintKind : long { kType = 1, kParameter = 2, }; -enum class MessageType : unsigned int { +enum class MessageType : long { kError = 1, kWarning = 2, kInfo = 3, @@ -132,19 +154,19 @@ enum class MessageType : unsigned int { kDebug = 5, }; -enum class TextDocumentSyncKind : unsigned int { +enum class TextDocumentSyncKind : long { kNone = 0, kFull = 1, kIncremental = 2, }; -enum class TextDocumentSaveReason : unsigned int { +enum class TextDocumentSaveReason : long { kManual = 1, kAfterDelay = 2, kFocusOut = 3, }; -enum class CompletionItemKind : unsigned int { +enum class CompletionItemKind : long { kText = 1, kMethod = 2, kFunction = 3, @@ -172,21 +194,21 @@ enum class CompletionItemKind : unsigned int { kTypeParameter = 25, }; -enum class CompletionItemTag : unsigned int { +enum class CompletionItemTag : long { kDeprecated = 1, }; -enum class InsertTextFormat : unsigned int { +enum class InsertTextFormat : long { kPlainText = 1, kSnippet = 2, }; -enum class InsertTextMode : unsigned int { +enum class InsertTextMode : long { kAsIs = 1, kAdjustIndentation = 2, }; -enum class DocumentHighlightKind : unsigned int { +enum class DocumentHighlightKind : long { kText = 1, kRead = 2, kWrite = 3, @@ -206,7 +228,7 @@ enum class CodeActionKind { kNotebook, }; -enum class CodeActionTag : unsigned int { +enum class CodeActionTag : long { kLLMGenerated = 1, }; @@ -285,7 +307,7 @@ enum class LanguageKind { kYAML, }; -enum class InlineCompletionTriggerKind : unsigned int { +enum class InlineCompletionTriggerKind : long { kInvoked = 1, kAutomatic = 2, }; @@ -296,48 +318,48 @@ enum class PositionEncodingKind { kUTF32, }; -enum class FileChangeType : unsigned int { +enum class FileChangeType : long { kCreated = 1, kChanged = 2, kDeleted = 3, }; -enum class WatchKind : unsigned int { +enum class WatchKind : long { kCreate = 1, kChange = 2, kDelete = 4, }; -enum class DiagnosticSeverity : unsigned int { +enum class DiagnosticSeverity : long { kError = 1, kWarning = 2, kInformation = 3, kHint = 4, }; -enum class DiagnosticTag : unsigned int { +enum class DiagnosticTag : long { kUnnecessary = 1, kDeprecated = 2, }; -enum class CompletionTriggerKind : unsigned int { +enum class CompletionTriggerKind : long { kInvoked = 1, kTriggerCharacter = 2, kTriggerForIncompleteCompletions = 3, }; -enum class ApplyKind : unsigned int { +enum class ApplyKind : long { kReplace = 1, kMerge = 2, }; -enum class SignatureHelpTriggerKind : unsigned int { +enum class SignatureHelpTriggerKind : long { kInvoked = 1, kTriggerCharacter = 2, kContentChange = 3, }; -enum class CodeActionTriggerKind : unsigned int { +enum class CodeActionTriggerKind : long { kInvoked = 1, kAutomatic = 2, }; @@ -347,7 +369,7 @@ enum class FileOperationPatternKind { kFolder, }; -enum class NotebookCellKind : unsigned int { +enum class NotebookCellKind : long { kMarkup = 1, kCode = 2, }; @@ -365,7 +387,7 @@ enum class FailureHandlingKind { kUndo, }; -enum class PrepareSupportDefaultBehavior : unsigned int { +enum class PrepareSupportDefaultBehavior : long { kIdentifier = 1, }; diff --git a/src/lsp/cxx/lsp/fwd.h b/src/lsp/cxx/lsp/fwd.h new file mode 100644 index 00000000..dd4e42a6 --- /dev/null +++ b/src/lsp/cxx/lsp/fwd.h @@ -0,0 +1,693 @@ +// 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 +#include + +namespace cxx::lsp { + +using json = nlohmann::json; + +enum class SemanticTokenTypes; +enum class SemanticTokenModifiers; +enum class DocumentDiagnosticReportKind; +enum class ErrorCodes : int; +enum class LSPErrorCodes : int; +enum class FoldingRangeKind; +enum class SymbolKind : long; +enum class SymbolTag : long; +enum class UniquenessLevel; +enum class MonikerKind; +enum class InlayHintKind : long; +enum class MessageType : long; +enum class TextDocumentSyncKind : long; +enum class TextDocumentSaveReason : long; +enum class CompletionItemKind : long; +enum class CompletionItemTag : long; +enum class InsertTextFormat : long; +enum class InsertTextMode : long; +enum class DocumentHighlightKind : long; +enum class CodeActionKind; +enum class CodeActionTag : long; +enum class TraceValue; +enum class MarkupKind; +enum class LanguageKind; +enum class InlineCompletionTriggerKind : long; +enum class PositionEncodingKind; +enum class FileChangeType : long; +enum class WatchKind : long; +enum class DiagnosticSeverity : long; +enum class DiagnosticTag : long; +enum class CompletionTriggerKind : long; +enum class ApplyKind : long; +enum class SignatureHelpTriggerKind : long; +enum class CodeActionTriggerKind : long; +enum class FileOperationPatternKind; +enum class NotebookCellKind : long; +enum class ResourceOperationKind; +enum class FailureHandlingKind; +enum class PrepareSupportDefaultBehavior : long; +enum class TokenFormat; + +class ImplementationParams; +class Location; +class ImplementationRegistrationOptions; +class TypeDefinitionParams; +class TypeDefinitionRegistrationOptions; +class WorkspaceFolder; +class DidChangeWorkspaceFoldersParams; +class ConfigurationParams; +class DocumentColorParams; +class ColorInformation; +class DocumentColorRegistrationOptions; +class ColorPresentationParams; +class ColorPresentation; +class WorkDoneProgressOptions; +class TextDocumentRegistrationOptions; +class FoldingRangeParams; +class FoldingRange; +class FoldingRangeRegistrationOptions; +class DeclarationParams; +class DeclarationRegistrationOptions; +class SelectionRangeParams; +class SelectionRange; +class SelectionRangeRegistrationOptions; +class WorkDoneProgressCreateParams; +class WorkDoneProgressCancelParams; +class CallHierarchyPrepareParams; +class CallHierarchyItem; +class CallHierarchyRegistrationOptions; +class CallHierarchyIncomingCallsParams; +class CallHierarchyIncomingCall; +class CallHierarchyOutgoingCallsParams; +class CallHierarchyOutgoingCall; +class SemanticTokensParams; +class SemanticTokens; +class SemanticTokensPartialResult; +class SemanticTokensRegistrationOptions; +class SemanticTokensDeltaParams; +class SemanticTokensDelta; +class SemanticTokensDeltaPartialResult; +class SemanticTokensRangeParams; +class ShowDocumentParams; +class ShowDocumentResult; +class LinkedEditingRangeParams; +class LinkedEditingRanges; +class LinkedEditingRangeRegistrationOptions; +class CreateFilesParams; +class WorkspaceEdit; +class FileOperationRegistrationOptions; +class RenameFilesParams; +class DeleteFilesParams; +class MonikerParams; +class Moniker; +class MonikerRegistrationOptions; +class TypeHierarchyPrepareParams; +class TypeHierarchyItem; +class TypeHierarchyRegistrationOptions; +class TypeHierarchySupertypesParams; +class TypeHierarchySubtypesParams; +class InlineValueParams; +class InlineValueRegistrationOptions; +class InlayHintParams; +class InlayHint; +class InlayHintRegistrationOptions; +class DocumentDiagnosticParams; +class DocumentDiagnosticReportPartialResult; +class DiagnosticServerCancellationData; +class DiagnosticRegistrationOptions; +class WorkspaceDiagnosticParams; +class WorkspaceDiagnosticReport; +class WorkspaceDiagnosticReportPartialResult; +class DidOpenNotebookDocumentParams; +class NotebookDocumentSyncRegistrationOptions; +class DidChangeNotebookDocumentParams; +class DidSaveNotebookDocumentParams; +class DidCloseNotebookDocumentParams; +class InlineCompletionParams; +class InlineCompletionList; +class InlineCompletionItem; +class InlineCompletionRegistrationOptions; +class TextDocumentContentParams; +class TextDocumentContentResult; +class TextDocumentContentRegistrationOptions; +class TextDocumentContentRefreshParams; +class RegistrationParams; +class UnregistrationParams; +class InitializeParams; +class InitializeResult; +class InitializeError; +class InitializedParams; +class DidChangeConfigurationParams; +class DidChangeConfigurationRegistrationOptions; +class ShowMessageParams; +class ShowMessageRequestParams; +class MessageActionItem; +class LogMessageParams; +class DidOpenTextDocumentParams; +class DidChangeTextDocumentParams; +class TextDocumentChangeRegistrationOptions; +class DidCloseTextDocumentParams; +class DidSaveTextDocumentParams; +class TextDocumentSaveRegistrationOptions; +class WillSaveTextDocumentParams; +class TextEdit; +class DidChangeWatchedFilesParams; +class DidChangeWatchedFilesRegistrationOptions; +class PublishDiagnosticsParams; +class CompletionParams; +class CompletionItem; +class CompletionList; +class CompletionRegistrationOptions; +class HoverParams; +class Hover; +class HoverRegistrationOptions; +class SignatureHelpParams; +class SignatureHelp; +class SignatureHelpRegistrationOptions; +class DefinitionParams; +class DefinitionRegistrationOptions; +class ReferenceParams; +class ReferenceRegistrationOptions; +class DocumentHighlightParams; +class DocumentHighlight; +class DocumentHighlightRegistrationOptions; +class DocumentSymbolParams; +class SymbolInformation; +class DocumentSymbol; +class DocumentSymbolRegistrationOptions; +class CodeActionParams; +class Command; +class CodeAction; +class CodeActionRegistrationOptions; +class WorkspaceSymbolParams; +class WorkspaceSymbol; +class WorkspaceSymbolRegistrationOptions; +class CodeLensParams; +class CodeLens; +class CodeLensRegistrationOptions; +class DocumentLinkParams; +class DocumentLink; +class DocumentLinkRegistrationOptions; +class DocumentFormattingParams; +class DocumentFormattingRegistrationOptions; +class DocumentRangeFormattingParams; +class DocumentRangeFormattingRegistrationOptions; +class DocumentRangesFormattingParams; +class DocumentOnTypeFormattingParams; +class DocumentOnTypeFormattingRegistrationOptions; +class RenameParams; +class RenameRegistrationOptions; +class PrepareRenameParams; +class ExecuteCommandParams; +class ExecuteCommandRegistrationOptions; +class ApplyWorkspaceEditParams; +class ApplyWorkspaceEditResult; +class WorkDoneProgressBegin; +class WorkDoneProgressReport; +class WorkDoneProgressEnd; +class SetTraceParams; +class LogTraceParams; +class CancelParams; +class ProgressParams; +class TextDocumentPositionParams; +class WorkDoneProgressParams; +class PartialResultParams; +class LocationLink; +class Range; +class ImplementationOptions; +class StaticRegistrationOptions; +class TypeDefinitionOptions; +class WorkspaceFoldersChangeEvent; +class ConfigurationItem; +class TextDocumentIdentifier; +class Color; +class DocumentColorOptions; +class FoldingRangeOptions; +class DeclarationOptions; +class Position; +class SelectionRangeOptions; +class CallHierarchyOptions; +class SemanticTokensOptions; +class SemanticTokensEdit; +class LinkedEditingRangeOptions; +class FileCreate; +class TextDocumentEdit; +class CreateFile; +class RenameFile; +class DeleteFile; +class ChangeAnnotation; +class FileOperationFilter; +class FileRename; +class FileDelete; +class MonikerOptions; +class TypeHierarchyOptions; +class InlineValueContext; +class InlineValueText; +class InlineValueVariableLookup; +class InlineValueEvaluatableExpression; +class InlineValueOptions; +class InlayHintLabelPart; +class MarkupContent; +class InlayHintOptions; +class RelatedFullDocumentDiagnosticReport; +class RelatedUnchangedDocumentDiagnosticReport; +class FullDocumentDiagnosticReport; +class UnchangedDocumentDiagnosticReport; +class DiagnosticOptions; +class PreviousResultId; +class NotebookDocument; +class TextDocumentItem; +class NotebookDocumentSyncOptions; +class VersionedNotebookDocumentIdentifier; +class NotebookDocumentChangeEvent; +class NotebookDocumentIdentifier; +class InlineCompletionContext; +class StringValue; +class InlineCompletionOptions; +class TextDocumentContentOptions; +class Registration; +class Unregistration; +class _InitializeParams; +class WorkspaceFoldersInitializeParams; +class ServerCapabilities; +class ServerInfo; +class VersionedTextDocumentIdentifier; +class SaveOptions; +class FileEvent; +class FileSystemWatcher; +class Diagnostic; +class CompletionContext; +class CompletionItemLabelDetails; +class InsertReplaceEdit; +class CompletionItemDefaults; +class CompletionItemApplyKinds; +class CompletionOptions; +class HoverOptions; +class SignatureHelpContext; +class SignatureInformation; +class SignatureHelpOptions; +class DefinitionOptions; +class ReferenceContext; +class ReferenceOptions; +class DocumentHighlightOptions; +class BaseSymbolInformation; +class DocumentSymbolOptions; +class CodeActionContext; +class CodeActionDisabled; +class CodeActionOptions; +class LocationUriOnly; +class WorkspaceSymbolOptions; +class CodeLensOptions; +class DocumentLinkOptions; +class FormattingOptions; +class DocumentFormattingOptions; +class DocumentRangeFormattingOptions; +class DocumentOnTypeFormattingOptions; +class RenameOptions; +class PrepareRenamePlaceholder; +class PrepareRenameDefaultBehavior; +class ExecuteCommandOptions; +class WorkspaceEditMetadata; +class SemanticTokensLegend; +class SemanticTokensFullDelta; +class OptionalVersionedTextDocumentIdentifier; +class AnnotatedTextEdit; +class SnippetTextEdit; +class ResourceOperation; +class CreateFileOptions; +class RenameFileOptions; +class DeleteFileOptions; +class FileOperationPattern; +class WorkspaceFullDocumentDiagnosticReport; +class WorkspaceUnchangedDocumentDiagnosticReport; +class NotebookCell; +class NotebookDocumentFilterWithNotebook; +class NotebookDocumentFilterWithCells; +class NotebookDocumentCellChanges; +class SelectedCompletionInfo; +class ClientInfo; +class ClientCapabilities; +class TextDocumentSyncOptions; +class WorkspaceOptions; +class TextDocumentContentChangePartial; +class TextDocumentContentChangeWholeDocument; +class CodeDescription; +class DiagnosticRelatedInformation; +class EditRangeWithInsertReplace; +class ServerCompletionItemOptions; +class MarkedStringWithLanguage; +class ParameterInformation; +class CodeActionKindDocumentation; +class NotebookCellTextDocumentFilter; +class FileOperationPatternOptions; +class ExecutionSummary; +class NotebookCellLanguage; +class NotebookDocumentCellChangeStructure; +class NotebookDocumentCellContentChanges; +class WorkspaceClientCapabilities; +class TextDocumentClientCapabilities; +class NotebookDocumentClientCapabilities; +class WindowClientCapabilities; +class GeneralClientCapabilities; +class WorkspaceFoldersServerCapabilities; +class FileOperationOptions; +class RelativePattern; +class TextDocumentFilterLanguage; +class TextDocumentFilterScheme; +class TextDocumentFilterPattern; +class NotebookDocumentFilterNotebookType; +class NotebookDocumentFilterScheme; +class NotebookDocumentFilterPattern; +class NotebookCellArrayChange; +class WorkspaceEditClientCapabilities; +class DidChangeConfigurationClientCapabilities; +class DidChangeWatchedFilesClientCapabilities; +class WorkspaceSymbolClientCapabilities; +class ExecuteCommandClientCapabilities; +class SemanticTokensWorkspaceClientCapabilities; +class CodeLensWorkspaceClientCapabilities; +class FileOperationClientCapabilities; +class InlineValueWorkspaceClientCapabilities; +class InlayHintWorkspaceClientCapabilities; +class DiagnosticWorkspaceClientCapabilities; +class FoldingRangeWorkspaceClientCapabilities; +class TextDocumentContentClientCapabilities; +class TextDocumentSyncClientCapabilities; +class TextDocumentFilterClientCapabilities; +class CompletionClientCapabilities; +class HoverClientCapabilities; +class SignatureHelpClientCapabilities; +class DeclarationClientCapabilities; +class DefinitionClientCapabilities; +class TypeDefinitionClientCapabilities; +class ImplementationClientCapabilities; +class ReferenceClientCapabilities; +class DocumentHighlightClientCapabilities; +class DocumentSymbolClientCapabilities; +class CodeActionClientCapabilities; +class CodeLensClientCapabilities; +class DocumentLinkClientCapabilities; +class DocumentColorClientCapabilities; +class DocumentFormattingClientCapabilities; +class DocumentRangeFormattingClientCapabilities; +class DocumentOnTypeFormattingClientCapabilities; +class RenameClientCapabilities; +class FoldingRangeClientCapabilities; +class SelectionRangeClientCapabilities; +class PublishDiagnosticsClientCapabilities; +class CallHierarchyClientCapabilities; +class SemanticTokensClientCapabilities; +class LinkedEditingRangeClientCapabilities; +class MonikerClientCapabilities; +class TypeHierarchyClientCapabilities; +class InlineValueClientCapabilities; +class InlayHintClientCapabilities; +class DiagnosticClientCapabilities; +class InlineCompletionClientCapabilities; +class NotebookDocumentSyncClientCapabilities; +class ShowMessageRequestClientCapabilities; +class ShowDocumentClientCapabilities; +class StaleRequestSupportOptions; +class RegularExpressionsClientCapabilities; +class MarkdownClientCapabilities; +class ChangeAnnotationsSupportOptions; +class ClientSymbolKindOptions; +class ClientSymbolTagOptions; +class ClientSymbolResolveOptions; +class ClientCompletionItemOptions; +class ClientCompletionItemOptionsKind; +class CompletionListCapabilities; +class ClientSignatureInformationOptions; +class ClientCodeActionLiteralOptions; +class ClientCodeActionResolveOptions; +class CodeActionTagOptions; +class ClientCodeLensResolveOptions; +class ClientFoldingRangeKindOptions; +class ClientFoldingRangeOptions; +class DiagnosticsCapabilities; +class ClientSemanticTokensRequestOptions; +class ClientInlayHintResolveOptions; +class ClientShowMessageActionItemOptions; +class CompletionItemTagOptions; +class ClientCompletionItemResolveOptions; +class ClientCompletionItemInsertTextModeOptions; +class ClientSignatureParameterInformationOptions; +class ClientCodeActionKindOptions; +class ClientDiagnosticsTagOptions; +class ClientSemanticTokensRequestFullDelta; + +[[noreturn]] void lsp_runtime_error(const std::string& msg); + +using LSPAny = json; +using Pattern = std::string; + +class LSPObject { + public: + explicit LSPObject(json repr) : repr_(std::move(repr)) {} + + [[nodiscard]] operator const json&() const { return repr_; } + + protected: + json repr_; +}; + +template +class Vector final : public LSPObject { + public: + using LSPObject::LSPObject; + + [[nodiscard]] explicit operator bool() const { return repr_.is_array(); } + [[nodiscard]] auto size() const -> std::size_t { return repr_.size(); } + [[nodiscard]] auto empty() const -> bool { return repr_.empty(); } + [[nodiscard]] auto at(int index) const -> const T& { return repr_[index]; } +}; + +namespace details { + +template +struct TryEmplace; + +template T> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + auto obj = T{value}; + if (!obj) return false; + result.template emplace(std::move(obj)); + return true; + } +}; + +template +auto try_emplace(std::variant& result, const json& value) -> bool { + return (details::TryEmplace{}(result, value) || ...); +} + +template <> +struct TryEmplace { + auto operator()(auto&, const json&) const -> bool { return false; } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_null()) return false; + result.template emplace(nullptr); + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_boolean()) return false; + result.template emplace(value); + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_number_integer()) return false; + result.template emplace(value); + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_number_integer()) return false; + result.template emplace(value); + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_number_float()) return false; + result.template emplace(value); + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + if (!value.is_string()) return false; + result.template emplace(value); + return true; + } +}; + +template +struct TryEmplace> { + auto operator()(auto& result, const json& value) const -> bool { + return try_emplace(result, value); + } +}; + +template +struct TryEmplace> { + auto operator()(auto& result, const json& value) const -> bool { + lsp_runtime_error("todo: TryEmplace>"); + return false; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + result = value; + return true; + } +}; + +template <> +struct TryEmplace { + auto operator()(auto& result, const json& value) const -> bool { + lsp_runtime_error("todo: TextDocumentSyncKind"); + return true; + } +}; + +} // namespace details + +template +class Vector> final : public LSPObject { + public: + using LSPObject::LSPObject; + + [[nodiscard]] explicit operator bool() const { return repr_.is_array(); } + [[nodiscard]] auto size() const -> std::size_t { return repr_.size(); } + [[nodiscard]] auto empty() const -> bool { return repr_.empty(); } + [[nodiscard]] auto at(int index) const -> std::variant { + std::variant result; + details::try_emplace(result, repr_[index]); + return result; + } +}; + +template +class Map final : public LSPObject { + public: + using LSPObject::LSPObject; + + [[nodiscard]] explicit operator bool() const { return repr_.is_object(); } + [[nodiscard]] auto size() const -> std::size_t { return repr_.size(); } + [[nodiscard]] auto empty() const -> bool { return repr_.empty(); } + [[nodiscard]] auto at(const Key& key) const -> const Value& { + return repr_[key]; + } +}; + +template +class Map> final : public LSPObject { + public: + using LSPObject::LSPObject; + + [[nodiscard]] explicit operator bool() const { return repr_.is_object(); } + [[nodiscard]] auto size() const -> std::size_t { return repr_.size(); } + [[nodiscard]] auto empty() const -> bool { return repr_.empty(); } + + [[nodiscard]] auto at(const Key& key) const -> std::variant { + std::variant result; + details::try_emplace(result, repr_[key]); + return result; + } +}; + +using RegularExpressionEngineKind = std::string; + +using NotebookDocumentFilter = + std::variant; + +using TextDocumentFilter = + std::variant; + +using GlobPattern = std::variant; + +using DocumentFilter = std::variant; + +using MarkedString = + std::variant; + +using TextDocumentContentChangeEvent = + std::variant; + +using WorkspaceDocumentDiagnosticReport = + std::variant; + +using ChangeAnnotationIdentifier = std::string; + +using ProgressToken = std::variant; + +using DocumentSelector = Vector; + +using PrepareRenameResult = + std::variant; + +using DocumentDiagnosticReport = + std::variant; + +using InlineValue = + std::variant; + +using DeclarationLink = LocationLink; + +using Declaration = std::variant>; + +using DefinitionLink = LocationLink; + +using Definition = std::variant>; + +} // namespace cxx::lsp diff --git a/src/lsp/cxx/lsp/lsp.cc b/src/lsp/cxx/lsp/lsp.cc new file mode 100644 index 00000000..91b00226 --- /dev/null +++ b/src/lsp/cxx/lsp/lsp.cc @@ -0,0 +1,42 @@ +// 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 + +#include "fwd.h" + +#if __cpp_exceptions +#include +#endif + +namespace cxx::lsp { + +[[noreturn]] void lsp_runtime_error(const std::string& msg) { +#if __cpp_exceptions + throw std::runtime_error(msg); +#else + std::cerr << std::format("lsp_runtime_error: {}\n", msg); + std::abort(); +#endif +} + +} // namespace cxx::lsp diff --git a/src/lsp/cxx/lsp/types.cc b/src/lsp/cxx/lsp/types.cc new file mode 100644 index 00000000..1c20852d --- /dev/null +++ b/src/lsp/cxx/lsp/types.cc @@ -0,0 +1,17743 @@ +// 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 + +namespace cxx::lsp { + +ImplementationParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto ImplementationParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto ImplementationParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto ImplementationParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto ImplementationParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto ImplementationParams::textDocument(TextDocumentIdentifier textDocument) + -> ImplementationParams& { + return *this; +} + +auto ImplementationParams::position(Position position) + -> ImplementationParams& { + return *this; +} + +auto ImplementationParams::workDoneToken( + std::optional workDoneToken) -> ImplementationParams& { + return *this; +} + +auto ImplementationParams::partialResultToken( + std::optional partialResultToken) -> ImplementationParams& { + return *this; +} + +Location::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + if (!repr_.contains("range")) return false; + return true; +} + +auto Location::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto Location::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto Location::uri(std::string uri) -> Location& { return *this; } + +auto Location::range(Range range) -> Location& { return *this; } + +ImplementationRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto ImplementationRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ImplementationRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ImplementationRegistrationOptions::id() const + -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto ImplementationRegistrationOptions::documentSelector( + std::variant + documentSelector) -> ImplementationRegistrationOptions& { + return *this; +} + +auto ImplementationRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> ImplementationRegistrationOptions& { + return *this; +} + +auto ImplementationRegistrationOptions::id(std::optional id) + -> ImplementationRegistrationOptions& { + return *this; +} + +TypeDefinitionParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto TypeDefinitionParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto TypeDefinitionParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto TypeDefinitionParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto TypeDefinitionParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto TypeDefinitionParams::textDocument(TextDocumentIdentifier textDocument) + -> TypeDefinitionParams& { + return *this; +} + +auto TypeDefinitionParams::position(Position position) + -> TypeDefinitionParams& { + return *this; +} + +auto TypeDefinitionParams::workDoneToken( + std::optional workDoneToken) -> TypeDefinitionParams& { + return *this; +} + +auto TypeDefinitionParams::partialResultToken( + std::optional partialResultToken) -> TypeDefinitionParams& { + return *this; +} + +TypeDefinitionRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto TypeDefinitionRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto TypeDefinitionRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TypeDefinitionRegistrationOptions::id() const + -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto TypeDefinitionRegistrationOptions::documentSelector( + std::variant + documentSelector) -> TypeDefinitionRegistrationOptions& { + return *this; +} + +auto TypeDefinitionRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> TypeDefinitionRegistrationOptions& { + return *this; +} + +auto TypeDefinitionRegistrationOptions::id(std::optional id) + -> TypeDefinitionRegistrationOptions& { + return *this; +} + +WorkspaceFolder::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + if (!repr_.contains("name")) return false; + return true; +} + +auto WorkspaceFolder::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceFolder::name() const -> std::string { + const auto& value = repr_["name"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceFolder::uri(std::string uri) -> WorkspaceFolder& { return *this; } + +auto WorkspaceFolder::name(std::string name) -> WorkspaceFolder& { + return *this; +} + +DidChangeWorkspaceFoldersParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("event")) return false; + return true; +} + +auto DidChangeWorkspaceFoldersParams::event() const + -> WorkspaceFoldersChangeEvent { + const auto& value = repr_["event"]; + + return WorkspaceFoldersChangeEvent(value); +} + +auto DidChangeWorkspaceFoldersParams::event(WorkspaceFoldersChangeEvent event) + -> DidChangeWorkspaceFoldersParams& { + return *this; +} + +ConfigurationParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("items")) return false; + return true; +} + +auto ConfigurationParams::items() const -> Vector { + const auto& value = repr_["items"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ConfigurationParams::items(Vector items) + -> ConfigurationParams& { + return *this; +} + +DocumentColorParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + return true; +} + +auto DocumentColorParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DocumentColorParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentColorParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentColorParams::textDocument(TextDocumentIdentifier textDocument) + -> DocumentColorParams& { + return *this; +} + +auto DocumentColorParams::workDoneToken( + std::optional workDoneToken) -> DocumentColorParams& { + return *this; +} + +auto DocumentColorParams::partialResultToken( + std::optional partialResultToken) -> DocumentColorParams& { + return *this; +} + +ColorInformation::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("color")) return false; + return true; +} + +auto ColorInformation::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto ColorInformation::color() const -> Color { + const auto& value = repr_["color"]; + + return Color(value); +} + +auto ColorInformation::range(Range range) -> ColorInformation& { return *this; } + +auto ColorInformation::color(Color color) -> ColorInformation& { return *this; } + +DocumentColorRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto DocumentColorRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentColorRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentColorRegistrationOptions::id() const + -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentColorRegistrationOptions::documentSelector( + std::variant + documentSelector) -> DocumentColorRegistrationOptions& { + return *this; +} + +auto DocumentColorRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> DocumentColorRegistrationOptions& { + return *this; +} + +auto DocumentColorRegistrationOptions::id(std::optional id) + -> DocumentColorRegistrationOptions& { + return *this; +} + +ColorPresentationParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("color")) return false; + if (!repr_.contains("range")) return false; + return true; +} + +auto ColorPresentationParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto ColorPresentationParams::color() const -> Color { + const auto& value = repr_["color"]; + + return Color(value); +} + +auto ColorPresentationParams::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto ColorPresentationParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto ColorPresentationParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto ColorPresentationParams::textDocument(TextDocumentIdentifier textDocument) + -> ColorPresentationParams& { + return *this; +} + +auto ColorPresentationParams::color(Color color) -> ColorPresentationParams& { + return *this; +} + +auto ColorPresentationParams::range(Range range) -> ColorPresentationParams& { + return *this; +} + +auto ColorPresentationParams::workDoneToken( + std::optional workDoneToken) -> ColorPresentationParams& { + return *this; +} + +auto ColorPresentationParams::partialResultToken( + std::optional partialResultToken) + -> ColorPresentationParams& { + return *this; +} + +ColorPresentation::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("label")) return false; + return true; +} + +auto ColorPresentation::label() const -> std::string { + const auto& value = repr_["label"]; + + assert(value.is_string()); + return value.get(); +} + +auto ColorPresentation::textEdit() const -> std::optional { + if (!repr_.contains("textEdit")) return std::nullopt; + + const auto& value = repr_["textEdit"]; + + return TextEdit(value); +} + +auto ColorPresentation::additionalTextEdits() const + -> std::optional> { + if (!repr_.contains("additionalTextEdits")) return std::nullopt; + + const auto& value = repr_["additionalTextEdits"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ColorPresentation::label(std::string label) -> ColorPresentation& { + return *this; +} + +auto ColorPresentation::textEdit(std::optional textEdit) + -> ColorPresentation& { + return *this; +} + +auto ColorPresentation::additionalTextEdits( + std::optional> additionalTextEdits) -> ColorPresentation& { + return *this; +} + +WorkDoneProgressOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkDoneProgressOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkDoneProgressOptions::workDoneProgress( + std::optional workDoneProgress) -> WorkDoneProgressOptions& { + return *this; +} + +TextDocumentRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto TextDocumentRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto TextDocumentRegistrationOptions::documentSelector( + std::variant + documentSelector) -> TextDocumentRegistrationOptions& { + return *this; +} + +FoldingRangeParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + return true; +} + +auto FoldingRangeParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto FoldingRangeParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto FoldingRangeParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto FoldingRangeParams::textDocument(TextDocumentIdentifier textDocument) + -> FoldingRangeParams& { + return *this; +} + +auto FoldingRangeParams::workDoneToken( + std::optional workDoneToken) -> FoldingRangeParams& { + return *this; +} + +auto FoldingRangeParams::partialResultToken( + std::optional partialResultToken) -> FoldingRangeParams& { + return *this; +} + +FoldingRange::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("startLine")) return false; + if (!repr_.contains("endLine")) return false; + return true; +} + +auto FoldingRange::startLine() const -> long { + const auto& value = repr_["startLine"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto FoldingRange::startCharacter() const -> std::optional { + if (!repr_.contains("startCharacter")) return std::nullopt; + + const auto& value = repr_["startCharacter"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto FoldingRange::endLine() const -> long { + const auto& value = repr_["endLine"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto FoldingRange::endCharacter() const -> std::optional { + if (!repr_.contains("endCharacter")) return std::nullopt; + + const auto& value = repr_["endCharacter"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto FoldingRange::kind() const -> std::optional { + if (!repr_.contains("kind")) return std::nullopt; + + const auto& value = repr_["kind"]; + + lsp_runtime_error("FoldingRange::kind: not implement yet"); +} + +auto FoldingRange::collapsedText() const -> std::optional { + if (!repr_.contains("collapsedText")) return std::nullopt; + + const auto& value = repr_["collapsedText"]; + + assert(value.is_string()); + return value.get(); +} + +auto FoldingRange::startLine(long startLine) -> FoldingRange& { return *this; } + +auto FoldingRange::startCharacter(std::optional startCharacter) + -> FoldingRange& { + return *this; +} + +auto FoldingRange::endLine(long endLine) -> FoldingRange& { return *this; } + +auto FoldingRange::endCharacter(std::optional endCharacter) + -> FoldingRange& { + return *this; +} + +auto FoldingRange::kind(std::optional kind) -> FoldingRange& { + return *this; +} + +auto FoldingRange::collapsedText(std::optional collapsedText) + -> FoldingRange& { + return *this; +} + +FoldingRangeRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto FoldingRangeRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto FoldingRangeRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FoldingRangeRegistrationOptions::id() const -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto FoldingRangeRegistrationOptions::documentSelector( + std::variant + documentSelector) -> FoldingRangeRegistrationOptions& { + return *this; +} + +auto FoldingRangeRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> FoldingRangeRegistrationOptions& { + return *this; +} + +auto FoldingRangeRegistrationOptions::id(std::optional id) + -> FoldingRangeRegistrationOptions& { + return *this; +} + +DeclarationParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto DeclarationParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DeclarationParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto DeclarationParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DeclarationParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DeclarationParams::textDocument(TextDocumentIdentifier textDocument) + -> DeclarationParams& { + return *this; +} + +auto DeclarationParams::position(Position position) -> DeclarationParams& { + return *this; +} + +auto DeclarationParams::workDoneToken( + std::optional workDoneToken) -> DeclarationParams& { + return *this; +} + +auto DeclarationParams::partialResultToken( + std::optional partialResultToken) -> DeclarationParams& { + return *this; +} + +DeclarationRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto DeclarationRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DeclarationRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto DeclarationRegistrationOptions::id() const -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto DeclarationRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> DeclarationRegistrationOptions& { + return *this; +} + +auto DeclarationRegistrationOptions::documentSelector( + std::variant + documentSelector) -> DeclarationRegistrationOptions& { + return *this; +} + +auto DeclarationRegistrationOptions::id(std::optional id) + -> DeclarationRegistrationOptions& { + return *this; +} + +SelectionRangeParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("positions")) return false; + return true; +} + +auto SelectionRangeParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto SelectionRangeParams::positions() const -> Vector { + const auto& value = repr_["positions"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SelectionRangeParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto SelectionRangeParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto SelectionRangeParams::textDocument(TextDocumentIdentifier textDocument) + -> SelectionRangeParams& { + return *this; +} + +auto SelectionRangeParams::positions(Vector positions) + -> SelectionRangeParams& { + return *this; +} + +auto SelectionRangeParams::workDoneToken( + std::optional workDoneToken) -> SelectionRangeParams& { + return *this; +} + +auto SelectionRangeParams::partialResultToken( + std::optional partialResultToken) -> SelectionRangeParams& { + return *this; +} + +SelectionRange::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + return true; +} + +auto SelectionRange::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto SelectionRange::parent() const -> std::optional { + if (!repr_.contains("parent")) return std::nullopt; + + const auto& value = repr_["parent"]; + + return SelectionRange(value); +} + +auto SelectionRange::range(Range range) -> SelectionRange& { return *this; } + +auto SelectionRange::parent(std::optional parent) + -> SelectionRange& { + return *this; +} + +SelectionRangeRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto SelectionRangeRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SelectionRangeRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto SelectionRangeRegistrationOptions::id() const + -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto SelectionRangeRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> SelectionRangeRegistrationOptions& { + return *this; +} + +auto SelectionRangeRegistrationOptions::documentSelector( + std::variant + documentSelector) -> SelectionRangeRegistrationOptions& { + return *this; +} + +auto SelectionRangeRegistrationOptions::id(std::optional id) + -> SelectionRangeRegistrationOptions& { + return *this; +} + +WorkDoneProgressCreateParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("token")) return false; + return true; +} + +auto WorkDoneProgressCreateParams::token() const -> ProgressToken { + const auto& value = repr_["token"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkDoneProgressCreateParams::token(ProgressToken token) + -> WorkDoneProgressCreateParams& { + return *this; +} + +WorkDoneProgressCancelParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("token")) return false; + return true; +} + +auto WorkDoneProgressCancelParams::token() const -> ProgressToken { + const auto& value = repr_["token"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkDoneProgressCancelParams::token(ProgressToken token) + -> WorkDoneProgressCancelParams& { + return *this; +} + +CallHierarchyPrepareParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto CallHierarchyPrepareParams::textDocument() const + -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto CallHierarchyPrepareParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto CallHierarchyPrepareParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto CallHierarchyPrepareParams::textDocument( + TextDocumentIdentifier textDocument) -> CallHierarchyPrepareParams& { + return *this; +} + +auto CallHierarchyPrepareParams::position(Position position) + -> CallHierarchyPrepareParams& { + return *this; +} + +auto CallHierarchyPrepareParams::workDoneToken( + std::optional workDoneToken) -> CallHierarchyPrepareParams& { + return *this; +} + +CallHierarchyItem::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("name")) return false; + if (!repr_.contains("kind")) return false; + if (!repr_.contains("uri")) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("selectionRange")) return false; + return true; +} + +auto CallHierarchyItem::name() const -> std::string { + const auto& value = repr_["name"]; + + assert(value.is_string()); + return value.get(); +} + +auto CallHierarchyItem::kind() const -> SymbolKind { + const auto& value = repr_["kind"]; + + return SymbolKind(value); +} + +auto CallHierarchyItem::tags() const -> std::optional> { + if (!repr_.contains("tags")) return std::nullopt; + + const auto& value = repr_["tags"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CallHierarchyItem::detail() const -> std::optional { + if (!repr_.contains("detail")) return std::nullopt; + + const auto& value = repr_["detail"]; + + assert(value.is_string()); + return value.get(); +} + +auto CallHierarchyItem::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto CallHierarchyItem::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto CallHierarchyItem::selectionRange() const -> Range { + const auto& value = repr_["selectionRange"]; + + return Range(value); +} + +auto CallHierarchyItem::data() const -> std::optional { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto CallHierarchyItem::name(std::string name) -> CallHierarchyItem& { + return *this; +} + +auto CallHierarchyItem::kind(SymbolKind kind) -> CallHierarchyItem& { + return *this; +} + +auto CallHierarchyItem::tags(std::optional> tags) + -> CallHierarchyItem& { + return *this; +} + +auto CallHierarchyItem::detail(std::optional detail) + -> CallHierarchyItem& { + return *this; +} + +auto CallHierarchyItem::uri(std::string uri) -> CallHierarchyItem& { + return *this; +} + +auto CallHierarchyItem::range(Range range) -> CallHierarchyItem& { + return *this; +} + +auto CallHierarchyItem::selectionRange(Range selectionRange) + -> CallHierarchyItem& { + return *this; +} + +auto CallHierarchyItem::data(std::optional data) -> CallHierarchyItem& { + return *this; +} + +CallHierarchyRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto CallHierarchyRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto CallHierarchyRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CallHierarchyRegistrationOptions::id() const + -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto CallHierarchyRegistrationOptions::documentSelector( + std::variant + documentSelector) -> CallHierarchyRegistrationOptions& { + return *this; +} + +auto CallHierarchyRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> CallHierarchyRegistrationOptions& { + return *this; +} + +auto CallHierarchyRegistrationOptions::id(std::optional id) + -> CallHierarchyRegistrationOptions& { + return *this; +} + +CallHierarchyIncomingCallsParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("item")) return false; + return true; +} + +auto CallHierarchyIncomingCallsParams::item() const -> CallHierarchyItem { + const auto& value = repr_["item"]; + + return CallHierarchyItem(value); +} + +auto CallHierarchyIncomingCallsParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto CallHierarchyIncomingCallsParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto CallHierarchyIncomingCallsParams::item(CallHierarchyItem item) + -> CallHierarchyIncomingCallsParams& { + return *this; +} + +auto CallHierarchyIncomingCallsParams::workDoneToken( + std::optional workDoneToken) + -> CallHierarchyIncomingCallsParams& { + return *this; +} + +auto CallHierarchyIncomingCallsParams::partialResultToken( + std::optional partialResultToken) + -> CallHierarchyIncomingCallsParams& { + return *this; +} + +CallHierarchyIncomingCall::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("from")) return false; + if (!repr_.contains("fromRanges")) return false; + return true; +} + +auto CallHierarchyIncomingCall::from() const -> CallHierarchyItem { + const auto& value = repr_["from"]; + + return CallHierarchyItem(value); +} + +auto CallHierarchyIncomingCall::fromRanges() const -> Vector { + const auto& value = repr_["fromRanges"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CallHierarchyIncomingCall::from(CallHierarchyItem from) + -> CallHierarchyIncomingCall& { + return *this; +} + +auto CallHierarchyIncomingCall::fromRanges(Vector fromRanges) + -> CallHierarchyIncomingCall& { + return *this; +} + +CallHierarchyOutgoingCallsParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("item")) return false; + return true; +} + +auto CallHierarchyOutgoingCallsParams::item() const -> CallHierarchyItem { + const auto& value = repr_["item"]; + + return CallHierarchyItem(value); +} + +auto CallHierarchyOutgoingCallsParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto CallHierarchyOutgoingCallsParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto CallHierarchyOutgoingCallsParams::item(CallHierarchyItem item) + -> CallHierarchyOutgoingCallsParams& { + return *this; +} + +auto CallHierarchyOutgoingCallsParams::workDoneToken( + std::optional workDoneToken) + -> CallHierarchyOutgoingCallsParams& { + return *this; +} + +auto CallHierarchyOutgoingCallsParams::partialResultToken( + std::optional partialResultToken) + -> CallHierarchyOutgoingCallsParams& { + return *this; +} + +CallHierarchyOutgoingCall::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("to")) return false; + if (!repr_.contains("fromRanges")) return false; + return true; +} + +auto CallHierarchyOutgoingCall::to() const -> CallHierarchyItem { + const auto& value = repr_["to"]; + + return CallHierarchyItem(value); +} + +auto CallHierarchyOutgoingCall::fromRanges() const -> Vector { + const auto& value = repr_["fromRanges"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CallHierarchyOutgoingCall::to(CallHierarchyItem to) + -> CallHierarchyOutgoingCall& { + return *this; +} + +auto CallHierarchyOutgoingCall::fromRanges(Vector fromRanges) + -> CallHierarchyOutgoingCall& { + return *this; +} + +SemanticTokensParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + return true; +} + +auto SemanticTokensParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto SemanticTokensParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto SemanticTokensParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto SemanticTokensParams::textDocument(TextDocumentIdentifier textDocument) + -> SemanticTokensParams& { + return *this; +} + +auto SemanticTokensParams::workDoneToken( + std::optional workDoneToken) -> SemanticTokensParams& { + return *this; +} + +auto SemanticTokensParams::partialResultToken( + std::optional partialResultToken) -> SemanticTokensParams& { + return *this; +} + +SemanticTokens::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("data")) return false; + return true; +} + +auto SemanticTokens::resultId() const -> std::optional { + if (!repr_.contains("resultId")) return std::nullopt; + + const auto& value = repr_["resultId"]; + + assert(value.is_string()); + return value.get(); +} + +auto SemanticTokens::data() const -> Vector { + const auto& value = repr_["data"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SemanticTokens::resultId(std::optional resultId) + -> SemanticTokens& { + return *this; +} + +auto SemanticTokens::data(Vector data) -> SemanticTokens& { + return *this; +} + +SemanticTokensPartialResult::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("data")) return false; + return true; +} + +auto SemanticTokensPartialResult::data() const -> Vector { + const auto& value = repr_["data"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SemanticTokensPartialResult::data(Vector data) + -> SemanticTokensPartialResult& { + return *this; +} + +SemanticTokensRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + if (!repr_.contains("legend")) return false; + return true; +} + +auto SemanticTokensRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto SemanticTokensRegistrationOptions::legend() const -> SemanticTokensLegend { + const auto& value = repr_["legend"]; + + return SemanticTokensLegend(value); +} + +auto SemanticTokensRegistrationOptions::range() const + -> std::optional> { + if (!repr_.contains("range")) return std::nullopt; + + const auto& value = repr_["range"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto SemanticTokensRegistrationOptions::full() const -> std::optional< + std::variant> { + if (!repr_.contains("full")) return std::nullopt; + + const auto& value = repr_["full"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto SemanticTokensRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SemanticTokensRegistrationOptions::id() const + -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto SemanticTokensRegistrationOptions::documentSelector( + std::variant + documentSelector) -> SemanticTokensRegistrationOptions& { + return *this; +} + +auto SemanticTokensRegistrationOptions::legend(SemanticTokensLegend legend) + -> SemanticTokensRegistrationOptions& { + return *this; +} + +auto SemanticTokensRegistrationOptions::range( + std::optional> range) + -> SemanticTokensRegistrationOptions& { + return *this; +} + +auto SemanticTokensRegistrationOptions::full( + std::optional> + full) -> SemanticTokensRegistrationOptions& { + return *this; +} + +auto SemanticTokensRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> SemanticTokensRegistrationOptions& { + return *this; +} + +auto SemanticTokensRegistrationOptions::id(std::optional id) + -> SemanticTokensRegistrationOptions& { + return *this; +} + +SemanticTokensDeltaParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("previousResultId")) return false; + return true; +} + +auto SemanticTokensDeltaParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto SemanticTokensDeltaParams::previousResultId() const -> std::string { + const auto& value = repr_["previousResultId"]; + + assert(value.is_string()); + return value.get(); +} + +auto SemanticTokensDeltaParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto SemanticTokensDeltaParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto SemanticTokensDeltaParams::textDocument( + TextDocumentIdentifier textDocument) -> SemanticTokensDeltaParams& { + return *this; +} + +auto SemanticTokensDeltaParams::previousResultId(std::string previousResultId) + -> SemanticTokensDeltaParams& { + return *this; +} + +auto SemanticTokensDeltaParams::workDoneToken( + std::optional workDoneToken) -> SemanticTokensDeltaParams& { + return *this; +} + +auto SemanticTokensDeltaParams::partialResultToken( + std::optional partialResultToken) + -> SemanticTokensDeltaParams& { + return *this; +} + +SemanticTokensDelta::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("edits")) return false; + return true; +} + +auto SemanticTokensDelta::resultId() const -> std::optional { + if (!repr_.contains("resultId")) return std::nullopt; + + const auto& value = repr_["resultId"]; + + assert(value.is_string()); + return value.get(); +} + +auto SemanticTokensDelta::edits() const -> Vector { + const auto& value = repr_["edits"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SemanticTokensDelta::resultId(std::optional resultId) + -> SemanticTokensDelta& { + return *this; +} + +auto SemanticTokensDelta::edits(Vector edits) + -> SemanticTokensDelta& { + return *this; +} + +SemanticTokensDeltaPartialResult::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("edits")) return false; + return true; +} + +auto SemanticTokensDeltaPartialResult::edits() const + -> Vector { + const auto& value = repr_["edits"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SemanticTokensDeltaPartialResult::edits(Vector edits) + -> SemanticTokensDeltaPartialResult& { + return *this; +} + +SemanticTokensRangeParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("range")) return false; + return true; +} + +auto SemanticTokensRangeParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto SemanticTokensRangeParams::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto SemanticTokensRangeParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto SemanticTokensRangeParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto SemanticTokensRangeParams::textDocument( + TextDocumentIdentifier textDocument) -> SemanticTokensRangeParams& { + return *this; +} + +auto SemanticTokensRangeParams::range(Range range) + -> SemanticTokensRangeParams& { + return *this; +} + +auto SemanticTokensRangeParams::workDoneToken( + std::optional workDoneToken) -> SemanticTokensRangeParams& { + return *this; +} + +auto SemanticTokensRangeParams::partialResultToken( + std::optional partialResultToken) + -> SemanticTokensRangeParams& { + return *this; +} + +ShowDocumentParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto ShowDocumentParams::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto ShowDocumentParams::external() const -> std::optional { + if (!repr_.contains("external")) return std::nullopt; + + const auto& value = repr_["external"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ShowDocumentParams::takeFocus() const -> std::optional { + if (!repr_.contains("takeFocus")) return std::nullopt; + + const auto& value = repr_["takeFocus"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ShowDocumentParams::selection() const -> std::optional { + if (!repr_.contains("selection")) return std::nullopt; + + const auto& value = repr_["selection"]; + + return Range(value); +} + +auto ShowDocumentParams::uri(std::string uri) -> ShowDocumentParams& { + return *this; +} + +auto ShowDocumentParams::external(std::optional external) + -> ShowDocumentParams& { + return *this; +} + +auto ShowDocumentParams::takeFocus(std::optional takeFocus) + -> ShowDocumentParams& { + return *this; +} + +auto ShowDocumentParams::selection(std::optional selection) + -> ShowDocumentParams& { + return *this; +} + +ShowDocumentResult::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("success")) return false; + return true; +} + +auto ShowDocumentResult::success() const -> bool { + const auto& value = repr_["success"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ShowDocumentResult::success(bool success) -> ShowDocumentResult& { + return *this; +} + +LinkedEditingRangeParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto LinkedEditingRangeParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto LinkedEditingRangeParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto LinkedEditingRangeParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto LinkedEditingRangeParams::textDocument(TextDocumentIdentifier textDocument) + -> LinkedEditingRangeParams& { + return *this; +} + +auto LinkedEditingRangeParams::position(Position position) + -> LinkedEditingRangeParams& { + return *this; +} + +auto LinkedEditingRangeParams::workDoneToken( + std::optional workDoneToken) -> LinkedEditingRangeParams& { + return *this; +} + +LinkedEditingRanges::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("ranges")) return false; + return true; +} + +auto LinkedEditingRanges::ranges() const -> Vector { + const auto& value = repr_["ranges"]; + + assert(value.is_array()); + return Vector(value); +} + +auto LinkedEditingRanges::wordPattern() const -> std::optional { + if (!repr_.contains("wordPattern")) return std::nullopt; + + const auto& value = repr_["wordPattern"]; + + assert(value.is_string()); + return value.get(); +} + +auto LinkedEditingRanges::ranges(Vector ranges) -> LinkedEditingRanges& { + return *this; +} + +auto LinkedEditingRanges::wordPattern(std::optional wordPattern) + -> LinkedEditingRanges& { + return *this; +} + +LinkedEditingRangeRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto LinkedEditingRangeRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto LinkedEditingRangeRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto LinkedEditingRangeRegistrationOptions::id() const + -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto LinkedEditingRangeRegistrationOptions::documentSelector( + std::variant + documentSelector) -> LinkedEditingRangeRegistrationOptions& { + return *this; +} + +auto LinkedEditingRangeRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> LinkedEditingRangeRegistrationOptions& { + return *this; +} + +auto LinkedEditingRangeRegistrationOptions::id(std::optional id) + -> LinkedEditingRangeRegistrationOptions& { + return *this; +} + +CreateFilesParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("files")) return false; + return true; +} + +auto CreateFilesParams::files() const -> Vector { + const auto& value = repr_["files"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CreateFilesParams::files(Vector files) -> CreateFilesParams& { + return *this; +} + +WorkspaceEdit::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkspaceEdit::changes() const + -> std::optional>> { + if (!repr_.contains("changes")) return std::nullopt; + + const auto& value = repr_["changes"]; + + assert(value.is_object()); + return Map>(value); +} + +auto WorkspaceEdit::documentChanges() const + -> std::optional>> { + if (!repr_.contains("documentChanges")) return std::nullopt; + + const auto& value = repr_["documentChanges"]; + + assert(value.is_array()); + return Vector>(value); +} + +auto WorkspaceEdit::changeAnnotations() const + -> std::optional> { + if (!repr_.contains("changeAnnotations")) return std::nullopt; + + const auto& value = repr_["changeAnnotations"]; + + assert(value.is_object()); + return Map(value); +} + +auto WorkspaceEdit::changes( + std::optional>> changes) + -> WorkspaceEdit& { + return *this; +} + +auto WorkspaceEdit::documentChanges( + std::optional>> + documentChanges) -> WorkspaceEdit& { + return *this; +} + +auto WorkspaceEdit::changeAnnotations( + std::optional> + changeAnnotations) -> WorkspaceEdit& { + return *this; +} + +FileOperationRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("filters")) return false; + return true; +} + +auto FileOperationRegistrationOptions::filters() const + -> Vector { + const auto& value = repr_["filters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto FileOperationRegistrationOptions::filters( + Vector filters) -> FileOperationRegistrationOptions& { + return *this; +} + +RenameFilesParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("files")) return false; + return true; +} + +auto RenameFilesParams::files() const -> Vector { + const auto& value = repr_["files"]; + + assert(value.is_array()); + return Vector(value); +} + +auto RenameFilesParams::files(Vector files) -> RenameFilesParams& { + return *this; +} + +DeleteFilesParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("files")) return false; + return true; +} + +auto DeleteFilesParams::files() const -> Vector { + const auto& value = repr_["files"]; + + assert(value.is_array()); + return Vector(value); +} + +auto DeleteFilesParams::files(Vector files) -> DeleteFilesParams& { + return *this; +} + +MonikerParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto MonikerParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto MonikerParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto MonikerParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto MonikerParams::partialResultToken() const -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto MonikerParams::textDocument(TextDocumentIdentifier textDocument) + -> MonikerParams& { + return *this; +} + +auto MonikerParams::position(Position position) -> MonikerParams& { + return *this; +} + +auto MonikerParams::workDoneToken(std::optional workDoneToken) + -> MonikerParams& { + return *this; +} + +auto MonikerParams::partialResultToken( + std::optional partialResultToken) -> MonikerParams& { + return *this; +} + +Moniker::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("scheme")) return false; + if (!repr_.contains("identifier")) return false; + if (!repr_.contains("unique")) return false; + return true; +} + +auto Moniker::scheme() const -> std::string { + const auto& value = repr_["scheme"]; + + assert(value.is_string()); + return value.get(); +} + +auto Moniker::identifier() const -> std::string { + const auto& value = repr_["identifier"]; + + assert(value.is_string()); + return value.get(); +} + +auto Moniker::unique() const -> UniquenessLevel { + const auto& value = repr_["unique"]; + + lsp_runtime_error("Moniker::unique: not implement yet"); +} + +auto Moniker::kind() const -> std::optional { + if (!repr_.contains("kind")) return std::nullopt; + + const auto& value = repr_["kind"]; + + lsp_runtime_error("Moniker::kind: not implement yet"); +} + +auto Moniker::scheme(std::string scheme) -> Moniker& { return *this; } + +auto Moniker::identifier(std::string identifier) -> Moniker& { return *this; } + +auto Moniker::unique(UniquenessLevel unique) -> Moniker& { return *this; } + +auto Moniker::kind(std::optional kind) -> Moniker& { + return *this; +} + +MonikerRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto MonikerRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto MonikerRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto MonikerRegistrationOptions::documentSelector( + std::variant + documentSelector) -> MonikerRegistrationOptions& { + return *this; +} + +auto MonikerRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> MonikerRegistrationOptions& { + return *this; +} + +TypeHierarchyPrepareParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto TypeHierarchyPrepareParams::textDocument() const + -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto TypeHierarchyPrepareParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto TypeHierarchyPrepareParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto TypeHierarchyPrepareParams::textDocument( + TextDocumentIdentifier textDocument) -> TypeHierarchyPrepareParams& { + return *this; +} + +auto TypeHierarchyPrepareParams::position(Position position) + -> TypeHierarchyPrepareParams& { + return *this; +} + +auto TypeHierarchyPrepareParams::workDoneToken( + std::optional workDoneToken) -> TypeHierarchyPrepareParams& { + return *this; +} + +TypeHierarchyItem::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("name")) return false; + if (!repr_.contains("kind")) return false; + if (!repr_.contains("uri")) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("selectionRange")) return false; + return true; +} + +auto TypeHierarchyItem::name() const -> std::string { + const auto& value = repr_["name"]; + + assert(value.is_string()); + return value.get(); +} + +auto TypeHierarchyItem::kind() const -> SymbolKind { + const auto& value = repr_["kind"]; + + return SymbolKind(value); +} + +auto TypeHierarchyItem::tags() const -> std::optional> { + if (!repr_.contains("tags")) return std::nullopt; + + const auto& value = repr_["tags"]; + + assert(value.is_array()); + return Vector(value); +} + +auto TypeHierarchyItem::detail() const -> std::optional { + if (!repr_.contains("detail")) return std::nullopt; + + const auto& value = repr_["detail"]; + + assert(value.is_string()); + return value.get(); +} + +auto TypeHierarchyItem::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto TypeHierarchyItem::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto TypeHierarchyItem::selectionRange() const -> Range { + const auto& value = repr_["selectionRange"]; + + return Range(value); +} + +auto TypeHierarchyItem::data() const -> std::optional { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto TypeHierarchyItem::name(std::string name) -> TypeHierarchyItem& { + return *this; +} + +auto TypeHierarchyItem::kind(SymbolKind kind) -> TypeHierarchyItem& { + return *this; +} + +auto TypeHierarchyItem::tags(std::optional> tags) + -> TypeHierarchyItem& { + return *this; +} + +auto TypeHierarchyItem::detail(std::optional detail) + -> TypeHierarchyItem& { + return *this; +} + +auto TypeHierarchyItem::uri(std::string uri) -> TypeHierarchyItem& { + return *this; +} + +auto TypeHierarchyItem::range(Range range) -> TypeHierarchyItem& { + return *this; +} + +auto TypeHierarchyItem::selectionRange(Range selectionRange) + -> TypeHierarchyItem& { + return *this; +} + +auto TypeHierarchyItem::data(std::optional data) -> TypeHierarchyItem& { + return *this; +} + +TypeHierarchyRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto TypeHierarchyRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto TypeHierarchyRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TypeHierarchyRegistrationOptions::id() const + -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto TypeHierarchyRegistrationOptions::documentSelector( + std::variant + documentSelector) -> TypeHierarchyRegistrationOptions& { + return *this; +} + +auto TypeHierarchyRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> TypeHierarchyRegistrationOptions& { + return *this; +} + +auto TypeHierarchyRegistrationOptions::id(std::optional id) + -> TypeHierarchyRegistrationOptions& { + return *this; +} + +TypeHierarchySupertypesParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("item")) return false; + return true; +} + +auto TypeHierarchySupertypesParams::item() const -> TypeHierarchyItem { + const auto& value = repr_["item"]; + + return TypeHierarchyItem(value); +} + +auto TypeHierarchySupertypesParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto TypeHierarchySupertypesParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto TypeHierarchySupertypesParams::item(TypeHierarchyItem item) + -> TypeHierarchySupertypesParams& { + return *this; +} + +auto TypeHierarchySupertypesParams::workDoneToken( + std::optional workDoneToken) + -> TypeHierarchySupertypesParams& { + return *this; +} + +auto TypeHierarchySupertypesParams::partialResultToken( + std::optional partialResultToken) + -> TypeHierarchySupertypesParams& { + return *this; +} + +TypeHierarchySubtypesParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("item")) return false; + return true; +} + +auto TypeHierarchySubtypesParams::item() const -> TypeHierarchyItem { + const auto& value = repr_["item"]; + + return TypeHierarchyItem(value); +} + +auto TypeHierarchySubtypesParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto TypeHierarchySubtypesParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto TypeHierarchySubtypesParams::item(TypeHierarchyItem item) + -> TypeHierarchySubtypesParams& { + return *this; +} + +auto TypeHierarchySubtypesParams::workDoneToken( + std::optional workDoneToken) + -> TypeHierarchySubtypesParams& { + return *this; +} + +auto TypeHierarchySubtypesParams::partialResultToken( + std::optional partialResultToken) + -> TypeHierarchySubtypesParams& { + return *this; +} + +InlineValueParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("context")) return false; + return true; +} + +auto InlineValueParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto InlineValueParams::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto InlineValueParams::context() const -> InlineValueContext { + const auto& value = repr_["context"]; + + return InlineValueContext(value); +} + +auto InlineValueParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto InlineValueParams::textDocument(TextDocumentIdentifier textDocument) + -> InlineValueParams& { + return *this; +} + +auto InlineValueParams::range(Range range) -> InlineValueParams& { + return *this; +} + +auto InlineValueParams::context(InlineValueContext context) + -> InlineValueParams& { + return *this; +} + +auto InlineValueParams::workDoneToken( + std::optional workDoneToken) -> InlineValueParams& { + return *this; +} + +InlineValueRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto InlineValueRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlineValueRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto InlineValueRegistrationOptions::id() const -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto InlineValueRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> InlineValueRegistrationOptions& { + return *this; +} + +auto InlineValueRegistrationOptions::documentSelector( + std::variant + documentSelector) -> InlineValueRegistrationOptions& { + return *this; +} + +auto InlineValueRegistrationOptions::id(std::optional id) + -> InlineValueRegistrationOptions& { + return *this; +} + +InlayHintParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("range")) return false; + return true; +} + +auto InlayHintParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto InlayHintParams::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto InlayHintParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto InlayHintParams::textDocument(TextDocumentIdentifier textDocument) + -> InlayHintParams& { + return *this; +} + +auto InlayHintParams::range(Range range) -> InlayHintParams& { return *this; } + +auto InlayHintParams::workDoneToken(std::optional workDoneToken) + -> InlayHintParams& { + return *this; +} + +InlayHint::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("position")) return false; + if (!repr_.contains("label")) return false; + return true; +} + +auto InlayHint::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto InlayHint::label() const + -> std::variant> { + const auto& value = repr_["label"]; + + std::variant> result; + + details::try_emplace(result, value); + + return result; +} + +auto InlayHint::kind() const -> std::optional { + if (!repr_.contains("kind")) return std::nullopt; + + const auto& value = repr_["kind"]; + + return InlayHintKind(value); +} + +auto InlayHint::textEdits() const -> std::optional> { + if (!repr_.contains("textEdits")) return std::nullopt; + + const auto& value = repr_["textEdits"]; + + assert(value.is_array()); + return Vector(value); +} + +auto InlayHint::tooltip() const + -> std::optional> { + if (!repr_.contains("tooltip")) return std::nullopt; + + const auto& value = repr_["tooltip"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto InlayHint::paddingLeft() const -> std::optional { + if (!repr_.contains("paddingLeft")) return std::nullopt; + + const auto& value = repr_["paddingLeft"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlayHint::paddingRight() const -> std::optional { + if (!repr_.contains("paddingRight")) return std::nullopt; + + const auto& value = repr_["paddingRight"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlayHint::data() const -> std::optional { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto InlayHint::position(Position position) -> InlayHint& { return *this; } + +auto InlayHint::label( + std::variant> label) + -> InlayHint& { + return *this; +} + +auto InlayHint::kind(std::optional kind) -> InlayHint& { + return *this; +} + +auto InlayHint::textEdits(std::optional> textEdits) + -> InlayHint& { + return *this; +} + +auto InlayHint::tooltip( + std::optional> + tooltip) -> InlayHint& { + return *this; +} + +auto InlayHint::paddingLeft(std::optional paddingLeft) -> InlayHint& { + return *this; +} + +auto InlayHint::paddingRight(std::optional paddingRight) -> InlayHint& { + return *this; +} + +auto InlayHint::data(std::optional data) -> InlayHint& { return *this; } + +InlayHintRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto InlayHintRegistrationOptions::resolveProvider() const + -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlayHintRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlayHintRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto InlayHintRegistrationOptions::id() const -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto InlayHintRegistrationOptions::resolveProvider( + std::optional resolveProvider) -> InlayHintRegistrationOptions& { + return *this; +} + +auto InlayHintRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> InlayHintRegistrationOptions& { + return *this; +} + +auto InlayHintRegistrationOptions::documentSelector( + std::variant + documentSelector) -> InlayHintRegistrationOptions& { + return *this; +} + +auto InlayHintRegistrationOptions::id(std::optional id) + -> InlayHintRegistrationOptions& { + return *this; +} + +DocumentDiagnosticParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + return true; +} + +auto DocumentDiagnosticParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DocumentDiagnosticParams::identifier() const + -> std::optional { + if (!repr_.contains("identifier")) return std::nullopt; + + const auto& value = repr_["identifier"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentDiagnosticParams::previousResultId() const + -> std::optional { + if (!repr_.contains("previousResultId")) return std::nullopt; + + const auto& value = repr_["previousResultId"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentDiagnosticParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentDiagnosticParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentDiagnosticParams::textDocument(TextDocumentIdentifier textDocument) + -> DocumentDiagnosticParams& { + return *this; +} + +auto DocumentDiagnosticParams::identifier(std::optional identifier) + -> DocumentDiagnosticParams& { + return *this; +} + +auto DocumentDiagnosticParams::previousResultId( + std::optional previousResultId) -> DocumentDiagnosticParams& { + return *this; +} + +auto DocumentDiagnosticParams::workDoneToken( + std::optional workDoneToken) -> DocumentDiagnosticParams& { + return *this; +} + +auto DocumentDiagnosticParams::partialResultToken( + std::optional partialResultToken) + -> DocumentDiagnosticParams& { + return *this; +} + +DocumentDiagnosticReportPartialResult::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("relatedDocuments")) return false; + return true; +} + +auto DocumentDiagnosticReportPartialResult::relatedDocuments() const + -> Map> { + const auto& value = repr_["relatedDocuments"]; + + assert(value.is_object()); + return Map>(value); +} + +auto DocumentDiagnosticReportPartialResult::relatedDocuments( + Map> + relatedDocuments) -> DocumentDiagnosticReportPartialResult& { + return *this; +} + +DiagnosticServerCancellationData::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("retriggerRequest")) return false; + return true; +} + +auto DiagnosticServerCancellationData::retriggerRequest() const -> bool { + const auto& value = repr_["retriggerRequest"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticServerCancellationData::retriggerRequest(bool retriggerRequest) + -> DiagnosticServerCancellationData& { + return *this; +} + +DiagnosticRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + if (!repr_.contains("interFileDependencies")) return false; + if (!repr_.contains("workspaceDiagnostics")) return false; + return true; +} + +auto DiagnosticRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto DiagnosticRegistrationOptions::identifier() const + -> std::optional { + if (!repr_.contains("identifier")) return std::nullopt; + + const auto& value = repr_["identifier"]; + + assert(value.is_string()); + return value.get(); +} + +auto DiagnosticRegistrationOptions::interFileDependencies() const -> bool { + const auto& value = repr_["interFileDependencies"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticRegistrationOptions::workspaceDiagnostics() const -> bool { + const auto& value = repr_["workspaceDiagnostics"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticRegistrationOptions::id() const -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto DiagnosticRegistrationOptions::documentSelector( + std::variant + documentSelector) -> DiagnosticRegistrationOptions& { + return *this; +} + +auto DiagnosticRegistrationOptions::identifier( + std::optional identifier) -> DiagnosticRegistrationOptions& { + return *this; +} + +auto DiagnosticRegistrationOptions::interFileDependencies( + bool interFileDependencies) -> DiagnosticRegistrationOptions& { + return *this; +} + +auto DiagnosticRegistrationOptions::workspaceDiagnostics( + bool workspaceDiagnostics) -> DiagnosticRegistrationOptions& { + return *this; +} + +auto DiagnosticRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> DiagnosticRegistrationOptions& { + return *this; +} + +auto DiagnosticRegistrationOptions::id(std::optional id) + -> DiagnosticRegistrationOptions& { + return *this; +} + +WorkspaceDiagnosticParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("previousResultIds")) return false; + return true; +} + +auto WorkspaceDiagnosticParams::identifier() const + -> std::optional { + if (!repr_.contains("identifier")) return std::nullopt; + + const auto& value = repr_["identifier"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceDiagnosticParams::previousResultIds() const + -> Vector { + const auto& value = repr_["previousResultIds"]; + + assert(value.is_array()); + return Vector(value); +} + +auto WorkspaceDiagnosticParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkspaceDiagnosticParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkspaceDiagnosticParams::identifier( + std::optional identifier) -> WorkspaceDiagnosticParams& { + return *this; +} + +auto WorkspaceDiagnosticParams::previousResultIds( + Vector previousResultIds) -> WorkspaceDiagnosticParams& { + return *this; +} + +auto WorkspaceDiagnosticParams::workDoneToken( + std::optional workDoneToken) -> WorkspaceDiagnosticParams& { + return *this; +} + +auto WorkspaceDiagnosticParams::partialResultToken( + std::optional partialResultToken) + -> WorkspaceDiagnosticParams& { + return *this; +} + +WorkspaceDiagnosticReport::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("items")) return false; + return true; +} + +auto WorkspaceDiagnosticReport::items() const + -> Vector { + const auto& value = repr_["items"]; + + assert(value.is_array()); + return Vector(value); +} + +auto WorkspaceDiagnosticReport::items( + Vector items) + -> WorkspaceDiagnosticReport& { + return *this; +} + +WorkspaceDiagnosticReportPartialResult::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("items")) return false; + return true; +} + +auto WorkspaceDiagnosticReportPartialResult::items() const + -> Vector { + const auto& value = repr_["items"]; + + assert(value.is_array()); + return Vector(value); +} + +auto WorkspaceDiagnosticReportPartialResult::items( + Vector items) + -> WorkspaceDiagnosticReportPartialResult& { + return *this; +} + +DidOpenNotebookDocumentParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("notebookDocument")) return false; + if (!repr_.contains("cellTextDocuments")) return false; + return true; +} + +auto DidOpenNotebookDocumentParams::notebookDocument() const + -> NotebookDocument { + const auto& value = repr_["notebookDocument"]; + + return NotebookDocument(value); +} + +auto DidOpenNotebookDocumentParams::cellTextDocuments() const + -> Vector { + const auto& value = repr_["cellTextDocuments"]; + + assert(value.is_array()); + return Vector(value); +} + +auto DidOpenNotebookDocumentParams::notebookDocument( + NotebookDocument notebookDocument) -> DidOpenNotebookDocumentParams& { + return *this; +} + +auto DidOpenNotebookDocumentParams::cellTextDocuments( + Vector cellTextDocuments) + -> DidOpenNotebookDocumentParams& { + return *this; +} + +NotebookDocumentSyncRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("notebookSelector")) return false; + return true; +} + +auto NotebookDocumentSyncRegistrationOptions::notebookSelector() const + -> Vector> { + const auto& value = repr_["notebookSelector"]; + + assert(value.is_array()); + return Vector>(value); +} + +auto NotebookDocumentSyncRegistrationOptions::save() const + -> std::optional { + if (!repr_.contains("save")) return std::nullopt; + + const auto& value = repr_["save"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto NotebookDocumentSyncRegistrationOptions::id() const + -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookDocumentSyncRegistrationOptions::notebookSelector( + Vector> + notebookSelector) -> NotebookDocumentSyncRegistrationOptions& { + return *this; +} + +auto NotebookDocumentSyncRegistrationOptions::save(std::optional save) + -> NotebookDocumentSyncRegistrationOptions& { + return *this; +} + +auto NotebookDocumentSyncRegistrationOptions::id(std::optional id) + -> NotebookDocumentSyncRegistrationOptions& { + return *this; +} + +DidChangeNotebookDocumentParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("notebookDocument")) return false; + if (!repr_.contains("change")) return false; + return true; +} + +auto DidChangeNotebookDocumentParams::notebookDocument() const + -> VersionedNotebookDocumentIdentifier { + const auto& value = repr_["notebookDocument"]; + + return VersionedNotebookDocumentIdentifier(value); +} + +auto DidChangeNotebookDocumentParams::change() const + -> NotebookDocumentChangeEvent { + const auto& value = repr_["change"]; + + return NotebookDocumentChangeEvent(value); +} + +auto DidChangeNotebookDocumentParams::notebookDocument( + VersionedNotebookDocumentIdentifier notebookDocument) + -> DidChangeNotebookDocumentParams& { + return *this; +} + +auto DidChangeNotebookDocumentParams::change(NotebookDocumentChangeEvent change) + -> DidChangeNotebookDocumentParams& { + return *this; +} + +DidSaveNotebookDocumentParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("notebookDocument")) return false; + return true; +} + +auto DidSaveNotebookDocumentParams::notebookDocument() const + -> NotebookDocumentIdentifier { + const auto& value = repr_["notebookDocument"]; + + return NotebookDocumentIdentifier(value); +} + +auto DidSaveNotebookDocumentParams::notebookDocument( + NotebookDocumentIdentifier notebookDocument) + -> DidSaveNotebookDocumentParams& { + return *this; +} + +DidCloseNotebookDocumentParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("notebookDocument")) return false; + if (!repr_.contains("cellTextDocuments")) return false; + return true; +} + +auto DidCloseNotebookDocumentParams::notebookDocument() const + -> NotebookDocumentIdentifier { + const auto& value = repr_["notebookDocument"]; + + return NotebookDocumentIdentifier(value); +} + +auto DidCloseNotebookDocumentParams::cellTextDocuments() const + -> Vector { + const auto& value = repr_["cellTextDocuments"]; + + assert(value.is_array()); + return Vector(value); +} + +auto DidCloseNotebookDocumentParams::notebookDocument( + NotebookDocumentIdentifier notebookDocument) + -> DidCloseNotebookDocumentParams& { + return *this; +} + +auto DidCloseNotebookDocumentParams::cellTextDocuments( + Vector cellTextDocuments) + -> DidCloseNotebookDocumentParams& { + return *this; +} + +InlineCompletionParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("context")) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto InlineCompletionParams::context() const -> InlineCompletionContext { + const auto& value = repr_["context"]; + + return InlineCompletionContext(value); +} + +auto InlineCompletionParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto InlineCompletionParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto InlineCompletionParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto InlineCompletionParams::context(InlineCompletionContext context) + -> InlineCompletionParams& { + return *this; +} + +auto InlineCompletionParams::textDocument(TextDocumentIdentifier textDocument) + -> InlineCompletionParams& { + return *this; +} + +auto InlineCompletionParams::position(Position position) + -> InlineCompletionParams& { + return *this; +} + +auto InlineCompletionParams::workDoneToken( + std::optional workDoneToken) -> InlineCompletionParams& { + return *this; +} + +InlineCompletionList::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("items")) return false; + return true; +} + +auto InlineCompletionList::items() const -> Vector { + const auto& value = repr_["items"]; + + assert(value.is_array()); + return Vector(value); +} + +auto InlineCompletionList::items(Vector items) + -> InlineCompletionList& { + return *this; +} + +InlineCompletionItem::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("insertText")) return false; + return true; +} + +auto InlineCompletionItem::insertText() const + -> std::variant { + const auto& value = repr_["insertText"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto InlineCompletionItem::filterText() const -> std::optional { + if (!repr_.contains("filterText")) return std::nullopt; + + const auto& value = repr_["filterText"]; + + assert(value.is_string()); + return value.get(); +} + +auto InlineCompletionItem::range() const -> std::optional { + if (!repr_.contains("range")) return std::nullopt; + + const auto& value = repr_["range"]; + + return Range(value); +} + +auto InlineCompletionItem::command() const -> std::optional { + if (!repr_.contains("command")) return std::nullopt; + + const auto& value = repr_["command"]; + + return Command(value); +} + +auto InlineCompletionItem::insertText( + std::variant insertText) + -> InlineCompletionItem& { + return *this; +} + +auto InlineCompletionItem::filterText(std::optional filterText) + -> InlineCompletionItem& { + return *this; +} + +auto InlineCompletionItem::range(std::optional range) + -> InlineCompletionItem& { + return *this; +} + +auto InlineCompletionItem::command(std::optional command) + -> InlineCompletionItem& { + return *this; +} + +InlineCompletionRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto InlineCompletionRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlineCompletionRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto InlineCompletionRegistrationOptions::id() const + -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto InlineCompletionRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> InlineCompletionRegistrationOptions& { + return *this; +} + +auto InlineCompletionRegistrationOptions::documentSelector( + std::variant + documentSelector) -> InlineCompletionRegistrationOptions& { + return *this; +} + +auto InlineCompletionRegistrationOptions::id(std::optional id) + -> InlineCompletionRegistrationOptions& { + return *this; +} + +TextDocumentContentParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto TextDocumentContentParams::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentContentParams::uri(std::string uri) + -> TextDocumentContentParams& { + return *this; +} + +TextDocumentContentResult::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("text")) return false; + return true; +} + +auto TextDocumentContentResult::text() const -> std::string { + const auto& value = repr_["text"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentContentResult::text(std::string text) + -> TextDocumentContentResult& { + return *this; +} + +TextDocumentContentRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("schemes")) return false; + return true; +} + +auto TextDocumentContentRegistrationOptions::schemes() const + -> Vector { + const auto& value = repr_["schemes"]; + + assert(value.is_array()); + return Vector(value); +} + +auto TextDocumentContentRegistrationOptions::id() const + -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentContentRegistrationOptions::schemes( + Vector schemes) -> TextDocumentContentRegistrationOptions& { + return *this; +} + +auto TextDocumentContentRegistrationOptions::id(std::optional id) + -> TextDocumentContentRegistrationOptions& { + return *this; +} + +TextDocumentContentRefreshParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto TextDocumentContentRefreshParams::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentContentRefreshParams::uri(std::string uri) + -> TextDocumentContentRefreshParams& { + return *this; +} + +RegistrationParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("registrations")) return false; + return true; +} + +auto RegistrationParams::registrations() const -> Vector { + const auto& value = repr_["registrations"]; + + assert(value.is_array()); + return Vector(value); +} + +auto RegistrationParams::registrations(Vector registrations) + -> RegistrationParams& { + return *this; +} + +UnregistrationParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("unregisterations")) return false; + return true; +} + +auto UnregistrationParams::unregisterations() const -> Vector { + const auto& value = repr_["unregisterations"]; + + assert(value.is_array()); + return Vector(value); +} + +auto UnregistrationParams::unregisterations( + Vector unregisterations) -> UnregistrationParams& { + return *this; +} + +InitializeParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("processId")) return false; + if (!repr_.contains("rootUri")) return false; + if (!repr_.contains("capabilities")) return false; + return true; +} + +auto InitializeParams::processId() const + -> std::variant { + const auto& value = repr_["processId"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto InitializeParams::clientInfo() const -> std::optional { + if (!repr_.contains("clientInfo")) return std::nullopt; + + const auto& value = repr_["clientInfo"]; + + return ClientInfo(value); +} + +auto InitializeParams::locale() const -> std::optional { + if (!repr_.contains("locale")) return std::nullopt; + + const auto& value = repr_["locale"]; + + assert(value.is_string()); + return value.get(); +} + +auto InitializeParams::rootPath() const -> std::optional< + std::variant> { + if (!repr_.contains("rootPath")) return std::nullopt; + + const auto& value = repr_["rootPath"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto InitializeParams::rootUri() const + -> std::variant { + const auto& value = repr_["rootUri"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto InitializeParams::capabilities() const -> ClientCapabilities { + const auto& value = repr_["capabilities"]; + + return ClientCapabilities(value); +} + +auto InitializeParams::initializationOptions() const -> std::optional { + if (!repr_.contains("initializationOptions")) return std::nullopt; + + const auto& value = repr_["initializationOptions"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto InitializeParams::trace() const -> std::optional { + if (!repr_.contains("trace")) return std::nullopt; + + const auto& value = repr_["trace"]; + + lsp_runtime_error("InitializeParams::trace: not implement yet"); +} + +auto InitializeParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto InitializeParams::workspaceFolders() const -> std::optional< + std::variant, std::nullptr_t>> { + if (!repr_.contains("workspaceFolders")) return std::nullopt; + + const auto& value = repr_["workspaceFolders"]; + + std::variant, std::nullptr_t> result; + + details::try_emplace(result, value); + + return result; +} + +auto InitializeParams::processId( + std::variant processId) + -> InitializeParams& { + return *this; +} + +auto InitializeParams::clientInfo(std::optional clientInfo) + -> InitializeParams& { + return *this; +} + +auto InitializeParams::locale(std::optional locale) + -> InitializeParams& { + return *this; +} + +auto InitializeParams::rootPath( + std::optional> + rootPath) -> InitializeParams& { + return *this; +} + +auto InitializeParams::rootUri( + std::variant rootUri) + -> InitializeParams& { + return *this; +} + +auto InitializeParams::capabilities(ClientCapabilities capabilities) + -> InitializeParams& { + return *this; +} + +auto InitializeParams::initializationOptions( + std::optional initializationOptions) -> InitializeParams& { + return *this; +} + +auto InitializeParams::trace(std::optional trace) + -> InitializeParams& { + return *this; +} + +auto InitializeParams::workDoneToken(std::optional workDoneToken) + -> InitializeParams& { + return *this; +} + +auto InitializeParams::workspaceFolders( + std::optional< + std::variant, std::nullptr_t>> + workspaceFolders) -> InitializeParams& { + return *this; +} + +InitializeResult::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("capabilities")) return false; + return true; +} + +auto InitializeResult::capabilities() const -> ServerCapabilities { + const auto& value = repr_["capabilities"]; + + return ServerCapabilities(value); +} + +auto InitializeResult::serverInfo() const -> std::optional { + if (!repr_.contains("serverInfo")) return std::nullopt; + + const auto& value = repr_["serverInfo"]; + + return ServerInfo(value); +} + +auto InitializeResult::capabilities(ServerCapabilities capabilities) + -> InitializeResult& { + return *this; +} + +auto InitializeResult::serverInfo(std::optional serverInfo) + -> InitializeResult& { + return *this; +} + +InitializeError::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("retry")) return false; + return true; +} + +auto InitializeError::retry() const -> bool { + const auto& value = repr_["retry"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InitializeError::retry(bool retry) -> InitializeError& { return *this; } + +InitializedParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +DidChangeConfigurationParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("settings")) return false; + return true; +} + +auto DidChangeConfigurationParams::settings() const -> LSPAny { + const auto& value = repr_["settings"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto DidChangeConfigurationParams::settings(LSPAny settings) + -> DidChangeConfigurationParams& { + return *this; +} + +DidChangeConfigurationRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DidChangeConfigurationRegistrationOptions::section() const + -> std::optional< + std::variant>> { + if (!repr_.contains("section")) return std::nullopt; + + const auto& value = repr_["section"]; + + std::variant> result; + + details::try_emplace(result, value); + + return result; +} + +auto DidChangeConfigurationRegistrationOptions::section( + std::optional< + std::variant>> + section) -> DidChangeConfigurationRegistrationOptions& { + return *this; +} + +ShowMessageParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("type")) return false; + if (!repr_.contains("message")) return false; + return true; +} + +auto ShowMessageParams::type() const -> MessageType { + const auto& value = repr_["type"]; + + return MessageType(value); +} + +auto ShowMessageParams::message() const -> std::string { + const auto& value = repr_["message"]; + + assert(value.is_string()); + return value.get(); +} + +auto ShowMessageParams::type(MessageType type) -> ShowMessageParams& { + return *this; +} + +auto ShowMessageParams::message(std::string message) -> ShowMessageParams& { + return *this; +} + +ShowMessageRequestParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("type")) return false; + if (!repr_.contains("message")) return false; + return true; +} + +auto ShowMessageRequestParams::type() const -> MessageType { + const auto& value = repr_["type"]; + + return MessageType(value); +} + +auto ShowMessageRequestParams::message() const -> std::string { + const auto& value = repr_["message"]; + + assert(value.is_string()); + return value.get(); +} + +auto ShowMessageRequestParams::actions() const + -> std::optional> { + if (!repr_.contains("actions")) return std::nullopt; + + const auto& value = repr_["actions"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ShowMessageRequestParams::type(MessageType type) + -> ShowMessageRequestParams& { + return *this; +} + +auto ShowMessageRequestParams::message(std::string message) + -> ShowMessageRequestParams& { + return *this; +} + +auto ShowMessageRequestParams::actions( + std::optional> actions) + -> ShowMessageRequestParams& { + return *this; +} + +MessageActionItem::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("title")) return false; + return true; +} + +auto MessageActionItem::title() const -> std::string { + const auto& value = repr_["title"]; + + assert(value.is_string()); + return value.get(); +} + +auto MessageActionItem::title(std::string title) -> MessageActionItem& { + return *this; +} + +LogMessageParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("type")) return false; + if (!repr_.contains("message")) return false; + return true; +} + +auto LogMessageParams::type() const -> MessageType { + const auto& value = repr_["type"]; + + return MessageType(value); +} + +auto LogMessageParams::message() const -> std::string { + const auto& value = repr_["message"]; + + assert(value.is_string()); + return value.get(); +} + +auto LogMessageParams::type(MessageType type) -> LogMessageParams& { + return *this; +} + +auto LogMessageParams::message(std::string message) -> LogMessageParams& { + return *this; +} + +DidOpenTextDocumentParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + return true; +} + +auto DidOpenTextDocumentParams::textDocument() const -> TextDocumentItem { + const auto& value = repr_["textDocument"]; + + return TextDocumentItem(value); +} + +auto DidOpenTextDocumentParams::textDocument(TextDocumentItem textDocument) + -> DidOpenTextDocumentParams& { + return *this; +} + +DidChangeTextDocumentParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("contentChanges")) return false; + return true; +} + +auto DidChangeTextDocumentParams::textDocument() const + -> VersionedTextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return VersionedTextDocumentIdentifier(value); +} + +auto DidChangeTextDocumentParams::contentChanges() const + -> Vector { + const auto& value = repr_["contentChanges"]; + + assert(value.is_array()); + return Vector(value); +} + +auto DidChangeTextDocumentParams::textDocument( + VersionedTextDocumentIdentifier textDocument) + -> DidChangeTextDocumentParams& { + return *this; +} + +auto DidChangeTextDocumentParams::contentChanges( + Vector contentChanges) + -> DidChangeTextDocumentParams& { + return *this; +} + +TextDocumentChangeRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("syncKind")) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto TextDocumentChangeRegistrationOptions::syncKind() const + -> TextDocumentSyncKind { + const auto& value = repr_["syncKind"]; + + return TextDocumentSyncKind(value); +} + +auto TextDocumentChangeRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto TextDocumentChangeRegistrationOptions::syncKind( + TextDocumentSyncKind syncKind) -> TextDocumentChangeRegistrationOptions& { + return *this; +} + +auto TextDocumentChangeRegistrationOptions::documentSelector( + std::variant + documentSelector) -> TextDocumentChangeRegistrationOptions& { + return *this; +} + +DidCloseTextDocumentParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + return true; +} + +auto DidCloseTextDocumentParams::textDocument() const + -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DidCloseTextDocumentParams::textDocument( + TextDocumentIdentifier textDocument) -> DidCloseTextDocumentParams& { + return *this; +} + +DidSaveTextDocumentParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + return true; +} + +auto DidSaveTextDocumentParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DidSaveTextDocumentParams::text() const -> std::optional { + if (!repr_.contains("text")) return std::nullopt; + + const auto& value = repr_["text"]; + + assert(value.is_string()); + return value.get(); +} + +auto DidSaveTextDocumentParams::textDocument( + TextDocumentIdentifier textDocument) -> DidSaveTextDocumentParams& { + return *this; +} + +auto DidSaveTextDocumentParams::text(std::optional text) + -> DidSaveTextDocumentParams& { + return *this; +} + +TextDocumentSaveRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto TextDocumentSaveRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto TextDocumentSaveRegistrationOptions::includeText() const + -> std::optional { + if (!repr_.contains("includeText")) return std::nullopt; + + const auto& value = repr_["includeText"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TextDocumentSaveRegistrationOptions::documentSelector( + std::variant + documentSelector) -> TextDocumentSaveRegistrationOptions& { + return *this; +} + +auto TextDocumentSaveRegistrationOptions::includeText( + std::optional includeText) -> TextDocumentSaveRegistrationOptions& { + return *this; +} + +WillSaveTextDocumentParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("reason")) return false; + return true; +} + +auto WillSaveTextDocumentParams::textDocument() const + -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto WillSaveTextDocumentParams::reason() const -> TextDocumentSaveReason { + const auto& value = repr_["reason"]; + + return TextDocumentSaveReason(value); +} + +auto WillSaveTextDocumentParams::textDocument( + TextDocumentIdentifier textDocument) -> WillSaveTextDocumentParams& { + return *this; +} + +auto WillSaveTextDocumentParams::reason(TextDocumentSaveReason reason) + -> WillSaveTextDocumentParams& { + return *this; +} + +TextEdit::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("newText")) return false; + return true; +} + +auto TextEdit::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto TextEdit::newText() const -> std::string { + const auto& value = repr_["newText"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextEdit::range(Range range) -> TextEdit& { return *this; } + +auto TextEdit::newText(std::string newText) -> TextEdit& { return *this; } + +DidChangeWatchedFilesParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("changes")) return false; + return true; +} + +auto DidChangeWatchedFilesParams::changes() const -> Vector { + const auto& value = repr_["changes"]; + + assert(value.is_array()); + return Vector(value); +} + +auto DidChangeWatchedFilesParams::changes(Vector changes) + -> DidChangeWatchedFilesParams& { + return *this; +} + +DidChangeWatchedFilesRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("watchers")) return false; + return true; +} + +auto DidChangeWatchedFilesRegistrationOptions::watchers() const + -> Vector { + const auto& value = repr_["watchers"]; + + assert(value.is_array()); + return Vector(value); +} + +auto DidChangeWatchedFilesRegistrationOptions::watchers( + Vector watchers) + -> DidChangeWatchedFilesRegistrationOptions& { + return *this; +} + +PublishDiagnosticsParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + if (!repr_.contains("diagnostics")) return false; + return true; +} + +auto PublishDiagnosticsParams::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto PublishDiagnosticsParams::version() const -> std::optional { + if (!repr_.contains("version")) return std::nullopt; + + const auto& value = repr_["version"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto PublishDiagnosticsParams::diagnostics() const -> Vector { + const auto& value = repr_["diagnostics"]; + + assert(value.is_array()); + return Vector(value); +} + +auto PublishDiagnosticsParams::uri(std::string uri) + -> PublishDiagnosticsParams& { + return *this; +} + +auto PublishDiagnosticsParams::version(std::optional version) + -> PublishDiagnosticsParams& { + return *this; +} + +auto PublishDiagnosticsParams::diagnostics(Vector diagnostics) + -> PublishDiagnosticsParams& { + return *this; +} + +CompletionParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto CompletionParams::context() const -> std::optional { + if (!repr_.contains("context")) return std::nullopt; + + const auto& value = repr_["context"]; + + return CompletionContext(value); +} + +auto CompletionParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto CompletionParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto CompletionParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto CompletionParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto CompletionParams::context(std::optional context) + -> CompletionParams& { + return *this; +} + +auto CompletionParams::textDocument(TextDocumentIdentifier textDocument) + -> CompletionParams& { + return *this; +} + +auto CompletionParams::position(Position position) -> CompletionParams& { + return *this; +} + +auto CompletionParams::workDoneToken(std::optional workDoneToken) + -> CompletionParams& { + return *this; +} + +auto CompletionParams::partialResultToken( + std::optional partialResultToken) -> CompletionParams& { + return *this; +} + +CompletionItem::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("label")) return false; + return true; +} + +auto CompletionItem::label() const -> std::string { + const auto& value = repr_["label"]; + + assert(value.is_string()); + return value.get(); +} + +auto CompletionItem::labelDetails() const + -> std::optional { + if (!repr_.contains("labelDetails")) return std::nullopt; + + const auto& value = repr_["labelDetails"]; + + return CompletionItemLabelDetails(value); +} + +auto CompletionItem::kind() const -> std::optional { + if (!repr_.contains("kind")) return std::nullopt; + + const auto& value = repr_["kind"]; + + return CompletionItemKind(value); +} + +auto CompletionItem::tags() const -> std::optional> { + if (!repr_.contains("tags")) return std::nullopt; + + const auto& value = repr_["tags"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CompletionItem::detail() const -> std::optional { + if (!repr_.contains("detail")) return std::nullopt; + + const auto& value = repr_["detail"]; + + assert(value.is_string()); + return value.get(); +} + +auto CompletionItem::documentation() const + -> std::optional> { + if (!repr_.contains("documentation")) return std::nullopt; + + const auto& value = repr_["documentation"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto CompletionItem::deprecated() const -> std::optional { + if (!repr_.contains("deprecated")) return std::nullopt; + + const auto& value = repr_["deprecated"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CompletionItem::preselect() const -> std::optional { + if (!repr_.contains("preselect")) return std::nullopt; + + const auto& value = repr_["preselect"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CompletionItem::sortText() const -> std::optional { + if (!repr_.contains("sortText")) return std::nullopt; + + const auto& value = repr_["sortText"]; + + assert(value.is_string()); + return value.get(); +} + +auto CompletionItem::filterText() const -> std::optional { + if (!repr_.contains("filterText")) return std::nullopt; + + const auto& value = repr_["filterText"]; + + assert(value.is_string()); + return value.get(); +} + +auto CompletionItem::insertText() const -> std::optional { + if (!repr_.contains("insertText")) return std::nullopt; + + const auto& value = repr_["insertText"]; + + assert(value.is_string()); + return value.get(); +} + +auto CompletionItem::insertTextFormat() const + -> std::optional { + if (!repr_.contains("insertTextFormat")) return std::nullopt; + + const auto& value = repr_["insertTextFormat"]; + + return InsertTextFormat(value); +} + +auto CompletionItem::insertTextMode() const -> std::optional { + if (!repr_.contains("insertTextMode")) return std::nullopt; + + const auto& value = repr_["insertTextMode"]; + + return InsertTextMode(value); +} + +auto CompletionItem::textEdit() const -> std::optional< + std::variant> { + if (!repr_.contains("textEdit")) return std::nullopt; + + const auto& value = repr_["textEdit"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto CompletionItem::textEditText() const -> std::optional { + if (!repr_.contains("textEditText")) return std::nullopt; + + const auto& value = repr_["textEditText"]; + + assert(value.is_string()); + return value.get(); +} + +auto CompletionItem::additionalTextEdits() const + -> std::optional> { + if (!repr_.contains("additionalTextEdits")) return std::nullopt; + + const auto& value = repr_["additionalTextEdits"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CompletionItem::commitCharacters() const + -> std::optional> { + if (!repr_.contains("commitCharacters")) return std::nullopt; + + const auto& value = repr_["commitCharacters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CompletionItem::command() const -> std::optional { + if (!repr_.contains("command")) return std::nullopt; + + const auto& value = repr_["command"]; + + return Command(value); +} + +auto CompletionItem::data() const -> std::optional { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto CompletionItem::label(std::string label) -> CompletionItem& { + return *this; +} + +auto CompletionItem::labelDetails( + std::optional labelDetails) -> CompletionItem& { + return *this; +} + +auto CompletionItem::kind(std::optional kind) + -> CompletionItem& { + return *this; +} + +auto CompletionItem::tags(std::optional> tags) + -> CompletionItem& { + return *this; +} + +auto CompletionItem::detail(std::optional detail) + -> CompletionItem& { + return *this; +} + +auto CompletionItem::documentation( + std::optional> + documentation) -> CompletionItem& { + return *this; +} + +auto CompletionItem::deprecated(std::optional deprecated) + -> CompletionItem& { + return *this; +} + +auto CompletionItem::preselect(std::optional preselect) + -> CompletionItem& { + return *this; +} + +auto CompletionItem::sortText(std::optional sortText) + -> CompletionItem& { + return *this; +} + +auto CompletionItem::filterText(std::optional filterText) + -> CompletionItem& { + return *this; +} + +auto CompletionItem::insertText(std::optional insertText) + -> CompletionItem& { + return *this; +} + +auto CompletionItem::insertTextFormat( + std::optional insertTextFormat) -> CompletionItem& { + return *this; +} + +auto CompletionItem::insertTextMode( + std::optional insertTextMode) -> CompletionItem& { + return *this; +} + +auto CompletionItem::textEdit( + std::optional> + textEdit) -> CompletionItem& { + return *this; +} + +auto CompletionItem::textEditText(std::optional textEditText) + -> CompletionItem& { + return *this; +} + +auto CompletionItem::additionalTextEdits( + std::optional> additionalTextEdits) -> CompletionItem& { + return *this; +} + +auto CompletionItem::commitCharacters( + std::optional> commitCharacters) -> CompletionItem& { + return *this; +} + +auto CompletionItem::command(std::optional command) + -> CompletionItem& { + return *this; +} + +auto CompletionItem::data(std::optional data) -> CompletionItem& { + return *this; +} + +CompletionList::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("isIncomplete")) return false; + if (!repr_.contains("items")) return false; + return true; +} + +auto CompletionList::isIncomplete() const -> bool { + const auto& value = repr_["isIncomplete"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CompletionList::itemDefaults() const + -> std::optional { + if (!repr_.contains("itemDefaults")) return std::nullopt; + + const auto& value = repr_["itemDefaults"]; + + return CompletionItemDefaults(value); +} + +auto CompletionList::applyKind() const + -> std::optional { + if (!repr_.contains("applyKind")) return std::nullopt; + + const auto& value = repr_["applyKind"]; + + return CompletionItemApplyKinds(value); +} + +auto CompletionList::items() const -> Vector { + const auto& value = repr_["items"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CompletionList::isIncomplete(bool isIncomplete) -> CompletionList& { + return *this; +} + +auto CompletionList::itemDefaults( + std::optional itemDefaults) -> CompletionList& { + return *this; +} + +auto CompletionList::applyKind( + std::optional applyKind) -> CompletionList& { + return *this; +} + +auto CompletionList::items(Vector items) -> CompletionList& { + return *this; +} + +CompletionRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto CompletionRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto CompletionRegistrationOptions::triggerCharacters() const + -> std::optional> { + if (!repr_.contains("triggerCharacters")) return std::nullopt; + + const auto& value = repr_["triggerCharacters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CompletionRegistrationOptions::allCommitCharacters() const + -> std::optional> { + if (!repr_.contains("allCommitCharacters")) return std::nullopt; + + const auto& value = repr_["allCommitCharacters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CompletionRegistrationOptions::resolveProvider() const + -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CompletionRegistrationOptions::completionItem() const + -> std::optional { + if (!repr_.contains("completionItem")) return std::nullopt; + + const auto& value = repr_["completionItem"]; + + return ServerCompletionItemOptions(value); +} + +auto CompletionRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CompletionRegistrationOptions::documentSelector( + std::variant + documentSelector) -> CompletionRegistrationOptions& { + return *this; +} + +auto CompletionRegistrationOptions::triggerCharacters( + std::optional> triggerCharacters) + -> CompletionRegistrationOptions& { + return *this; +} + +auto CompletionRegistrationOptions::allCommitCharacters( + std::optional> allCommitCharacters) + -> CompletionRegistrationOptions& { + return *this; +} + +auto CompletionRegistrationOptions::resolveProvider( + std::optional resolveProvider) -> CompletionRegistrationOptions& { + return *this; +} + +auto CompletionRegistrationOptions::completionItem( + std::optional completionItem) + -> CompletionRegistrationOptions& { + return *this; +} + +auto CompletionRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> CompletionRegistrationOptions& { + return *this; +} + +HoverParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto HoverParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto HoverParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto HoverParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto HoverParams::textDocument(TextDocumentIdentifier textDocument) + -> HoverParams& { + return *this; +} + +auto HoverParams::position(Position position) -> HoverParams& { return *this; } + +auto HoverParams::workDoneToken(std::optional workDoneToken) + -> HoverParams& { + return *this; +} + +Hover::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("contents")) return false; + return true; +} + +auto Hover::contents() const + -> std::variant> { + const auto& value = repr_["contents"]; + + std::variant> + result; + + details::try_emplace(result, value); + + return result; +} + +auto Hover::range() const -> std::optional { + if (!repr_.contains("range")) return std::nullopt; + + const auto& value = repr_["range"]; + + return Range(value); +} + +auto Hover::contents(std::variant> + contents) -> Hover& { + return *this; +} + +auto Hover::range(std::optional range) -> Hover& { return *this; } + +HoverRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto HoverRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto HoverRegistrationOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto HoverRegistrationOptions::documentSelector( + std::variant + documentSelector) -> HoverRegistrationOptions& { + return *this; +} + +auto HoverRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> HoverRegistrationOptions& { + return *this; +} + +SignatureHelpParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto SignatureHelpParams::context() const + -> std::optional { + if (!repr_.contains("context")) return std::nullopt; + + const auto& value = repr_["context"]; + + return SignatureHelpContext(value); +} + +auto SignatureHelpParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto SignatureHelpParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto SignatureHelpParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto SignatureHelpParams::context(std::optional context) + -> SignatureHelpParams& { + return *this; +} + +auto SignatureHelpParams::textDocument(TextDocumentIdentifier textDocument) + -> SignatureHelpParams& { + return *this; +} + +auto SignatureHelpParams::position(Position position) -> SignatureHelpParams& { + return *this; +} + +auto SignatureHelpParams::workDoneToken( + std::optional workDoneToken) -> SignatureHelpParams& { + return *this; +} + +SignatureHelp::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("signatures")) return false; + return true; +} + +auto SignatureHelp::signatures() const -> Vector { + const auto& value = repr_["signatures"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SignatureHelp::activeSignature() const -> std::optional { + if (!repr_.contains("activeSignature")) return std::nullopt; + + const auto& value = repr_["activeSignature"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto SignatureHelp::activeParameter() const + -> std::optional> { + if (!repr_.contains("activeParameter")) return std::nullopt; + + const auto& value = repr_["activeParameter"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto SignatureHelp::signatures(Vector signatures) + -> SignatureHelp& { + return *this; +} + +auto SignatureHelp::activeSignature(std::optional activeSignature) + -> SignatureHelp& { + return *this; +} + +auto SignatureHelp::activeParameter( + std::optional> + activeParameter) -> SignatureHelp& { + return *this; +} + +SignatureHelpRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto SignatureHelpRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto SignatureHelpRegistrationOptions::triggerCharacters() const + -> std::optional> { + if (!repr_.contains("triggerCharacters")) return std::nullopt; + + const auto& value = repr_["triggerCharacters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SignatureHelpRegistrationOptions::retriggerCharacters() const + -> std::optional> { + if (!repr_.contains("retriggerCharacters")) return std::nullopt; + + const auto& value = repr_["retriggerCharacters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SignatureHelpRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SignatureHelpRegistrationOptions::documentSelector( + std::variant + documentSelector) -> SignatureHelpRegistrationOptions& { + return *this; +} + +auto SignatureHelpRegistrationOptions::triggerCharacters( + std::optional> triggerCharacters) + -> SignatureHelpRegistrationOptions& { + return *this; +} + +auto SignatureHelpRegistrationOptions::retriggerCharacters( + std::optional> retriggerCharacters) + -> SignatureHelpRegistrationOptions& { + return *this; +} + +auto SignatureHelpRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> SignatureHelpRegistrationOptions& { + return *this; +} + +DefinitionParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto DefinitionParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DefinitionParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto DefinitionParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DefinitionParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DefinitionParams::textDocument(TextDocumentIdentifier textDocument) + -> DefinitionParams& { + return *this; +} + +auto DefinitionParams::position(Position position) -> DefinitionParams& { + return *this; +} + +auto DefinitionParams::workDoneToken(std::optional workDoneToken) + -> DefinitionParams& { + return *this; +} + +auto DefinitionParams::partialResultToken( + std::optional partialResultToken) -> DefinitionParams& { + return *this; +} + +DefinitionRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto DefinitionRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto DefinitionRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DefinitionRegistrationOptions::documentSelector( + std::variant + documentSelector) -> DefinitionRegistrationOptions& { + return *this; +} + +auto DefinitionRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> DefinitionRegistrationOptions& { + return *this; +} + +ReferenceParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("context")) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto ReferenceParams::context() const -> ReferenceContext { + const auto& value = repr_["context"]; + + return ReferenceContext(value); +} + +auto ReferenceParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto ReferenceParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto ReferenceParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto ReferenceParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto ReferenceParams::context(ReferenceContext context) -> ReferenceParams& { + return *this; +} + +auto ReferenceParams::textDocument(TextDocumentIdentifier textDocument) + -> ReferenceParams& { + return *this; +} + +auto ReferenceParams::position(Position position) -> ReferenceParams& { + return *this; +} + +auto ReferenceParams::workDoneToken(std::optional workDoneToken) + -> ReferenceParams& { + return *this; +} + +auto ReferenceParams::partialResultToken( + std::optional partialResultToken) -> ReferenceParams& { + return *this; +} + +ReferenceRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto ReferenceRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ReferenceRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ReferenceRegistrationOptions::documentSelector( + std::variant + documentSelector) -> ReferenceRegistrationOptions& { + return *this; +} + +auto ReferenceRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> ReferenceRegistrationOptions& { + return *this; +} + +DocumentHighlightParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto DocumentHighlightParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DocumentHighlightParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto DocumentHighlightParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentHighlightParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentHighlightParams::textDocument(TextDocumentIdentifier textDocument) + -> DocumentHighlightParams& { + return *this; +} + +auto DocumentHighlightParams::position(Position position) + -> DocumentHighlightParams& { + return *this; +} + +auto DocumentHighlightParams::workDoneToken( + std::optional workDoneToken) -> DocumentHighlightParams& { + return *this; +} + +auto DocumentHighlightParams::partialResultToken( + std::optional partialResultToken) + -> DocumentHighlightParams& { + return *this; +} + +DocumentHighlight::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + return true; +} + +auto DocumentHighlight::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto DocumentHighlight::kind() const -> std::optional { + if (!repr_.contains("kind")) return std::nullopt; + + const auto& value = repr_["kind"]; + + return DocumentHighlightKind(value); +} + +auto DocumentHighlight::range(Range range) -> DocumentHighlight& { + return *this; +} + +auto DocumentHighlight::kind(std::optional kind) + -> DocumentHighlight& { + return *this; +} + +DocumentHighlightRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto DocumentHighlightRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentHighlightRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentHighlightRegistrationOptions::documentSelector( + std::variant + documentSelector) -> DocumentHighlightRegistrationOptions& { + return *this; +} + +auto DocumentHighlightRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> DocumentHighlightRegistrationOptions& { + return *this; +} + +DocumentSymbolParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + return true; +} + +auto DocumentSymbolParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DocumentSymbolParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentSymbolParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentSymbolParams::textDocument(TextDocumentIdentifier textDocument) + -> DocumentSymbolParams& { + return *this; +} + +auto DocumentSymbolParams::workDoneToken( + std::optional workDoneToken) -> DocumentSymbolParams& { + return *this; +} + +auto DocumentSymbolParams::partialResultToken( + std::optional partialResultToken) -> DocumentSymbolParams& { + return *this; +} + +SymbolInformation::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("location")) return false; + if (!repr_.contains("name")) return false; + if (!repr_.contains("kind")) return false; + return true; +} + +auto SymbolInformation::deprecated() const -> std::optional { + if (!repr_.contains("deprecated")) return std::nullopt; + + const auto& value = repr_["deprecated"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SymbolInformation::location() const -> Location { + const auto& value = repr_["location"]; + + return Location(value); +} + +auto SymbolInformation::name() const -> std::string { + const auto& value = repr_["name"]; + + assert(value.is_string()); + return value.get(); +} + +auto SymbolInformation::kind() const -> SymbolKind { + const auto& value = repr_["kind"]; + + return SymbolKind(value); +} + +auto SymbolInformation::tags() const -> std::optional> { + if (!repr_.contains("tags")) return std::nullopt; + + const auto& value = repr_["tags"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SymbolInformation::containerName() const -> std::optional { + if (!repr_.contains("containerName")) return std::nullopt; + + const auto& value = repr_["containerName"]; + + assert(value.is_string()); + return value.get(); +} + +auto SymbolInformation::deprecated(std::optional deprecated) + -> SymbolInformation& { + return *this; +} + +auto SymbolInformation::location(Location location) -> SymbolInformation& { + return *this; +} + +auto SymbolInformation::name(std::string name) -> SymbolInformation& { + return *this; +} + +auto SymbolInformation::kind(SymbolKind kind) -> SymbolInformation& { + return *this; +} + +auto SymbolInformation::tags(std::optional> tags) + -> SymbolInformation& { + return *this; +} + +auto SymbolInformation::containerName(std::optional containerName) + -> SymbolInformation& { + return *this; +} + +DocumentSymbol::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("name")) return false; + if (!repr_.contains("kind")) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("selectionRange")) return false; + return true; +} + +auto DocumentSymbol::name() const -> std::string { + const auto& value = repr_["name"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentSymbol::detail() const -> std::optional { + if (!repr_.contains("detail")) return std::nullopt; + + const auto& value = repr_["detail"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentSymbol::kind() const -> SymbolKind { + const auto& value = repr_["kind"]; + + return SymbolKind(value); +} + +auto DocumentSymbol::tags() const -> std::optional> { + if (!repr_.contains("tags")) return std::nullopt; + + const auto& value = repr_["tags"]; + + assert(value.is_array()); + return Vector(value); +} + +auto DocumentSymbol::deprecated() const -> std::optional { + if (!repr_.contains("deprecated")) return std::nullopt; + + const auto& value = repr_["deprecated"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentSymbol::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto DocumentSymbol::selectionRange() const -> Range { + const auto& value = repr_["selectionRange"]; + + return Range(value); +} + +auto DocumentSymbol::children() const -> std::optional> { + if (!repr_.contains("children")) return std::nullopt; + + const auto& value = repr_["children"]; + + assert(value.is_array()); + return Vector(value); +} + +auto DocumentSymbol::name(std::string name) -> DocumentSymbol& { return *this; } + +auto DocumentSymbol::detail(std::optional detail) + -> DocumentSymbol& { + return *this; +} + +auto DocumentSymbol::kind(SymbolKind kind) -> DocumentSymbol& { return *this; } + +auto DocumentSymbol::tags(std::optional> tags) + -> DocumentSymbol& { + return *this; +} + +auto DocumentSymbol::deprecated(std::optional deprecated) + -> DocumentSymbol& { + return *this; +} + +auto DocumentSymbol::range(Range range) -> DocumentSymbol& { return *this; } + +auto DocumentSymbol::selectionRange(Range selectionRange) -> DocumentSymbol& { + return *this; +} + +auto DocumentSymbol::children(std::optional> children) + -> DocumentSymbol& { + return *this; +} + +DocumentSymbolRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto DocumentSymbolRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentSymbolRegistrationOptions::label() const + -> std::optional { + if (!repr_.contains("label")) return std::nullopt; + + const auto& value = repr_["label"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentSymbolRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentSymbolRegistrationOptions::documentSelector( + std::variant + documentSelector) -> DocumentSymbolRegistrationOptions& { + return *this; +} + +auto DocumentSymbolRegistrationOptions::label(std::optional label) + -> DocumentSymbolRegistrationOptions& { + return *this; +} + +auto DocumentSymbolRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> DocumentSymbolRegistrationOptions& { + return *this; +} + +CodeActionParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("context")) return false; + return true; +} + +auto CodeActionParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto CodeActionParams::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto CodeActionParams::context() const -> CodeActionContext { + const auto& value = repr_["context"]; + + return CodeActionContext(value); +} + +auto CodeActionParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto CodeActionParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto CodeActionParams::textDocument(TextDocumentIdentifier textDocument) + -> CodeActionParams& { + return *this; +} + +auto CodeActionParams::range(Range range) -> CodeActionParams& { return *this; } + +auto CodeActionParams::context(CodeActionContext context) -> CodeActionParams& { + return *this; +} + +auto CodeActionParams::workDoneToken(std::optional workDoneToken) + -> CodeActionParams& { + return *this; +} + +auto CodeActionParams::partialResultToken( + std::optional partialResultToken) -> CodeActionParams& { + return *this; +} + +Command::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("title")) return false; + if (!repr_.contains("command")) return false; + return true; +} + +auto Command::title() const -> std::string { + const auto& value = repr_["title"]; + + assert(value.is_string()); + return value.get(); +} + +auto Command::tooltip() const -> std::optional { + if (!repr_.contains("tooltip")) return std::nullopt; + + const auto& value = repr_["tooltip"]; + + assert(value.is_string()); + return value.get(); +} + +auto Command::command() const -> std::string { + const auto& value = repr_["command"]; + + assert(value.is_string()); + return value.get(); +} + +auto Command::arguments() const -> std::optional> { + if (!repr_.contains("arguments")) return std::nullopt; + + const auto& value = repr_["arguments"]; + + assert(value.is_array()); + return Vector(value); +} + +auto Command::title(std::string title) -> Command& { return *this; } + +auto Command::tooltip(std::optional tooltip) -> Command& { + return *this; +} + +auto Command::command(std::string command) -> Command& { return *this; } + +auto Command::arguments(std::optional> arguments) -> Command& { + return *this; +} + +CodeAction::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("title")) return false; + return true; +} + +auto CodeAction::title() const -> std::string { + const auto& value = repr_["title"]; + + assert(value.is_string()); + return value.get(); +} + +auto CodeAction::kind() const -> std::optional { + if (!repr_.contains("kind")) return std::nullopt; + + const auto& value = repr_["kind"]; + + lsp_runtime_error("CodeAction::kind: not implement yet"); +} + +auto CodeAction::diagnostics() const -> std::optional> { + if (!repr_.contains("diagnostics")) return std::nullopt; + + const auto& value = repr_["diagnostics"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CodeAction::isPreferred() const -> std::optional { + if (!repr_.contains("isPreferred")) return std::nullopt; + + const auto& value = repr_["isPreferred"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeAction::disabled() const -> std::optional { + if (!repr_.contains("disabled")) return std::nullopt; + + const auto& value = repr_["disabled"]; + + return CodeActionDisabled(value); +} + +auto CodeAction::edit() const -> std::optional { + if (!repr_.contains("edit")) return std::nullopt; + + const auto& value = repr_["edit"]; + + return WorkspaceEdit(value); +} + +auto CodeAction::command() const -> std::optional { + if (!repr_.contains("command")) return std::nullopt; + + const auto& value = repr_["command"]; + + return Command(value); +} + +auto CodeAction::data() const -> std::optional { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto CodeAction::tags() const -> std::optional> { + if (!repr_.contains("tags")) return std::nullopt; + + const auto& value = repr_["tags"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CodeAction::title(std::string title) -> CodeAction& { return *this; } + +auto CodeAction::kind(std::optional kind) -> CodeAction& { + return *this; +} + +auto CodeAction::diagnostics(std::optional> diagnostics) + -> CodeAction& { + return *this; +} + +auto CodeAction::isPreferred(std::optional isPreferred) -> CodeAction& { + return *this; +} + +auto CodeAction::disabled(std::optional disabled) + -> CodeAction& { + return *this; +} + +auto CodeAction::edit(std::optional edit) -> CodeAction& { + return *this; +} + +auto CodeAction::command(std::optional command) -> CodeAction& { + return *this; +} + +auto CodeAction::data(std::optional data) -> CodeAction& { + return *this; +} + +auto CodeAction::tags(std::optional> tags) + -> CodeAction& { + return *this; +} + +CodeActionRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto CodeActionRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto CodeActionRegistrationOptions::codeActionKinds() const + -> std::optional> { + if (!repr_.contains("codeActionKinds")) return std::nullopt; + + const auto& value = repr_["codeActionKinds"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CodeActionRegistrationOptions::documentation() const + -> std::optional> { + if (!repr_.contains("documentation")) return std::nullopt; + + const auto& value = repr_["documentation"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CodeActionRegistrationOptions::resolveProvider() const + -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeActionRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeActionRegistrationOptions::documentSelector( + std::variant + documentSelector) -> CodeActionRegistrationOptions& { + return *this; +} + +auto CodeActionRegistrationOptions::codeActionKinds( + std::optional> codeActionKinds) + -> CodeActionRegistrationOptions& { + return *this; +} + +auto CodeActionRegistrationOptions::documentation( + std::optional> documentation) + -> CodeActionRegistrationOptions& { + return *this; +} + +auto CodeActionRegistrationOptions::resolveProvider( + std::optional resolveProvider) -> CodeActionRegistrationOptions& { + return *this; +} + +auto CodeActionRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> CodeActionRegistrationOptions& { + return *this; +} + +WorkspaceSymbolParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("query")) return false; + return true; +} + +auto WorkspaceSymbolParams::query() const -> std::string { + const auto& value = repr_["query"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceSymbolParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkspaceSymbolParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkspaceSymbolParams::query(std::string query) -> WorkspaceSymbolParams& { + return *this; +} + +auto WorkspaceSymbolParams::workDoneToken( + std::optional workDoneToken) -> WorkspaceSymbolParams& { + return *this; +} + +auto WorkspaceSymbolParams::partialResultToken( + std::optional partialResultToken) -> WorkspaceSymbolParams& { + return *this; +} + +WorkspaceSymbol::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("location")) return false; + if (!repr_.contains("name")) return false; + if (!repr_.contains("kind")) return false; + return true; +} + +auto WorkspaceSymbol::location() const + -> std::variant { + const auto& value = repr_["location"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkspaceSymbol::data() const -> std::optional { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto WorkspaceSymbol::name() const -> std::string { + const auto& value = repr_["name"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceSymbol::kind() const -> SymbolKind { + const auto& value = repr_["kind"]; + + return SymbolKind(value); +} + +auto WorkspaceSymbol::tags() const -> std::optional> { + if (!repr_.contains("tags")) return std::nullopt; + + const auto& value = repr_["tags"]; + + assert(value.is_array()); + return Vector(value); +} + +auto WorkspaceSymbol::containerName() const -> std::optional { + if (!repr_.contains("containerName")) return std::nullopt; + + const auto& value = repr_["containerName"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceSymbol::location( + std::variant location) + -> WorkspaceSymbol& { + return *this; +} + +auto WorkspaceSymbol::data(std::optional data) -> WorkspaceSymbol& { + return *this; +} + +auto WorkspaceSymbol::name(std::string name) -> WorkspaceSymbol& { + return *this; +} + +auto WorkspaceSymbol::kind(SymbolKind kind) -> WorkspaceSymbol& { + return *this; +} + +auto WorkspaceSymbol::tags(std::optional> tags) + -> WorkspaceSymbol& { + return *this; +} + +auto WorkspaceSymbol::containerName(std::optional containerName) + -> WorkspaceSymbol& { + return *this; +} + +WorkspaceSymbolRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkspaceSymbolRegistrationOptions::resolveProvider() const + -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceSymbolRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceSymbolRegistrationOptions::resolveProvider( + std::optional resolveProvider) + -> WorkspaceSymbolRegistrationOptions& { + return *this; +} + +auto WorkspaceSymbolRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> WorkspaceSymbolRegistrationOptions& { + return *this; +} + +CodeLensParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + return true; +} + +auto CodeLensParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto CodeLensParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto CodeLensParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto CodeLensParams::textDocument(TextDocumentIdentifier textDocument) + -> CodeLensParams& { + return *this; +} + +auto CodeLensParams::workDoneToken(std::optional workDoneToken) + -> CodeLensParams& { + return *this; +} + +auto CodeLensParams::partialResultToken( + std::optional partialResultToken) -> CodeLensParams& { + return *this; +} + +CodeLens::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + return true; +} + +auto CodeLens::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto CodeLens::command() const -> std::optional { + if (!repr_.contains("command")) return std::nullopt; + + const auto& value = repr_["command"]; + + return Command(value); +} + +auto CodeLens::data() const -> std::optional { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto CodeLens::range(Range range) -> CodeLens& { return *this; } + +auto CodeLens::command(std::optional command) -> CodeLens& { + return *this; +} + +auto CodeLens::data(std::optional data) -> CodeLens& { return *this; } + +CodeLensRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto CodeLensRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto CodeLensRegistrationOptions::resolveProvider() const + -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeLensRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeLensRegistrationOptions::documentSelector( + std::variant + documentSelector) -> CodeLensRegistrationOptions& { + return *this; +} + +auto CodeLensRegistrationOptions::resolveProvider( + std::optional resolveProvider) -> CodeLensRegistrationOptions& { + return *this; +} + +auto CodeLensRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> CodeLensRegistrationOptions& { + return *this; +} + +DocumentLinkParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + return true; +} + +auto DocumentLinkParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DocumentLinkParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentLinkParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentLinkParams::textDocument(TextDocumentIdentifier textDocument) + -> DocumentLinkParams& { + return *this; +} + +auto DocumentLinkParams::workDoneToken( + std::optional workDoneToken) -> DocumentLinkParams& { + return *this; +} + +auto DocumentLinkParams::partialResultToken( + std::optional partialResultToken) -> DocumentLinkParams& { + return *this; +} + +DocumentLink::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + return true; +} + +auto DocumentLink::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto DocumentLink::target() const -> std::optional { + if (!repr_.contains("target")) return std::nullopt; + + const auto& value = repr_["target"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentLink::tooltip() const -> std::optional { + if (!repr_.contains("tooltip")) return std::nullopt; + + const auto& value = repr_["tooltip"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentLink::data() const -> std::optional { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto DocumentLink::range(Range range) -> DocumentLink& { return *this; } + +auto DocumentLink::target(std::optional target) -> DocumentLink& { + return *this; +} + +auto DocumentLink::tooltip(std::optional tooltip) + -> DocumentLink& { + return *this; +} + +auto DocumentLink::data(std::optional data) -> DocumentLink& { + return *this; +} + +DocumentLinkRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto DocumentLinkRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentLinkRegistrationOptions::resolveProvider() const + -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentLinkRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentLinkRegistrationOptions::documentSelector( + std::variant + documentSelector) -> DocumentLinkRegistrationOptions& { + return *this; +} + +auto DocumentLinkRegistrationOptions::resolveProvider( + std::optional resolveProvider) -> DocumentLinkRegistrationOptions& { + return *this; +} + +auto DocumentLinkRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> DocumentLinkRegistrationOptions& { + return *this; +} + +DocumentFormattingParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("options")) return false; + return true; +} + +auto DocumentFormattingParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DocumentFormattingParams::options() const -> FormattingOptions { + const auto& value = repr_["options"]; + + return FormattingOptions(value); +} + +auto DocumentFormattingParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentFormattingParams::textDocument(TextDocumentIdentifier textDocument) + -> DocumentFormattingParams& { + return *this; +} + +auto DocumentFormattingParams::options(FormattingOptions options) + -> DocumentFormattingParams& { + return *this; +} + +auto DocumentFormattingParams::workDoneToken( + std::optional workDoneToken) -> DocumentFormattingParams& { + return *this; +} + +DocumentFormattingRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto DocumentFormattingRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentFormattingRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentFormattingRegistrationOptions::documentSelector( + std::variant + documentSelector) -> DocumentFormattingRegistrationOptions& { + return *this; +} + +auto DocumentFormattingRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> DocumentFormattingRegistrationOptions& { + return *this; +} + +DocumentRangeFormattingParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("options")) return false; + return true; +} + +auto DocumentRangeFormattingParams::textDocument() const + -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DocumentRangeFormattingParams::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto DocumentRangeFormattingParams::options() const -> FormattingOptions { + const auto& value = repr_["options"]; + + return FormattingOptions(value); +} + +auto DocumentRangeFormattingParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentRangeFormattingParams::textDocument( + TextDocumentIdentifier textDocument) -> DocumentRangeFormattingParams& { + return *this; +} + +auto DocumentRangeFormattingParams::range(Range range) + -> DocumentRangeFormattingParams& { + return *this; +} + +auto DocumentRangeFormattingParams::options(FormattingOptions options) + -> DocumentRangeFormattingParams& { + return *this; +} + +auto DocumentRangeFormattingParams::workDoneToken( + std::optional workDoneToken) + -> DocumentRangeFormattingParams& { + return *this; +} + +DocumentRangeFormattingRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto DocumentRangeFormattingRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentRangeFormattingRegistrationOptions::rangesSupport() const + -> std::optional { + if (!repr_.contains("rangesSupport")) return std::nullopt; + + const auto& value = repr_["rangesSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentRangeFormattingRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentRangeFormattingRegistrationOptions::documentSelector( + std::variant + documentSelector) -> DocumentRangeFormattingRegistrationOptions& { + return *this; +} + +auto DocumentRangeFormattingRegistrationOptions::rangesSupport( + std::optional rangesSupport) + -> DocumentRangeFormattingRegistrationOptions& { + return *this; +} + +auto DocumentRangeFormattingRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> DocumentRangeFormattingRegistrationOptions& { + return *this; +} + +DocumentRangesFormattingParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("ranges")) return false; + if (!repr_.contains("options")) return false; + return true; +} + +auto DocumentRangesFormattingParams::textDocument() const + -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DocumentRangesFormattingParams::ranges() const -> Vector { + const auto& value = repr_["ranges"]; + + assert(value.is_array()); + return Vector(value); +} + +auto DocumentRangesFormattingParams::options() const -> FormattingOptions { + const auto& value = repr_["options"]; + + return FormattingOptions(value); +} + +auto DocumentRangesFormattingParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentRangesFormattingParams::textDocument( + TextDocumentIdentifier textDocument) -> DocumentRangesFormattingParams& { + return *this; +} + +auto DocumentRangesFormattingParams::ranges(Vector ranges) + -> DocumentRangesFormattingParams& { + return *this; +} + +auto DocumentRangesFormattingParams::options(FormattingOptions options) + -> DocumentRangesFormattingParams& { + return *this; +} + +auto DocumentRangesFormattingParams::workDoneToken( + std::optional workDoneToken) + -> DocumentRangesFormattingParams& { + return *this; +} + +DocumentOnTypeFormattingParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + if (!repr_.contains("ch")) return false; + if (!repr_.contains("options")) return false; + return true; +} + +auto DocumentOnTypeFormattingParams::textDocument() const + -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto DocumentOnTypeFormattingParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto DocumentOnTypeFormattingParams::ch() const -> std::string { + const auto& value = repr_["ch"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentOnTypeFormattingParams::options() const -> FormattingOptions { + const auto& value = repr_["options"]; + + return FormattingOptions(value); +} + +auto DocumentOnTypeFormattingParams::textDocument( + TextDocumentIdentifier textDocument) -> DocumentOnTypeFormattingParams& { + return *this; +} + +auto DocumentOnTypeFormattingParams::position(Position position) + -> DocumentOnTypeFormattingParams& { + return *this; +} + +auto DocumentOnTypeFormattingParams::ch(std::string ch) + -> DocumentOnTypeFormattingParams& { + return *this; +} + +auto DocumentOnTypeFormattingParams::options(FormattingOptions options) + -> DocumentOnTypeFormattingParams& { + return *this; +} + +DocumentOnTypeFormattingRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + if (!repr_.contains("firstTriggerCharacter")) return false; + return true; +} + +auto DocumentOnTypeFormattingRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto DocumentOnTypeFormattingRegistrationOptions::firstTriggerCharacter() const + -> std::string { + const auto& value = repr_["firstTriggerCharacter"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentOnTypeFormattingRegistrationOptions::moreTriggerCharacter() const + -> std::optional> { + if (!repr_.contains("moreTriggerCharacter")) return std::nullopt; + + const auto& value = repr_["moreTriggerCharacter"]; + + assert(value.is_array()); + return Vector(value); +} + +auto DocumentOnTypeFormattingRegistrationOptions::documentSelector( + std::variant + documentSelector) -> DocumentOnTypeFormattingRegistrationOptions& { + return *this; +} + +auto DocumentOnTypeFormattingRegistrationOptions::firstTriggerCharacter( + std::string firstTriggerCharacter) + -> DocumentOnTypeFormattingRegistrationOptions& { + return *this; +} + +auto DocumentOnTypeFormattingRegistrationOptions::moreTriggerCharacter( + std::optional> moreTriggerCharacter) + -> DocumentOnTypeFormattingRegistrationOptions& { + return *this; +} + +RenameParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + if (!repr_.contains("newName")) return false; + return true; +} + +auto RenameParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto RenameParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto RenameParams::newName() const -> std::string { + const auto& value = repr_["newName"]; + + assert(value.is_string()); + return value.get(); +} + +auto RenameParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto RenameParams::textDocument(TextDocumentIdentifier textDocument) + -> RenameParams& { + return *this; +} + +auto RenameParams::position(Position position) -> RenameParams& { + return *this; +} + +auto RenameParams::newName(std::string newName) -> RenameParams& { + return *this; +} + +auto RenameParams::workDoneToken(std::optional workDoneToken) + -> RenameParams& { + return *this; +} + +RenameRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("documentSelector")) return false; + return true; +} + +auto RenameRegistrationOptions::documentSelector() const + -> std::variant { + const auto& value = repr_["documentSelector"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto RenameRegistrationOptions::prepareProvider() const -> std::optional { + if (!repr_.contains("prepareProvider")) return std::nullopt; + + const auto& value = repr_["prepareProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto RenameRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto RenameRegistrationOptions::documentSelector( + std::variant + documentSelector) -> RenameRegistrationOptions& { + return *this; +} + +auto RenameRegistrationOptions::prepareProvider( + std::optional prepareProvider) -> RenameRegistrationOptions& { + return *this; +} + +auto RenameRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) -> RenameRegistrationOptions& { + return *this; +} + +PrepareRenameParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto PrepareRenameParams::textDocument() const -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto PrepareRenameParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto PrepareRenameParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto PrepareRenameParams::textDocument(TextDocumentIdentifier textDocument) + -> PrepareRenameParams& { + return *this; +} + +auto PrepareRenameParams::position(Position position) -> PrepareRenameParams& { + return *this; +} + +auto PrepareRenameParams::workDoneToken( + std::optional workDoneToken) -> PrepareRenameParams& { + return *this; +} + +ExecuteCommandParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("command")) return false; + return true; +} + +auto ExecuteCommandParams::command() const -> std::string { + const auto& value = repr_["command"]; + + assert(value.is_string()); + return value.get(); +} + +auto ExecuteCommandParams::arguments() const -> std::optional> { + if (!repr_.contains("arguments")) return std::nullopt; + + const auto& value = repr_["arguments"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ExecuteCommandParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto ExecuteCommandParams::command(std::string command) + -> ExecuteCommandParams& { + return *this; +} + +auto ExecuteCommandParams::arguments(std::optional> arguments) + -> ExecuteCommandParams& { + return *this; +} + +auto ExecuteCommandParams::workDoneToken( + std::optional workDoneToken) -> ExecuteCommandParams& { + return *this; +} + +ExecuteCommandRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("commands")) return false; + return true; +} + +auto ExecuteCommandRegistrationOptions::commands() const + -> Vector { + const auto& value = repr_["commands"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ExecuteCommandRegistrationOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ExecuteCommandRegistrationOptions::commands(Vector commands) + -> ExecuteCommandRegistrationOptions& { + return *this; +} + +auto ExecuteCommandRegistrationOptions::workDoneProgress( + std::optional workDoneProgress) + -> ExecuteCommandRegistrationOptions& { + return *this; +} + +ApplyWorkspaceEditParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("edit")) return false; + return true; +} + +auto ApplyWorkspaceEditParams::label() const -> std::optional { + if (!repr_.contains("label")) return std::nullopt; + + const auto& value = repr_["label"]; + + assert(value.is_string()); + return value.get(); +} + +auto ApplyWorkspaceEditParams::edit() const -> WorkspaceEdit { + const auto& value = repr_["edit"]; + + return WorkspaceEdit(value); +} + +auto ApplyWorkspaceEditParams::metadata() const + -> std::optional { + if (!repr_.contains("metadata")) return std::nullopt; + + const auto& value = repr_["metadata"]; + + return WorkspaceEditMetadata(value); +} + +auto ApplyWorkspaceEditParams::label(std::optional label) + -> ApplyWorkspaceEditParams& { + return *this; +} + +auto ApplyWorkspaceEditParams::edit(WorkspaceEdit edit) + -> ApplyWorkspaceEditParams& { + return *this; +} + +auto ApplyWorkspaceEditParams::metadata( + std::optional metadata) + -> ApplyWorkspaceEditParams& { + return *this; +} + +ApplyWorkspaceEditResult::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("applied")) return false; + return true; +} + +auto ApplyWorkspaceEditResult::applied() const -> bool { + const auto& value = repr_["applied"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ApplyWorkspaceEditResult::failureReason() const + -> std::optional { + if (!repr_.contains("failureReason")) return std::nullopt; + + const auto& value = repr_["failureReason"]; + + assert(value.is_string()); + return value.get(); +} + +auto ApplyWorkspaceEditResult::failedChange() const -> std::optional { + if (!repr_.contains("failedChange")) return std::nullopt; + + const auto& value = repr_["failedChange"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto ApplyWorkspaceEditResult::applied(bool applied) + -> ApplyWorkspaceEditResult& { + return *this; +} + +auto ApplyWorkspaceEditResult::failureReason( + std::optional failureReason) -> ApplyWorkspaceEditResult& { + return *this; +} + +auto ApplyWorkspaceEditResult::failedChange(std::optional failedChange) + -> ApplyWorkspaceEditResult& { + return *this; +} + +WorkDoneProgressBegin::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "begin") return false; + if (!repr_.contains("title")) return false; + return true; +} + +auto WorkDoneProgressBegin::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkDoneProgressBegin::title() const -> std::string { + const auto& value = repr_["title"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkDoneProgressBegin::cancellable() const -> std::optional { + if (!repr_.contains("cancellable")) return std::nullopt; + + const auto& value = repr_["cancellable"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkDoneProgressBegin::message() const -> std::optional { + if (!repr_.contains("message")) return std::nullopt; + + const auto& value = repr_["message"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkDoneProgressBegin::percentage() const -> std::optional { + if (!repr_.contains("percentage")) return std::nullopt; + + const auto& value = repr_["percentage"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto WorkDoneProgressBegin::kind(std::string kind) -> WorkDoneProgressBegin& { + return *this; +} + +auto WorkDoneProgressBegin::title(std::string title) -> WorkDoneProgressBegin& { + return *this; +} + +auto WorkDoneProgressBegin::cancellable(std::optional cancellable) + -> WorkDoneProgressBegin& { + return *this; +} + +auto WorkDoneProgressBegin::message(std::optional message) + -> WorkDoneProgressBegin& { + return *this; +} + +auto WorkDoneProgressBegin::percentage(std::optional percentage) + -> WorkDoneProgressBegin& { + return *this; +} + +WorkDoneProgressReport::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "report") return false; + return true; +} + +auto WorkDoneProgressReport::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkDoneProgressReport::cancellable() const -> std::optional { + if (!repr_.contains("cancellable")) return std::nullopt; + + const auto& value = repr_["cancellable"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkDoneProgressReport::message() const -> std::optional { + if (!repr_.contains("message")) return std::nullopt; + + const auto& value = repr_["message"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkDoneProgressReport::percentage() const -> std::optional { + if (!repr_.contains("percentage")) return std::nullopt; + + const auto& value = repr_["percentage"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto WorkDoneProgressReport::kind(std::string kind) -> WorkDoneProgressReport& { + return *this; +} + +auto WorkDoneProgressReport::cancellable(std::optional cancellable) + -> WorkDoneProgressReport& { + return *this; +} + +auto WorkDoneProgressReport::message(std::optional message) + -> WorkDoneProgressReport& { + return *this; +} + +auto WorkDoneProgressReport::percentage(std::optional percentage) + -> WorkDoneProgressReport& { + return *this; +} + +WorkDoneProgressEnd::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "end") return false; + return true; +} + +auto WorkDoneProgressEnd::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkDoneProgressEnd::message() const -> std::optional { + if (!repr_.contains("message")) return std::nullopt; + + const auto& value = repr_["message"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkDoneProgressEnd::kind(std::string kind) -> WorkDoneProgressEnd& { + return *this; +} + +auto WorkDoneProgressEnd::message(std::optional message) + -> WorkDoneProgressEnd& { + return *this; +} + +SetTraceParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("value")) return false; + return true; +} + +auto SetTraceParams::value() const -> TraceValue { + const auto& value = repr_["value"]; + + lsp_runtime_error("SetTraceParams::value: not implement yet"); +} + +auto SetTraceParams::value(TraceValue value) -> SetTraceParams& { + return *this; +} + +LogTraceParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("message")) return false; + return true; +} + +auto LogTraceParams::message() const -> std::string { + const auto& value = repr_["message"]; + + assert(value.is_string()); + return value.get(); +} + +auto LogTraceParams::verbose() const -> std::optional { + if (!repr_.contains("verbose")) return std::nullopt; + + const auto& value = repr_["verbose"]; + + assert(value.is_string()); + return value.get(); +} + +auto LogTraceParams::message(std::string message) -> LogTraceParams& { + return *this; +} + +auto LogTraceParams::verbose(std::optional verbose) + -> LogTraceParams& { + return *this; +} + +CancelParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("id")) return false; + return true; +} + +auto CancelParams::id() const + -> std::variant { + const auto& value = repr_["id"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto CancelParams::id(std::variant id) + -> CancelParams& { + return *this; +} + +ProgressParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("token")) return false; + if (!repr_.contains("value")) return false; + return true; +} + +auto ProgressParams::token() const -> ProgressToken { + const auto& value = repr_["token"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto ProgressParams::value() const -> LSPAny { + const auto& value = repr_["value"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto ProgressParams::token(ProgressToken token) -> ProgressParams& { + return *this; +} + +auto ProgressParams::value(LSPAny value) -> ProgressParams& { return *this; } + +TextDocumentPositionParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("position")) return false; + return true; +} + +auto TextDocumentPositionParams::textDocument() const + -> TextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return TextDocumentIdentifier(value); +} + +auto TextDocumentPositionParams::position() const -> Position { + const auto& value = repr_["position"]; + + return Position(value); +} + +auto TextDocumentPositionParams::textDocument( + TextDocumentIdentifier textDocument) -> TextDocumentPositionParams& { + return *this; +} + +auto TextDocumentPositionParams::position(Position position) + -> TextDocumentPositionParams& { + return *this; +} + +WorkDoneProgressParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkDoneProgressParams::workDoneToken() const + -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkDoneProgressParams::workDoneToken( + std::optional workDoneToken) -> WorkDoneProgressParams& { + return *this; +} + +PartialResultParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto PartialResultParams::partialResultToken() const + -> std::optional { + if (!repr_.contains("partialResultToken")) return std::nullopt; + + const auto& value = repr_["partialResultToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto PartialResultParams::partialResultToken( + std::optional partialResultToken) -> PartialResultParams& { + return *this; +} + +LocationLink::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("targetUri")) return false; + if (!repr_.contains("targetRange")) return false; + if (!repr_.contains("targetSelectionRange")) return false; + return true; +} + +auto LocationLink::originSelectionRange() const -> std::optional { + if (!repr_.contains("originSelectionRange")) return std::nullopt; + + const auto& value = repr_["originSelectionRange"]; + + return Range(value); +} + +auto LocationLink::targetUri() const -> std::string { + const auto& value = repr_["targetUri"]; + + assert(value.is_string()); + return value.get(); +} + +auto LocationLink::targetRange() const -> Range { + const auto& value = repr_["targetRange"]; + + return Range(value); +} + +auto LocationLink::targetSelectionRange() const -> Range { + const auto& value = repr_["targetSelectionRange"]; + + return Range(value); +} + +auto LocationLink::originSelectionRange( + std::optional originSelectionRange) -> LocationLink& { + return *this; +} + +auto LocationLink::targetUri(std::string targetUri) -> LocationLink& { + return *this; +} + +auto LocationLink::targetRange(Range targetRange) -> LocationLink& { + return *this; +} + +auto LocationLink::targetSelectionRange(Range targetSelectionRange) + -> LocationLink& { + return *this; +} + +Range::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("start")) return false; + if (!repr_.contains("end")) return false; + return true; +} + +auto Range::start() const -> Position { + const auto& value = repr_["start"]; + + return Position(value); +} + +auto Range::end() const -> Position { + const auto& value = repr_["end"]; + + return Position(value); +} + +auto Range::start(Position start) -> Range& { return *this; } + +auto Range::end(Position end) -> Range& { return *this; } + +ImplementationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ImplementationOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ImplementationOptions::workDoneProgress( + std::optional workDoneProgress) -> ImplementationOptions& { + return *this; +} + +StaticRegistrationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto StaticRegistrationOptions::id() const -> std::optional { + if (!repr_.contains("id")) return std::nullopt; + + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto StaticRegistrationOptions::id(std::optional id) + -> StaticRegistrationOptions& { + return *this; +} + +TypeDefinitionOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto TypeDefinitionOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TypeDefinitionOptions::workDoneProgress( + std::optional workDoneProgress) -> TypeDefinitionOptions& { + return *this; +} + +WorkspaceFoldersChangeEvent::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("added")) return false; + if (!repr_.contains("removed")) return false; + return true; +} + +auto WorkspaceFoldersChangeEvent::added() const -> Vector { + const auto& value = repr_["added"]; + + assert(value.is_array()); + return Vector(value); +} + +auto WorkspaceFoldersChangeEvent::removed() const -> Vector { + const auto& value = repr_["removed"]; + + assert(value.is_array()); + return Vector(value); +} + +auto WorkspaceFoldersChangeEvent::added(Vector added) + -> WorkspaceFoldersChangeEvent& { + return *this; +} + +auto WorkspaceFoldersChangeEvent::removed(Vector removed) + -> WorkspaceFoldersChangeEvent& { + return *this; +} + +ConfigurationItem::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ConfigurationItem::scopeUri() const -> std::optional { + if (!repr_.contains("scopeUri")) return std::nullopt; + + const auto& value = repr_["scopeUri"]; + + assert(value.is_string()); + return value.get(); +} + +auto ConfigurationItem::section() const -> std::optional { + if (!repr_.contains("section")) return std::nullopt; + + const auto& value = repr_["section"]; + + assert(value.is_string()); + return value.get(); +} + +auto ConfigurationItem::scopeUri(std::optional scopeUri) + -> ConfigurationItem& { + return *this; +} + +auto ConfigurationItem::section(std::optional section) + -> ConfigurationItem& { + return *this; +} + +TextDocumentIdentifier::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto TextDocumentIdentifier::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentIdentifier::uri(std::string uri) -> TextDocumentIdentifier& { + return *this; +} + +Color::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("red")) return false; + if (!repr_.contains("green")) return false; + if (!repr_.contains("blue")) return false; + if (!repr_.contains("alpha")) return false; + return true; +} + +auto Color::red() const -> double { + const auto& value = repr_["red"]; + + assert(value.is_number()); + return value.get(); +} + +auto Color::green() const -> double { + const auto& value = repr_["green"]; + + assert(value.is_number()); + return value.get(); +} + +auto Color::blue() const -> double { + const auto& value = repr_["blue"]; + + assert(value.is_number()); + return value.get(); +} + +auto Color::alpha() const -> double { + const auto& value = repr_["alpha"]; + + assert(value.is_number()); + return value.get(); +} + +auto Color::red(double red) -> Color& { return *this; } + +auto Color::green(double green) -> Color& { return *this; } + +auto Color::blue(double blue) -> Color& { return *this; } + +auto Color::alpha(double alpha) -> Color& { return *this; } + +DocumentColorOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentColorOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentColorOptions::workDoneProgress( + std::optional workDoneProgress) -> DocumentColorOptions& { + return *this; +} + +FoldingRangeOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto FoldingRangeOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FoldingRangeOptions::workDoneProgress(std::optional workDoneProgress) + -> FoldingRangeOptions& { + return *this; +} + +DeclarationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DeclarationOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DeclarationOptions::workDoneProgress(std::optional workDoneProgress) + -> DeclarationOptions& { + return *this; +} + +Position::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("line")) return false; + if (!repr_.contains("character")) return false; + return true; +} + +auto Position::line() const -> long { + const auto& value = repr_["line"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto Position::character() const -> long { + const auto& value = repr_["character"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto Position::line(long line) -> Position& { return *this; } + +auto Position::character(long character) -> Position& { return *this; } + +SelectionRangeOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto SelectionRangeOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SelectionRangeOptions::workDoneProgress( + std::optional workDoneProgress) -> SelectionRangeOptions& { + return *this; +} + +CallHierarchyOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CallHierarchyOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CallHierarchyOptions::workDoneProgress( + std::optional workDoneProgress) -> CallHierarchyOptions& { + return *this; +} + +SemanticTokensOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("legend")) return false; + return true; +} + +auto SemanticTokensOptions::legend() const -> SemanticTokensLegend { + const auto& value = repr_["legend"]; + + return SemanticTokensLegend(value); +} + +auto SemanticTokensOptions::range() const + -> std::optional> { + if (!repr_.contains("range")) return std::nullopt; + + const auto& value = repr_["range"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto SemanticTokensOptions::full() const -> std::optional< + std::variant> { + if (!repr_.contains("full")) return std::nullopt; + + const auto& value = repr_["full"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto SemanticTokensOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SemanticTokensOptions::legend(SemanticTokensLegend legend) + -> SemanticTokensOptions& { + return *this; +} + +auto SemanticTokensOptions::range( + std::optional> range) + -> SemanticTokensOptions& { + return *this; +} + +auto SemanticTokensOptions::full( + std::optional> + full) -> SemanticTokensOptions& { + return *this; +} + +auto SemanticTokensOptions::workDoneProgress( + std::optional workDoneProgress) -> SemanticTokensOptions& { + return *this; +} + +SemanticTokensEdit::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("start")) return false; + if (!repr_.contains("deleteCount")) return false; + return true; +} + +auto SemanticTokensEdit::start() const -> long { + const auto& value = repr_["start"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto SemanticTokensEdit::deleteCount() const -> long { + const auto& value = repr_["deleteCount"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto SemanticTokensEdit::data() const -> std::optional> { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SemanticTokensEdit::start(long start) -> SemanticTokensEdit& { + return *this; +} + +auto SemanticTokensEdit::deleteCount(long deleteCount) -> SemanticTokensEdit& { + return *this; +} + +auto SemanticTokensEdit::data(std::optional> data) + -> SemanticTokensEdit& { + return *this; +} + +LinkedEditingRangeOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto LinkedEditingRangeOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto LinkedEditingRangeOptions::workDoneProgress( + std::optional workDoneProgress) -> LinkedEditingRangeOptions& { + return *this; +} + +FileCreate::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto FileCreate::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto FileCreate::uri(std::string uri) -> FileCreate& { return *this; } + +TextDocumentEdit::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("textDocument")) return false; + if (!repr_.contains("edits")) return false; + return true; +} + +auto TextDocumentEdit::textDocument() const + -> OptionalVersionedTextDocumentIdentifier { + const auto& value = repr_["textDocument"]; + + return OptionalVersionedTextDocumentIdentifier(value); +} + +auto TextDocumentEdit::edits() const + -> Vector> { + const auto& value = repr_["edits"]; + + assert(value.is_array()); + return Vector>(value); +} + +auto TextDocumentEdit::textDocument( + OptionalVersionedTextDocumentIdentifier textDocument) -> TextDocumentEdit& { + return *this; +} + +auto TextDocumentEdit::edits( + Vector> + edits) -> TextDocumentEdit& { + return *this; +} + +CreateFile::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "create") return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto CreateFile::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto CreateFile::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto CreateFile::options() const -> std::optional { + if (!repr_.contains("options")) return std::nullopt; + + const auto& value = repr_["options"]; + + return CreateFileOptions(value); +} + +auto CreateFile::annotationId() const + -> std::optional { + if (!repr_.contains("annotationId")) return std::nullopt; + + const auto& value = repr_["annotationId"]; + + assert(value.is_string()); + return value.get(); +} + +auto CreateFile::kind(std::string kind) -> CreateFile& { return *this; } + +auto CreateFile::uri(std::string uri) -> CreateFile& { return *this; } + +auto CreateFile::options(std::optional options) + -> CreateFile& { + return *this; +} + +auto CreateFile::annotationId( + std::optional annotationId) -> CreateFile& { + return *this; +} + +RenameFile::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "rename") return false; + if (!repr_.contains("oldUri")) return false; + if (!repr_.contains("newUri")) return false; + return true; +} + +auto RenameFile::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto RenameFile::oldUri() const -> std::string { + const auto& value = repr_["oldUri"]; + + assert(value.is_string()); + return value.get(); +} + +auto RenameFile::newUri() const -> std::string { + const auto& value = repr_["newUri"]; + + assert(value.is_string()); + return value.get(); +} + +auto RenameFile::options() const -> std::optional { + if (!repr_.contains("options")) return std::nullopt; + + const auto& value = repr_["options"]; + + return RenameFileOptions(value); +} + +auto RenameFile::annotationId() const + -> std::optional { + if (!repr_.contains("annotationId")) return std::nullopt; + + const auto& value = repr_["annotationId"]; + + assert(value.is_string()); + return value.get(); +} + +auto RenameFile::kind(std::string kind) -> RenameFile& { return *this; } + +auto RenameFile::oldUri(std::string oldUri) -> RenameFile& { return *this; } + +auto RenameFile::newUri(std::string newUri) -> RenameFile& { return *this; } + +auto RenameFile::options(std::optional options) + -> RenameFile& { + return *this; +} + +auto RenameFile::annotationId( + std::optional annotationId) -> RenameFile& { + return *this; +} + +DeleteFile::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "delete") return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto DeleteFile::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto DeleteFile::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto DeleteFile::options() const -> std::optional { + if (!repr_.contains("options")) return std::nullopt; + + const auto& value = repr_["options"]; + + return DeleteFileOptions(value); +} + +auto DeleteFile::annotationId() const + -> std::optional { + if (!repr_.contains("annotationId")) return std::nullopt; + + const auto& value = repr_["annotationId"]; + + assert(value.is_string()); + return value.get(); +} + +auto DeleteFile::kind(std::string kind) -> DeleteFile& { return *this; } + +auto DeleteFile::uri(std::string uri) -> DeleteFile& { return *this; } + +auto DeleteFile::options(std::optional options) + -> DeleteFile& { + return *this; +} + +auto DeleteFile::annotationId( + std::optional annotationId) -> DeleteFile& { + return *this; +} + +ChangeAnnotation::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("label")) return false; + return true; +} + +auto ChangeAnnotation::label() const -> std::string { + const auto& value = repr_["label"]; + + assert(value.is_string()); + return value.get(); +} + +auto ChangeAnnotation::needsConfirmation() const -> std::optional { + if (!repr_.contains("needsConfirmation")) return std::nullopt; + + const auto& value = repr_["needsConfirmation"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ChangeAnnotation::description() const -> std::optional { + if (!repr_.contains("description")) return std::nullopt; + + const auto& value = repr_["description"]; + + assert(value.is_string()); + return value.get(); +} + +auto ChangeAnnotation::label(std::string label) -> ChangeAnnotation& { + return *this; +} + +auto ChangeAnnotation::needsConfirmation(std::optional needsConfirmation) + -> ChangeAnnotation& { + return *this; +} + +auto ChangeAnnotation::description(std::optional description) + -> ChangeAnnotation& { + return *this; +} + +FileOperationFilter::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("pattern")) return false; + return true; +} + +auto FileOperationFilter::scheme() const -> std::optional { + if (!repr_.contains("scheme")) return std::nullopt; + + const auto& value = repr_["scheme"]; + + assert(value.is_string()); + return value.get(); +} + +auto FileOperationFilter::pattern() const -> FileOperationPattern { + const auto& value = repr_["pattern"]; + + return FileOperationPattern(value); +} + +auto FileOperationFilter::scheme(std::optional scheme) + -> FileOperationFilter& { + return *this; +} + +auto FileOperationFilter::pattern(FileOperationPattern pattern) + -> FileOperationFilter& { + return *this; +} + +FileRename::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("oldUri")) return false; + if (!repr_.contains("newUri")) return false; + return true; +} + +auto FileRename::oldUri() const -> std::string { + const auto& value = repr_["oldUri"]; + + assert(value.is_string()); + return value.get(); +} + +auto FileRename::newUri() const -> std::string { + const auto& value = repr_["newUri"]; + + assert(value.is_string()); + return value.get(); +} + +auto FileRename::oldUri(std::string oldUri) -> FileRename& { return *this; } + +auto FileRename::newUri(std::string newUri) -> FileRename& { return *this; } + +FileDelete::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto FileDelete::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto FileDelete::uri(std::string uri) -> FileDelete& { return *this; } + +MonikerOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto MonikerOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto MonikerOptions::workDoneProgress(std::optional workDoneProgress) + -> MonikerOptions& { + return *this; +} + +TypeHierarchyOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto TypeHierarchyOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TypeHierarchyOptions::workDoneProgress( + std::optional workDoneProgress) -> TypeHierarchyOptions& { + return *this; +} + +InlineValueContext::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("frameId")) return false; + if (!repr_.contains("stoppedLocation")) return false; + return true; +} + +auto InlineValueContext::frameId() const -> int { + const auto& value = repr_["frameId"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto InlineValueContext::stoppedLocation() const -> Range { + const auto& value = repr_["stoppedLocation"]; + + return Range(value); +} + +auto InlineValueContext::frameId(int frameId) -> InlineValueContext& { + return *this; +} + +auto InlineValueContext::stoppedLocation(Range stoppedLocation) + -> InlineValueContext& { + return *this; +} + +InlineValueText::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("text")) return false; + return true; +} + +auto InlineValueText::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto InlineValueText::text() const -> std::string { + const auto& value = repr_["text"]; + + assert(value.is_string()); + return value.get(); +} + +auto InlineValueText::range(Range range) -> InlineValueText& { return *this; } + +auto InlineValueText::text(std::string text) -> InlineValueText& { + return *this; +} + +InlineValueVariableLookup::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("caseSensitiveLookup")) return false; + return true; +} + +auto InlineValueVariableLookup::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto InlineValueVariableLookup::variableName() const + -> std::optional { + if (!repr_.contains("variableName")) return std::nullopt; + + const auto& value = repr_["variableName"]; + + assert(value.is_string()); + return value.get(); +} + +auto InlineValueVariableLookup::caseSensitiveLookup() const -> bool { + const auto& value = repr_["caseSensitiveLookup"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlineValueVariableLookup::range(Range range) + -> InlineValueVariableLookup& { + return *this; +} + +auto InlineValueVariableLookup::variableName( + std::optional variableName) -> InlineValueVariableLookup& { + return *this; +} + +auto InlineValueVariableLookup::caseSensitiveLookup(bool caseSensitiveLookup) + -> InlineValueVariableLookup& { + return *this; +} + +InlineValueEvaluatableExpression::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + return true; +} + +auto InlineValueEvaluatableExpression::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto InlineValueEvaluatableExpression::expression() const + -> std::optional { + if (!repr_.contains("expression")) return std::nullopt; + + const auto& value = repr_["expression"]; + + assert(value.is_string()); + return value.get(); +} + +auto InlineValueEvaluatableExpression::range(Range range) + -> InlineValueEvaluatableExpression& { + return *this; +} + +auto InlineValueEvaluatableExpression::expression( + std::optional expression) + -> InlineValueEvaluatableExpression& { + return *this; +} + +InlineValueOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto InlineValueOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlineValueOptions::workDoneProgress(std::optional workDoneProgress) + -> InlineValueOptions& { + return *this; +} + +InlayHintLabelPart::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("value")) return false; + return true; +} + +auto InlayHintLabelPart::value() const -> std::string { + const auto& value = repr_["value"]; + + assert(value.is_string()); + return value.get(); +} + +auto InlayHintLabelPart::tooltip() const + -> std::optional> { + if (!repr_.contains("tooltip")) return std::nullopt; + + const auto& value = repr_["tooltip"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto InlayHintLabelPart::location() const -> std::optional { + if (!repr_.contains("location")) return std::nullopt; + + const auto& value = repr_["location"]; + + return Location(value); +} + +auto InlayHintLabelPart::command() const -> std::optional { + if (!repr_.contains("command")) return std::nullopt; + + const auto& value = repr_["command"]; + + return Command(value); +} + +auto InlayHintLabelPart::value(std::string value) -> InlayHintLabelPart& { + return *this; +} + +auto InlayHintLabelPart::tooltip( + std::optional> + tooltip) -> InlayHintLabelPart& { + return *this; +} + +auto InlayHintLabelPart::location(std::optional location) + -> InlayHintLabelPart& { + return *this; +} + +auto InlayHintLabelPart::command(std::optional command) + -> InlayHintLabelPart& { + return *this; +} + +MarkupContent::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (!repr_.contains("value")) return false; + return true; +} + +auto MarkupContent::kind() const -> MarkupKind { + const auto& value = repr_["kind"]; + + lsp_runtime_error("MarkupContent::kind: not implement yet"); +} + +auto MarkupContent::value() const -> std::string { + const auto& value = repr_["value"]; + + assert(value.is_string()); + return value.get(); +} + +auto MarkupContent::kind(MarkupKind kind) -> MarkupContent& { return *this; } + +auto MarkupContent::value(std::string value) -> MarkupContent& { return *this; } + +InlayHintOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto InlayHintOptions::resolveProvider() const -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlayHintOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlayHintOptions::resolveProvider(std::optional resolveProvider) + -> InlayHintOptions& { + return *this; +} + +auto InlayHintOptions::workDoneProgress(std::optional workDoneProgress) + -> InlayHintOptions& { + return *this; +} + +RelatedFullDocumentDiagnosticReport::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "full") return false; + if (!repr_.contains("items")) return false; + return true; +} + +auto RelatedFullDocumentDiagnosticReport::relatedDocuments() const + -> std::optional>> { + if (!repr_.contains("relatedDocuments")) return std::nullopt; + + const auto& value = repr_["relatedDocuments"]; + + assert(value.is_object()); + return Map>(value); +} + +auto RelatedFullDocumentDiagnosticReport::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto RelatedFullDocumentDiagnosticReport::resultId() const + -> std::optional { + if (!repr_.contains("resultId")) return std::nullopt; + + const auto& value = repr_["resultId"]; + + assert(value.is_string()); + return value.get(); +} + +auto RelatedFullDocumentDiagnosticReport::items() const -> Vector { + const auto& value = repr_["items"]; + + assert(value.is_array()); + return Vector(value); +} + +auto RelatedFullDocumentDiagnosticReport::relatedDocuments( + std::optional>> + relatedDocuments) -> RelatedFullDocumentDiagnosticReport& { + return *this; +} + +auto RelatedFullDocumentDiagnosticReport::kind(std::string kind) + -> RelatedFullDocumentDiagnosticReport& { + return *this; +} + +auto RelatedFullDocumentDiagnosticReport::resultId( + std::optional resultId) + -> RelatedFullDocumentDiagnosticReport& { + return *this; +} + +auto RelatedFullDocumentDiagnosticReport::items(Vector items) + -> RelatedFullDocumentDiagnosticReport& { + return *this; +} + +RelatedUnchangedDocumentDiagnosticReport::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "unchanged") return false; + if (!repr_.contains("resultId")) return false; + return true; +} + +auto RelatedUnchangedDocumentDiagnosticReport::relatedDocuments() const + -> std::optional>> { + if (!repr_.contains("relatedDocuments")) return std::nullopt; + + const auto& value = repr_["relatedDocuments"]; + + assert(value.is_object()); + return Map>(value); +} + +auto RelatedUnchangedDocumentDiagnosticReport::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto RelatedUnchangedDocumentDiagnosticReport::resultId() const -> std::string { + const auto& value = repr_["resultId"]; + + assert(value.is_string()); + return value.get(); +} + +auto RelatedUnchangedDocumentDiagnosticReport::relatedDocuments( + std::optional>> + relatedDocuments) -> RelatedUnchangedDocumentDiagnosticReport& { + return *this; +} + +auto RelatedUnchangedDocumentDiagnosticReport::kind(std::string kind) + -> RelatedUnchangedDocumentDiagnosticReport& { + return *this; +} + +auto RelatedUnchangedDocumentDiagnosticReport::resultId(std::string resultId) + -> RelatedUnchangedDocumentDiagnosticReport& { + return *this; +} + +FullDocumentDiagnosticReport::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "full") return false; + if (!repr_.contains("items")) return false; + return true; +} + +auto FullDocumentDiagnosticReport::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto FullDocumentDiagnosticReport::resultId() const + -> std::optional { + if (!repr_.contains("resultId")) return std::nullopt; + + const auto& value = repr_["resultId"]; + + assert(value.is_string()); + return value.get(); +} + +auto FullDocumentDiagnosticReport::items() const -> Vector { + const auto& value = repr_["items"]; + + assert(value.is_array()); + return Vector(value); +} + +auto FullDocumentDiagnosticReport::kind(std::string kind) + -> FullDocumentDiagnosticReport& { + return *this; +} + +auto FullDocumentDiagnosticReport::resultId(std::optional resultId) + -> FullDocumentDiagnosticReport& { + return *this; +} + +auto FullDocumentDiagnosticReport::items(Vector items) + -> FullDocumentDiagnosticReport& { + return *this; +} + +UnchangedDocumentDiagnosticReport::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "unchanged") return false; + if (!repr_.contains("resultId")) return false; + return true; +} + +auto UnchangedDocumentDiagnosticReport::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto UnchangedDocumentDiagnosticReport::resultId() const -> std::string { + const auto& value = repr_["resultId"]; + + assert(value.is_string()); + return value.get(); +} + +auto UnchangedDocumentDiagnosticReport::kind(std::string kind) + -> UnchangedDocumentDiagnosticReport& { + return *this; +} + +auto UnchangedDocumentDiagnosticReport::resultId(std::string resultId) + -> UnchangedDocumentDiagnosticReport& { + return *this; +} + +DiagnosticOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("interFileDependencies")) return false; + if (!repr_.contains("workspaceDiagnostics")) return false; + return true; +} + +auto DiagnosticOptions::identifier() const -> std::optional { + if (!repr_.contains("identifier")) return std::nullopt; + + const auto& value = repr_["identifier"]; + + assert(value.is_string()); + return value.get(); +} + +auto DiagnosticOptions::interFileDependencies() const -> bool { + const auto& value = repr_["interFileDependencies"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticOptions::workspaceDiagnostics() const -> bool { + const auto& value = repr_["workspaceDiagnostics"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticOptions::identifier(std::optional identifier) + -> DiagnosticOptions& { + return *this; +} + +auto DiagnosticOptions::interFileDependencies(bool interFileDependencies) + -> DiagnosticOptions& { + return *this; +} + +auto DiagnosticOptions::workspaceDiagnostics(bool workspaceDiagnostics) + -> DiagnosticOptions& { + return *this; +} + +auto DiagnosticOptions::workDoneProgress(std::optional workDoneProgress) + -> DiagnosticOptions& { + return *this; +} + +PreviousResultId::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + if (!repr_.contains("value")) return false; + return true; +} + +auto PreviousResultId::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto PreviousResultId::value() const -> std::string { + const auto& value = repr_["value"]; + + assert(value.is_string()); + return value.get(); +} + +auto PreviousResultId::uri(std::string uri) -> PreviousResultId& { + return *this; +} + +auto PreviousResultId::value(std::string value) -> PreviousResultId& { + return *this; +} + +NotebookDocument::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + if (!repr_.contains("notebookType")) return false; + if (!repr_.contains("version")) return false; + if (!repr_.contains("cells")) return false; + return true; +} + +auto NotebookDocument::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookDocument::notebookType() const -> std::string { + const auto& value = repr_["notebookType"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookDocument::version() const -> int { + const auto& value = repr_["version"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto NotebookDocument::metadata() const -> std::optional { + if (!repr_.contains("metadata")) return std::nullopt; + + const auto& value = repr_["metadata"]; + + assert(value.is_object()); + return LSPObject(value); +} + +auto NotebookDocument::cells() const -> Vector { + const auto& value = repr_["cells"]; + + assert(value.is_array()); + return Vector(value); +} + +auto NotebookDocument::uri(std::string uri) -> NotebookDocument& { + return *this; +} + +auto NotebookDocument::notebookType(std::string notebookType) + -> NotebookDocument& { + return *this; +} + +auto NotebookDocument::version(int version) -> NotebookDocument& { + return *this; +} + +auto NotebookDocument::metadata(std::optional metadata) + -> NotebookDocument& { + return *this; +} + +auto NotebookDocument::cells(Vector cells) -> NotebookDocument& { + return *this; +} + +TextDocumentItem::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + if (!repr_.contains("languageId")) return false; + if (!repr_.contains("version")) return false; + if (!repr_.contains("text")) return false; + return true; +} + +auto TextDocumentItem::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentItem::languageId() const -> LanguageKind { + const auto& value = repr_["languageId"]; + + lsp_runtime_error("TextDocumentItem::languageId: not implement yet"); +} + +auto TextDocumentItem::version() const -> int { + const auto& value = repr_["version"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto TextDocumentItem::text() const -> std::string { + const auto& value = repr_["text"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentItem::uri(std::string uri) -> TextDocumentItem& { + return *this; +} + +auto TextDocumentItem::languageId(LanguageKind languageId) + -> TextDocumentItem& { + return *this; +} + +auto TextDocumentItem::version(int version) -> TextDocumentItem& { + return *this; +} + +auto TextDocumentItem::text(std::string text) -> TextDocumentItem& { + return *this; +} + +NotebookDocumentSyncOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("notebookSelector")) return false; + return true; +} + +auto NotebookDocumentSyncOptions::notebookSelector() const + -> Vector> { + const auto& value = repr_["notebookSelector"]; + + assert(value.is_array()); + return Vector>(value); +} + +auto NotebookDocumentSyncOptions::save() const -> std::optional { + if (!repr_.contains("save")) return std::nullopt; + + const auto& value = repr_["save"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto NotebookDocumentSyncOptions::notebookSelector( + Vector> + notebookSelector) -> NotebookDocumentSyncOptions& { + return *this; +} + +auto NotebookDocumentSyncOptions::save(std::optional save) + -> NotebookDocumentSyncOptions& { + return *this; +} + +VersionedNotebookDocumentIdentifier::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("version")) return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto VersionedNotebookDocumentIdentifier::version() const -> int { + const auto& value = repr_["version"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto VersionedNotebookDocumentIdentifier::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto VersionedNotebookDocumentIdentifier::version(int version) + -> VersionedNotebookDocumentIdentifier& { + return *this; +} + +auto VersionedNotebookDocumentIdentifier::uri(std::string uri) + -> VersionedNotebookDocumentIdentifier& { + return *this; +} + +NotebookDocumentChangeEvent::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto NotebookDocumentChangeEvent::metadata() const -> std::optional { + if (!repr_.contains("metadata")) return std::nullopt; + + const auto& value = repr_["metadata"]; + + assert(value.is_object()); + return LSPObject(value); +} + +auto NotebookDocumentChangeEvent::cells() const + -> std::optional { + if (!repr_.contains("cells")) return std::nullopt; + + const auto& value = repr_["cells"]; + + return NotebookDocumentCellChanges(value); +} + +auto NotebookDocumentChangeEvent::metadata(std::optional metadata) + -> NotebookDocumentChangeEvent& { + return *this; +} + +auto NotebookDocumentChangeEvent::cells( + std::optional cells) + -> NotebookDocumentChangeEvent& { + return *this; +} + +NotebookDocumentIdentifier::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto NotebookDocumentIdentifier::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookDocumentIdentifier::uri(std::string uri) + -> NotebookDocumentIdentifier& { + return *this; +} + +InlineCompletionContext::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("triggerKind")) return false; + return true; +} + +auto InlineCompletionContext::triggerKind() const + -> InlineCompletionTriggerKind { + const auto& value = repr_["triggerKind"]; + + return InlineCompletionTriggerKind(value); +} + +auto InlineCompletionContext::selectedCompletionInfo() const + -> std::optional { + if (!repr_.contains("selectedCompletionInfo")) return std::nullopt; + + const auto& value = repr_["selectedCompletionInfo"]; + + return SelectedCompletionInfo(value); +} + +auto InlineCompletionContext::triggerKind( + InlineCompletionTriggerKind triggerKind) -> InlineCompletionContext& { + return *this; +} + +auto InlineCompletionContext::selectedCompletionInfo( + std::optional selectedCompletionInfo) + -> InlineCompletionContext& { + return *this; +} + +StringValue::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "snippet") return false; + if (!repr_.contains("value")) return false; + return true; +} + +auto StringValue::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto StringValue::value() const -> std::string { + const auto& value = repr_["value"]; + + assert(value.is_string()); + return value.get(); +} + +auto StringValue::kind(std::string kind) -> StringValue& { return *this; } + +auto StringValue::value(std::string value) -> StringValue& { return *this; } + +InlineCompletionOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto InlineCompletionOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlineCompletionOptions::workDoneProgress( + std::optional workDoneProgress) -> InlineCompletionOptions& { + return *this; +} + +TextDocumentContentOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("schemes")) return false; + return true; +} + +auto TextDocumentContentOptions::schemes() const -> Vector { + const auto& value = repr_["schemes"]; + + assert(value.is_array()); + return Vector(value); +} + +auto TextDocumentContentOptions::schemes(Vector schemes) + -> TextDocumentContentOptions& { + return *this; +} + +Registration::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("id")) return false; + if (!repr_.contains("method")) return false; + return true; +} + +auto Registration::id() const -> std::string { + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto Registration::method() const -> std::string { + const auto& value = repr_["method"]; + + assert(value.is_string()); + return value.get(); +} + +auto Registration::registerOptions() const -> std::optional { + if (!repr_.contains("registerOptions")) return std::nullopt; + + const auto& value = repr_["registerOptions"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto Registration::id(std::string id) -> Registration& { return *this; } + +auto Registration::method(std::string method) -> Registration& { return *this; } + +auto Registration::registerOptions(std::optional registerOptions) + -> Registration& { + return *this; +} + +Unregistration::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("id")) return false; + if (!repr_.contains("method")) return false; + return true; +} + +auto Unregistration::id() const -> std::string { + const auto& value = repr_["id"]; + + assert(value.is_string()); + return value.get(); +} + +auto Unregistration::method() const -> std::string { + const auto& value = repr_["method"]; + + assert(value.is_string()); + return value.get(); +} + +auto Unregistration::id(std::string id) -> Unregistration& { return *this; } + +auto Unregistration::method(std::string method) -> Unregistration& { + return *this; +} + +_InitializeParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("processId")) return false; + if (!repr_.contains("rootUri")) return false; + if (!repr_.contains("capabilities")) return false; + return true; +} + +auto _InitializeParams::processId() const + -> std::variant { + const auto& value = repr_["processId"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto _InitializeParams::clientInfo() const -> std::optional { + if (!repr_.contains("clientInfo")) return std::nullopt; + + const auto& value = repr_["clientInfo"]; + + return ClientInfo(value); +} + +auto _InitializeParams::locale() const -> std::optional { + if (!repr_.contains("locale")) return std::nullopt; + + const auto& value = repr_["locale"]; + + assert(value.is_string()); + return value.get(); +} + +auto _InitializeParams::rootPath() const -> std::optional< + std::variant> { + if (!repr_.contains("rootPath")) return std::nullopt; + + const auto& value = repr_["rootPath"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto _InitializeParams::rootUri() const + -> std::variant { + const auto& value = repr_["rootUri"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto _InitializeParams::capabilities() const -> ClientCapabilities { + const auto& value = repr_["capabilities"]; + + return ClientCapabilities(value); +} + +auto _InitializeParams::initializationOptions() const -> std::optional { + if (!repr_.contains("initializationOptions")) return std::nullopt; + + const auto& value = repr_["initializationOptions"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto _InitializeParams::trace() const -> std::optional { + if (!repr_.contains("trace")) return std::nullopt; + + const auto& value = repr_["trace"]; + + lsp_runtime_error("_InitializeParams::trace: not implement yet"); +} + +auto _InitializeParams::workDoneToken() const -> std::optional { + if (!repr_.contains("workDoneToken")) return std::nullopt; + + const auto& value = repr_["workDoneToken"]; + + ProgressToken result; + + details::try_emplace(result, value); + + return result; +} + +auto _InitializeParams::processId( + std::variant processId) + -> _InitializeParams& { + return *this; +} + +auto _InitializeParams::clientInfo(std::optional clientInfo) + -> _InitializeParams& { + return *this; +} + +auto _InitializeParams::locale(std::optional locale) + -> _InitializeParams& { + return *this; +} + +auto _InitializeParams::rootPath( + std::optional> + rootPath) -> _InitializeParams& { + return *this; +} + +auto _InitializeParams::rootUri( + std::variant rootUri) + -> _InitializeParams& { + return *this; +} + +auto _InitializeParams::capabilities(ClientCapabilities capabilities) + -> _InitializeParams& { + return *this; +} + +auto _InitializeParams::initializationOptions( + std::optional initializationOptions) -> _InitializeParams& { + return *this; +} + +auto _InitializeParams::trace(std::optional trace) + -> _InitializeParams& { + return *this; +} + +auto _InitializeParams::workDoneToken( + std::optional workDoneToken) -> _InitializeParams& { + return *this; +} + +WorkspaceFoldersInitializeParams::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkspaceFoldersInitializeParams::workspaceFolders() const + -> std::optional< + std::variant, std::nullptr_t>> { + if (!repr_.contains("workspaceFolders")) return std::nullopt; + + const auto& value = repr_["workspaceFolders"]; + + std::variant, std::nullptr_t> result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkspaceFoldersInitializeParams::workspaceFolders( + std::optional< + std::variant, std::nullptr_t>> + workspaceFolders) -> WorkspaceFoldersInitializeParams& { + return *this; +} + +ServerCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ServerCapabilities::positionEncoding() const + -> std::optional { + if (!repr_.contains("positionEncoding")) return std::nullopt; + + const auto& value = repr_["positionEncoding"]; + + lsp_runtime_error("ServerCapabilities::positionEncoding: not implement yet"); +} + +auto ServerCapabilities::textDocumentSync() const + -> std::optional> { + if (!repr_.contains("textDocumentSync")) return std::nullopt; + + const auto& value = repr_["textDocumentSync"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::notebookDocumentSync() const + -> std::optional> { + if (!repr_.contains("notebookDocumentSync")) return std::nullopt; + + const auto& value = repr_["notebookDocumentSync"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::completionProvider() const + -> std::optional { + if (!repr_.contains("completionProvider")) return std::nullopt; + + const auto& value = repr_["completionProvider"]; + + return CompletionOptions(value); +} + +auto ServerCapabilities::hoverProvider() const + -> std::optional> { + if (!repr_.contains("hoverProvider")) return std::nullopt; + + const auto& value = repr_["hoverProvider"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::signatureHelpProvider() const + -> std::optional { + if (!repr_.contains("signatureHelpProvider")) return std::nullopt; + + const auto& value = repr_["signatureHelpProvider"]; + + return SignatureHelpOptions(value); +} + +auto ServerCapabilities::declarationProvider() const + -> std::optional> { + if (!repr_.contains("declarationProvider")) return std::nullopt; + + const auto& value = repr_["declarationProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::definitionProvider() const + -> std::optional> { + if (!repr_.contains("definitionProvider")) return std::nullopt; + + const auto& value = repr_["definitionProvider"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::typeDefinitionProvider() const + -> std::optional> { + if (!repr_.contains("typeDefinitionProvider")) return std::nullopt; + + const auto& value = repr_["typeDefinitionProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::implementationProvider() const + -> std::optional> { + if (!repr_.contains("implementationProvider")) return std::nullopt; + + const auto& value = repr_["implementationProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::referencesProvider() const + -> std::optional> { + if (!repr_.contains("referencesProvider")) return std::nullopt; + + const auto& value = repr_["referencesProvider"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::documentHighlightProvider() const -> std::optional< + std::variant> { + if (!repr_.contains("documentHighlightProvider")) return std::nullopt; + + const auto& value = repr_["documentHighlightProvider"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::documentSymbolProvider() const -> std::optional< + std::variant> { + if (!repr_.contains("documentSymbolProvider")) return std::nullopt; + + const auto& value = repr_["documentSymbolProvider"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::codeActionProvider() const + -> std::optional> { + if (!repr_.contains("codeActionProvider")) return std::nullopt; + + const auto& value = repr_["codeActionProvider"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::codeLensProvider() const + -> std::optional { + if (!repr_.contains("codeLensProvider")) return std::nullopt; + + const auto& value = repr_["codeLensProvider"]; + + return CodeLensOptions(value); +} + +auto ServerCapabilities::documentLinkProvider() const + -> std::optional { + if (!repr_.contains("documentLinkProvider")) return std::nullopt; + + const auto& value = repr_["documentLinkProvider"]; + + return DocumentLinkOptions(value); +} + +auto ServerCapabilities::colorProvider() const + -> std::optional> { + if (!repr_.contains("colorProvider")) return std::nullopt; + + const auto& value = repr_["colorProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::workspaceSymbolProvider() const -> std::optional< + std::variant> { + if (!repr_.contains("workspaceSymbolProvider")) return std::nullopt; + + const auto& value = repr_["workspaceSymbolProvider"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::documentFormattingProvider() const -> std::optional< + std::variant> { + if (!repr_.contains("documentFormattingProvider")) return std::nullopt; + + const auto& value = repr_["documentFormattingProvider"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::documentRangeFormattingProvider() const + -> std::optional< + std::variant> { + if (!repr_.contains("documentRangeFormattingProvider")) return std::nullopt; + + const auto& value = repr_["documentRangeFormattingProvider"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::documentOnTypeFormattingProvider() const + -> std::optional { + if (!repr_.contains("documentOnTypeFormattingProvider")) return std::nullopt; + + const auto& value = repr_["documentOnTypeFormattingProvider"]; + + return DocumentOnTypeFormattingOptions(value); +} + +auto ServerCapabilities::renameProvider() const + -> std::optional> { + if (!repr_.contains("renameProvider")) return std::nullopt; + + const auto& value = repr_["renameProvider"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::foldingRangeProvider() const + -> std::optional> { + if (!repr_.contains("foldingRangeProvider")) return std::nullopt; + + const auto& value = repr_["foldingRangeProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::selectionRangeProvider() const + -> std::optional> { + if (!repr_.contains("selectionRangeProvider")) return std::nullopt; + + const auto& value = repr_["selectionRangeProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::executeCommandProvider() const + -> std::optional { + if (!repr_.contains("executeCommandProvider")) return std::nullopt; + + const auto& value = repr_["executeCommandProvider"]; + + return ExecuteCommandOptions(value); +} + +auto ServerCapabilities::callHierarchyProvider() const + -> std::optional> { + if (!repr_.contains("callHierarchyProvider")) return std::nullopt; + + const auto& value = repr_["callHierarchyProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::linkedEditingRangeProvider() const -> std::optional< + std::variant> { + if (!repr_.contains("linkedEditingRangeProvider")) return std::nullopt; + + const auto& value = repr_["linkedEditingRangeProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::semanticTokensProvider() const + -> std::optional> { + if (!repr_.contains("semanticTokensProvider")) return std::nullopt; + + const auto& value = repr_["semanticTokensProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::monikerProvider() const + -> std::optional> { + if (!repr_.contains("monikerProvider")) return std::nullopt; + + const auto& value = repr_["monikerProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::typeHierarchyProvider() const + -> std::optional> { + if (!repr_.contains("typeHierarchyProvider")) return std::nullopt; + + const auto& value = repr_["typeHierarchyProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::inlineValueProvider() const + -> std::optional> { + if (!repr_.contains("inlineValueProvider")) return std::nullopt; + + const auto& value = repr_["inlineValueProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::inlayHintProvider() const + -> std::optional> { + if (!repr_.contains("inlayHintProvider")) return std::nullopt; + + const auto& value = repr_["inlayHintProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::diagnosticProvider() const + -> std::optional> { + if (!repr_.contains("diagnosticProvider")) return std::nullopt; + + const auto& value = repr_["diagnosticProvider"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::inlineCompletionProvider() const -> std::optional< + std::variant> { + if (!repr_.contains("inlineCompletionProvider")) return std::nullopt; + + const auto& value = repr_["inlineCompletionProvider"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ServerCapabilities::workspace() const -> std::optional { + if (!repr_.contains("workspace")) return std::nullopt; + + const auto& value = repr_["workspace"]; + + return WorkspaceOptions(value); +} + +auto ServerCapabilities::experimental() const -> std::optional { + if (!repr_.contains("experimental")) return std::nullopt; + + const auto& value = repr_["experimental"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto ServerCapabilities::positionEncoding( + std::optional positionEncoding) + -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::textDocumentSync( + std::optional> + textDocumentSync) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::notebookDocumentSync( + std::optional> + notebookDocumentSync) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::completionProvider( + std::optional completionProvider) + -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::hoverProvider( + std::optional> + hoverProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::signatureHelpProvider( + std::optional signatureHelpProvider) + -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::declarationProvider( + std::optional> + declarationProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::definitionProvider( + std::optional> + definitionProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::typeDefinitionProvider( + std::optional> + typeDefinitionProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::implementationProvider( + std::optional> + implementationProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::referencesProvider( + std::optional> + referencesProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::documentHighlightProvider( + std::optional> + documentHighlightProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::documentSymbolProvider( + std::optional> + documentSymbolProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::codeActionProvider( + std::optional> + codeActionProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::codeLensProvider( + std::optional codeLensProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::documentLinkProvider( + std::optional documentLinkProvider) + -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::colorProvider( + std::optional> + colorProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::workspaceSymbolProvider( + std::optional> + workspaceSymbolProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::documentFormattingProvider( + std::optional> + documentFormattingProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::documentRangeFormattingProvider( + std::optional< + std::variant> + documentRangeFormattingProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::documentOnTypeFormattingProvider( + std::optional + documentOnTypeFormattingProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::renameProvider( + std::optional> + renameProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::foldingRangeProvider( + std::optional> + foldingRangeProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::selectionRangeProvider( + std::optional> + selectionRangeProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::executeCommandProvider( + std::optional executeCommandProvider) + -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::callHierarchyProvider( + std::optional> + callHierarchyProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::linkedEditingRangeProvider( + std::optional> + linkedEditingRangeProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::semanticTokensProvider( + std::optional> + semanticTokensProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::monikerProvider( + std::optional> + monikerProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::typeHierarchyProvider( + std::optional> + typeHierarchyProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::inlineValueProvider( + std::optional> + inlineValueProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::inlayHintProvider( + std::optional> + inlayHintProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::diagnosticProvider( + std::optional> + diagnosticProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::inlineCompletionProvider( + std::optional> + inlineCompletionProvider) -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::workspace(std::optional workspace) + -> ServerCapabilities& { + return *this; +} + +auto ServerCapabilities::experimental(std::optional experimental) + -> ServerCapabilities& { + return *this; +} + +ServerInfo::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("name")) return false; + return true; +} + +auto ServerInfo::name() const -> std::string { + const auto& value = repr_["name"]; + + assert(value.is_string()); + return value.get(); +} + +auto ServerInfo::version() const -> std::optional { + if (!repr_.contains("version")) return std::nullopt; + + const auto& value = repr_["version"]; + + assert(value.is_string()); + return value.get(); +} + +auto ServerInfo::name(std::string name) -> ServerInfo& { return *this; } + +auto ServerInfo::version(std::optional version) -> ServerInfo& { + return *this; +} + +VersionedTextDocumentIdentifier::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("version")) return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto VersionedTextDocumentIdentifier::version() const -> int { + const auto& value = repr_["version"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto VersionedTextDocumentIdentifier::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto VersionedTextDocumentIdentifier::version(int version) + -> VersionedTextDocumentIdentifier& { + return *this; +} + +auto VersionedTextDocumentIdentifier::uri(std::string uri) + -> VersionedTextDocumentIdentifier& { + return *this; +} + +SaveOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto SaveOptions::includeText() const -> std::optional { + if (!repr_.contains("includeText")) return std::nullopt; + + const auto& value = repr_["includeText"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SaveOptions::includeText(std::optional includeText) -> SaveOptions& { + return *this; +} + +FileEvent::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + if (!repr_.contains("type")) return false; + return true; +} + +auto FileEvent::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto FileEvent::type() const -> FileChangeType { + const auto& value = repr_["type"]; + + return FileChangeType(value); +} + +auto FileEvent::uri(std::string uri) -> FileEvent& { return *this; } + +auto FileEvent::type(FileChangeType type) -> FileEvent& { return *this; } + +FileSystemWatcher::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("globPattern")) return false; + return true; +} + +auto FileSystemWatcher::globPattern() const -> GlobPattern { + const auto& value = repr_["globPattern"]; + + GlobPattern result; + + details::try_emplace(result, value); + + return result; +} + +auto FileSystemWatcher::kind() const -> std::optional { + if (!repr_.contains("kind")) return std::nullopt; + + const auto& value = repr_["kind"]; + + return WatchKind(value); +} + +auto FileSystemWatcher::globPattern(GlobPattern globPattern) + -> FileSystemWatcher& { + return *this; +} + +auto FileSystemWatcher::kind(std::optional kind) + -> FileSystemWatcher& { + return *this; +} + +Diagnostic::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("message")) return false; + return true; +} + +auto Diagnostic::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto Diagnostic::severity() const -> std::optional { + if (!repr_.contains("severity")) return std::nullopt; + + const auto& value = repr_["severity"]; + + return DiagnosticSeverity(value); +} + +auto Diagnostic::code() const + -> std::optional> { + if (!repr_.contains("code")) return std::nullopt; + + const auto& value = repr_["code"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto Diagnostic::codeDescription() const -> std::optional { + if (!repr_.contains("codeDescription")) return std::nullopt; + + const auto& value = repr_["codeDescription"]; + + return CodeDescription(value); +} + +auto Diagnostic::source() const -> std::optional { + if (!repr_.contains("source")) return std::nullopt; + + const auto& value = repr_["source"]; + + assert(value.is_string()); + return value.get(); +} + +auto Diagnostic::message() const -> std::string { + const auto& value = repr_["message"]; + + assert(value.is_string()); + return value.get(); +} + +auto Diagnostic::tags() const -> std::optional> { + if (!repr_.contains("tags")) return std::nullopt; + + const auto& value = repr_["tags"]; + + assert(value.is_array()); + return Vector(value); +} + +auto Diagnostic::relatedInformation() const + -> std::optional> { + if (!repr_.contains("relatedInformation")) return std::nullopt; + + const auto& value = repr_["relatedInformation"]; + + assert(value.is_array()); + return Vector(value); +} + +auto Diagnostic::data() const -> std::optional { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto Diagnostic::range(Range range) -> Diagnostic& { return *this; } + +auto Diagnostic::severity(std::optional severity) + -> Diagnostic& { + return *this; +} + +auto Diagnostic::code( + std::optional> code) + -> Diagnostic& { + return *this; +} + +auto Diagnostic::codeDescription(std::optional codeDescription) + -> Diagnostic& { + return *this; +} + +auto Diagnostic::source(std::optional source) -> Diagnostic& { + return *this; +} + +auto Diagnostic::message(std::string message) -> Diagnostic& { return *this; } + +auto Diagnostic::tags(std::optional> tags) + -> Diagnostic& { + return *this; +} + +auto Diagnostic::relatedInformation( + std::optional> relatedInformation) + -> Diagnostic& { + return *this; +} + +auto Diagnostic::data(std::optional data) -> Diagnostic& { + return *this; +} + +CompletionContext::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("triggerKind")) return false; + return true; +} + +auto CompletionContext::triggerKind() const -> CompletionTriggerKind { + const auto& value = repr_["triggerKind"]; + + return CompletionTriggerKind(value); +} + +auto CompletionContext::triggerCharacter() const -> std::optional { + if (!repr_.contains("triggerCharacter")) return std::nullopt; + + const auto& value = repr_["triggerCharacter"]; + + assert(value.is_string()); + return value.get(); +} + +auto CompletionContext::triggerKind(CompletionTriggerKind triggerKind) + -> CompletionContext& { + return *this; +} + +auto CompletionContext::triggerCharacter( + std::optional triggerCharacter) -> CompletionContext& { + return *this; +} + +CompletionItemLabelDetails::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CompletionItemLabelDetails::detail() const -> std::optional { + if (!repr_.contains("detail")) return std::nullopt; + + const auto& value = repr_["detail"]; + + assert(value.is_string()); + return value.get(); +} + +auto CompletionItemLabelDetails::description() const + -> std::optional { + if (!repr_.contains("description")) return std::nullopt; + + const auto& value = repr_["description"]; + + assert(value.is_string()); + return value.get(); +} + +auto CompletionItemLabelDetails::detail(std::optional detail) + -> CompletionItemLabelDetails& { + return *this; +} + +auto CompletionItemLabelDetails::description( + std::optional description) -> CompletionItemLabelDetails& { + return *this; +} + +InsertReplaceEdit::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("newText")) return false; + if (!repr_.contains("insert")) return false; + if (!repr_.contains("replace")) return false; + return true; +} + +auto InsertReplaceEdit::newText() const -> std::string { + const auto& value = repr_["newText"]; + + assert(value.is_string()); + return value.get(); +} + +auto InsertReplaceEdit::insert() const -> Range { + const auto& value = repr_["insert"]; + + return Range(value); +} + +auto InsertReplaceEdit::replace() const -> Range { + const auto& value = repr_["replace"]; + + return Range(value); +} + +auto InsertReplaceEdit::newText(std::string newText) -> InsertReplaceEdit& { + return *this; +} + +auto InsertReplaceEdit::insert(Range insert) -> InsertReplaceEdit& { + return *this; +} + +auto InsertReplaceEdit::replace(Range replace) -> InsertReplaceEdit& { + return *this; +} + +CompletionItemDefaults::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CompletionItemDefaults::commitCharacters() const + -> std::optional> { + if (!repr_.contains("commitCharacters")) return std::nullopt; + + const auto& value = repr_["commitCharacters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CompletionItemDefaults::editRange() const -> std::optional< + std::variant> { + if (!repr_.contains("editRange")) return std::nullopt; + + const auto& value = repr_["editRange"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto CompletionItemDefaults::insertTextFormat() const + -> std::optional { + if (!repr_.contains("insertTextFormat")) return std::nullopt; + + const auto& value = repr_["insertTextFormat"]; + + return InsertTextFormat(value); +} + +auto CompletionItemDefaults::insertTextMode() const + -> std::optional { + if (!repr_.contains("insertTextMode")) return std::nullopt; + + const auto& value = repr_["insertTextMode"]; + + return InsertTextMode(value); +} + +auto CompletionItemDefaults::data() const -> std::optional { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto CompletionItemDefaults::commitCharacters( + std::optional> commitCharacters) + -> CompletionItemDefaults& { + return *this; +} + +auto CompletionItemDefaults::editRange( + std::optional< + std::variant> + editRange) -> CompletionItemDefaults& { + return *this; +} + +auto CompletionItemDefaults::insertTextFormat( + std::optional insertTextFormat) + -> CompletionItemDefaults& { + return *this; +} + +auto CompletionItemDefaults::insertTextMode( + std::optional insertTextMode) -> CompletionItemDefaults& { + return *this; +} + +auto CompletionItemDefaults::data(std::optional data) + -> CompletionItemDefaults& { + return *this; +} + +CompletionItemApplyKinds::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CompletionItemApplyKinds::commitCharacters() const + -> std::optional { + if (!repr_.contains("commitCharacters")) return std::nullopt; + + const auto& value = repr_["commitCharacters"]; + + return ApplyKind(value); +} + +auto CompletionItemApplyKinds::data() const -> std::optional { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + return ApplyKind(value); +} + +auto CompletionItemApplyKinds::commitCharacters( + std::optional commitCharacters) -> CompletionItemApplyKinds& { + return *this; +} + +auto CompletionItemApplyKinds::data(std::optional data) + -> CompletionItemApplyKinds& { + return *this; +} + +CompletionOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CompletionOptions::triggerCharacters() const + -> std::optional> { + if (!repr_.contains("triggerCharacters")) return std::nullopt; + + const auto& value = repr_["triggerCharacters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CompletionOptions::allCommitCharacters() const + -> std::optional> { + if (!repr_.contains("allCommitCharacters")) return std::nullopt; + + const auto& value = repr_["allCommitCharacters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CompletionOptions::resolveProvider() const -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CompletionOptions::completionItem() const + -> std::optional { + if (!repr_.contains("completionItem")) return std::nullopt; + + const auto& value = repr_["completionItem"]; + + return ServerCompletionItemOptions(value); +} + +auto CompletionOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CompletionOptions::triggerCharacters( + std::optional> triggerCharacters) + -> CompletionOptions& { + return *this; +} + +auto CompletionOptions::allCommitCharacters( + std::optional> allCommitCharacters) + -> CompletionOptions& { + return *this; +} + +auto CompletionOptions::resolveProvider(std::optional resolveProvider) + -> CompletionOptions& { + return *this; +} + +auto CompletionOptions::completionItem( + std::optional completionItem) + -> CompletionOptions& { + return *this; +} + +auto CompletionOptions::workDoneProgress(std::optional workDoneProgress) + -> CompletionOptions& { + return *this; +} + +HoverOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto HoverOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto HoverOptions::workDoneProgress(std::optional workDoneProgress) + -> HoverOptions& { + return *this; +} + +SignatureHelpContext::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("triggerKind")) return false; + if (!repr_.contains("isRetrigger")) return false; + return true; +} + +auto SignatureHelpContext::triggerKind() const -> SignatureHelpTriggerKind { + const auto& value = repr_["triggerKind"]; + + return SignatureHelpTriggerKind(value); +} + +auto SignatureHelpContext::triggerCharacter() const + -> std::optional { + if (!repr_.contains("triggerCharacter")) return std::nullopt; + + const auto& value = repr_["triggerCharacter"]; + + assert(value.is_string()); + return value.get(); +} + +auto SignatureHelpContext::isRetrigger() const -> bool { + const auto& value = repr_["isRetrigger"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SignatureHelpContext::activeSignatureHelp() const + -> std::optional { + if (!repr_.contains("activeSignatureHelp")) return std::nullopt; + + const auto& value = repr_["activeSignatureHelp"]; + + return SignatureHelp(value); +} + +auto SignatureHelpContext::triggerKind(SignatureHelpTriggerKind triggerKind) + -> SignatureHelpContext& { + return *this; +} + +auto SignatureHelpContext::triggerCharacter( + std::optional triggerCharacter) -> SignatureHelpContext& { + return *this; +} + +auto SignatureHelpContext::isRetrigger(bool isRetrigger) + -> SignatureHelpContext& { + return *this; +} + +auto SignatureHelpContext::activeSignatureHelp( + std::optional activeSignatureHelp) -> SignatureHelpContext& { + return *this; +} + +SignatureInformation::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("label")) return false; + return true; +} + +auto SignatureInformation::label() const -> std::string { + const auto& value = repr_["label"]; + + assert(value.is_string()); + return value.get(); +} + +auto SignatureInformation::documentation() const + -> std::optional> { + if (!repr_.contains("documentation")) return std::nullopt; + + const auto& value = repr_["documentation"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto SignatureInformation::parameters() const + -> std::optional> { + if (!repr_.contains("parameters")) return std::nullopt; + + const auto& value = repr_["parameters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SignatureInformation::activeParameter() const + -> std::optional> { + if (!repr_.contains("activeParameter")) return std::nullopt; + + const auto& value = repr_["activeParameter"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto SignatureInformation::label(std::string label) -> SignatureInformation& { + return *this; +} + +auto SignatureInformation::documentation( + std::optional> + documentation) -> SignatureInformation& { + return *this; +} + +auto SignatureInformation::parameters( + std::optional> parameters) + -> SignatureInformation& { + return *this; +} + +auto SignatureInformation::activeParameter( + std::optional> + activeParameter) -> SignatureInformation& { + return *this; +} + +SignatureHelpOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto SignatureHelpOptions::triggerCharacters() const + -> std::optional> { + if (!repr_.contains("triggerCharacters")) return std::nullopt; + + const auto& value = repr_["triggerCharacters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SignatureHelpOptions::retriggerCharacters() const + -> std::optional> { + if (!repr_.contains("retriggerCharacters")) return std::nullopt; + + const auto& value = repr_["retriggerCharacters"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SignatureHelpOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SignatureHelpOptions::triggerCharacters( + std::optional> triggerCharacters) + -> SignatureHelpOptions& { + return *this; +} + +auto SignatureHelpOptions::retriggerCharacters( + std::optional> retriggerCharacters) + -> SignatureHelpOptions& { + return *this; +} + +auto SignatureHelpOptions::workDoneProgress( + std::optional workDoneProgress) -> SignatureHelpOptions& { + return *this; +} + +DefinitionOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DefinitionOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DefinitionOptions::workDoneProgress(std::optional workDoneProgress) + -> DefinitionOptions& { + return *this; +} + +ReferenceContext::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("includeDeclaration")) return false; + return true; +} + +auto ReferenceContext::includeDeclaration() const -> bool { + const auto& value = repr_["includeDeclaration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ReferenceContext::includeDeclaration(bool includeDeclaration) + -> ReferenceContext& { + return *this; +} + +ReferenceOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ReferenceOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ReferenceOptions::workDoneProgress(std::optional workDoneProgress) + -> ReferenceOptions& { + return *this; +} + +DocumentHighlightOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentHighlightOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentHighlightOptions::workDoneProgress( + std::optional workDoneProgress) -> DocumentHighlightOptions& { + return *this; +} + +BaseSymbolInformation::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("name")) return false; + if (!repr_.contains("kind")) return false; + return true; +} + +auto BaseSymbolInformation::name() const -> std::string { + const auto& value = repr_["name"]; + + assert(value.is_string()); + return value.get(); +} + +auto BaseSymbolInformation::kind() const -> SymbolKind { + const auto& value = repr_["kind"]; + + return SymbolKind(value); +} + +auto BaseSymbolInformation::tags() const -> std::optional> { + if (!repr_.contains("tags")) return std::nullopt; + + const auto& value = repr_["tags"]; + + assert(value.is_array()); + return Vector(value); +} + +auto BaseSymbolInformation::containerName() const + -> std::optional { + if (!repr_.contains("containerName")) return std::nullopt; + + const auto& value = repr_["containerName"]; + + assert(value.is_string()); + return value.get(); +} + +auto BaseSymbolInformation::name(std::string name) -> BaseSymbolInformation& { + return *this; +} + +auto BaseSymbolInformation::kind(SymbolKind kind) -> BaseSymbolInformation& { + return *this; +} + +auto BaseSymbolInformation::tags(std::optional> tags) + -> BaseSymbolInformation& { + return *this; +} + +auto BaseSymbolInformation::containerName( + std::optional containerName) -> BaseSymbolInformation& { + return *this; +} + +DocumentSymbolOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentSymbolOptions::label() const -> std::optional { + if (!repr_.contains("label")) return std::nullopt; + + const auto& value = repr_["label"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentSymbolOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentSymbolOptions::label(std::optional label) + -> DocumentSymbolOptions& { + return *this; +} + +auto DocumentSymbolOptions::workDoneProgress( + std::optional workDoneProgress) -> DocumentSymbolOptions& { + return *this; +} + +CodeActionContext::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("diagnostics")) return false; + return true; +} + +auto CodeActionContext::diagnostics() const -> Vector { + const auto& value = repr_["diagnostics"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CodeActionContext::only() const -> std::optional> { + if (!repr_.contains("only")) return std::nullopt; + + const auto& value = repr_["only"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CodeActionContext::triggerKind() const + -> std::optional { + if (!repr_.contains("triggerKind")) return std::nullopt; + + const auto& value = repr_["triggerKind"]; + + return CodeActionTriggerKind(value); +} + +auto CodeActionContext::diagnostics(Vector diagnostics) + -> CodeActionContext& { + return *this; +} + +auto CodeActionContext::only(std::optional> only) + -> CodeActionContext& { + return *this; +} + +auto CodeActionContext::triggerKind( + std::optional triggerKind) -> CodeActionContext& { + return *this; +} + +CodeActionDisabled::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("reason")) return false; + return true; +} + +auto CodeActionDisabled::reason() const -> std::string { + const auto& value = repr_["reason"]; + + assert(value.is_string()); + return value.get(); +} + +auto CodeActionDisabled::reason(std::string reason) -> CodeActionDisabled& { + return *this; +} + +CodeActionOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CodeActionOptions::codeActionKinds() const + -> std::optional> { + if (!repr_.contains("codeActionKinds")) return std::nullopt; + + const auto& value = repr_["codeActionKinds"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CodeActionOptions::documentation() const + -> std::optional> { + if (!repr_.contains("documentation")) return std::nullopt; + + const auto& value = repr_["documentation"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CodeActionOptions::resolveProvider() const -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeActionOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeActionOptions::codeActionKinds( + std::optional> codeActionKinds) + -> CodeActionOptions& { + return *this; +} + +auto CodeActionOptions::documentation( + std::optional> documentation) + -> CodeActionOptions& { + return *this; +} + +auto CodeActionOptions::resolveProvider(std::optional resolveProvider) + -> CodeActionOptions& { + return *this; +} + +auto CodeActionOptions::workDoneProgress(std::optional workDoneProgress) + -> CodeActionOptions& { + return *this; +} + +LocationUriOnly::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto LocationUriOnly::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto LocationUriOnly::uri(std::string uri) -> LocationUriOnly& { return *this; } + +WorkspaceSymbolOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkspaceSymbolOptions::resolveProvider() const -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceSymbolOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceSymbolOptions::resolveProvider( + std::optional resolveProvider) -> WorkspaceSymbolOptions& { + return *this; +} + +auto WorkspaceSymbolOptions::workDoneProgress( + std::optional workDoneProgress) -> WorkspaceSymbolOptions& { + return *this; +} + +CodeLensOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CodeLensOptions::resolveProvider() const -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeLensOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeLensOptions::resolveProvider(std::optional resolveProvider) + -> CodeLensOptions& { + return *this; +} + +auto CodeLensOptions::workDoneProgress(std::optional workDoneProgress) + -> CodeLensOptions& { + return *this; +} + +DocumentLinkOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentLinkOptions::resolveProvider() const -> std::optional { + if (!repr_.contains("resolveProvider")) return std::nullopt; + + const auto& value = repr_["resolveProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentLinkOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentLinkOptions::resolveProvider(std::optional resolveProvider) + -> DocumentLinkOptions& { + return *this; +} + +auto DocumentLinkOptions::workDoneProgress(std::optional workDoneProgress) + -> DocumentLinkOptions& { + return *this; +} + +FormattingOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("tabSize")) return false; + if (!repr_.contains("insertSpaces")) return false; + return true; +} + +auto FormattingOptions::tabSize() const -> long { + const auto& value = repr_["tabSize"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto FormattingOptions::insertSpaces() const -> bool { + const auto& value = repr_["insertSpaces"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FormattingOptions::trimTrailingWhitespace() const -> std::optional { + if (!repr_.contains("trimTrailingWhitespace")) return std::nullopt; + + const auto& value = repr_["trimTrailingWhitespace"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FormattingOptions::insertFinalNewline() const -> std::optional { + if (!repr_.contains("insertFinalNewline")) return std::nullopt; + + const auto& value = repr_["insertFinalNewline"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FormattingOptions::trimFinalNewlines() const -> std::optional { + if (!repr_.contains("trimFinalNewlines")) return std::nullopt; + + const auto& value = repr_["trimFinalNewlines"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FormattingOptions::tabSize(long tabSize) -> FormattingOptions& { + return *this; +} + +auto FormattingOptions::insertSpaces(bool insertSpaces) -> FormattingOptions& { + return *this; +} + +auto FormattingOptions::trimTrailingWhitespace( + std::optional trimTrailingWhitespace) -> FormattingOptions& { + return *this; +} + +auto FormattingOptions::insertFinalNewline( + std::optional insertFinalNewline) -> FormattingOptions& { + return *this; +} + +auto FormattingOptions::trimFinalNewlines(std::optional trimFinalNewlines) + -> FormattingOptions& { + return *this; +} + +DocumentFormattingOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentFormattingOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentFormattingOptions::workDoneProgress( + std::optional workDoneProgress) -> DocumentFormattingOptions& { + return *this; +} + +DocumentRangeFormattingOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentRangeFormattingOptions::rangesSupport() const + -> std::optional { + if (!repr_.contains("rangesSupport")) return std::nullopt; + + const auto& value = repr_["rangesSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentRangeFormattingOptions::workDoneProgress() const + -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentRangeFormattingOptions::rangesSupport( + std::optional rangesSupport) -> DocumentRangeFormattingOptions& { + return *this; +} + +auto DocumentRangeFormattingOptions::workDoneProgress( + std::optional workDoneProgress) -> DocumentRangeFormattingOptions& { + return *this; +} + +DocumentOnTypeFormattingOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("firstTriggerCharacter")) return false; + return true; +} + +auto DocumentOnTypeFormattingOptions::firstTriggerCharacter() const + -> std::string { + const auto& value = repr_["firstTriggerCharacter"]; + + assert(value.is_string()); + return value.get(); +} + +auto DocumentOnTypeFormattingOptions::moreTriggerCharacter() const + -> std::optional> { + if (!repr_.contains("moreTriggerCharacter")) return std::nullopt; + + const auto& value = repr_["moreTriggerCharacter"]; + + assert(value.is_array()); + return Vector(value); +} + +auto DocumentOnTypeFormattingOptions::firstTriggerCharacter( + std::string firstTriggerCharacter) -> DocumentOnTypeFormattingOptions& { + return *this; +} + +auto DocumentOnTypeFormattingOptions::moreTriggerCharacter( + std::optional> moreTriggerCharacter) + -> DocumentOnTypeFormattingOptions& { + return *this; +} + +RenameOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto RenameOptions::prepareProvider() const -> std::optional { + if (!repr_.contains("prepareProvider")) return std::nullopt; + + const auto& value = repr_["prepareProvider"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto RenameOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto RenameOptions::prepareProvider(std::optional prepareProvider) + -> RenameOptions& { + return *this; +} + +auto RenameOptions::workDoneProgress(std::optional workDoneProgress) + -> RenameOptions& { + return *this; +} + +PrepareRenamePlaceholder::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("placeholder")) return false; + return true; +} + +auto PrepareRenamePlaceholder::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto PrepareRenamePlaceholder::placeholder() const -> std::string { + const auto& value = repr_["placeholder"]; + + assert(value.is_string()); + return value.get(); +} + +auto PrepareRenamePlaceholder::range(Range range) -> PrepareRenamePlaceholder& { + return *this; +} + +auto PrepareRenamePlaceholder::placeholder(std::string placeholder) + -> PrepareRenamePlaceholder& { + return *this; +} + +PrepareRenameDefaultBehavior::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("defaultBehavior")) return false; + return true; +} + +auto PrepareRenameDefaultBehavior::defaultBehavior() const -> bool { + const auto& value = repr_["defaultBehavior"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto PrepareRenameDefaultBehavior::defaultBehavior(bool defaultBehavior) + -> PrepareRenameDefaultBehavior& { + return *this; +} + +ExecuteCommandOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("commands")) return false; + return true; +} + +auto ExecuteCommandOptions::commands() const -> Vector { + const auto& value = repr_["commands"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ExecuteCommandOptions::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ExecuteCommandOptions::commands(Vector commands) + -> ExecuteCommandOptions& { + return *this; +} + +auto ExecuteCommandOptions::workDoneProgress( + std::optional workDoneProgress) -> ExecuteCommandOptions& { + return *this; +} + +WorkspaceEditMetadata::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkspaceEditMetadata::isRefactoring() const -> std::optional { + if (!repr_.contains("isRefactoring")) return std::nullopt; + + const auto& value = repr_["isRefactoring"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceEditMetadata::isRefactoring(std::optional isRefactoring) + -> WorkspaceEditMetadata& { + return *this; +} + +SemanticTokensLegend::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("tokenTypes")) return false; + if (!repr_.contains("tokenModifiers")) return false; + return true; +} + +auto SemanticTokensLegend::tokenTypes() const -> Vector { + const auto& value = repr_["tokenTypes"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SemanticTokensLegend::tokenModifiers() const -> Vector { + const auto& value = repr_["tokenModifiers"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SemanticTokensLegend::tokenTypes(Vector tokenTypes) + -> SemanticTokensLegend& { + return *this; +} + +auto SemanticTokensLegend::tokenModifiers(Vector tokenModifiers) + -> SemanticTokensLegend& { + return *this; +} + +SemanticTokensFullDelta::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto SemanticTokensFullDelta::delta() const -> std::optional { + if (!repr_.contains("delta")) return std::nullopt; + + const auto& value = repr_["delta"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SemanticTokensFullDelta::delta(std::optional delta) + -> SemanticTokensFullDelta& { + return *this; +} + +OptionalVersionedTextDocumentIdentifier::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("version")) return false; + if (!repr_.contains("uri")) return false; + return true; +} + +auto OptionalVersionedTextDocumentIdentifier::version() const + -> std::variant { + const auto& value = repr_["version"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto OptionalVersionedTextDocumentIdentifier::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto OptionalVersionedTextDocumentIdentifier::version( + std::variant version) + -> OptionalVersionedTextDocumentIdentifier& { + return *this; +} + +auto OptionalVersionedTextDocumentIdentifier::uri(std::string uri) + -> OptionalVersionedTextDocumentIdentifier& { + return *this; +} + +AnnotatedTextEdit::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("annotationId")) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("newText")) return false; + return true; +} + +auto AnnotatedTextEdit::annotationId() const -> ChangeAnnotationIdentifier { + const auto& value = repr_["annotationId"]; + + assert(value.is_string()); + return value.get(); +} + +auto AnnotatedTextEdit::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto AnnotatedTextEdit::newText() const -> std::string { + const auto& value = repr_["newText"]; + + assert(value.is_string()); + return value.get(); +} + +auto AnnotatedTextEdit::annotationId(ChangeAnnotationIdentifier annotationId) + -> AnnotatedTextEdit& { + return *this; +} + +auto AnnotatedTextEdit::range(Range range) -> AnnotatedTextEdit& { + return *this; +} + +auto AnnotatedTextEdit::newText(std::string newText) -> AnnotatedTextEdit& { + return *this; +} + +SnippetTextEdit::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("snippet")) return false; + return true; +} + +auto SnippetTextEdit::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto SnippetTextEdit::snippet() const -> StringValue { + const auto& value = repr_["snippet"]; + + return StringValue(value); +} + +auto SnippetTextEdit::annotationId() const + -> std::optional { + if (!repr_.contains("annotationId")) return std::nullopt; + + const auto& value = repr_["annotationId"]; + + assert(value.is_string()); + return value.get(); +} + +auto SnippetTextEdit::range(Range range) -> SnippetTextEdit& { return *this; } + +auto SnippetTextEdit::snippet(StringValue snippet) -> SnippetTextEdit& { + return *this; +} + +auto SnippetTextEdit::annotationId( + std::optional annotationId) + -> SnippetTextEdit& { + return *this; +} + +ResourceOperation::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + return true; +} + +auto ResourceOperation::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto ResourceOperation::annotationId() const + -> std::optional { + if (!repr_.contains("annotationId")) return std::nullopt; + + const auto& value = repr_["annotationId"]; + + assert(value.is_string()); + return value.get(); +} + +auto ResourceOperation::kind(std::string kind) -> ResourceOperation& { + return *this; +} + +auto ResourceOperation::annotationId( + std::optional annotationId) + -> ResourceOperation& { + return *this; +} + +CreateFileOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CreateFileOptions::overwrite() const -> std::optional { + if (!repr_.contains("overwrite")) return std::nullopt; + + const auto& value = repr_["overwrite"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CreateFileOptions::ignoreIfExists() const -> std::optional { + if (!repr_.contains("ignoreIfExists")) return std::nullopt; + + const auto& value = repr_["ignoreIfExists"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CreateFileOptions::overwrite(std::optional overwrite) + -> CreateFileOptions& { + return *this; +} + +auto CreateFileOptions::ignoreIfExists(std::optional ignoreIfExists) + -> CreateFileOptions& { + return *this; +} + +RenameFileOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto RenameFileOptions::overwrite() const -> std::optional { + if (!repr_.contains("overwrite")) return std::nullopt; + + const auto& value = repr_["overwrite"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto RenameFileOptions::ignoreIfExists() const -> std::optional { + if (!repr_.contains("ignoreIfExists")) return std::nullopt; + + const auto& value = repr_["ignoreIfExists"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto RenameFileOptions::overwrite(std::optional overwrite) + -> RenameFileOptions& { + return *this; +} + +auto RenameFileOptions::ignoreIfExists(std::optional ignoreIfExists) + -> RenameFileOptions& { + return *this; +} + +DeleteFileOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DeleteFileOptions::recursive() const -> std::optional { + if (!repr_.contains("recursive")) return std::nullopt; + + const auto& value = repr_["recursive"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DeleteFileOptions::ignoreIfNotExists() const -> std::optional { + if (!repr_.contains("ignoreIfNotExists")) return std::nullopt; + + const auto& value = repr_["ignoreIfNotExists"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DeleteFileOptions::recursive(std::optional recursive) + -> DeleteFileOptions& { + return *this; +} + +auto DeleteFileOptions::ignoreIfNotExists(std::optional ignoreIfNotExists) + -> DeleteFileOptions& { + return *this; +} + +FileOperationPattern::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("glob")) return false; + return true; +} + +auto FileOperationPattern::glob() const -> std::string { + const auto& value = repr_["glob"]; + + assert(value.is_string()); + return value.get(); +} + +auto FileOperationPattern::matches() const + -> std::optional { + if (!repr_.contains("matches")) return std::nullopt; + + const auto& value = repr_["matches"]; + + lsp_runtime_error("FileOperationPattern::matches: not implement yet"); +} + +auto FileOperationPattern::options() const + -> std::optional { + if (!repr_.contains("options")) return std::nullopt; + + const auto& value = repr_["options"]; + + return FileOperationPatternOptions(value); +} + +auto FileOperationPattern::glob(std::string glob) -> FileOperationPattern& { + return *this; +} + +auto FileOperationPattern::matches( + std::optional matches) -> FileOperationPattern& { + return *this; +} + +auto FileOperationPattern::options( + std::optional options) + -> FileOperationPattern& { + return *this; +} + +WorkspaceFullDocumentDiagnosticReport::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + if (!repr_.contains("version")) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "full") return false; + if (!repr_.contains("items")) return false; + return true; +} + +auto WorkspaceFullDocumentDiagnosticReport::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceFullDocumentDiagnosticReport::version() const + -> std::variant { + const auto& value = repr_["version"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkspaceFullDocumentDiagnosticReport::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceFullDocumentDiagnosticReport::resultId() const + -> std::optional { + if (!repr_.contains("resultId")) return std::nullopt; + + const auto& value = repr_["resultId"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceFullDocumentDiagnosticReport::items() const + -> Vector { + const auto& value = repr_["items"]; + + assert(value.is_array()); + return Vector(value); +} + +auto WorkspaceFullDocumentDiagnosticReport::uri(std::string uri) + -> WorkspaceFullDocumentDiagnosticReport& { + return *this; +} + +auto WorkspaceFullDocumentDiagnosticReport::version( + std::variant version) + -> WorkspaceFullDocumentDiagnosticReport& { + return *this; +} + +auto WorkspaceFullDocumentDiagnosticReport::kind(std::string kind) + -> WorkspaceFullDocumentDiagnosticReport& { + return *this; +} + +auto WorkspaceFullDocumentDiagnosticReport::resultId( + std::optional resultId) + -> WorkspaceFullDocumentDiagnosticReport& { + return *this; +} + +auto WorkspaceFullDocumentDiagnosticReport::items(Vector items) + -> WorkspaceFullDocumentDiagnosticReport& { + return *this; +} + +WorkspaceUnchangedDocumentDiagnosticReport::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("uri")) return false; + if (!repr_.contains("version")) return false; + if (!repr_.contains("kind")) return false; + if (repr_["kind"] != "unchanged") return false; + if (!repr_.contains("resultId")) return false; + return true; +} + +auto WorkspaceUnchangedDocumentDiagnosticReport::uri() const -> std::string { + const auto& value = repr_["uri"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceUnchangedDocumentDiagnosticReport::version() const + -> std::variant { + const auto& value = repr_["version"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkspaceUnchangedDocumentDiagnosticReport::kind() const -> std::string { + const auto& value = repr_["kind"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceUnchangedDocumentDiagnosticReport::resultId() const + -> std::string { + const auto& value = repr_["resultId"]; + + assert(value.is_string()); + return value.get(); +} + +auto WorkspaceUnchangedDocumentDiagnosticReport::uri(std::string uri) + -> WorkspaceUnchangedDocumentDiagnosticReport& { + return *this; +} + +auto WorkspaceUnchangedDocumentDiagnosticReport::version( + std::variant version) + -> WorkspaceUnchangedDocumentDiagnosticReport& { + return *this; +} + +auto WorkspaceUnchangedDocumentDiagnosticReport::kind(std::string kind) + -> WorkspaceUnchangedDocumentDiagnosticReport& { + return *this; +} + +auto WorkspaceUnchangedDocumentDiagnosticReport::resultId(std::string resultId) + -> WorkspaceUnchangedDocumentDiagnosticReport& { + return *this; +} + +NotebookCell::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (!repr_.contains("document")) return false; + return true; +} + +auto NotebookCell::kind() const -> NotebookCellKind { + const auto& value = repr_["kind"]; + + return NotebookCellKind(value); +} + +auto NotebookCell::document() const -> std::string { + const auto& value = repr_["document"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookCell::metadata() const -> std::optional { + if (!repr_.contains("metadata")) return std::nullopt; + + const auto& value = repr_["metadata"]; + + assert(value.is_object()); + return LSPObject(value); +} + +auto NotebookCell::executionSummary() const -> std::optional { + if (!repr_.contains("executionSummary")) return std::nullopt; + + const auto& value = repr_["executionSummary"]; + + return ExecutionSummary(value); +} + +auto NotebookCell::kind(NotebookCellKind kind) -> NotebookCell& { + return *this; +} + +auto NotebookCell::document(std::string document) -> NotebookCell& { + return *this; +} + +auto NotebookCell::metadata(std::optional metadata) + -> NotebookCell& { + return *this; +} + +auto NotebookCell::executionSummary( + std::optional executionSummary) -> NotebookCell& { + return *this; +} + +NotebookDocumentFilterWithNotebook::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("notebook")) return false; + return true; +} + +auto NotebookDocumentFilterWithNotebook::notebook() const + -> std::variant { + const auto& value = repr_["notebook"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto NotebookDocumentFilterWithNotebook::cells() const + -> std::optional> { + if (!repr_.contains("cells")) return std::nullopt; + + const auto& value = repr_["cells"]; + + assert(value.is_array()); + return Vector(value); +} + +auto NotebookDocumentFilterWithNotebook::notebook( + std::variant notebook) + -> NotebookDocumentFilterWithNotebook& { + return *this; +} + +auto NotebookDocumentFilterWithNotebook::cells( + std::optional> cells) + -> NotebookDocumentFilterWithNotebook& { + return *this; +} + +NotebookDocumentFilterWithCells::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("cells")) return false; + return true; +} + +auto NotebookDocumentFilterWithCells::notebook() const -> std::optional< + std::variant> { + if (!repr_.contains("notebook")) return std::nullopt; + + const auto& value = repr_["notebook"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto NotebookDocumentFilterWithCells::cells() const + -> Vector { + const auto& value = repr_["cells"]; + + assert(value.is_array()); + return Vector(value); +} + +auto NotebookDocumentFilterWithCells::notebook( + std::optional< + std::variant> + notebook) -> NotebookDocumentFilterWithCells& { + return *this; +} + +auto NotebookDocumentFilterWithCells::cells(Vector cells) + -> NotebookDocumentFilterWithCells& { + return *this; +} + +NotebookDocumentCellChanges::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto NotebookDocumentCellChanges::structure() const + -> std::optional { + if (!repr_.contains("structure")) return std::nullopt; + + const auto& value = repr_["structure"]; + + return NotebookDocumentCellChangeStructure(value); +} + +auto NotebookDocumentCellChanges::data() const + -> std::optional> { + if (!repr_.contains("data")) return std::nullopt; + + const auto& value = repr_["data"]; + + assert(value.is_array()); + return Vector(value); +} + +auto NotebookDocumentCellChanges::textContent() const + -> std::optional> { + if (!repr_.contains("textContent")) return std::nullopt; + + const auto& value = repr_["textContent"]; + + assert(value.is_array()); + return Vector(value); +} + +auto NotebookDocumentCellChanges::structure( + std::optional structure) + -> NotebookDocumentCellChanges& { + return *this; +} + +auto NotebookDocumentCellChanges::data(std::optional> data) + -> NotebookDocumentCellChanges& { + return *this; +} + +auto NotebookDocumentCellChanges::textContent( + std::optional> textContent) + -> NotebookDocumentCellChanges& { + return *this; +} + +SelectedCompletionInfo::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("text")) return false; + return true; +} + +auto SelectedCompletionInfo::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto SelectedCompletionInfo::text() const -> std::string { + const auto& value = repr_["text"]; + + assert(value.is_string()); + return value.get(); +} + +auto SelectedCompletionInfo::range(Range range) -> SelectedCompletionInfo& { + return *this; +} + +auto SelectedCompletionInfo::text(std::string text) -> SelectedCompletionInfo& { + return *this; +} + +ClientInfo::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("name")) return false; + return true; +} + +auto ClientInfo::name() const -> std::string { + const auto& value = repr_["name"]; + + assert(value.is_string()); + return value.get(); +} + +auto ClientInfo::version() const -> std::optional { + if (!repr_.contains("version")) return std::nullopt; + + const auto& value = repr_["version"]; + + assert(value.is_string()); + return value.get(); +} + +auto ClientInfo::name(std::string name) -> ClientInfo& { return *this; } + +auto ClientInfo::version(std::optional version) -> ClientInfo& { + return *this; +} + +ClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ClientCapabilities::workspace() const + -> std::optional { + if (!repr_.contains("workspace")) return std::nullopt; + + const auto& value = repr_["workspace"]; + + return WorkspaceClientCapabilities(value); +} + +auto ClientCapabilities::textDocument() const + -> std::optional { + if (!repr_.contains("textDocument")) return std::nullopt; + + const auto& value = repr_["textDocument"]; + + return TextDocumentClientCapabilities(value); +} + +auto ClientCapabilities::notebookDocument() const + -> std::optional { + if (!repr_.contains("notebookDocument")) return std::nullopt; + + const auto& value = repr_["notebookDocument"]; + + return NotebookDocumentClientCapabilities(value); +} + +auto ClientCapabilities::window() const + -> std::optional { + if (!repr_.contains("window")) return std::nullopt; + + const auto& value = repr_["window"]; + + return WindowClientCapabilities(value); +} + +auto ClientCapabilities::general() const + -> std::optional { + if (!repr_.contains("general")) return std::nullopt; + + const auto& value = repr_["general"]; + + return GeneralClientCapabilities(value); +} + +auto ClientCapabilities::experimental() const -> std::optional { + if (!repr_.contains("experimental")) return std::nullopt; + + const auto& value = repr_["experimental"]; + + assert(value.is_object()); + return LSPAny(value); +} + +auto ClientCapabilities::workspace( + std::optional workspace) + -> ClientCapabilities& { + return *this; +} + +auto ClientCapabilities::textDocument( + std::optional textDocument) + -> ClientCapabilities& { + return *this; +} + +auto ClientCapabilities::notebookDocument( + std::optional notebookDocument) + -> ClientCapabilities& { + return *this; +} + +auto ClientCapabilities::window(std::optional window) + -> ClientCapabilities& { + return *this; +} + +auto ClientCapabilities::general( + std::optional general) -> ClientCapabilities& { + return *this; +} + +auto ClientCapabilities::experimental(std::optional experimental) + -> ClientCapabilities& { + return *this; +} + +TextDocumentSyncOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto TextDocumentSyncOptions::openClose() const -> std::optional { + if (!repr_.contains("openClose")) return std::nullopt; + + const auto& value = repr_["openClose"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TextDocumentSyncOptions::change() const + -> std::optional { + if (!repr_.contains("change")) return std::nullopt; + + const auto& value = repr_["change"]; + + return TextDocumentSyncKind(value); +} + +auto TextDocumentSyncOptions::willSave() const -> std::optional { + if (!repr_.contains("willSave")) return std::nullopt; + + const auto& value = repr_["willSave"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TextDocumentSyncOptions::willSaveWaitUntil() const -> std::optional { + if (!repr_.contains("willSaveWaitUntil")) return std::nullopt; + + const auto& value = repr_["willSaveWaitUntil"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TextDocumentSyncOptions::save() const + -> std::optional> { + if (!repr_.contains("save")) return std::nullopt; + + const auto& value = repr_["save"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto TextDocumentSyncOptions::openClose(std::optional openClose) + -> TextDocumentSyncOptions& { + return *this; +} + +auto TextDocumentSyncOptions::change(std::optional change) + -> TextDocumentSyncOptions& { + return *this; +} + +auto TextDocumentSyncOptions::willSave(std::optional willSave) + -> TextDocumentSyncOptions& { + return *this; +} + +auto TextDocumentSyncOptions::willSaveWaitUntil( + std::optional willSaveWaitUntil) -> TextDocumentSyncOptions& { + return *this; +} + +auto TextDocumentSyncOptions::save( + std::optional> save) + -> TextDocumentSyncOptions& { + return *this; +} + +WorkspaceOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkspaceOptions::workspaceFolders() const + -> std::optional { + if (!repr_.contains("workspaceFolders")) return std::nullopt; + + const auto& value = repr_["workspaceFolders"]; + + return WorkspaceFoldersServerCapabilities(value); +} + +auto WorkspaceOptions::fileOperations() const + -> std::optional { + if (!repr_.contains("fileOperations")) return std::nullopt; + + const auto& value = repr_["fileOperations"]; + + return FileOperationOptions(value); +} + +auto WorkspaceOptions::textDocumentContent() const + -> std::optional> { + if (!repr_.contains("textDocumentContent")) return std::nullopt; + + const auto& value = repr_["textDocumentContent"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkspaceOptions::workspaceFolders( + std::optional workspaceFolders) + -> WorkspaceOptions& { + return *this; +} + +auto WorkspaceOptions::fileOperations( + std::optional fileOperations) -> WorkspaceOptions& { + return *this; +} + +auto WorkspaceOptions::textDocumentContent( + std::optional> + textDocumentContent) -> WorkspaceOptions& { + return *this; +} + +TextDocumentContentChangePartial::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("range")) return false; + if (!repr_.contains("text")) return false; + return true; +} + +auto TextDocumentContentChangePartial::range() const -> Range { + const auto& value = repr_["range"]; + + return Range(value); +} + +auto TextDocumentContentChangePartial::rangeLength() const + -> std::optional { + if (!repr_.contains("rangeLength")) return std::nullopt; + + const auto& value = repr_["rangeLength"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto TextDocumentContentChangePartial::text() const -> std::string { + const auto& value = repr_["text"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentContentChangePartial::range(Range range) + -> TextDocumentContentChangePartial& { + return *this; +} + +auto TextDocumentContentChangePartial::rangeLength( + std::optional rangeLength) -> TextDocumentContentChangePartial& { + return *this; +} + +auto TextDocumentContentChangePartial::text(std::string text) + -> TextDocumentContentChangePartial& { + return *this; +} + +TextDocumentContentChangeWholeDocument::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("text")) return false; + return true; +} + +auto TextDocumentContentChangeWholeDocument::text() const -> std::string { + const auto& value = repr_["text"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentContentChangeWholeDocument::text(std::string text) + -> TextDocumentContentChangeWholeDocument& { + return *this; +} + +CodeDescription::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("href")) return false; + return true; +} + +auto CodeDescription::href() const -> std::string { + const auto& value = repr_["href"]; + + assert(value.is_string()); + return value.get(); +} + +auto CodeDescription::href(std::string href) -> CodeDescription& { + return *this; +} + +DiagnosticRelatedInformation::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("location")) return false; + if (!repr_.contains("message")) return false; + return true; +} + +auto DiagnosticRelatedInformation::location() const -> Location { + const auto& value = repr_["location"]; + + return Location(value); +} + +auto DiagnosticRelatedInformation::message() const -> std::string { + const auto& value = repr_["message"]; + + assert(value.is_string()); + return value.get(); +} + +auto DiagnosticRelatedInformation::location(Location location) + -> DiagnosticRelatedInformation& { + return *this; +} + +auto DiagnosticRelatedInformation::message(std::string message) + -> DiagnosticRelatedInformation& { + return *this; +} + +EditRangeWithInsertReplace::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("insert")) return false; + if (!repr_.contains("replace")) return false; + return true; +} + +auto EditRangeWithInsertReplace::insert() const -> Range { + const auto& value = repr_["insert"]; + + return Range(value); +} + +auto EditRangeWithInsertReplace::replace() const -> Range { + const auto& value = repr_["replace"]; + + return Range(value); +} + +auto EditRangeWithInsertReplace::insert(Range insert) + -> EditRangeWithInsertReplace& { + return *this; +} + +auto EditRangeWithInsertReplace::replace(Range replace) + -> EditRangeWithInsertReplace& { + return *this; +} + +ServerCompletionItemOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ServerCompletionItemOptions::labelDetailsSupport() const + -> std::optional { + if (!repr_.contains("labelDetailsSupport")) return std::nullopt; + + const auto& value = repr_["labelDetailsSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ServerCompletionItemOptions::labelDetailsSupport( + std::optional labelDetailsSupport) -> ServerCompletionItemOptions& { + return *this; +} + +MarkedStringWithLanguage::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("language")) return false; + if (!repr_.contains("value")) return false; + return true; +} + +auto MarkedStringWithLanguage::language() const -> std::string { + const auto& value = repr_["language"]; + + assert(value.is_string()); + return value.get(); +} + +auto MarkedStringWithLanguage::value() const -> std::string { + const auto& value = repr_["value"]; + + assert(value.is_string()); + return value.get(); +} + +auto MarkedStringWithLanguage::language(std::string language) + -> MarkedStringWithLanguage& { + return *this; +} + +auto MarkedStringWithLanguage::value(std::string value) + -> MarkedStringWithLanguage& { + return *this; +} + +ParameterInformation::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("label")) return false; + return true; +} + +auto ParameterInformation::label() const + -> std::variant> { + const auto& value = repr_["label"]; + + std::variant> result; + + details::try_emplace(result, value); + + return result; +} + +auto ParameterInformation::documentation() const + -> std::optional> { + if (!repr_.contains("documentation")) return std::nullopt; + + const auto& value = repr_["documentation"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ParameterInformation::label( + std::variant> label) + -> ParameterInformation& { + return *this; +} + +auto ParameterInformation::documentation( + std::optional> + documentation) -> ParameterInformation& { + return *this; +} + +CodeActionKindDocumentation::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("kind")) return false; + if (!repr_.contains("command")) return false; + return true; +} + +auto CodeActionKindDocumentation::kind() const -> CodeActionKind { + const auto& value = repr_["kind"]; + + lsp_runtime_error("CodeActionKindDocumentation::kind: not implement yet"); +} + +auto CodeActionKindDocumentation::command() const -> Command { + const auto& value = repr_["command"]; + + return Command(value); +} + +auto CodeActionKindDocumentation::kind(CodeActionKind kind) + -> CodeActionKindDocumentation& { + return *this; +} + +auto CodeActionKindDocumentation::command(Command command) + -> CodeActionKindDocumentation& { + return *this; +} + +NotebookCellTextDocumentFilter::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("notebook")) return false; + return true; +} + +auto NotebookCellTextDocumentFilter::notebook() const + -> std::variant { + const auto& value = repr_["notebook"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto NotebookCellTextDocumentFilter::language() const + -> std::optional { + if (!repr_.contains("language")) return std::nullopt; + + const auto& value = repr_["language"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookCellTextDocumentFilter::notebook( + std::variant notebook) + -> NotebookCellTextDocumentFilter& { + return *this; +} + +auto NotebookCellTextDocumentFilter::language( + std::optional language) -> NotebookCellTextDocumentFilter& { + return *this; +} + +FileOperationPatternOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto FileOperationPatternOptions::ignoreCase() const -> std::optional { + if (!repr_.contains("ignoreCase")) return std::nullopt; + + const auto& value = repr_["ignoreCase"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FileOperationPatternOptions::ignoreCase(std::optional ignoreCase) + -> FileOperationPatternOptions& { + return *this; +} + +ExecutionSummary::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("executionOrder")) return false; + return true; +} + +auto ExecutionSummary::executionOrder() const -> long { + const auto& value = repr_["executionOrder"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto ExecutionSummary::success() const -> std::optional { + if (!repr_.contains("success")) return std::nullopt; + + const auto& value = repr_["success"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ExecutionSummary::executionOrder(long executionOrder) + -> ExecutionSummary& { + return *this; +} + +auto ExecutionSummary::success(std::optional success) + -> ExecutionSummary& { + return *this; +} + +NotebookCellLanguage::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("language")) return false; + return true; +} + +auto NotebookCellLanguage::language() const -> std::string { + const auto& value = repr_["language"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookCellLanguage::language(std::string language) + -> NotebookCellLanguage& { + return *this; +} + +NotebookDocumentCellChangeStructure::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("array")) return false; + return true; +} + +auto NotebookDocumentCellChangeStructure::array() const + -> NotebookCellArrayChange { + const auto& value = repr_["array"]; + + return NotebookCellArrayChange(value); +} + +auto NotebookDocumentCellChangeStructure::didOpen() const + -> std::optional> { + if (!repr_.contains("didOpen")) return std::nullopt; + + const auto& value = repr_["didOpen"]; + + assert(value.is_array()); + return Vector(value); +} + +auto NotebookDocumentCellChangeStructure::didClose() const + -> std::optional> { + if (!repr_.contains("didClose")) return std::nullopt; + + const auto& value = repr_["didClose"]; + + assert(value.is_array()); + return Vector(value); +} + +auto NotebookDocumentCellChangeStructure::array(NotebookCellArrayChange array) + -> NotebookDocumentCellChangeStructure& { + return *this; +} + +auto NotebookDocumentCellChangeStructure::didOpen( + std::optional> didOpen) + -> NotebookDocumentCellChangeStructure& { + return *this; +} + +auto NotebookDocumentCellChangeStructure::didClose( + std::optional> didClose) + -> NotebookDocumentCellChangeStructure& { + return *this; +} + +NotebookDocumentCellContentChanges::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("document")) return false; + if (!repr_.contains("changes")) return false; + return true; +} + +auto NotebookDocumentCellContentChanges::document() const + -> VersionedTextDocumentIdentifier { + const auto& value = repr_["document"]; + + return VersionedTextDocumentIdentifier(value); +} + +auto NotebookDocumentCellContentChanges::changes() const + -> Vector { + const auto& value = repr_["changes"]; + + assert(value.is_array()); + return Vector(value); +} + +auto NotebookDocumentCellContentChanges::document( + VersionedTextDocumentIdentifier document) + -> NotebookDocumentCellContentChanges& { + return *this; +} + +auto NotebookDocumentCellContentChanges::changes( + Vector changes) + -> NotebookDocumentCellContentChanges& { + return *this; +} + +WorkspaceClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkspaceClientCapabilities::applyEdit() const -> std::optional { + if (!repr_.contains("applyEdit")) return std::nullopt; + + const auto& value = repr_["applyEdit"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceClientCapabilities::workspaceEdit() const + -> std::optional { + if (!repr_.contains("workspaceEdit")) return std::nullopt; + + const auto& value = repr_["workspaceEdit"]; + + return WorkspaceEditClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::didChangeConfiguration() const + -> std::optional { + if (!repr_.contains("didChangeConfiguration")) return std::nullopt; + + const auto& value = repr_["didChangeConfiguration"]; + + return DidChangeConfigurationClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::didChangeWatchedFiles() const + -> std::optional { + if (!repr_.contains("didChangeWatchedFiles")) return std::nullopt; + + const auto& value = repr_["didChangeWatchedFiles"]; + + return DidChangeWatchedFilesClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::symbol() const + -> std::optional { + if (!repr_.contains("symbol")) return std::nullopt; + + const auto& value = repr_["symbol"]; + + return WorkspaceSymbolClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::executeCommand() const + -> std::optional { + if (!repr_.contains("executeCommand")) return std::nullopt; + + const auto& value = repr_["executeCommand"]; + + return ExecuteCommandClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::workspaceFolders() const + -> std::optional { + if (!repr_.contains("workspaceFolders")) return std::nullopt; + + const auto& value = repr_["workspaceFolders"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceClientCapabilities::configuration() const -> std::optional { + if (!repr_.contains("configuration")) return std::nullopt; + + const auto& value = repr_["configuration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceClientCapabilities::semanticTokens() const + -> std::optional { + if (!repr_.contains("semanticTokens")) return std::nullopt; + + const auto& value = repr_["semanticTokens"]; + + return SemanticTokensWorkspaceClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::codeLens() const + -> std::optional { + if (!repr_.contains("codeLens")) return std::nullopt; + + const auto& value = repr_["codeLens"]; + + return CodeLensWorkspaceClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::fileOperations() const + -> std::optional { + if (!repr_.contains("fileOperations")) return std::nullopt; + + const auto& value = repr_["fileOperations"]; + + return FileOperationClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::inlineValue() const + -> std::optional { + if (!repr_.contains("inlineValue")) return std::nullopt; + + const auto& value = repr_["inlineValue"]; + + return InlineValueWorkspaceClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::inlayHint() const + -> std::optional { + if (!repr_.contains("inlayHint")) return std::nullopt; + + const auto& value = repr_["inlayHint"]; + + return InlayHintWorkspaceClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::diagnostics() const + -> std::optional { + if (!repr_.contains("diagnostics")) return std::nullopt; + + const auto& value = repr_["diagnostics"]; + + return DiagnosticWorkspaceClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::foldingRange() const + -> std::optional { + if (!repr_.contains("foldingRange")) return std::nullopt; + + const auto& value = repr_["foldingRange"]; + + return FoldingRangeWorkspaceClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::textDocumentContent() const + -> std::optional { + if (!repr_.contains("textDocumentContent")) return std::nullopt; + + const auto& value = repr_["textDocumentContent"]; + + return TextDocumentContentClientCapabilities(value); +} + +auto WorkspaceClientCapabilities::applyEdit(std::optional applyEdit) + -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::workspaceEdit( + std::optional workspaceEdit) + -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::didChangeConfiguration( + std::optional + didChangeConfiguration) -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::didChangeWatchedFiles( + std::optional + didChangeWatchedFiles) -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::symbol( + std::optional symbol) + -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::executeCommand( + std::optional executeCommand) + -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::workspaceFolders( + std::optional workspaceFolders) -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::configuration( + std::optional configuration) -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::semanticTokens( + std::optional semanticTokens) + -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::codeLens( + std::optional codeLens) + -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::fileOperations( + std::optional fileOperations) + -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::inlineValue( + std::optional inlineValue) + -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::inlayHint( + std::optional inlayHint) + -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::diagnostics( + std::optional diagnostics) + -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::foldingRange( + std::optional foldingRange) + -> WorkspaceClientCapabilities& { + return *this; +} + +auto WorkspaceClientCapabilities::textDocumentContent( + std::optional textDocumentContent) + -> WorkspaceClientCapabilities& { + return *this; +} + +TextDocumentClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto TextDocumentClientCapabilities::synchronization() const + -> std::optional { + if (!repr_.contains("synchronization")) return std::nullopt; + + const auto& value = repr_["synchronization"]; + + return TextDocumentSyncClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::filters() const + -> std::optional { + if (!repr_.contains("filters")) return std::nullopt; + + const auto& value = repr_["filters"]; + + return TextDocumentFilterClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::completion() const + -> std::optional { + if (!repr_.contains("completion")) return std::nullopt; + + const auto& value = repr_["completion"]; + + return CompletionClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::hover() const + -> std::optional { + if (!repr_.contains("hover")) return std::nullopt; + + const auto& value = repr_["hover"]; + + return HoverClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::signatureHelp() const + -> std::optional { + if (!repr_.contains("signatureHelp")) return std::nullopt; + + const auto& value = repr_["signatureHelp"]; + + return SignatureHelpClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::declaration() const + -> std::optional { + if (!repr_.contains("declaration")) return std::nullopt; + + const auto& value = repr_["declaration"]; + + return DeclarationClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::definition() const + -> std::optional { + if (!repr_.contains("definition")) return std::nullopt; + + const auto& value = repr_["definition"]; + + return DefinitionClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::typeDefinition() const + -> std::optional { + if (!repr_.contains("typeDefinition")) return std::nullopt; + + const auto& value = repr_["typeDefinition"]; + + return TypeDefinitionClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::implementation() const + -> std::optional { + if (!repr_.contains("implementation")) return std::nullopt; + + const auto& value = repr_["implementation"]; + + return ImplementationClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::references() const + -> std::optional { + if (!repr_.contains("references")) return std::nullopt; + + const auto& value = repr_["references"]; + + return ReferenceClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::documentHighlight() const + -> std::optional { + if (!repr_.contains("documentHighlight")) return std::nullopt; + + const auto& value = repr_["documentHighlight"]; + + return DocumentHighlightClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::documentSymbol() const + -> std::optional { + if (!repr_.contains("documentSymbol")) return std::nullopt; + + const auto& value = repr_["documentSymbol"]; + + return DocumentSymbolClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::codeAction() const + -> std::optional { + if (!repr_.contains("codeAction")) return std::nullopt; + + const auto& value = repr_["codeAction"]; + + return CodeActionClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::codeLens() const + -> std::optional { + if (!repr_.contains("codeLens")) return std::nullopt; + + const auto& value = repr_["codeLens"]; + + return CodeLensClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::documentLink() const + -> std::optional { + if (!repr_.contains("documentLink")) return std::nullopt; + + const auto& value = repr_["documentLink"]; + + return DocumentLinkClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::colorProvider() const + -> std::optional { + if (!repr_.contains("colorProvider")) return std::nullopt; + + const auto& value = repr_["colorProvider"]; + + return DocumentColorClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::formatting() const + -> std::optional { + if (!repr_.contains("formatting")) return std::nullopt; + + const auto& value = repr_["formatting"]; + + return DocumentFormattingClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::rangeFormatting() const + -> std::optional { + if (!repr_.contains("rangeFormatting")) return std::nullopt; + + const auto& value = repr_["rangeFormatting"]; + + return DocumentRangeFormattingClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::onTypeFormatting() const + -> std::optional { + if (!repr_.contains("onTypeFormatting")) return std::nullopt; + + const auto& value = repr_["onTypeFormatting"]; + + return DocumentOnTypeFormattingClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::rename() const + -> std::optional { + if (!repr_.contains("rename")) return std::nullopt; + + const auto& value = repr_["rename"]; + + return RenameClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::foldingRange() const + -> std::optional { + if (!repr_.contains("foldingRange")) return std::nullopt; + + const auto& value = repr_["foldingRange"]; + + return FoldingRangeClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::selectionRange() const + -> std::optional { + if (!repr_.contains("selectionRange")) return std::nullopt; + + const auto& value = repr_["selectionRange"]; + + return SelectionRangeClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::publishDiagnostics() const + -> std::optional { + if (!repr_.contains("publishDiagnostics")) return std::nullopt; + + const auto& value = repr_["publishDiagnostics"]; + + return PublishDiagnosticsClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::callHierarchy() const + -> std::optional { + if (!repr_.contains("callHierarchy")) return std::nullopt; + + const auto& value = repr_["callHierarchy"]; + + return CallHierarchyClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::semanticTokens() const + -> std::optional { + if (!repr_.contains("semanticTokens")) return std::nullopt; + + const auto& value = repr_["semanticTokens"]; + + return SemanticTokensClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::linkedEditingRange() const + -> std::optional { + if (!repr_.contains("linkedEditingRange")) return std::nullopt; + + const auto& value = repr_["linkedEditingRange"]; + + return LinkedEditingRangeClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::moniker() const + -> std::optional { + if (!repr_.contains("moniker")) return std::nullopt; + + const auto& value = repr_["moniker"]; + + return MonikerClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::typeHierarchy() const + -> std::optional { + if (!repr_.contains("typeHierarchy")) return std::nullopt; + + const auto& value = repr_["typeHierarchy"]; + + return TypeHierarchyClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::inlineValue() const + -> std::optional { + if (!repr_.contains("inlineValue")) return std::nullopt; + + const auto& value = repr_["inlineValue"]; + + return InlineValueClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::inlayHint() const + -> std::optional { + if (!repr_.contains("inlayHint")) return std::nullopt; + + const auto& value = repr_["inlayHint"]; + + return InlayHintClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::diagnostic() const + -> std::optional { + if (!repr_.contains("diagnostic")) return std::nullopt; + + const auto& value = repr_["diagnostic"]; + + return DiagnosticClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::inlineCompletion() const + -> std::optional { + if (!repr_.contains("inlineCompletion")) return std::nullopt; + + const auto& value = repr_["inlineCompletion"]; + + return InlineCompletionClientCapabilities(value); +} + +auto TextDocumentClientCapabilities::synchronization( + std::optional synchronization) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::filters( + std::optional filters) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::completion( + std::optional completion) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::hover( + std::optional hover) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::signatureHelp( + std::optional signatureHelp) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::declaration( + std::optional declaration) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::definition( + std::optional definition) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::typeDefinition( + std::optional typeDefinition) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::implementation( + std::optional implementation) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::references( + std::optional references) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::documentHighlight( + std::optional documentHighlight) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::documentSymbol( + std::optional documentSymbol) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::codeAction( + std::optional codeAction) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::codeLens( + std::optional codeLens) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::documentLink( + std::optional documentLink) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::colorProvider( + std::optional colorProvider) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::formatting( + std::optional formatting) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::rangeFormatting( + std::optional rangeFormatting) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::onTypeFormatting( + std::optional onTypeFormatting) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::rename( + std::optional rename) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::foldingRange( + std::optional foldingRange) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::selectionRange( + std::optional selectionRange) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::publishDiagnostics( + std::optional publishDiagnostics) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::callHierarchy( + std::optional callHierarchy) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::semanticTokens( + std::optional semanticTokens) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::linkedEditingRange( + std::optional linkedEditingRange) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::moniker( + std::optional moniker) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::typeHierarchy( + std::optional typeHierarchy) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::inlineValue( + std::optional inlineValue) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::inlayHint( + std::optional inlayHint) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::diagnostic( + std::optional diagnostic) + -> TextDocumentClientCapabilities& { + return *this; +} + +auto TextDocumentClientCapabilities::inlineCompletion( + std::optional inlineCompletion) + -> TextDocumentClientCapabilities& { + return *this; +} + +NotebookDocumentClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("synchronization")) return false; + return true; +} + +auto NotebookDocumentClientCapabilities::synchronization() const + -> NotebookDocumentSyncClientCapabilities { + const auto& value = repr_["synchronization"]; + + return NotebookDocumentSyncClientCapabilities(value); +} + +auto NotebookDocumentClientCapabilities::synchronization( + NotebookDocumentSyncClientCapabilities synchronization) + -> NotebookDocumentClientCapabilities& { + return *this; +} + +WindowClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WindowClientCapabilities::workDoneProgress() const -> std::optional { + if (!repr_.contains("workDoneProgress")) return std::nullopt; + + const auto& value = repr_["workDoneProgress"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WindowClientCapabilities::showMessage() const + -> std::optional { + if (!repr_.contains("showMessage")) return std::nullopt; + + const auto& value = repr_["showMessage"]; + + return ShowMessageRequestClientCapabilities(value); +} + +auto WindowClientCapabilities::showDocument() const + -> std::optional { + if (!repr_.contains("showDocument")) return std::nullopt; + + const auto& value = repr_["showDocument"]; + + return ShowDocumentClientCapabilities(value); +} + +auto WindowClientCapabilities::workDoneProgress( + std::optional workDoneProgress) -> WindowClientCapabilities& { + return *this; +} + +auto WindowClientCapabilities::showMessage( + std::optional showMessage) + -> WindowClientCapabilities& { + return *this; +} + +auto WindowClientCapabilities::showDocument( + std::optional showDocument) + -> WindowClientCapabilities& { + return *this; +} + +GeneralClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto GeneralClientCapabilities::staleRequestSupport() const + -> std::optional { + if (!repr_.contains("staleRequestSupport")) return std::nullopt; + + const auto& value = repr_["staleRequestSupport"]; + + return StaleRequestSupportOptions(value); +} + +auto GeneralClientCapabilities::regularExpressions() const + -> std::optional { + if (!repr_.contains("regularExpressions")) return std::nullopt; + + const auto& value = repr_["regularExpressions"]; + + return RegularExpressionsClientCapabilities(value); +} + +auto GeneralClientCapabilities::markdown() const + -> std::optional { + if (!repr_.contains("markdown")) return std::nullopt; + + const auto& value = repr_["markdown"]; + + return MarkdownClientCapabilities(value); +} + +auto GeneralClientCapabilities::positionEncodings() const + -> std::optional> { + if (!repr_.contains("positionEncodings")) return std::nullopt; + + const auto& value = repr_["positionEncodings"]; + + assert(value.is_array()); + return Vector(value); +} + +auto GeneralClientCapabilities::staleRequestSupport( + std::optional staleRequestSupport) + -> GeneralClientCapabilities& { + return *this; +} + +auto GeneralClientCapabilities::regularExpressions( + std::optional regularExpressions) + -> GeneralClientCapabilities& { + return *this; +} + +auto GeneralClientCapabilities::markdown( + std::optional markdown) + -> GeneralClientCapabilities& { + return *this; +} + +auto GeneralClientCapabilities::positionEncodings( + std::optional> positionEncodings) + -> GeneralClientCapabilities& { + return *this; +} + +WorkspaceFoldersServerCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkspaceFoldersServerCapabilities::supported() const + -> std::optional { + if (!repr_.contains("supported")) return std::nullopt; + + const auto& value = repr_["supported"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceFoldersServerCapabilities::changeNotifications() const + -> std::optional> { + if (!repr_.contains("changeNotifications")) return std::nullopt; + + const auto& value = repr_["changeNotifications"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto WorkspaceFoldersServerCapabilities::supported( + std::optional supported) -> WorkspaceFoldersServerCapabilities& { + return *this; +} + +auto WorkspaceFoldersServerCapabilities::changeNotifications( + std::optional> + changeNotifications) -> WorkspaceFoldersServerCapabilities& { + return *this; +} + +FileOperationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto FileOperationOptions::didCreate() const + -> std::optional { + if (!repr_.contains("didCreate")) return std::nullopt; + + const auto& value = repr_["didCreate"]; + + return FileOperationRegistrationOptions(value); +} + +auto FileOperationOptions::willCreate() const + -> std::optional { + if (!repr_.contains("willCreate")) return std::nullopt; + + const auto& value = repr_["willCreate"]; + + return FileOperationRegistrationOptions(value); +} + +auto FileOperationOptions::didRename() const + -> std::optional { + if (!repr_.contains("didRename")) return std::nullopt; + + const auto& value = repr_["didRename"]; + + return FileOperationRegistrationOptions(value); +} + +auto FileOperationOptions::willRename() const + -> std::optional { + if (!repr_.contains("willRename")) return std::nullopt; + + const auto& value = repr_["willRename"]; + + return FileOperationRegistrationOptions(value); +} + +auto FileOperationOptions::didDelete() const + -> std::optional { + if (!repr_.contains("didDelete")) return std::nullopt; + + const auto& value = repr_["didDelete"]; + + return FileOperationRegistrationOptions(value); +} + +auto FileOperationOptions::willDelete() const + -> std::optional { + if (!repr_.contains("willDelete")) return std::nullopt; + + const auto& value = repr_["willDelete"]; + + return FileOperationRegistrationOptions(value); +} + +auto FileOperationOptions::didCreate( + std::optional didCreate) + -> FileOperationOptions& { + return *this; +} + +auto FileOperationOptions::willCreate( + std::optional willCreate) + -> FileOperationOptions& { + return *this; +} + +auto FileOperationOptions::didRename( + std::optional didRename) + -> FileOperationOptions& { + return *this; +} + +auto FileOperationOptions::willRename( + std::optional willRename) + -> FileOperationOptions& { + return *this; +} + +auto FileOperationOptions::didDelete( + std::optional didDelete) + -> FileOperationOptions& { + return *this; +} + +auto FileOperationOptions::willDelete( + std::optional willDelete) + -> FileOperationOptions& { + return *this; +} + +RelativePattern::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("baseUri")) return false; + if (!repr_.contains("pattern")) return false; + return true; +} + +auto RelativePattern::baseUri() const + -> std::variant { + const auto& value = repr_["baseUri"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto RelativePattern::pattern() const -> Pattern { + const auto& value = repr_["pattern"]; + + assert(value.is_string()); + return value.get(); +} + +auto RelativePattern::baseUri( + std::variant baseUri) + -> RelativePattern& { + return *this; +} + +auto RelativePattern::pattern(Pattern pattern) -> RelativePattern& { + return *this; +} + +TextDocumentFilterLanguage::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("language")) return false; + return true; +} + +auto TextDocumentFilterLanguage::language() const -> std::string { + const auto& value = repr_["language"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentFilterLanguage::scheme() const -> std::optional { + if (!repr_.contains("scheme")) return std::nullopt; + + const auto& value = repr_["scheme"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentFilterLanguage::pattern() const -> std::optional { + if (!repr_.contains("pattern")) return std::nullopt; + + const auto& value = repr_["pattern"]; + + GlobPattern result; + + details::try_emplace(result, value); + + return result; +} + +auto TextDocumentFilterLanguage::language(std::string language) + -> TextDocumentFilterLanguage& { + return *this; +} + +auto TextDocumentFilterLanguage::scheme(std::optional scheme) + -> TextDocumentFilterLanguage& { + return *this; +} + +auto TextDocumentFilterLanguage::pattern(std::optional pattern) + -> TextDocumentFilterLanguage& { + return *this; +} + +TextDocumentFilterScheme::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("scheme")) return false; + return true; +} + +auto TextDocumentFilterScheme::language() const -> std::optional { + if (!repr_.contains("language")) return std::nullopt; + + const auto& value = repr_["language"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentFilterScheme::scheme() const -> std::string { + const auto& value = repr_["scheme"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentFilterScheme::pattern() const -> std::optional { + if (!repr_.contains("pattern")) return std::nullopt; + + const auto& value = repr_["pattern"]; + + GlobPattern result; + + details::try_emplace(result, value); + + return result; +} + +auto TextDocumentFilterScheme::language(std::optional language) + -> TextDocumentFilterScheme& { + return *this; +} + +auto TextDocumentFilterScheme::scheme(std::string scheme) + -> TextDocumentFilterScheme& { + return *this; +} + +auto TextDocumentFilterScheme::pattern(std::optional pattern) + -> TextDocumentFilterScheme& { + return *this; +} + +TextDocumentFilterPattern::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("pattern")) return false; + return true; +} + +auto TextDocumentFilterPattern::language() const -> std::optional { + if (!repr_.contains("language")) return std::nullopt; + + const auto& value = repr_["language"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentFilterPattern::scheme() const -> std::optional { + if (!repr_.contains("scheme")) return std::nullopt; + + const auto& value = repr_["scheme"]; + + assert(value.is_string()); + return value.get(); +} + +auto TextDocumentFilterPattern::pattern() const -> GlobPattern { + const auto& value = repr_["pattern"]; + + GlobPattern result; + + details::try_emplace(result, value); + + return result; +} + +auto TextDocumentFilterPattern::language(std::optional language) + -> TextDocumentFilterPattern& { + return *this; +} + +auto TextDocumentFilterPattern::scheme(std::optional scheme) + -> TextDocumentFilterPattern& { + return *this; +} + +auto TextDocumentFilterPattern::pattern(GlobPattern pattern) + -> TextDocumentFilterPattern& { + return *this; +} + +NotebookDocumentFilterNotebookType::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("notebookType")) return false; + return true; +} + +auto NotebookDocumentFilterNotebookType::notebookType() const -> std::string { + const auto& value = repr_["notebookType"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookDocumentFilterNotebookType::scheme() const + -> std::optional { + if (!repr_.contains("scheme")) return std::nullopt; + + const auto& value = repr_["scheme"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookDocumentFilterNotebookType::pattern() const + -> std::optional { + if (!repr_.contains("pattern")) return std::nullopt; + + const auto& value = repr_["pattern"]; + + GlobPattern result; + + details::try_emplace(result, value); + + return result; +} + +auto NotebookDocumentFilterNotebookType::notebookType(std::string notebookType) + -> NotebookDocumentFilterNotebookType& { + return *this; +} + +auto NotebookDocumentFilterNotebookType::scheme( + std::optional scheme) -> NotebookDocumentFilterNotebookType& { + return *this; +} + +auto NotebookDocumentFilterNotebookType::pattern( + std::optional pattern) -> NotebookDocumentFilterNotebookType& { + return *this; +} + +NotebookDocumentFilterScheme::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("scheme")) return false; + return true; +} + +auto NotebookDocumentFilterScheme::notebookType() const + -> std::optional { + if (!repr_.contains("notebookType")) return std::nullopt; + + const auto& value = repr_["notebookType"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookDocumentFilterScheme::scheme() const -> std::string { + const auto& value = repr_["scheme"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookDocumentFilterScheme::pattern() const + -> std::optional { + if (!repr_.contains("pattern")) return std::nullopt; + + const auto& value = repr_["pattern"]; + + GlobPattern result; + + details::try_emplace(result, value); + + return result; +} + +auto NotebookDocumentFilterScheme::notebookType( + std::optional notebookType) -> NotebookDocumentFilterScheme& { + return *this; +} + +auto NotebookDocumentFilterScheme::scheme(std::string scheme) + -> NotebookDocumentFilterScheme& { + return *this; +} + +auto NotebookDocumentFilterScheme::pattern(std::optional pattern) + -> NotebookDocumentFilterScheme& { + return *this; +} + +NotebookDocumentFilterPattern::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("pattern")) return false; + return true; +} + +auto NotebookDocumentFilterPattern::notebookType() const + -> std::optional { + if (!repr_.contains("notebookType")) return std::nullopt; + + const auto& value = repr_["notebookType"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookDocumentFilterPattern::scheme() const + -> std::optional { + if (!repr_.contains("scheme")) return std::nullopt; + + const auto& value = repr_["scheme"]; + + assert(value.is_string()); + return value.get(); +} + +auto NotebookDocumentFilterPattern::pattern() const -> GlobPattern { + const auto& value = repr_["pattern"]; + + GlobPattern result; + + details::try_emplace(result, value); + + return result; +} + +auto NotebookDocumentFilterPattern::notebookType( + std::optional notebookType) -> NotebookDocumentFilterPattern& { + return *this; +} + +auto NotebookDocumentFilterPattern::scheme(std::optional scheme) + -> NotebookDocumentFilterPattern& { + return *this; +} + +auto NotebookDocumentFilterPattern::pattern(GlobPattern pattern) + -> NotebookDocumentFilterPattern& { + return *this; +} + +NotebookCellArrayChange::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("start")) return false; + if (!repr_.contains("deleteCount")) return false; + return true; +} + +auto NotebookCellArrayChange::start() const -> long { + const auto& value = repr_["start"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto NotebookCellArrayChange::deleteCount() const -> long { + const auto& value = repr_["deleteCount"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto NotebookCellArrayChange::cells() const + -> std::optional> { + if (!repr_.contains("cells")) return std::nullopt; + + const auto& value = repr_["cells"]; + + assert(value.is_array()); + return Vector(value); +} + +auto NotebookCellArrayChange::start(long start) -> NotebookCellArrayChange& { + return *this; +} + +auto NotebookCellArrayChange::deleteCount(long deleteCount) + -> NotebookCellArrayChange& { + return *this; +} + +auto NotebookCellArrayChange::cells(std::optional> cells) + -> NotebookCellArrayChange& { + return *this; +} + +WorkspaceEditClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkspaceEditClientCapabilities::documentChanges() const + -> std::optional { + if (!repr_.contains("documentChanges")) return std::nullopt; + + const auto& value = repr_["documentChanges"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceEditClientCapabilities::resourceOperations() const + -> std::optional> { + if (!repr_.contains("resourceOperations")) return std::nullopt; + + const auto& value = repr_["resourceOperations"]; + + assert(value.is_array()); + return Vector(value); +} + +auto WorkspaceEditClientCapabilities::failureHandling() const + -> std::optional { + if (!repr_.contains("failureHandling")) return std::nullopt; + + const auto& value = repr_["failureHandling"]; + + lsp_runtime_error( + "WorkspaceEditClientCapabilities::failureHandling: not implement yet"); +} + +auto WorkspaceEditClientCapabilities::normalizesLineEndings() const + -> std::optional { + if (!repr_.contains("normalizesLineEndings")) return std::nullopt; + + const auto& value = repr_["normalizesLineEndings"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceEditClientCapabilities::changeAnnotationSupport() const + -> std::optional { + if (!repr_.contains("changeAnnotationSupport")) return std::nullopt; + + const auto& value = repr_["changeAnnotationSupport"]; + + return ChangeAnnotationsSupportOptions(value); +} + +auto WorkspaceEditClientCapabilities::metadataSupport() const + -> std::optional { + if (!repr_.contains("metadataSupport")) return std::nullopt; + + const auto& value = repr_["metadataSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceEditClientCapabilities::snippetEditSupport() const + -> std::optional { + if (!repr_.contains("snippetEditSupport")) return std::nullopt; + + const auto& value = repr_["snippetEditSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceEditClientCapabilities::documentChanges( + std::optional documentChanges) -> WorkspaceEditClientCapabilities& { + return *this; +} + +auto WorkspaceEditClientCapabilities::resourceOperations( + std::optional> resourceOperations) + -> WorkspaceEditClientCapabilities& { + return *this; +} + +auto WorkspaceEditClientCapabilities::failureHandling( + std::optional failureHandling) + -> WorkspaceEditClientCapabilities& { + return *this; +} + +auto WorkspaceEditClientCapabilities::normalizesLineEndings( + std::optional normalizesLineEndings) + -> WorkspaceEditClientCapabilities& { + return *this; +} + +auto WorkspaceEditClientCapabilities::changeAnnotationSupport( + std::optional changeAnnotationSupport) + -> WorkspaceEditClientCapabilities& { + return *this; +} + +auto WorkspaceEditClientCapabilities::metadataSupport( + std::optional metadataSupport) -> WorkspaceEditClientCapabilities& { + return *this; +} + +auto WorkspaceEditClientCapabilities::snippetEditSupport( + std::optional snippetEditSupport) + -> WorkspaceEditClientCapabilities& { + return *this; +} + +DidChangeConfigurationClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DidChangeConfigurationClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DidChangeConfigurationClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> DidChangeConfigurationClientCapabilities& { + return *this; +} + +DidChangeWatchedFilesClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DidChangeWatchedFilesClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DidChangeWatchedFilesClientCapabilities::relativePatternSupport() const + -> std::optional { + if (!repr_.contains("relativePatternSupport")) return std::nullopt; + + const auto& value = repr_["relativePatternSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DidChangeWatchedFilesClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> DidChangeWatchedFilesClientCapabilities& { + return *this; +} + +auto DidChangeWatchedFilesClientCapabilities::relativePatternSupport( + std::optional relativePatternSupport) + -> DidChangeWatchedFilesClientCapabilities& { + return *this; +} + +WorkspaceSymbolClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto WorkspaceSymbolClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto WorkspaceSymbolClientCapabilities::symbolKind() const + -> std::optional { + if (!repr_.contains("symbolKind")) return std::nullopt; + + const auto& value = repr_["symbolKind"]; + + return ClientSymbolKindOptions(value); +} + +auto WorkspaceSymbolClientCapabilities::tagSupport() const + -> std::optional { + if (!repr_.contains("tagSupport")) return std::nullopt; + + const auto& value = repr_["tagSupport"]; + + return ClientSymbolTagOptions(value); +} + +auto WorkspaceSymbolClientCapabilities::resolveSupport() const + -> std::optional { + if (!repr_.contains("resolveSupport")) return std::nullopt; + + const auto& value = repr_["resolveSupport"]; + + return ClientSymbolResolveOptions(value); +} + +auto WorkspaceSymbolClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> WorkspaceSymbolClientCapabilities& { + return *this; +} + +auto WorkspaceSymbolClientCapabilities::symbolKind( + std::optional symbolKind) + -> WorkspaceSymbolClientCapabilities& { + return *this; +} + +auto WorkspaceSymbolClientCapabilities::tagSupport( + std::optional tagSupport) + -> WorkspaceSymbolClientCapabilities& { + return *this; +} + +auto WorkspaceSymbolClientCapabilities::resolveSupport( + std::optional resolveSupport) + -> WorkspaceSymbolClientCapabilities& { + return *this; +} + +ExecuteCommandClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ExecuteCommandClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ExecuteCommandClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> ExecuteCommandClientCapabilities& { + return *this; +} + +SemanticTokensWorkspaceClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto SemanticTokensWorkspaceClientCapabilities::refreshSupport() const + -> std::optional { + if (!repr_.contains("refreshSupport")) return std::nullopt; + + const auto& value = repr_["refreshSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SemanticTokensWorkspaceClientCapabilities::refreshSupport( + std::optional refreshSupport) + -> SemanticTokensWorkspaceClientCapabilities& { + return *this; +} + +CodeLensWorkspaceClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CodeLensWorkspaceClientCapabilities::refreshSupport() const + -> std::optional { + if (!repr_.contains("refreshSupport")) return std::nullopt; + + const auto& value = repr_["refreshSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeLensWorkspaceClientCapabilities::refreshSupport( + std::optional refreshSupport) + -> CodeLensWorkspaceClientCapabilities& { + return *this; +} + +FileOperationClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto FileOperationClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FileOperationClientCapabilities::didCreate() const -> std::optional { + if (!repr_.contains("didCreate")) return std::nullopt; + + const auto& value = repr_["didCreate"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FileOperationClientCapabilities::willCreate() const + -> std::optional { + if (!repr_.contains("willCreate")) return std::nullopt; + + const auto& value = repr_["willCreate"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FileOperationClientCapabilities::didRename() const -> std::optional { + if (!repr_.contains("didRename")) return std::nullopt; + + const auto& value = repr_["didRename"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FileOperationClientCapabilities::willRename() const + -> std::optional { + if (!repr_.contains("willRename")) return std::nullopt; + + const auto& value = repr_["willRename"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FileOperationClientCapabilities::didDelete() const -> std::optional { + if (!repr_.contains("didDelete")) return std::nullopt; + + const auto& value = repr_["didDelete"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FileOperationClientCapabilities::willDelete() const + -> std::optional { + if (!repr_.contains("willDelete")) return std::nullopt; + + const auto& value = repr_["willDelete"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FileOperationClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> FileOperationClientCapabilities& { + return *this; +} + +auto FileOperationClientCapabilities::didCreate(std::optional didCreate) + -> FileOperationClientCapabilities& { + return *this; +} + +auto FileOperationClientCapabilities::willCreate(std::optional willCreate) + -> FileOperationClientCapabilities& { + return *this; +} + +auto FileOperationClientCapabilities::didRename(std::optional didRename) + -> FileOperationClientCapabilities& { + return *this; +} + +auto FileOperationClientCapabilities::willRename(std::optional willRename) + -> FileOperationClientCapabilities& { + return *this; +} + +auto FileOperationClientCapabilities::didDelete(std::optional didDelete) + -> FileOperationClientCapabilities& { + return *this; +} + +auto FileOperationClientCapabilities::willDelete(std::optional willDelete) + -> FileOperationClientCapabilities& { + return *this; +} + +InlineValueWorkspaceClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto InlineValueWorkspaceClientCapabilities::refreshSupport() const + -> std::optional { + if (!repr_.contains("refreshSupport")) return std::nullopt; + + const auto& value = repr_["refreshSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlineValueWorkspaceClientCapabilities::refreshSupport( + std::optional refreshSupport) + -> InlineValueWorkspaceClientCapabilities& { + return *this; +} + +InlayHintWorkspaceClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto InlayHintWorkspaceClientCapabilities::refreshSupport() const + -> std::optional { + if (!repr_.contains("refreshSupport")) return std::nullopt; + + const auto& value = repr_["refreshSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlayHintWorkspaceClientCapabilities::refreshSupport( + std::optional refreshSupport) + -> InlayHintWorkspaceClientCapabilities& { + return *this; +} + +DiagnosticWorkspaceClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DiagnosticWorkspaceClientCapabilities::refreshSupport() const + -> std::optional { + if (!repr_.contains("refreshSupport")) return std::nullopt; + + const auto& value = repr_["refreshSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticWorkspaceClientCapabilities::refreshSupport( + std::optional refreshSupport) + -> DiagnosticWorkspaceClientCapabilities& { + return *this; +} + +FoldingRangeWorkspaceClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto FoldingRangeWorkspaceClientCapabilities::refreshSupport() const + -> std::optional { + if (!repr_.contains("refreshSupport")) return std::nullopt; + + const auto& value = repr_["refreshSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FoldingRangeWorkspaceClientCapabilities::refreshSupport( + std::optional refreshSupport) + -> FoldingRangeWorkspaceClientCapabilities& { + return *this; +} + +TextDocumentContentClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto TextDocumentContentClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TextDocumentContentClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> TextDocumentContentClientCapabilities& { + return *this; +} + +TextDocumentSyncClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto TextDocumentSyncClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TextDocumentSyncClientCapabilities::willSave() const + -> std::optional { + if (!repr_.contains("willSave")) return std::nullopt; + + const auto& value = repr_["willSave"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TextDocumentSyncClientCapabilities::willSaveWaitUntil() const + -> std::optional { + if (!repr_.contains("willSaveWaitUntil")) return std::nullopt; + + const auto& value = repr_["willSaveWaitUntil"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TextDocumentSyncClientCapabilities::didSave() const + -> std::optional { + if (!repr_.contains("didSave")) return std::nullopt; + + const auto& value = repr_["didSave"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TextDocumentSyncClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> TextDocumentSyncClientCapabilities& { + return *this; +} + +auto TextDocumentSyncClientCapabilities::willSave(std::optional willSave) + -> TextDocumentSyncClientCapabilities& { + return *this; +} + +auto TextDocumentSyncClientCapabilities::willSaveWaitUntil( + std::optional willSaveWaitUntil) + -> TextDocumentSyncClientCapabilities& { + return *this; +} + +auto TextDocumentSyncClientCapabilities::didSave(std::optional didSave) + -> TextDocumentSyncClientCapabilities& { + return *this; +} + +TextDocumentFilterClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto TextDocumentFilterClientCapabilities::relativePatternSupport() const + -> std::optional { + if (!repr_.contains("relativePatternSupport")) return std::nullopt; + + const auto& value = repr_["relativePatternSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TextDocumentFilterClientCapabilities::relativePatternSupport( + std::optional relativePatternSupport) + -> TextDocumentFilterClientCapabilities& { + return *this; +} + +CompletionClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CompletionClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CompletionClientCapabilities::completionItem() const + -> std::optional { + if (!repr_.contains("completionItem")) return std::nullopt; + + const auto& value = repr_["completionItem"]; + + return ClientCompletionItemOptions(value); +} + +auto CompletionClientCapabilities::completionItemKind() const + -> std::optional { + if (!repr_.contains("completionItemKind")) return std::nullopt; + + const auto& value = repr_["completionItemKind"]; + + return ClientCompletionItemOptionsKind(value); +} + +auto CompletionClientCapabilities::insertTextMode() const + -> std::optional { + if (!repr_.contains("insertTextMode")) return std::nullopt; + + const auto& value = repr_["insertTextMode"]; + + return InsertTextMode(value); +} + +auto CompletionClientCapabilities::contextSupport() const + -> std::optional { + if (!repr_.contains("contextSupport")) return std::nullopt; + + const auto& value = repr_["contextSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CompletionClientCapabilities::completionList() const + -> std::optional { + if (!repr_.contains("completionList")) return std::nullopt; + + const auto& value = repr_["completionList"]; + + return CompletionListCapabilities(value); +} + +auto CompletionClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> CompletionClientCapabilities& { + return *this; +} + +auto CompletionClientCapabilities::completionItem( + std::optional completionItem) + -> CompletionClientCapabilities& { + return *this; +} + +auto CompletionClientCapabilities::completionItemKind( + std::optional completionItemKind) + -> CompletionClientCapabilities& { + return *this; +} + +auto CompletionClientCapabilities::insertTextMode( + std::optional insertTextMode) + -> CompletionClientCapabilities& { + return *this; +} + +auto CompletionClientCapabilities::contextSupport( + std::optional contextSupport) -> CompletionClientCapabilities& { + return *this; +} + +auto CompletionClientCapabilities::completionList( + std::optional completionList) + -> CompletionClientCapabilities& { + return *this; +} + +HoverClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto HoverClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto HoverClientCapabilities::contentFormat() const + -> std::optional> { + if (!repr_.contains("contentFormat")) return std::nullopt; + + const auto& value = repr_["contentFormat"]; + + assert(value.is_array()); + return Vector(value); +} + +auto HoverClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> HoverClientCapabilities& { + return *this; +} + +auto HoverClientCapabilities::contentFormat( + std::optional> contentFormat) + -> HoverClientCapabilities& { + return *this; +} + +SignatureHelpClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto SignatureHelpClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SignatureHelpClientCapabilities::signatureInformation() const + -> std::optional { + if (!repr_.contains("signatureInformation")) return std::nullopt; + + const auto& value = repr_["signatureInformation"]; + + return ClientSignatureInformationOptions(value); +} + +auto SignatureHelpClientCapabilities::contextSupport() const + -> std::optional { + if (!repr_.contains("contextSupport")) return std::nullopt; + + const auto& value = repr_["contextSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SignatureHelpClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> SignatureHelpClientCapabilities& { + return *this; +} + +auto SignatureHelpClientCapabilities::signatureInformation( + std::optional signatureInformation) + -> SignatureHelpClientCapabilities& { + return *this; +} + +auto SignatureHelpClientCapabilities::contextSupport( + std::optional contextSupport) -> SignatureHelpClientCapabilities& { + return *this; +} + +DeclarationClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DeclarationClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DeclarationClientCapabilities::linkSupport() const -> std::optional { + if (!repr_.contains("linkSupport")) return std::nullopt; + + const auto& value = repr_["linkSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DeclarationClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> DeclarationClientCapabilities& { + return *this; +} + +auto DeclarationClientCapabilities::linkSupport(std::optional linkSupport) + -> DeclarationClientCapabilities& { + return *this; +} + +DefinitionClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DefinitionClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DefinitionClientCapabilities::linkSupport() const -> std::optional { + if (!repr_.contains("linkSupport")) return std::nullopt; + + const auto& value = repr_["linkSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DefinitionClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> DefinitionClientCapabilities& { + return *this; +} + +auto DefinitionClientCapabilities::linkSupport(std::optional linkSupport) + -> DefinitionClientCapabilities& { + return *this; +} + +TypeDefinitionClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto TypeDefinitionClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TypeDefinitionClientCapabilities::linkSupport() const + -> std::optional { + if (!repr_.contains("linkSupport")) return std::nullopt; + + const auto& value = repr_["linkSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TypeDefinitionClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> TypeDefinitionClientCapabilities& { + return *this; +} + +auto TypeDefinitionClientCapabilities::linkSupport( + std::optional linkSupport) -> TypeDefinitionClientCapabilities& { + return *this; +} + +ImplementationClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ImplementationClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ImplementationClientCapabilities::linkSupport() const + -> std::optional { + if (!repr_.contains("linkSupport")) return std::nullopt; + + const auto& value = repr_["linkSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ImplementationClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> ImplementationClientCapabilities& { + return *this; +} + +auto ImplementationClientCapabilities::linkSupport( + std::optional linkSupport) -> ImplementationClientCapabilities& { + return *this; +} + +ReferenceClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ReferenceClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ReferenceClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> ReferenceClientCapabilities& { + return *this; +} + +DocumentHighlightClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentHighlightClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentHighlightClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> DocumentHighlightClientCapabilities& { + return *this; +} + +DocumentSymbolClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentSymbolClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentSymbolClientCapabilities::symbolKind() const + -> std::optional { + if (!repr_.contains("symbolKind")) return std::nullopt; + + const auto& value = repr_["symbolKind"]; + + return ClientSymbolKindOptions(value); +} + +auto DocumentSymbolClientCapabilities::hierarchicalDocumentSymbolSupport() const + -> std::optional { + if (!repr_.contains("hierarchicalDocumentSymbolSupport")) return std::nullopt; + + const auto& value = repr_["hierarchicalDocumentSymbolSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentSymbolClientCapabilities::tagSupport() const + -> std::optional { + if (!repr_.contains("tagSupport")) return std::nullopt; + + const auto& value = repr_["tagSupport"]; + + return ClientSymbolTagOptions(value); +} + +auto DocumentSymbolClientCapabilities::labelSupport() const + -> std::optional { + if (!repr_.contains("labelSupport")) return std::nullopt; + + const auto& value = repr_["labelSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentSymbolClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> DocumentSymbolClientCapabilities& { + return *this; +} + +auto DocumentSymbolClientCapabilities::symbolKind( + std::optional symbolKind) + -> DocumentSymbolClientCapabilities& { + return *this; +} + +auto DocumentSymbolClientCapabilities::hierarchicalDocumentSymbolSupport( + std::optional hierarchicalDocumentSymbolSupport) + -> DocumentSymbolClientCapabilities& { + return *this; +} + +auto DocumentSymbolClientCapabilities::tagSupport( + std::optional tagSupport) + -> DocumentSymbolClientCapabilities& { + return *this; +} + +auto DocumentSymbolClientCapabilities::labelSupport( + std::optional labelSupport) -> DocumentSymbolClientCapabilities& { + return *this; +} + +CodeActionClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CodeActionClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeActionClientCapabilities::codeActionLiteralSupport() const + -> std::optional { + if (!repr_.contains("codeActionLiteralSupport")) return std::nullopt; + + const auto& value = repr_["codeActionLiteralSupport"]; + + return ClientCodeActionLiteralOptions(value); +} + +auto CodeActionClientCapabilities::isPreferredSupport() const + -> std::optional { + if (!repr_.contains("isPreferredSupport")) return std::nullopt; + + const auto& value = repr_["isPreferredSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeActionClientCapabilities::disabledSupport() const + -> std::optional { + if (!repr_.contains("disabledSupport")) return std::nullopt; + + const auto& value = repr_["disabledSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeActionClientCapabilities::dataSupport() const -> std::optional { + if (!repr_.contains("dataSupport")) return std::nullopt; + + const auto& value = repr_["dataSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeActionClientCapabilities::resolveSupport() const + -> std::optional { + if (!repr_.contains("resolveSupport")) return std::nullopt; + + const auto& value = repr_["resolveSupport"]; + + return ClientCodeActionResolveOptions(value); +} + +auto CodeActionClientCapabilities::honorsChangeAnnotations() const + -> std::optional { + if (!repr_.contains("honorsChangeAnnotations")) return std::nullopt; + + const auto& value = repr_["honorsChangeAnnotations"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeActionClientCapabilities::documentationSupport() const + -> std::optional { + if (!repr_.contains("documentationSupport")) return std::nullopt; + + const auto& value = repr_["documentationSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeActionClientCapabilities::tagSupport() const + -> std::optional { + if (!repr_.contains("tagSupport")) return std::nullopt; + + const auto& value = repr_["tagSupport"]; + + return CodeActionTagOptions(value); +} + +auto CodeActionClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> CodeActionClientCapabilities& { + return *this; +} + +auto CodeActionClientCapabilities::codeActionLiteralSupport( + std::optional codeActionLiteralSupport) + -> CodeActionClientCapabilities& { + return *this; +} + +auto CodeActionClientCapabilities::isPreferredSupport( + std::optional isPreferredSupport) -> CodeActionClientCapabilities& { + return *this; +} + +auto CodeActionClientCapabilities::disabledSupport( + std::optional disabledSupport) -> CodeActionClientCapabilities& { + return *this; +} + +auto CodeActionClientCapabilities::dataSupport(std::optional dataSupport) + -> CodeActionClientCapabilities& { + return *this; +} + +auto CodeActionClientCapabilities::resolveSupport( + std::optional resolveSupport) + -> CodeActionClientCapabilities& { + return *this; +} + +auto CodeActionClientCapabilities::honorsChangeAnnotations( + std::optional honorsChangeAnnotations) + -> CodeActionClientCapabilities& { + return *this; +} + +auto CodeActionClientCapabilities::documentationSupport( + std::optional documentationSupport) -> CodeActionClientCapabilities& { + return *this; +} + +auto CodeActionClientCapabilities::tagSupport( + std::optional tagSupport) + -> CodeActionClientCapabilities& { + return *this; +} + +CodeLensClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CodeLensClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CodeLensClientCapabilities::resolveSupport() const + -> std::optional { + if (!repr_.contains("resolveSupport")) return std::nullopt; + + const auto& value = repr_["resolveSupport"]; + + return ClientCodeLensResolveOptions(value); +} + +auto CodeLensClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> CodeLensClientCapabilities& { + return *this; +} + +auto CodeLensClientCapabilities::resolveSupport( + std::optional resolveSupport) + -> CodeLensClientCapabilities& { + return *this; +} + +DocumentLinkClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentLinkClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentLinkClientCapabilities::tooltipSupport() const + -> std::optional { + if (!repr_.contains("tooltipSupport")) return std::nullopt; + + const auto& value = repr_["tooltipSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentLinkClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> DocumentLinkClientCapabilities& { + return *this; +} + +auto DocumentLinkClientCapabilities::tooltipSupport( + std::optional tooltipSupport) -> DocumentLinkClientCapabilities& { + return *this; +} + +DocumentColorClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentColorClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentColorClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> DocumentColorClientCapabilities& { + return *this; +} + +DocumentFormattingClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentFormattingClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentFormattingClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> DocumentFormattingClientCapabilities& { + return *this; +} + +DocumentRangeFormattingClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentRangeFormattingClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentRangeFormattingClientCapabilities::rangesSupport() const + -> std::optional { + if (!repr_.contains("rangesSupport")) return std::nullopt; + + const auto& value = repr_["rangesSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentRangeFormattingClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> DocumentRangeFormattingClientCapabilities& { + return *this; +} + +auto DocumentRangeFormattingClientCapabilities::rangesSupport( + std::optional rangesSupport) + -> DocumentRangeFormattingClientCapabilities& { + return *this; +} + +DocumentOnTypeFormattingClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DocumentOnTypeFormattingClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DocumentOnTypeFormattingClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> DocumentOnTypeFormattingClientCapabilities& { + return *this; +} + +RenameClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto RenameClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto RenameClientCapabilities::prepareSupport() const -> std::optional { + if (!repr_.contains("prepareSupport")) return std::nullopt; + + const auto& value = repr_["prepareSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto RenameClientCapabilities::prepareSupportDefaultBehavior() const + -> std::optional { + if (!repr_.contains("prepareSupportDefaultBehavior")) return std::nullopt; + + const auto& value = repr_["prepareSupportDefaultBehavior"]; + + return PrepareSupportDefaultBehavior(value); +} + +auto RenameClientCapabilities::honorsChangeAnnotations() const + -> std::optional { + if (!repr_.contains("honorsChangeAnnotations")) return std::nullopt; + + const auto& value = repr_["honorsChangeAnnotations"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto RenameClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> RenameClientCapabilities& { + return *this; +} + +auto RenameClientCapabilities::prepareSupport( + std::optional prepareSupport) -> RenameClientCapabilities& { + return *this; +} + +auto RenameClientCapabilities::prepareSupportDefaultBehavior( + std::optional prepareSupportDefaultBehavior) + -> RenameClientCapabilities& { + return *this; +} + +auto RenameClientCapabilities::honorsChangeAnnotations( + std::optional honorsChangeAnnotations) -> RenameClientCapabilities& { + return *this; +} + +FoldingRangeClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto FoldingRangeClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FoldingRangeClientCapabilities::rangeLimit() const -> std::optional { + if (!repr_.contains("rangeLimit")) return std::nullopt; + + const auto& value = repr_["rangeLimit"]; + + assert(value.is_number_integer()); + return value.get(); +} + +auto FoldingRangeClientCapabilities::lineFoldingOnly() const + -> std::optional { + if (!repr_.contains("lineFoldingOnly")) return std::nullopt; + + const auto& value = repr_["lineFoldingOnly"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto FoldingRangeClientCapabilities::foldingRangeKind() const + -> std::optional { + if (!repr_.contains("foldingRangeKind")) return std::nullopt; + + const auto& value = repr_["foldingRangeKind"]; + + return ClientFoldingRangeKindOptions(value); +} + +auto FoldingRangeClientCapabilities::foldingRange() const + -> std::optional { + if (!repr_.contains("foldingRange")) return std::nullopt; + + const auto& value = repr_["foldingRange"]; + + return ClientFoldingRangeOptions(value); +} + +auto FoldingRangeClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> FoldingRangeClientCapabilities& { + return *this; +} + +auto FoldingRangeClientCapabilities::rangeLimit(std::optional rangeLimit) + -> FoldingRangeClientCapabilities& { + return *this; +} + +auto FoldingRangeClientCapabilities::lineFoldingOnly( + std::optional lineFoldingOnly) -> FoldingRangeClientCapabilities& { + return *this; +} + +auto FoldingRangeClientCapabilities::foldingRangeKind( + std::optional foldingRangeKind) + -> FoldingRangeClientCapabilities& { + return *this; +} + +auto FoldingRangeClientCapabilities::foldingRange( + std::optional foldingRange) + -> FoldingRangeClientCapabilities& { + return *this; +} + +SelectionRangeClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto SelectionRangeClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SelectionRangeClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> SelectionRangeClientCapabilities& { + return *this; +} + +PublishDiagnosticsClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto PublishDiagnosticsClientCapabilities::versionSupport() const + -> std::optional { + if (!repr_.contains("versionSupport")) return std::nullopt; + + const auto& value = repr_["versionSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto PublishDiagnosticsClientCapabilities::relatedInformation() const + -> std::optional { + if (!repr_.contains("relatedInformation")) return std::nullopt; + + const auto& value = repr_["relatedInformation"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto PublishDiagnosticsClientCapabilities::tagSupport() const + -> std::optional { + if (!repr_.contains("tagSupport")) return std::nullopt; + + const auto& value = repr_["tagSupport"]; + + return ClientDiagnosticsTagOptions(value); +} + +auto PublishDiagnosticsClientCapabilities::codeDescriptionSupport() const + -> std::optional { + if (!repr_.contains("codeDescriptionSupport")) return std::nullopt; + + const auto& value = repr_["codeDescriptionSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto PublishDiagnosticsClientCapabilities::dataSupport() const + -> std::optional { + if (!repr_.contains("dataSupport")) return std::nullopt; + + const auto& value = repr_["dataSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto PublishDiagnosticsClientCapabilities::versionSupport( + std::optional versionSupport) + -> PublishDiagnosticsClientCapabilities& { + return *this; +} + +auto PublishDiagnosticsClientCapabilities::relatedInformation( + std::optional relatedInformation) + -> PublishDiagnosticsClientCapabilities& { + return *this; +} + +auto PublishDiagnosticsClientCapabilities::tagSupport( + std::optional tagSupport) + -> PublishDiagnosticsClientCapabilities& { + return *this; +} + +auto PublishDiagnosticsClientCapabilities::codeDescriptionSupport( + std::optional codeDescriptionSupport) + -> PublishDiagnosticsClientCapabilities& { + return *this; +} + +auto PublishDiagnosticsClientCapabilities::dataSupport( + std::optional dataSupport) -> PublishDiagnosticsClientCapabilities& { + return *this; +} + +CallHierarchyClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CallHierarchyClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CallHierarchyClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> CallHierarchyClientCapabilities& { + return *this; +} + +SemanticTokensClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("requests")) return false; + if (!repr_.contains("tokenTypes")) return false; + if (!repr_.contains("tokenModifiers")) return false; + if (!repr_.contains("formats")) return false; + return true; +} + +auto SemanticTokensClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SemanticTokensClientCapabilities::requests() const + -> ClientSemanticTokensRequestOptions { + const auto& value = repr_["requests"]; + + return ClientSemanticTokensRequestOptions(value); +} + +auto SemanticTokensClientCapabilities::tokenTypes() const + -> Vector { + const auto& value = repr_["tokenTypes"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SemanticTokensClientCapabilities::tokenModifiers() const + -> Vector { + const auto& value = repr_["tokenModifiers"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SemanticTokensClientCapabilities::formats() const -> Vector { + const auto& value = repr_["formats"]; + + assert(value.is_array()); + return Vector(value); +} + +auto SemanticTokensClientCapabilities::overlappingTokenSupport() const + -> std::optional { + if (!repr_.contains("overlappingTokenSupport")) return std::nullopt; + + const auto& value = repr_["overlappingTokenSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SemanticTokensClientCapabilities::multilineTokenSupport() const + -> std::optional { + if (!repr_.contains("multilineTokenSupport")) return std::nullopt; + + const auto& value = repr_["multilineTokenSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SemanticTokensClientCapabilities::serverCancelSupport() const + -> std::optional { + if (!repr_.contains("serverCancelSupport")) return std::nullopt; + + const auto& value = repr_["serverCancelSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SemanticTokensClientCapabilities::augmentsSyntaxTokens() const + -> std::optional { + if (!repr_.contains("augmentsSyntaxTokens")) return std::nullopt; + + const auto& value = repr_["augmentsSyntaxTokens"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto SemanticTokensClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> SemanticTokensClientCapabilities& { + return *this; +} + +auto SemanticTokensClientCapabilities::requests( + ClientSemanticTokensRequestOptions requests) + -> SemanticTokensClientCapabilities& { + return *this; +} + +auto SemanticTokensClientCapabilities::tokenTypes( + Vector tokenTypes) -> SemanticTokensClientCapabilities& { + return *this; +} + +auto SemanticTokensClientCapabilities::tokenModifiers( + Vector tokenModifiers) -> SemanticTokensClientCapabilities& { + return *this; +} + +auto SemanticTokensClientCapabilities::formats(Vector formats) + -> SemanticTokensClientCapabilities& { + return *this; +} + +auto SemanticTokensClientCapabilities::overlappingTokenSupport( + std::optional overlappingTokenSupport) + -> SemanticTokensClientCapabilities& { + return *this; +} + +auto SemanticTokensClientCapabilities::multilineTokenSupport( + std::optional multilineTokenSupport) + -> SemanticTokensClientCapabilities& { + return *this; +} + +auto SemanticTokensClientCapabilities::serverCancelSupport( + std::optional serverCancelSupport) + -> SemanticTokensClientCapabilities& { + return *this; +} + +auto SemanticTokensClientCapabilities::augmentsSyntaxTokens( + std::optional augmentsSyntaxTokens) + -> SemanticTokensClientCapabilities& { + return *this; +} + +LinkedEditingRangeClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto LinkedEditingRangeClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto LinkedEditingRangeClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> LinkedEditingRangeClientCapabilities& { + return *this; +} + +MonikerClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto MonikerClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto MonikerClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> MonikerClientCapabilities& { + return *this; +} + +TypeHierarchyClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto TypeHierarchyClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto TypeHierarchyClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> TypeHierarchyClientCapabilities& { + return *this; +} + +InlineValueClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto InlineValueClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlineValueClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> InlineValueClientCapabilities& { + return *this; +} + +InlayHintClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto InlayHintClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlayHintClientCapabilities::resolveSupport() const + -> std::optional { + if (!repr_.contains("resolveSupport")) return std::nullopt; + + const auto& value = repr_["resolveSupport"]; + + return ClientInlayHintResolveOptions(value); +} + +auto InlayHintClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> InlayHintClientCapabilities& { + return *this; +} + +auto InlayHintClientCapabilities::resolveSupport( + std::optional resolveSupport) + -> InlayHintClientCapabilities& { + return *this; +} + +DiagnosticClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DiagnosticClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticClientCapabilities::relatedDocumentSupport() const + -> std::optional { + if (!repr_.contains("relatedDocumentSupport")) return std::nullopt; + + const auto& value = repr_["relatedDocumentSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticClientCapabilities::relatedInformation() const + -> std::optional { + if (!repr_.contains("relatedInformation")) return std::nullopt; + + const auto& value = repr_["relatedInformation"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticClientCapabilities::tagSupport() const + -> std::optional { + if (!repr_.contains("tagSupport")) return std::nullopt; + + const auto& value = repr_["tagSupport"]; + + return ClientDiagnosticsTagOptions(value); +} + +auto DiagnosticClientCapabilities::codeDescriptionSupport() const + -> std::optional { + if (!repr_.contains("codeDescriptionSupport")) return std::nullopt; + + const auto& value = repr_["codeDescriptionSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticClientCapabilities::dataSupport() const -> std::optional { + if (!repr_.contains("dataSupport")) return std::nullopt; + + const auto& value = repr_["dataSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) -> DiagnosticClientCapabilities& { + return *this; +} + +auto DiagnosticClientCapabilities::relatedDocumentSupport( + std::optional relatedDocumentSupport) + -> DiagnosticClientCapabilities& { + return *this; +} + +auto DiagnosticClientCapabilities::relatedInformation( + std::optional relatedInformation) -> DiagnosticClientCapabilities& { + return *this; +} + +auto DiagnosticClientCapabilities::tagSupport( + std::optional tagSupport) + -> DiagnosticClientCapabilities& { + return *this; +} + +auto DiagnosticClientCapabilities::codeDescriptionSupport( + std::optional codeDescriptionSupport) + -> DiagnosticClientCapabilities& { + return *this; +} + +auto DiagnosticClientCapabilities::dataSupport(std::optional dataSupport) + -> DiagnosticClientCapabilities& { + return *this; +} + +InlineCompletionClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto InlineCompletionClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto InlineCompletionClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> InlineCompletionClientCapabilities& { + return *this; +} + +NotebookDocumentSyncClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto NotebookDocumentSyncClientCapabilities::dynamicRegistration() const + -> std::optional { + if (!repr_.contains("dynamicRegistration")) return std::nullopt; + + const auto& value = repr_["dynamicRegistration"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto NotebookDocumentSyncClientCapabilities::executionSummarySupport() const + -> std::optional { + if (!repr_.contains("executionSummarySupport")) return std::nullopt; + + const auto& value = repr_["executionSummarySupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto NotebookDocumentSyncClientCapabilities::dynamicRegistration( + std::optional dynamicRegistration) + -> NotebookDocumentSyncClientCapabilities& { + return *this; +} + +auto NotebookDocumentSyncClientCapabilities::executionSummarySupport( + std::optional executionSummarySupport) + -> NotebookDocumentSyncClientCapabilities& { + return *this; +} + +ShowMessageRequestClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ShowMessageRequestClientCapabilities::messageActionItem() const + -> std::optional { + if (!repr_.contains("messageActionItem")) return std::nullopt; + + const auto& value = repr_["messageActionItem"]; + + return ClientShowMessageActionItemOptions(value); +} + +auto ShowMessageRequestClientCapabilities::messageActionItem( + std::optional messageActionItem) + -> ShowMessageRequestClientCapabilities& { + return *this; +} + +ShowDocumentClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("support")) return false; + return true; +} + +auto ShowDocumentClientCapabilities::support() const -> bool { + const auto& value = repr_["support"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ShowDocumentClientCapabilities::support(bool support) + -> ShowDocumentClientCapabilities& { + return *this; +} + +StaleRequestSupportOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("cancel")) return false; + if (!repr_.contains("retryOnContentModified")) return false; + return true; +} + +auto StaleRequestSupportOptions::cancel() const -> bool { + const auto& value = repr_["cancel"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto StaleRequestSupportOptions::retryOnContentModified() const + -> Vector { + const auto& value = repr_["retryOnContentModified"]; + + assert(value.is_array()); + return Vector(value); +} + +auto StaleRequestSupportOptions::cancel(bool cancel) + -> StaleRequestSupportOptions& { + return *this; +} + +auto StaleRequestSupportOptions::retryOnContentModified( + Vector retryOnContentModified) -> StaleRequestSupportOptions& { + return *this; +} + +RegularExpressionsClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("engine")) return false; + return true; +} + +auto RegularExpressionsClientCapabilities::engine() const + -> RegularExpressionEngineKind { + const auto& value = repr_["engine"]; + + assert(value.is_string()); + return value.get(); +} + +auto RegularExpressionsClientCapabilities::version() const + -> std::optional { + if (!repr_.contains("version")) return std::nullopt; + + const auto& value = repr_["version"]; + + assert(value.is_string()); + return value.get(); +} + +auto RegularExpressionsClientCapabilities::engine( + RegularExpressionEngineKind engine) + -> RegularExpressionsClientCapabilities& { + return *this; +} + +auto RegularExpressionsClientCapabilities::version( + std::optional version) + -> RegularExpressionsClientCapabilities& { + return *this; +} + +MarkdownClientCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("parser")) return false; + return true; +} + +auto MarkdownClientCapabilities::parser() const -> std::string { + const auto& value = repr_["parser"]; + + assert(value.is_string()); + return value.get(); +} + +auto MarkdownClientCapabilities::version() const -> std::optional { + if (!repr_.contains("version")) return std::nullopt; + + const auto& value = repr_["version"]; + + assert(value.is_string()); + return value.get(); +} + +auto MarkdownClientCapabilities::allowedTags() const + -> std::optional> { + if (!repr_.contains("allowedTags")) return std::nullopt; + + const auto& value = repr_["allowedTags"]; + + assert(value.is_array()); + return Vector(value); +} + +auto MarkdownClientCapabilities::parser(std::string parser) + -> MarkdownClientCapabilities& { + return *this; +} + +auto MarkdownClientCapabilities::version(std::optional version) + -> MarkdownClientCapabilities& { + return *this; +} + +auto MarkdownClientCapabilities::allowedTags( + std::optional> allowedTags) + -> MarkdownClientCapabilities& { + return *this; +} + +ChangeAnnotationsSupportOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ChangeAnnotationsSupportOptions::groupsOnLabel() const + -> std::optional { + if (!repr_.contains("groupsOnLabel")) return std::nullopt; + + const auto& value = repr_["groupsOnLabel"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ChangeAnnotationsSupportOptions::groupsOnLabel( + std::optional groupsOnLabel) -> ChangeAnnotationsSupportOptions& { + return *this; +} + +ClientSymbolKindOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ClientSymbolKindOptions::valueSet() const + -> std::optional> { + if (!repr_.contains("valueSet")) return std::nullopt; + + const auto& value = repr_["valueSet"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientSymbolKindOptions::valueSet( + std::optional> valueSet) -> ClientSymbolKindOptions& { + return *this; +} + +ClientSymbolTagOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("valueSet")) return false; + return true; +} + +auto ClientSymbolTagOptions::valueSet() const -> Vector { + const auto& value = repr_["valueSet"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientSymbolTagOptions::valueSet(Vector valueSet) + -> ClientSymbolTagOptions& { + return *this; +} + +ClientSymbolResolveOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("properties")) return false; + return true; +} + +auto ClientSymbolResolveOptions::properties() const -> Vector { + const auto& value = repr_["properties"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientSymbolResolveOptions::properties(Vector properties) + -> ClientSymbolResolveOptions& { + return *this; +} + +ClientCompletionItemOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ClientCompletionItemOptions::snippetSupport() const + -> std::optional { + if (!repr_.contains("snippetSupport")) return std::nullopt; + + const auto& value = repr_["snippetSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientCompletionItemOptions::commitCharactersSupport() const + -> std::optional { + if (!repr_.contains("commitCharactersSupport")) return std::nullopt; + + const auto& value = repr_["commitCharactersSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientCompletionItemOptions::documentationFormat() const + -> std::optional> { + if (!repr_.contains("documentationFormat")) return std::nullopt; + + const auto& value = repr_["documentationFormat"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientCompletionItemOptions::deprecatedSupport() const + -> std::optional { + if (!repr_.contains("deprecatedSupport")) return std::nullopt; + + const auto& value = repr_["deprecatedSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientCompletionItemOptions::preselectSupport() const + -> std::optional { + if (!repr_.contains("preselectSupport")) return std::nullopt; + + const auto& value = repr_["preselectSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientCompletionItemOptions::tagSupport() const + -> std::optional { + if (!repr_.contains("tagSupport")) return std::nullopt; + + const auto& value = repr_["tagSupport"]; + + return CompletionItemTagOptions(value); +} + +auto ClientCompletionItemOptions::insertReplaceSupport() const + -> std::optional { + if (!repr_.contains("insertReplaceSupport")) return std::nullopt; + + const auto& value = repr_["insertReplaceSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientCompletionItemOptions::resolveSupport() const + -> std::optional { + if (!repr_.contains("resolveSupport")) return std::nullopt; + + const auto& value = repr_["resolveSupport"]; + + return ClientCompletionItemResolveOptions(value); +} + +auto ClientCompletionItemOptions::insertTextModeSupport() const + -> std::optional { + if (!repr_.contains("insertTextModeSupport")) return std::nullopt; + + const auto& value = repr_["insertTextModeSupport"]; + + return ClientCompletionItemInsertTextModeOptions(value); +} + +auto ClientCompletionItemOptions::labelDetailsSupport() const + -> std::optional { + if (!repr_.contains("labelDetailsSupport")) return std::nullopt; + + const auto& value = repr_["labelDetailsSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientCompletionItemOptions::snippetSupport( + std::optional snippetSupport) -> ClientCompletionItemOptions& { + return *this; +} + +auto ClientCompletionItemOptions::commitCharactersSupport( + std::optional commitCharactersSupport) + -> ClientCompletionItemOptions& { + return *this; +} + +auto ClientCompletionItemOptions::documentationFormat( + std::optional> documentationFormat) + -> ClientCompletionItemOptions& { + return *this; +} + +auto ClientCompletionItemOptions::deprecatedSupport( + std::optional deprecatedSupport) -> ClientCompletionItemOptions& { + return *this; +} + +auto ClientCompletionItemOptions::preselectSupport( + std::optional preselectSupport) -> ClientCompletionItemOptions& { + return *this; +} + +auto ClientCompletionItemOptions::tagSupport( + std::optional tagSupport) + -> ClientCompletionItemOptions& { + return *this; +} + +auto ClientCompletionItemOptions::insertReplaceSupport( + std::optional insertReplaceSupport) -> ClientCompletionItemOptions& { + return *this; +} + +auto ClientCompletionItemOptions::resolveSupport( + std::optional resolveSupport) + -> ClientCompletionItemOptions& { + return *this; +} + +auto ClientCompletionItemOptions::insertTextModeSupport( + std::optional + insertTextModeSupport) -> ClientCompletionItemOptions& { + return *this; +} + +auto ClientCompletionItemOptions::labelDetailsSupport( + std::optional labelDetailsSupport) -> ClientCompletionItemOptions& { + return *this; +} + +ClientCompletionItemOptionsKind::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ClientCompletionItemOptionsKind::valueSet() const + -> std::optional> { + if (!repr_.contains("valueSet")) return std::nullopt; + + const auto& value = repr_["valueSet"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientCompletionItemOptionsKind::valueSet( + std::optional> valueSet) + -> ClientCompletionItemOptionsKind& { + return *this; +} + +CompletionListCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto CompletionListCapabilities::itemDefaults() const + -> std::optional> { + if (!repr_.contains("itemDefaults")) return std::nullopt; + + const auto& value = repr_["itemDefaults"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CompletionListCapabilities::applyKindSupport() const + -> std::optional { + if (!repr_.contains("applyKindSupport")) return std::nullopt; + + const auto& value = repr_["applyKindSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto CompletionListCapabilities::itemDefaults( + std::optional> itemDefaults) + -> CompletionListCapabilities& { + return *this; +} + +auto CompletionListCapabilities::applyKindSupport( + std::optional applyKindSupport) -> CompletionListCapabilities& { + return *this; +} + +ClientSignatureInformationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ClientSignatureInformationOptions::documentationFormat() const + -> std::optional> { + if (!repr_.contains("documentationFormat")) return std::nullopt; + + const auto& value = repr_["documentationFormat"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientSignatureInformationOptions::parameterInformation() const + -> std::optional { + if (!repr_.contains("parameterInformation")) return std::nullopt; + + const auto& value = repr_["parameterInformation"]; + + return ClientSignatureParameterInformationOptions(value); +} + +auto ClientSignatureInformationOptions::activeParameterSupport() const + -> std::optional { + if (!repr_.contains("activeParameterSupport")) return std::nullopt; + + const auto& value = repr_["activeParameterSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientSignatureInformationOptions::noActiveParameterSupport() const + -> std::optional { + if (!repr_.contains("noActiveParameterSupport")) return std::nullopt; + + const auto& value = repr_["noActiveParameterSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientSignatureInformationOptions::documentationFormat( + std::optional> documentationFormat) + -> ClientSignatureInformationOptions& { + return *this; +} + +auto ClientSignatureInformationOptions::parameterInformation( + std::optional + parameterInformation) -> ClientSignatureInformationOptions& { + return *this; +} + +auto ClientSignatureInformationOptions::activeParameterSupport( + std::optional activeParameterSupport) + -> ClientSignatureInformationOptions& { + return *this; +} + +auto ClientSignatureInformationOptions::noActiveParameterSupport( + std::optional noActiveParameterSupport) + -> ClientSignatureInformationOptions& { + return *this; +} + +ClientCodeActionLiteralOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("codeActionKind")) return false; + return true; +} + +auto ClientCodeActionLiteralOptions::codeActionKind() const + -> ClientCodeActionKindOptions { + const auto& value = repr_["codeActionKind"]; + + return ClientCodeActionKindOptions(value); +} + +auto ClientCodeActionLiteralOptions::codeActionKind( + ClientCodeActionKindOptions codeActionKind) + -> ClientCodeActionLiteralOptions& { + return *this; +} + +ClientCodeActionResolveOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("properties")) return false; + return true; +} + +auto ClientCodeActionResolveOptions::properties() const -> Vector { + const auto& value = repr_["properties"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientCodeActionResolveOptions::properties(Vector properties) + -> ClientCodeActionResolveOptions& { + return *this; +} + +CodeActionTagOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("valueSet")) return false; + return true; +} + +auto CodeActionTagOptions::valueSet() const -> Vector { + const auto& value = repr_["valueSet"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CodeActionTagOptions::valueSet(Vector valueSet) + -> CodeActionTagOptions& { + return *this; +} + +ClientCodeLensResolveOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("properties")) return false; + return true; +} + +auto ClientCodeLensResolveOptions::properties() const -> Vector { + const auto& value = repr_["properties"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientCodeLensResolveOptions::properties(Vector properties) + -> ClientCodeLensResolveOptions& { + return *this; +} + +ClientFoldingRangeKindOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ClientFoldingRangeKindOptions::valueSet() const + -> std::optional> { + if (!repr_.contains("valueSet")) return std::nullopt; + + const auto& value = repr_["valueSet"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientFoldingRangeKindOptions::valueSet( + std::optional> valueSet) + -> ClientFoldingRangeKindOptions& { + return *this; +} + +ClientFoldingRangeOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ClientFoldingRangeOptions::collapsedText() const -> std::optional { + if (!repr_.contains("collapsedText")) return std::nullopt; + + const auto& value = repr_["collapsedText"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientFoldingRangeOptions::collapsedText(std::optional collapsedText) + -> ClientFoldingRangeOptions& { + return *this; +} + +DiagnosticsCapabilities::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto DiagnosticsCapabilities::relatedInformation() const + -> std::optional { + if (!repr_.contains("relatedInformation")) return std::nullopt; + + const auto& value = repr_["relatedInformation"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticsCapabilities::tagSupport() const + -> std::optional { + if (!repr_.contains("tagSupport")) return std::nullopt; + + const auto& value = repr_["tagSupport"]; + + return ClientDiagnosticsTagOptions(value); +} + +auto DiagnosticsCapabilities::codeDescriptionSupport() const + -> std::optional { + if (!repr_.contains("codeDescriptionSupport")) return std::nullopt; + + const auto& value = repr_["codeDescriptionSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticsCapabilities::dataSupport() const -> std::optional { + if (!repr_.contains("dataSupport")) return std::nullopt; + + const auto& value = repr_["dataSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto DiagnosticsCapabilities::relatedInformation( + std::optional relatedInformation) -> DiagnosticsCapabilities& { + return *this; +} + +auto DiagnosticsCapabilities::tagSupport( + std::optional tagSupport) + -> DiagnosticsCapabilities& { + return *this; +} + +auto DiagnosticsCapabilities::codeDescriptionSupport( + std::optional codeDescriptionSupport) -> DiagnosticsCapabilities& { + return *this; +} + +auto DiagnosticsCapabilities::dataSupport(std::optional dataSupport) + -> DiagnosticsCapabilities& { + return *this; +} + +ClientSemanticTokensRequestOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ClientSemanticTokensRequestOptions::range() const + -> std::optional> { + if (!repr_.contains("range")) return std::nullopt; + + const auto& value = repr_["range"]; + + std::variant result; + + details::try_emplace(result, value); + + return result; +} + +auto ClientSemanticTokensRequestOptions::full() const -> std::optional< + std::variant> { + if (!repr_.contains("full")) return std::nullopt; + + const auto& value = repr_["full"]; + + std::variant + result; + + details::try_emplace(result, value); + + return result; +} + +auto ClientSemanticTokensRequestOptions::range( + std::optional> range) + -> ClientSemanticTokensRequestOptions& { + return *this; +} + +auto ClientSemanticTokensRequestOptions::full( + std::optional> + full) -> ClientSemanticTokensRequestOptions& { + return *this; +} + +ClientInlayHintResolveOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("properties")) return false; + return true; +} + +auto ClientInlayHintResolveOptions::properties() const -> Vector { + const auto& value = repr_["properties"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientInlayHintResolveOptions::properties(Vector properties) + -> ClientInlayHintResolveOptions& { + return *this; +} + +ClientShowMessageActionItemOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ClientShowMessageActionItemOptions::additionalPropertiesSupport() const + -> std::optional { + if (!repr_.contains("additionalPropertiesSupport")) return std::nullopt; + + const auto& value = repr_["additionalPropertiesSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientShowMessageActionItemOptions::additionalPropertiesSupport( + std::optional additionalPropertiesSupport) + -> ClientShowMessageActionItemOptions& { + return *this; +} + +CompletionItemTagOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("valueSet")) return false; + return true; +} + +auto CompletionItemTagOptions::valueSet() const -> Vector { + const auto& value = repr_["valueSet"]; + + assert(value.is_array()); + return Vector(value); +} + +auto CompletionItemTagOptions::valueSet(Vector valueSet) + -> CompletionItemTagOptions& { + return *this; +} + +ClientCompletionItemResolveOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("properties")) return false; + return true; +} + +auto ClientCompletionItemResolveOptions::properties() const + -> Vector { + const auto& value = repr_["properties"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientCompletionItemResolveOptions::properties( + Vector properties) -> ClientCompletionItemResolveOptions& { + return *this; +} + +ClientCompletionItemInsertTextModeOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("valueSet")) return false; + return true; +} + +auto ClientCompletionItemInsertTextModeOptions::valueSet() const + -> Vector { + const auto& value = repr_["valueSet"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientCompletionItemInsertTextModeOptions::valueSet( + Vector valueSet) + -> ClientCompletionItemInsertTextModeOptions& { + return *this; +} + +ClientSignatureParameterInformationOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ClientSignatureParameterInformationOptions::labelOffsetSupport() const + -> std::optional { + if (!repr_.contains("labelOffsetSupport")) return std::nullopt; + + const auto& value = repr_["labelOffsetSupport"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientSignatureParameterInformationOptions::labelOffsetSupport( + std::optional labelOffsetSupport) + -> ClientSignatureParameterInformationOptions& { + return *this; +} + +ClientCodeActionKindOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("valueSet")) return false; + return true; +} + +auto ClientCodeActionKindOptions::valueSet() const -> Vector { + const auto& value = repr_["valueSet"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientCodeActionKindOptions::valueSet(Vector valueSet) + -> ClientCodeActionKindOptions& { + return *this; +} + +ClientDiagnosticsTagOptions::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + if (!repr_.contains("valueSet")) return false; + return true; +} + +auto ClientDiagnosticsTagOptions::valueSet() const -> Vector { + const auto& value = repr_["valueSet"]; + + assert(value.is_array()); + return Vector(value); +} + +auto ClientDiagnosticsTagOptions::valueSet(Vector valueSet) + -> ClientDiagnosticsTagOptions& { + return *this; +} + +ClientSemanticTokensRequestFullDelta::operator bool() const { + if (!repr_.is_object() || repr_.is_null()) return false; + return true; +} + +auto ClientSemanticTokensRequestFullDelta::delta() const + -> std::optional { + if (!repr_.contains("delta")) return std::nullopt; + + const auto& value = repr_["delta"]; + + assert(value.is_boolean()); + return value.get(); +} + +auto ClientSemanticTokensRequestFullDelta::delta(std::optional delta) + -> ClientSemanticTokensRequestFullDelta& { + return *this; +} +} // namespace cxx::lsp diff --git a/src/lsp/cxx/lsp/types.h b/src/lsp/cxx/lsp/types.h new file mode 100644 index 00000000..2f6e781e --- /dev/null +++ b/src/lsp/cxx/lsp/types.h @@ -0,0 +1,8242 @@ +// 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 ImplementationParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> ImplementationParams&; + + auto position(Position position) -> ImplementationParams&; + + auto workDoneToken(std::optional workDoneToken) + -> ImplementationParams&; + + auto partialResultToken(std::optional partialResultToken) + -> ImplementationParams&; +}; + +class Location final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto range() const -> Range; + + auto uri(std::string uri) -> Location&; + + auto range(Range range) -> Location&; +}; + +class ImplementationRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto id() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> ImplementationRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> ImplementationRegistrationOptions&; + + auto id(std::optional id) -> ImplementationRegistrationOptions&; +}; + +class TypeDefinitionParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> TypeDefinitionParams&; + + auto position(Position position) -> TypeDefinitionParams&; + + auto workDoneToken(std::optional workDoneToken) + -> TypeDefinitionParams&; + + auto partialResultToken(std::optional partialResultToken) + -> TypeDefinitionParams&; +}; + +class TypeDefinitionRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto id() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> TypeDefinitionRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> TypeDefinitionRegistrationOptions&; + + auto id(std::optional id) -> TypeDefinitionRegistrationOptions&; +}; + +class WorkspaceFolder final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto name() const -> std::string; + + auto uri(std::string uri) -> WorkspaceFolder&; + + auto name(std::string name) -> WorkspaceFolder&; +}; + +class DidChangeWorkspaceFoldersParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto event() const -> WorkspaceFoldersChangeEvent; + + auto event(WorkspaceFoldersChangeEvent event) + -> DidChangeWorkspaceFoldersParams&; +}; + +class ConfigurationParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto items() const -> Vector; + + auto items(Vector items) -> ConfigurationParams&; +}; + +class DocumentColorParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> DocumentColorParams&; + + auto workDoneToken(std::optional workDoneToken) + -> DocumentColorParams&; + + auto partialResultToken(std::optional partialResultToken) + -> DocumentColorParams&; +}; + +class ColorInformation final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto color() const -> Color; + + auto range(Range range) -> ColorInformation&; + + auto color(Color color) -> ColorInformation&; +}; + +class DocumentColorRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto id() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> DocumentColorRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentColorRegistrationOptions&; + + auto id(std::optional id) -> DocumentColorRegistrationOptions&; +}; + +class ColorPresentationParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto color() const -> Color; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> ColorPresentationParams&; + + auto color(Color color) -> ColorPresentationParams&; + + auto range(Range range) -> ColorPresentationParams&; + + auto workDoneToken(std::optional workDoneToken) + -> ColorPresentationParams&; + + auto partialResultToken(std::optional partialResultToken) + -> ColorPresentationParams&; +}; + +class ColorPresentation final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto label() const -> std::string; + + [[nodiscard]] auto textEdit() const -> std::optional; + + [[nodiscard]] auto additionalTextEdits() const + -> std::optional>; + + auto label(std::string label) -> ColorPresentation&; + + auto textEdit(std::optional textEdit) -> ColorPresentation&; + + auto additionalTextEdits(std::optional> additionalTextEdits) + -> ColorPresentation&; +}; + +class WorkDoneProgressOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> WorkDoneProgressOptions&; +}; + +class TextDocumentRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + auto documentSelector( + std::variant + documentSelector) -> TextDocumentRegistrationOptions&; +}; + +class FoldingRangeParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) -> FoldingRangeParams&; + + auto workDoneToken(std::optional workDoneToken) + -> FoldingRangeParams&; + + auto partialResultToken(std::optional partialResultToken) + -> FoldingRangeParams&; +}; + +class FoldingRange final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto startLine() const -> long; + + [[nodiscard]] auto startCharacter() const -> std::optional; + + [[nodiscard]] auto endLine() const -> long; + + [[nodiscard]] auto endCharacter() const -> std::optional; + + [[nodiscard]] auto kind() const -> std::optional; + + [[nodiscard]] auto collapsedText() const -> std::optional; + + auto startLine(long startLine) -> FoldingRange&; + + auto startCharacter(std::optional startCharacter) -> FoldingRange&; + + auto endLine(long endLine) -> FoldingRange&; + + auto endCharacter(std::optional endCharacter) -> FoldingRange&; + + auto kind(std::optional kind) -> FoldingRange&; + + auto collapsedText(std::optional collapsedText) -> FoldingRange&; +}; + +class FoldingRangeRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto id() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> FoldingRangeRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> FoldingRangeRegistrationOptions&; + + auto id(std::optional id) -> FoldingRangeRegistrationOptions&; +}; + +class DeclarationParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) -> DeclarationParams&; + + auto position(Position position) -> DeclarationParams&; + + auto workDoneToken(std::optional workDoneToken) + -> DeclarationParams&; + + auto partialResultToken(std::optional partialResultToken) + -> DeclarationParams&; +}; + +class DeclarationRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto id() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> DeclarationRegistrationOptions&; + + auto documentSelector( + std::variant + documentSelector) -> DeclarationRegistrationOptions&; + + auto id(std::optional id) -> DeclarationRegistrationOptions&; +}; + +class SelectionRangeParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto positions() const -> Vector; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> SelectionRangeParams&; + + auto positions(Vector positions) -> SelectionRangeParams&; + + auto workDoneToken(std::optional workDoneToken) + -> SelectionRangeParams&; + + auto partialResultToken(std::optional partialResultToken) + -> SelectionRangeParams&; +}; + +class SelectionRange final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto parent() const -> std::optional; + + auto range(Range range) -> SelectionRange&; + + auto parent(std::optional parent) -> SelectionRange&; +}; + +class SelectionRangeRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto id() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> SelectionRangeRegistrationOptions&; + + auto documentSelector( + std::variant + documentSelector) -> SelectionRangeRegistrationOptions&; + + auto id(std::optional id) -> SelectionRangeRegistrationOptions&; +}; + +class WorkDoneProgressCreateParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto token() const -> ProgressToken; + + auto token(ProgressToken token) -> WorkDoneProgressCreateParams&; +}; + +class WorkDoneProgressCancelParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto token() const -> ProgressToken; + + auto token(ProgressToken token) -> WorkDoneProgressCancelParams&; +}; + +class CallHierarchyPrepareParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> CallHierarchyPrepareParams&; + + auto position(Position position) -> CallHierarchyPrepareParams&; + + auto workDoneToken(std::optional workDoneToken) + -> CallHierarchyPrepareParams&; +}; + +class CallHierarchyItem final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto name() const -> std::string; + + [[nodiscard]] auto kind() const -> SymbolKind; + + [[nodiscard]] auto tags() const -> std::optional>; + + [[nodiscard]] auto detail() const -> std::optional; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto selectionRange() const -> Range; + + [[nodiscard]] auto data() const -> std::optional; + + auto name(std::string name) -> CallHierarchyItem&; + + auto kind(SymbolKind kind) -> CallHierarchyItem&; + + auto tags(std::optional> tags) -> CallHierarchyItem&; + + auto detail(std::optional detail) -> CallHierarchyItem&; + + auto uri(std::string uri) -> CallHierarchyItem&; + + auto range(Range range) -> CallHierarchyItem&; + + auto selectionRange(Range selectionRange) -> CallHierarchyItem&; + + auto data(std::optional data) -> CallHierarchyItem&; +}; + +class CallHierarchyRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto id() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> CallHierarchyRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> CallHierarchyRegistrationOptions&; + + auto id(std::optional id) -> CallHierarchyRegistrationOptions&; +}; + +class CallHierarchyIncomingCallsParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto item() const -> CallHierarchyItem; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto item(CallHierarchyItem item) -> CallHierarchyIncomingCallsParams&; + + auto workDoneToken(std::optional workDoneToken) + -> CallHierarchyIncomingCallsParams&; + + auto partialResultToken(std::optional partialResultToken) + -> CallHierarchyIncomingCallsParams&; +}; + +class CallHierarchyIncomingCall final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto from() const -> CallHierarchyItem; + + [[nodiscard]] auto fromRanges() const -> Vector; + + auto from(CallHierarchyItem from) -> CallHierarchyIncomingCall&; + + auto fromRanges(Vector fromRanges) -> CallHierarchyIncomingCall&; +}; + +class CallHierarchyOutgoingCallsParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto item() const -> CallHierarchyItem; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto item(CallHierarchyItem item) -> CallHierarchyOutgoingCallsParams&; + + auto workDoneToken(std::optional workDoneToken) + -> CallHierarchyOutgoingCallsParams&; + + auto partialResultToken(std::optional partialResultToken) + -> CallHierarchyOutgoingCallsParams&; +}; + +class CallHierarchyOutgoingCall final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto to() const -> CallHierarchyItem; + + [[nodiscard]] auto fromRanges() const -> Vector; + + auto to(CallHierarchyItem to) -> CallHierarchyOutgoingCall&; + + auto fromRanges(Vector fromRanges) -> CallHierarchyOutgoingCall&; +}; + +class SemanticTokensParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> SemanticTokensParams&; + + auto workDoneToken(std::optional workDoneToken) + -> SemanticTokensParams&; + + auto partialResultToken(std::optional partialResultToken) + -> SemanticTokensParams&; +}; + +class SemanticTokens final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto resultId() const -> std::optional; + + [[nodiscard]] auto data() const -> Vector; + + auto resultId(std::optional resultId) -> SemanticTokens&; + + auto data(Vector data) -> SemanticTokens&; +}; + +class SemanticTokensPartialResult final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto data() const -> Vector; + + auto data(Vector data) -> SemanticTokensPartialResult&; +}; + +class SemanticTokensRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto legend() const -> SemanticTokensLegend; + + [[nodiscard]] auto range() const + -> std::optional>; + + [[nodiscard]] auto full() const -> std::optional< + std::variant>; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto id() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> SemanticTokensRegistrationOptions&; + + auto legend(SemanticTokensLegend legend) + -> SemanticTokensRegistrationOptions&; + + auto range(std::optional> range) + -> SemanticTokensRegistrationOptions&; + + auto full( + std::optional> + full) -> SemanticTokensRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> SemanticTokensRegistrationOptions&; + + auto id(std::optional id) -> SemanticTokensRegistrationOptions&; +}; + +class SemanticTokensDeltaParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto previousResultId() const -> std::string; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> SemanticTokensDeltaParams&; + + auto previousResultId(std::string previousResultId) + -> SemanticTokensDeltaParams&; + + auto workDoneToken(std::optional workDoneToken) + -> SemanticTokensDeltaParams&; + + auto partialResultToken(std::optional partialResultToken) + -> SemanticTokensDeltaParams&; +}; + +class SemanticTokensDelta final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto resultId() const -> std::optional; + + [[nodiscard]] auto edits() const -> Vector; + + auto resultId(std::optional resultId) -> SemanticTokensDelta&; + + auto edits(Vector edits) -> SemanticTokensDelta&; +}; + +class SemanticTokensDeltaPartialResult final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto edits() const -> Vector; + + auto edits(Vector edits) + -> SemanticTokensDeltaPartialResult&; +}; + +class SemanticTokensRangeParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> SemanticTokensRangeParams&; + + auto range(Range range) -> SemanticTokensRangeParams&; + + auto workDoneToken(std::optional workDoneToken) + -> SemanticTokensRangeParams&; + + auto partialResultToken(std::optional partialResultToken) + -> SemanticTokensRangeParams&; +}; + +class ShowDocumentParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto external() const -> std::optional; + + [[nodiscard]] auto takeFocus() const -> std::optional; + + [[nodiscard]] auto selection() const -> std::optional; + + auto uri(std::string uri) -> ShowDocumentParams&; + + auto external(std::optional external) -> ShowDocumentParams&; + + auto takeFocus(std::optional takeFocus) -> ShowDocumentParams&; + + auto selection(std::optional selection) -> ShowDocumentParams&; +}; + +class ShowDocumentResult final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto success() const -> bool; + + auto success(bool success) -> ShowDocumentResult&; +}; + +class LinkedEditingRangeParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> LinkedEditingRangeParams&; + + auto position(Position position) -> LinkedEditingRangeParams&; + + auto workDoneToken(std::optional workDoneToken) + -> LinkedEditingRangeParams&; +}; + +class LinkedEditingRanges final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto ranges() const -> Vector; + + [[nodiscard]] auto wordPattern() const -> std::optional; + + auto ranges(Vector ranges) -> LinkedEditingRanges&; + + auto wordPattern(std::optional wordPattern) + -> LinkedEditingRanges&; +}; + +class LinkedEditingRangeRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto id() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> LinkedEditingRangeRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> LinkedEditingRangeRegistrationOptions&; + + auto id(std::optional id) + -> LinkedEditingRangeRegistrationOptions&; +}; + +class CreateFilesParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto files() const -> Vector; + + auto files(Vector files) -> CreateFilesParams&; +}; + +class WorkspaceEdit final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto changes() const + -> std::optional>>; + + [[nodiscard]] auto + documentChanges() const -> std::optional>>; + + [[nodiscard]] auto changeAnnotations() const + -> std::optional>; + + auto changes(std::optional>> changes) + -> WorkspaceEdit&; + + auto documentChanges( + std::optional>> + documentChanges) -> WorkspaceEdit&; + + auto changeAnnotations( + std::optional> + changeAnnotations) -> WorkspaceEdit&; +}; + +class FileOperationRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto filters() const -> Vector; + + auto filters(Vector filters) + -> FileOperationRegistrationOptions&; +}; + +class RenameFilesParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto files() const -> Vector; + + auto files(Vector files) -> RenameFilesParams&; +}; + +class DeleteFilesParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto files() const -> Vector; + + auto files(Vector files) -> DeleteFilesParams&; +}; + +class MonikerParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) -> MonikerParams&; + + auto position(Position position) -> MonikerParams&; + + auto workDoneToken(std::optional workDoneToken) + -> MonikerParams&; + + auto partialResultToken(std::optional partialResultToken) + -> MonikerParams&; +}; + +class Moniker final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto scheme() const -> std::string; + + [[nodiscard]] auto identifier() const -> std::string; + + [[nodiscard]] auto unique() const -> UniquenessLevel; + + [[nodiscard]] auto kind() const -> std::optional; + + auto scheme(std::string scheme) -> Moniker&; + + auto identifier(std::string identifier) -> Moniker&; + + auto unique(UniquenessLevel unique) -> Moniker&; + + auto kind(std::optional kind) -> Moniker&; +}; + +class MonikerRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> MonikerRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> MonikerRegistrationOptions&; +}; + +class TypeHierarchyPrepareParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> TypeHierarchyPrepareParams&; + + auto position(Position position) -> TypeHierarchyPrepareParams&; + + auto workDoneToken(std::optional workDoneToken) + -> TypeHierarchyPrepareParams&; +}; + +class TypeHierarchyItem final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto name() const -> std::string; + + [[nodiscard]] auto kind() const -> SymbolKind; + + [[nodiscard]] auto tags() const -> std::optional>; + + [[nodiscard]] auto detail() const -> std::optional; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto selectionRange() const -> Range; + + [[nodiscard]] auto data() const -> std::optional; + + auto name(std::string name) -> TypeHierarchyItem&; + + auto kind(SymbolKind kind) -> TypeHierarchyItem&; + + auto tags(std::optional> tags) -> TypeHierarchyItem&; + + auto detail(std::optional detail) -> TypeHierarchyItem&; + + auto uri(std::string uri) -> TypeHierarchyItem&; + + auto range(Range range) -> TypeHierarchyItem&; + + auto selectionRange(Range selectionRange) -> TypeHierarchyItem&; + + auto data(std::optional data) -> TypeHierarchyItem&; +}; + +class TypeHierarchyRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto id() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> TypeHierarchyRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> TypeHierarchyRegistrationOptions&; + + auto id(std::optional id) -> TypeHierarchyRegistrationOptions&; +}; + +class TypeHierarchySupertypesParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto item() const -> TypeHierarchyItem; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto item(TypeHierarchyItem item) -> TypeHierarchySupertypesParams&; + + auto workDoneToken(std::optional workDoneToken) + -> TypeHierarchySupertypesParams&; + + auto partialResultToken(std::optional partialResultToken) + -> TypeHierarchySupertypesParams&; +}; + +class TypeHierarchySubtypesParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto item() const -> TypeHierarchyItem; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto item(TypeHierarchyItem item) -> TypeHierarchySubtypesParams&; + + auto workDoneToken(std::optional workDoneToken) + -> TypeHierarchySubtypesParams&; + + auto partialResultToken(std::optional partialResultToken) + -> TypeHierarchySubtypesParams&; +}; + +class InlineValueParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto context() const -> InlineValueContext; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) -> InlineValueParams&; + + auto range(Range range) -> InlineValueParams&; + + auto context(InlineValueContext context) -> InlineValueParams&; + + auto workDoneToken(std::optional workDoneToken) + -> InlineValueParams&; +}; + +class InlineValueRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto id() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> InlineValueRegistrationOptions&; + + auto documentSelector( + std::variant + documentSelector) -> InlineValueRegistrationOptions&; + + auto id(std::optional id) -> InlineValueRegistrationOptions&; +}; + +class InlayHintParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) -> InlayHintParams&; + + auto range(Range range) -> InlayHintParams&; + + auto workDoneToken(std::optional workDoneToken) + -> InlayHintParams&; +}; + +class InlayHint final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto label() const + -> std::variant>; + + [[nodiscard]] auto kind() const -> std::optional; + + [[nodiscard]] auto textEdits() const -> std::optional>; + + [[nodiscard]] auto tooltip() const -> std::optional< + std::variant>; + + [[nodiscard]] auto paddingLeft() const -> std::optional; + + [[nodiscard]] auto paddingRight() const -> std::optional; + + [[nodiscard]] auto data() const -> std::optional; + + auto position(Position position) -> InlayHint&; + + auto label( + std::variant> + label) -> InlayHint&; + + auto kind(std::optional kind) -> InlayHint&; + + auto textEdits(std::optional> textEdits) -> InlayHint&; + + auto tooltip( + std::optional> + tooltip) -> InlayHint&; + + auto paddingLeft(std::optional paddingLeft) -> InlayHint&; + + auto paddingRight(std::optional paddingRight) -> InlayHint&; + + auto data(std::optional data) -> InlayHint&; +}; + +class InlayHintRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto id() const -> std::optional; + + auto resolveProvider(std::optional resolveProvider) + -> InlayHintRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> InlayHintRegistrationOptions&; + + auto documentSelector( + std::variant + documentSelector) -> InlayHintRegistrationOptions&; + + auto id(std::optional id) -> InlayHintRegistrationOptions&; +}; + +class DocumentDiagnosticParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto identifier() const -> std::optional; + + [[nodiscard]] auto previousResultId() const -> std::optional; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> DocumentDiagnosticParams&; + + auto identifier(std::optional identifier) + -> DocumentDiagnosticParams&; + + auto previousResultId(std::optional previousResultId) + -> DocumentDiagnosticParams&; + + auto workDoneToken(std::optional workDoneToken) + -> DocumentDiagnosticParams&; + + auto partialResultToken(std::optional partialResultToken) + -> DocumentDiagnosticParams&; +}; + +class DocumentDiagnosticReportPartialResult final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto relatedDocuments() const + -> Map>; + + auto relatedDocuments( + Map> + relatedDocuments) -> DocumentDiagnosticReportPartialResult&; +}; + +class DiagnosticServerCancellationData final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto retriggerRequest() const -> bool; + + auto retriggerRequest(bool retriggerRequest) + -> DiagnosticServerCancellationData&; +}; + +class DiagnosticRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto identifier() const -> std::optional; + + [[nodiscard]] auto interFileDependencies() const -> bool; + + [[nodiscard]] auto workspaceDiagnostics() const -> bool; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto id() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> DiagnosticRegistrationOptions&; + + auto identifier(std::optional identifier) + -> DiagnosticRegistrationOptions&; + + auto interFileDependencies(bool interFileDependencies) + -> DiagnosticRegistrationOptions&; + + auto workspaceDiagnostics(bool workspaceDiagnostics) + -> DiagnosticRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DiagnosticRegistrationOptions&; + + auto id(std::optional id) -> DiagnosticRegistrationOptions&; +}; + +class WorkspaceDiagnosticParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto identifier() const -> std::optional; + + [[nodiscard]] auto previousResultIds() const -> Vector; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto identifier(std::optional identifier) + -> WorkspaceDiagnosticParams&; + + auto previousResultIds(Vector previousResultIds) + -> WorkspaceDiagnosticParams&; + + auto workDoneToken(std::optional workDoneToken) + -> WorkspaceDiagnosticParams&; + + auto partialResultToken(std::optional partialResultToken) + -> WorkspaceDiagnosticParams&; +}; + +class WorkspaceDiagnosticReport final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto items() const -> Vector; + + auto items(Vector items) + -> WorkspaceDiagnosticReport&; +}; + +class WorkspaceDiagnosticReportPartialResult final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto items() const -> Vector; + + auto items(Vector items) + -> WorkspaceDiagnosticReportPartialResult&; +}; + +class DidOpenNotebookDocumentParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebookDocument() const -> NotebookDocument; + + [[nodiscard]] auto cellTextDocuments() const -> Vector; + + auto notebookDocument(NotebookDocument notebookDocument) + -> DidOpenNotebookDocumentParams&; + + auto cellTextDocuments(Vector cellTextDocuments) + -> DidOpenNotebookDocumentParams&; +}; + +class NotebookDocumentSyncRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebookSelector() const + -> Vector>; + + [[nodiscard]] auto save() const -> std::optional; + + [[nodiscard]] auto id() const -> std::optional; + + auto notebookSelector( + Vector> + notebookSelector) -> NotebookDocumentSyncRegistrationOptions&; + + auto save(std::optional save) + -> NotebookDocumentSyncRegistrationOptions&; + + auto id(std::optional id) + -> NotebookDocumentSyncRegistrationOptions&; +}; + +class DidChangeNotebookDocumentParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebookDocument() const + -> VersionedNotebookDocumentIdentifier; + + [[nodiscard]] auto change() const -> NotebookDocumentChangeEvent; + + auto notebookDocument(VersionedNotebookDocumentIdentifier notebookDocument) + -> DidChangeNotebookDocumentParams&; + + auto change(NotebookDocumentChangeEvent change) + -> DidChangeNotebookDocumentParams&; +}; + +class DidSaveNotebookDocumentParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebookDocument() const -> NotebookDocumentIdentifier; + + auto notebookDocument(NotebookDocumentIdentifier notebookDocument) + -> DidSaveNotebookDocumentParams&; +}; + +class DidCloseNotebookDocumentParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebookDocument() const -> NotebookDocumentIdentifier; + + [[nodiscard]] auto cellTextDocuments() const + -> Vector; + + auto notebookDocument(NotebookDocumentIdentifier notebookDocument) + -> DidCloseNotebookDocumentParams&; + + auto cellTextDocuments(Vector cellTextDocuments) + -> DidCloseNotebookDocumentParams&; +}; + +class InlineCompletionParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto context() const -> InlineCompletionContext; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto context(InlineCompletionContext context) -> InlineCompletionParams&; + + auto textDocument(TextDocumentIdentifier textDocument) + -> InlineCompletionParams&; + + auto position(Position position) -> InlineCompletionParams&; + + auto workDoneToken(std::optional workDoneToken) + -> InlineCompletionParams&; +}; + +class InlineCompletionList final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto items() const -> Vector; + + auto items(Vector items) -> InlineCompletionList&; +}; + +class InlineCompletionItem final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto insertText() const + -> std::variant; + + [[nodiscard]] auto filterText() const -> std::optional; + + [[nodiscard]] auto range() const -> std::optional; + + [[nodiscard]] auto command() const -> std::optional; + + auto insertText( + std::variant insertText) + -> InlineCompletionItem&; + + auto filterText(std::optional filterText) + -> InlineCompletionItem&; + + auto range(std::optional range) -> InlineCompletionItem&; + + auto command(std::optional command) -> InlineCompletionItem&; +}; + +class InlineCompletionRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto id() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> InlineCompletionRegistrationOptions&; + + auto documentSelector( + std::variant + documentSelector) -> InlineCompletionRegistrationOptions&; + + auto id(std::optional id) + -> InlineCompletionRegistrationOptions&; +}; + +class TextDocumentContentParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + auto uri(std::string uri) -> TextDocumentContentParams&; +}; + +class TextDocumentContentResult final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto text() const -> std::string; + + auto text(std::string text) -> TextDocumentContentResult&; +}; + +class TextDocumentContentRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto schemes() const -> Vector; + + [[nodiscard]] auto id() const -> std::optional; + + auto schemes(Vector schemes) + -> TextDocumentContentRegistrationOptions&; + + auto id(std::optional id) + -> TextDocumentContentRegistrationOptions&; +}; + +class TextDocumentContentRefreshParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + auto uri(std::string uri) -> TextDocumentContentRefreshParams&; +}; + +class RegistrationParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto registrations() const -> Vector; + + auto registrations(Vector registrations) -> RegistrationParams&; +}; + +class UnregistrationParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto unregisterations() const -> Vector; + + auto unregisterations(Vector unregisterations) + -> UnregistrationParams&; +}; + +class InitializeParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto processId() const + -> std::variant; + + [[nodiscard]] auto clientInfo() const -> std::optional; + + [[nodiscard]] auto locale() const -> std::optional; + + [[nodiscard]] auto rootPath() const -> std::optional< + std::variant>; + + [[nodiscard]] auto rootUri() const + -> std::variant; + + [[nodiscard]] auto capabilities() const -> ClientCapabilities; + + [[nodiscard]] auto initializationOptions() const -> std::optional; + + [[nodiscard]] auto trace() const -> std::optional; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto workspaceFolders() const -> std::optional< + std::variant, std::nullptr_t>>; + + auto processId(std::variant processId) + -> InitializeParams&; + + auto clientInfo(std::optional clientInfo) -> InitializeParams&; + + auto locale(std::optional locale) -> InitializeParams&; + + auto rootPath( + std::optional> + rootPath) -> InitializeParams&; + + auto rootUri( + std::variant rootUri) + -> InitializeParams&; + + auto capabilities(ClientCapabilities capabilities) -> InitializeParams&; + + auto initializationOptions(std::optional initializationOptions) + -> InitializeParams&; + + auto trace(std::optional trace) -> InitializeParams&; + + auto workDoneToken(std::optional workDoneToken) + -> InitializeParams&; + + auto workspaceFolders( + std::optional< + std::variant, std::nullptr_t>> + workspaceFolders) -> InitializeParams&; +}; + +class InitializeResult final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto capabilities() const -> ServerCapabilities; + + [[nodiscard]] auto serverInfo() const -> std::optional; + + auto capabilities(ServerCapabilities capabilities) -> InitializeResult&; + + auto serverInfo(std::optional serverInfo) -> InitializeResult&; +}; + +class InitializeError final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto retry() const -> bool; + + auto retry(bool retry) -> InitializeError&; +}; + +class InitializedParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; +}; + +class DidChangeConfigurationParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto settings() const -> LSPAny; + + auto settings(LSPAny settings) -> DidChangeConfigurationParams&; +}; + +class DidChangeConfigurationRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto section() const -> std::optional< + std::variant>>; + + auto section(std::optional< + std::variant>> + section) -> DidChangeConfigurationRegistrationOptions&; +}; + +class ShowMessageParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto type() const -> MessageType; + + [[nodiscard]] auto message() const -> std::string; + + auto type(MessageType type) -> ShowMessageParams&; + + auto message(std::string message) -> ShowMessageParams&; +}; + +class ShowMessageRequestParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto type() const -> MessageType; + + [[nodiscard]] auto message() const -> std::string; + + [[nodiscard]] auto actions() const + -> std::optional>; + + auto type(MessageType type) -> ShowMessageRequestParams&; + + auto message(std::string message) -> ShowMessageRequestParams&; + + auto actions(std::optional> actions) + -> ShowMessageRequestParams&; +}; + +class MessageActionItem final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto title() const -> std::string; + + auto title(std::string title) -> MessageActionItem&; +}; + +class LogMessageParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto type() const -> MessageType; + + [[nodiscard]] auto message() const -> std::string; + + auto type(MessageType type) -> LogMessageParams&; + + auto message(std::string message) -> LogMessageParams&; +}; + +class DidOpenTextDocumentParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentItem; + + auto textDocument(TextDocumentItem textDocument) + -> DidOpenTextDocumentParams&; +}; + +class DidChangeTextDocumentParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> VersionedTextDocumentIdentifier; + + [[nodiscard]] auto contentChanges() const + -> Vector; + + auto textDocument(VersionedTextDocumentIdentifier textDocument) + -> DidChangeTextDocumentParams&; + + auto contentChanges(Vector contentChanges) + -> DidChangeTextDocumentParams&; +}; + +class TextDocumentChangeRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto syncKind() const -> TextDocumentSyncKind; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + auto syncKind(TextDocumentSyncKind syncKind) + -> TextDocumentChangeRegistrationOptions&; + + auto documentSelector( + std::variant + documentSelector) -> TextDocumentChangeRegistrationOptions&; +}; + +class DidCloseTextDocumentParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + auto textDocument(TextDocumentIdentifier textDocument) + -> DidCloseTextDocumentParams&; +}; + +class DidSaveTextDocumentParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto text() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> DidSaveTextDocumentParams&; + + auto text(std::optional text) -> DidSaveTextDocumentParams&; +}; + +class TextDocumentSaveRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto includeText() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> TextDocumentSaveRegistrationOptions&; + + auto includeText(std::optional includeText) + -> TextDocumentSaveRegistrationOptions&; +}; + +class WillSaveTextDocumentParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto reason() const -> TextDocumentSaveReason; + + auto textDocument(TextDocumentIdentifier textDocument) + -> WillSaveTextDocumentParams&; + + auto reason(TextDocumentSaveReason reason) -> WillSaveTextDocumentParams&; +}; + +class TextEdit final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto newText() const -> std::string; + + auto range(Range range) -> TextEdit&; + + auto newText(std::string newText) -> TextEdit&; +}; + +class DidChangeWatchedFilesParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto changes() const -> Vector; + + auto changes(Vector changes) -> DidChangeWatchedFilesParams&; +}; + +class DidChangeWatchedFilesRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto watchers() const -> Vector; + + auto watchers(Vector watchers) + -> DidChangeWatchedFilesRegistrationOptions&; +}; + +class PublishDiagnosticsParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto version() const -> std::optional; + + [[nodiscard]] auto diagnostics() const -> Vector; + + auto uri(std::string uri) -> PublishDiagnosticsParams&; + + auto version(std::optional version) -> PublishDiagnosticsParams&; + + auto diagnostics(Vector diagnostics) -> PublishDiagnosticsParams&; +}; + +class CompletionParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto context() const -> std::optional; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto context(std::optional context) -> CompletionParams&; + + auto textDocument(TextDocumentIdentifier textDocument) -> CompletionParams&; + + auto position(Position position) -> CompletionParams&; + + auto workDoneToken(std::optional workDoneToken) + -> CompletionParams&; + + auto partialResultToken(std::optional partialResultToken) + -> CompletionParams&; +}; + +class CompletionItem final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto label() const -> std::string; + + [[nodiscard]] auto labelDetails() const + -> std::optional; + + [[nodiscard]] auto kind() const -> std::optional; + + [[nodiscard]] auto tags() const -> std::optional>; + + [[nodiscard]] auto detail() const -> std::optional; + + [[nodiscard]] auto documentation() const -> std::optional< + std::variant>; + + [[nodiscard]] auto deprecated() const -> std::optional; + + [[nodiscard]] auto preselect() const -> std::optional; + + [[nodiscard]] auto sortText() const -> std::optional; + + [[nodiscard]] auto filterText() const -> std::optional; + + [[nodiscard]] auto insertText() const -> std::optional; + + [[nodiscard]] auto insertTextFormat() const + -> std::optional; + + [[nodiscard]] auto insertTextMode() const -> std::optional; + + [[nodiscard]] auto textEdit() const -> std::optional< + std::variant>; + + [[nodiscard]] auto textEditText() const -> std::optional; + + [[nodiscard]] auto additionalTextEdits() const + -> std::optional>; + + [[nodiscard]] auto commitCharacters() const + -> std::optional>; + + [[nodiscard]] auto command() const -> std::optional; + + [[nodiscard]] auto data() const -> std::optional; + + auto label(std::string label) -> CompletionItem&; + + auto labelDetails(std::optional labelDetails) + -> CompletionItem&; + + auto kind(std::optional kind) -> CompletionItem&; + + auto tags(std::optional> tags) -> CompletionItem&; + + auto detail(std::optional detail) -> CompletionItem&; + + auto documentation( + std::optional> + documentation) -> CompletionItem&; + + auto deprecated(std::optional deprecated) -> CompletionItem&; + + auto preselect(std::optional preselect) -> CompletionItem&; + + auto sortText(std::optional sortText) -> CompletionItem&; + + auto filterText(std::optional filterText) -> CompletionItem&; + + auto insertText(std::optional insertText) -> CompletionItem&; + + auto insertTextFormat(std::optional insertTextFormat) + -> CompletionItem&; + + auto insertTextMode(std::optional insertTextMode) + -> CompletionItem&; + + auto textEdit( + std::optional> + textEdit) -> CompletionItem&; + + auto textEditText(std::optional textEditText) -> CompletionItem&; + + auto additionalTextEdits(std::optional> additionalTextEdits) + -> CompletionItem&; + + auto commitCharacters(std::optional> commitCharacters) + -> CompletionItem&; + + auto command(std::optional command) -> CompletionItem&; + + auto data(std::optional data) -> CompletionItem&; +}; + +class CompletionList final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto isIncomplete() const -> bool; + + [[nodiscard]] auto itemDefaults() const + -> std::optional; + + [[nodiscard]] auto applyKind() const + -> std::optional; + + [[nodiscard]] auto items() const -> Vector; + + auto isIncomplete(bool isIncomplete) -> CompletionList&; + + auto itemDefaults(std::optional itemDefaults) + -> CompletionList&; + + auto applyKind(std::optional applyKind) + -> CompletionList&; + + auto items(Vector items) -> CompletionList&; +}; + +class CompletionRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto triggerCharacters() const + -> std::optional>; + + [[nodiscard]] auto allCommitCharacters() const + -> std::optional>; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto completionItem() const + -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> CompletionRegistrationOptions&; + + auto triggerCharacters(std::optional> triggerCharacters) + -> CompletionRegistrationOptions&; + + auto allCommitCharacters( + std::optional> allCommitCharacters) + -> CompletionRegistrationOptions&; + + auto resolveProvider(std::optional resolveProvider) + -> CompletionRegistrationOptions&; + + auto completionItem(std::optional completionItem) + -> CompletionRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> CompletionRegistrationOptions&; +}; + +class HoverParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) -> HoverParams&; + + auto position(Position position) -> HoverParams&; + + auto workDoneToken(std::optional workDoneToken) + -> HoverParams&; +}; + +class Hover final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto contents() const + -> std::variant>; + + [[nodiscard]] auto range() const -> std::optional; + + auto contents(std::variant> + contents) -> Hover&; + + auto range(std::optional range) -> Hover&; +}; + +class HoverRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> HoverRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> HoverRegistrationOptions&; +}; + +class SignatureHelpParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto context() const -> std::optional; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto context(std::optional context) + -> SignatureHelpParams&; + + auto textDocument(TextDocumentIdentifier textDocument) + -> SignatureHelpParams&; + + auto position(Position position) -> SignatureHelpParams&; + + auto workDoneToken(std::optional workDoneToken) + -> SignatureHelpParams&; +}; + +class SignatureHelp final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto signatures() const -> Vector; + + [[nodiscard]] auto activeSignature() const -> std::optional; + + [[nodiscard]] auto activeParameter() const + -> std::optional>; + + auto signatures(Vector signatures) -> SignatureHelp&; + + auto activeSignature(std::optional activeSignature) -> SignatureHelp&; + + auto activeParameter( + std::optional> + activeParameter) -> SignatureHelp&; +}; + +class SignatureHelpRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto triggerCharacters() const + -> std::optional>; + + [[nodiscard]] auto retriggerCharacters() const + -> std::optional>; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> SignatureHelpRegistrationOptions&; + + auto triggerCharacters(std::optional> triggerCharacters) + -> SignatureHelpRegistrationOptions&; + + auto retriggerCharacters( + std::optional> retriggerCharacters) + -> SignatureHelpRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> SignatureHelpRegistrationOptions&; +}; + +class DefinitionParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) -> DefinitionParams&; + + auto position(Position position) -> DefinitionParams&; + + auto workDoneToken(std::optional workDoneToken) + -> DefinitionParams&; + + auto partialResultToken(std::optional partialResultToken) + -> DefinitionParams&; +}; + +class DefinitionRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> DefinitionRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DefinitionRegistrationOptions&; +}; + +class ReferenceParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto context() const -> ReferenceContext; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto context(ReferenceContext context) -> ReferenceParams&; + + auto textDocument(TextDocumentIdentifier textDocument) -> ReferenceParams&; + + auto position(Position position) -> ReferenceParams&; + + auto workDoneToken(std::optional workDoneToken) + -> ReferenceParams&; + + auto partialResultToken(std::optional partialResultToken) + -> ReferenceParams&; +}; + +class ReferenceRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> ReferenceRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> ReferenceRegistrationOptions&; +}; + +class DocumentHighlightParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> DocumentHighlightParams&; + + auto position(Position position) -> DocumentHighlightParams&; + + auto workDoneToken(std::optional workDoneToken) + -> DocumentHighlightParams&; + + auto partialResultToken(std::optional partialResultToken) + -> DocumentHighlightParams&; +}; + +class DocumentHighlight final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto kind() const -> std::optional; + + auto range(Range range) -> DocumentHighlight&; + + auto kind(std::optional kind) -> DocumentHighlight&; +}; + +class DocumentHighlightRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> DocumentHighlightRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentHighlightRegistrationOptions&; +}; + +class DocumentSymbolParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> DocumentSymbolParams&; + + auto workDoneToken(std::optional workDoneToken) + -> DocumentSymbolParams&; + + auto partialResultToken(std::optional partialResultToken) + -> DocumentSymbolParams&; +}; + +class SymbolInformation final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto deprecated() const -> std::optional; + + [[nodiscard]] auto location() const -> Location; + + [[nodiscard]] auto name() const -> std::string; + + [[nodiscard]] auto kind() const -> SymbolKind; + + [[nodiscard]] auto tags() const -> std::optional>; + + [[nodiscard]] auto containerName() const -> std::optional; + + auto deprecated(std::optional deprecated) -> SymbolInformation&; + + auto location(Location location) -> SymbolInformation&; + + auto name(std::string name) -> SymbolInformation&; + + auto kind(SymbolKind kind) -> SymbolInformation&; + + auto tags(std::optional> tags) -> SymbolInformation&; + + auto containerName(std::optional containerName) + -> SymbolInformation&; +}; + +class DocumentSymbol final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto name() const -> std::string; + + [[nodiscard]] auto detail() const -> std::optional; + + [[nodiscard]] auto kind() const -> SymbolKind; + + [[nodiscard]] auto tags() const -> std::optional>; + + [[nodiscard]] auto deprecated() const -> std::optional; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto selectionRange() const -> Range; + + [[nodiscard]] auto children() const -> std::optional>; + + auto name(std::string name) -> DocumentSymbol&; + + auto detail(std::optional detail) -> DocumentSymbol&; + + auto kind(SymbolKind kind) -> DocumentSymbol&; + + auto tags(std::optional> tags) -> DocumentSymbol&; + + auto deprecated(std::optional deprecated) -> DocumentSymbol&; + + auto range(Range range) -> DocumentSymbol&; + + auto selectionRange(Range selectionRange) -> DocumentSymbol&; + + auto children(std::optional> children) + -> DocumentSymbol&; +}; + +class DocumentSymbolRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto label() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> DocumentSymbolRegistrationOptions&; + + auto label(std::optional label) + -> DocumentSymbolRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentSymbolRegistrationOptions&; +}; + +class CodeActionParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto context() const -> CodeActionContext; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) -> CodeActionParams&; + + auto range(Range range) -> CodeActionParams&; + + auto context(CodeActionContext context) -> CodeActionParams&; + + auto workDoneToken(std::optional workDoneToken) + -> CodeActionParams&; + + auto partialResultToken(std::optional partialResultToken) + -> CodeActionParams&; +}; + +class Command final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto title() const -> std::string; + + [[nodiscard]] auto tooltip() const -> std::optional; + + [[nodiscard]] auto command() const -> std::string; + + [[nodiscard]] auto arguments() const -> std::optional>; + + auto title(std::string title) -> Command&; + + auto tooltip(std::optional tooltip) -> Command&; + + auto command(std::string command) -> Command&; + + auto arguments(std::optional> arguments) -> Command&; +}; + +class CodeAction final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto title() const -> std::string; + + [[nodiscard]] auto kind() const -> std::optional; + + [[nodiscard]] auto diagnostics() const -> std::optional>; + + [[nodiscard]] auto isPreferred() const -> std::optional; + + [[nodiscard]] auto disabled() const -> std::optional; + + [[nodiscard]] auto edit() const -> std::optional; + + [[nodiscard]] auto command() const -> std::optional; + + [[nodiscard]] auto data() const -> std::optional; + + [[nodiscard]] auto tags() const -> std::optional>; + + auto title(std::string title) -> CodeAction&; + + auto kind(std::optional kind) -> CodeAction&; + + auto diagnostics(std::optional> diagnostics) + -> CodeAction&; + + auto isPreferred(std::optional isPreferred) -> CodeAction&; + + auto disabled(std::optional disabled) -> CodeAction&; + + auto edit(std::optional edit) -> CodeAction&; + + auto command(std::optional command) -> CodeAction&; + + auto data(std::optional data) -> CodeAction&; + + auto tags(std::optional> tags) -> CodeAction&; +}; + +class CodeActionRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto codeActionKinds() const + -> std::optional>; + + [[nodiscard]] auto documentation() const + -> std::optional>; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> CodeActionRegistrationOptions&; + + auto codeActionKinds(std::optional> codeActionKinds) + -> CodeActionRegistrationOptions&; + + auto documentation( + std::optional> documentation) + -> CodeActionRegistrationOptions&; + + auto resolveProvider(std::optional resolveProvider) + -> CodeActionRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> CodeActionRegistrationOptions&; +}; + +class WorkspaceSymbolParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto query() const -> std::string; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto query(std::string query) -> WorkspaceSymbolParams&; + + auto workDoneToken(std::optional workDoneToken) + -> WorkspaceSymbolParams&; + + auto partialResultToken(std::optional partialResultToken) + -> WorkspaceSymbolParams&; +}; + +class WorkspaceSymbol final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto location() const + -> std::variant; + + [[nodiscard]] auto data() const -> std::optional; + + [[nodiscard]] auto name() const -> std::string; + + [[nodiscard]] auto kind() const -> SymbolKind; + + [[nodiscard]] auto tags() const -> std::optional>; + + [[nodiscard]] auto containerName() const -> std::optional; + + auto location( + std::variant location) + -> WorkspaceSymbol&; + + auto data(std::optional data) -> WorkspaceSymbol&; + + auto name(std::string name) -> WorkspaceSymbol&; + + auto kind(SymbolKind kind) -> WorkspaceSymbol&; + + auto tags(std::optional> tags) -> WorkspaceSymbol&; + + auto containerName(std::optional containerName) + -> WorkspaceSymbol&; +}; + +class WorkspaceSymbolRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto resolveProvider(std::optional resolveProvider) + -> WorkspaceSymbolRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> WorkspaceSymbolRegistrationOptions&; +}; + +class CodeLensParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) -> CodeLensParams&; + + auto workDoneToken(std::optional workDoneToken) + -> CodeLensParams&; + + auto partialResultToken(std::optional partialResultToken) + -> CodeLensParams&; +}; + +class CodeLens final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto command() const -> std::optional; + + [[nodiscard]] auto data() const -> std::optional; + + auto range(Range range) -> CodeLens&; + + auto command(std::optional command) -> CodeLens&; + + auto data(std::optional data) -> CodeLens&; +}; + +class CodeLensRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> CodeLensRegistrationOptions&; + + auto resolveProvider(std::optional resolveProvider) + -> CodeLensRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> CodeLensRegistrationOptions&; +}; + +class DocumentLinkParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) -> DocumentLinkParams&; + + auto workDoneToken(std::optional workDoneToken) + -> DocumentLinkParams&; + + auto partialResultToken(std::optional partialResultToken) + -> DocumentLinkParams&; +}; + +class DocumentLink final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto target() const -> std::optional; + + [[nodiscard]] auto tooltip() const -> std::optional; + + [[nodiscard]] auto data() const -> std::optional; + + auto range(Range range) -> DocumentLink&; + + auto target(std::optional target) -> DocumentLink&; + + auto tooltip(std::optional tooltip) -> DocumentLink&; + + auto data(std::optional data) -> DocumentLink&; +}; + +class DocumentLinkRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> DocumentLinkRegistrationOptions&; + + auto resolveProvider(std::optional resolveProvider) + -> DocumentLinkRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentLinkRegistrationOptions&; +}; + +class DocumentFormattingParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto options() const -> FormattingOptions; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> DocumentFormattingParams&; + + auto options(FormattingOptions options) -> DocumentFormattingParams&; + + auto workDoneToken(std::optional workDoneToken) + -> DocumentFormattingParams&; +}; + +class DocumentFormattingRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> DocumentFormattingRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentFormattingRegistrationOptions&; +}; + +class DocumentRangeFormattingParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto options() const -> FormattingOptions; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> DocumentRangeFormattingParams&; + + auto range(Range range) -> DocumentRangeFormattingParams&; + + auto options(FormattingOptions options) -> DocumentRangeFormattingParams&; + + auto workDoneToken(std::optional workDoneToken) + -> DocumentRangeFormattingParams&; +}; + +class DocumentRangeFormattingRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto rangesSupport() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> DocumentRangeFormattingRegistrationOptions&; + + auto rangesSupport(std::optional rangesSupport) + -> DocumentRangeFormattingRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentRangeFormattingRegistrationOptions&; +}; + +class DocumentRangesFormattingParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto ranges() const -> Vector; + + [[nodiscard]] auto options() const -> FormattingOptions; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> DocumentRangesFormattingParams&; + + auto ranges(Vector ranges) -> DocumentRangesFormattingParams&; + + auto options(FormattingOptions options) -> DocumentRangesFormattingParams&; + + auto workDoneToken(std::optional workDoneToken) + -> DocumentRangesFormattingParams&; +}; + +class DocumentOnTypeFormattingParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto ch() const -> std::string; + + [[nodiscard]] auto options() const -> FormattingOptions; + + auto textDocument(TextDocumentIdentifier textDocument) + -> DocumentOnTypeFormattingParams&; + + auto position(Position position) -> DocumentOnTypeFormattingParams&; + + auto ch(std::string ch) -> DocumentOnTypeFormattingParams&; + + auto options(FormattingOptions options) -> DocumentOnTypeFormattingParams&; +}; + +class DocumentOnTypeFormattingRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto firstTriggerCharacter() const -> std::string; + + [[nodiscard]] auto moreTriggerCharacter() const + -> std::optional>; + + auto documentSelector( + std::variant + documentSelector) -> DocumentOnTypeFormattingRegistrationOptions&; + + auto firstTriggerCharacter(std::string firstTriggerCharacter) + -> DocumentOnTypeFormattingRegistrationOptions&; + + auto moreTriggerCharacter( + std::optional> moreTriggerCharacter) + -> DocumentOnTypeFormattingRegistrationOptions&; +}; + +class RenameParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto newName() const -> std::string; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) -> RenameParams&; + + auto position(Position position) -> RenameParams&; + + auto newName(std::string newName) -> RenameParams&; + + auto workDoneToken(std::optional workDoneToken) + -> RenameParams&; +}; + +class RenameRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentSelector() const + -> std::variant; + + [[nodiscard]] auto prepareProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto documentSelector( + std::variant + documentSelector) -> RenameRegistrationOptions&; + + auto prepareProvider(std::optional prepareProvider) + -> RenameRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> RenameRegistrationOptions&; +}; + +class PrepareRenameParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto textDocument(TextDocumentIdentifier textDocument) + -> PrepareRenameParams&; + + auto position(Position position) -> PrepareRenameParams&; + + auto workDoneToken(std::optional workDoneToken) + -> PrepareRenameParams&; +}; + +class ExecuteCommandParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto command() const -> std::string; + + [[nodiscard]] auto arguments() const -> std::optional>; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto command(std::string command) -> ExecuteCommandParams&; + + auto arguments(std::optional> arguments) + -> ExecuteCommandParams&; + + auto workDoneToken(std::optional workDoneToken) + -> ExecuteCommandParams&; +}; + +class ExecuteCommandRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto commands() const -> Vector; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto commands(Vector commands) + -> ExecuteCommandRegistrationOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> ExecuteCommandRegistrationOptions&; +}; + +class ApplyWorkspaceEditParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto label() const -> std::optional; + + [[nodiscard]] auto edit() const -> WorkspaceEdit; + + [[nodiscard]] auto metadata() const -> std::optional; + + auto label(std::optional label) -> ApplyWorkspaceEditParams&; + + auto edit(WorkspaceEdit edit) -> ApplyWorkspaceEditParams&; + + auto metadata(std::optional metadata) + -> ApplyWorkspaceEditParams&; +}; + +class ApplyWorkspaceEditResult final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto applied() const -> bool; + + [[nodiscard]] auto failureReason() const -> std::optional; + + [[nodiscard]] auto failedChange() const -> std::optional; + + auto applied(bool applied) -> ApplyWorkspaceEditResult&; + + auto failureReason(std::optional failureReason) + -> ApplyWorkspaceEditResult&; + + auto failedChange(std::optional failedChange) + -> ApplyWorkspaceEditResult&; +}; + +class WorkDoneProgressBegin final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto title() const -> std::string; + + [[nodiscard]] auto cancellable() const -> std::optional; + + [[nodiscard]] auto message() const -> std::optional; + + [[nodiscard]] auto percentage() const -> std::optional; + + auto kind(std::string kind) -> WorkDoneProgressBegin&; + + auto title(std::string title) -> WorkDoneProgressBegin&; + + auto cancellable(std::optional cancellable) -> WorkDoneProgressBegin&; + + auto message(std::optional message) -> WorkDoneProgressBegin&; + + auto percentage(std::optional percentage) -> WorkDoneProgressBegin&; +}; + +class WorkDoneProgressReport final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto cancellable() const -> std::optional; + + [[nodiscard]] auto message() const -> std::optional; + + [[nodiscard]] auto percentage() const -> std::optional; + + auto kind(std::string kind) -> WorkDoneProgressReport&; + + auto cancellable(std::optional cancellable) -> WorkDoneProgressReport&; + + auto message(std::optional message) -> WorkDoneProgressReport&; + + auto percentage(std::optional percentage) -> WorkDoneProgressReport&; +}; + +class WorkDoneProgressEnd final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto message() const -> std::optional; + + auto kind(std::string kind) -> WorkDoneProgressEnd&; + + auto message(std::optional message) -> WorkDoneProgressEnd&; +}; + +class SetTraceParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto value() const -> TraceValue; + + auto value(TraceValue value) -> SetTraceParams&; +}; + +class LogTraceParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto message() const -> std::string; + + [[nodiscard]] auto verbose() const -> std::optional; + + auto message(std::string message) -> LogTraceParams&; + + auto verbose(std::optional verbose) -> LogTraceParams&; +}; + +class CancelParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto id() const + -> std::variant; + + auto id(std::variant id) -> CancelParams&; +}; + +class ProgressParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto token() const -> ProgressToken; + + [[nodiscard]] auto value() const -> LSPAny; + + auto token(ProgressToken token) -> ProgressParams&; + + auto value(LSPAny value) -> ProgressParams&; +}; + +class TextDocumentPositionParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const -> TextDocumentIdentifier; + + [[nodiscard]] auto position() const -> Position; + + auto textDocument(TextDocumentIdentifier textDocument) + -> TextDocumentPositionParams&; + + auto position(Position position) -> TextDocumentPositionParams&; +}; + +class WorkDoneProgressParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto workDoneToken(std::optional workDoneToken) + -> WorkDoneProgressParams&; +}; + +class PartialResultParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto partialResultToken() const -> std::optional; + + auto partialResultToken(std::optional partialResultToken) + -> PartialResultParams&; +}; + +class LocationLink final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto originSelectionRange() const -> std::optional; + + [[nodiscard]] auto targetUri() const -> std::string; + + [[nodiscard]] auto targetRange() const -> Range; + + [[nodiscard]] auto targetSelectionRange() const -> Range; + + auto originSelectionRange(std::optional originSelectionRange) + -> LocationLink&; + + auto targetUri(std::string targetUri) -> LocationLink&; + + auto targetRange(Range targetRange) -> LocationLink&; + + auto targetSelectionRange(Range targetSelectionRange) -> LocationLink&; +}; + +class Range final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto start() const -> Position; + + [[nodiscard]] auto end() const -> Position; + + auto start(Position start) -> Range&; + + auto end(Position end) -> Range&; +}; + +class ImplementationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> ImplementationOptions&; +}; + +class StaticRegistrationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto id() const -> std::optional; + + auto id(std::optional id) -> StaticRegistrationOptions&; +}; + +class TypeDefinitionOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> TypeDefinitionOptions&; +}; + +class WorkspaceFoldersChangeEvent final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto added() const -> Vector; + + [[nodiscard]] auto removed() const -> Vector; + + auto added(Vector added) -> WorkspaceFoldersChangeEvent&; + + auto removed(Vector removed) -> WorkspaceFoldersChangeEvent&; +}; + +class ConfigurationItem final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto scopeUri() const -> std::optional; + + [[nodiscard]] auto section() const -> std::optional; + + auto scopeUri(std::optional scopeUri) -> ConfigurationItem&; + + auto section(std::optional section) -> ConfigurationItem&; +}; + +class TextDocumentIdentifier final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + auto uri(std::string uri) -> TextDocumentIdentifier&; +}; + +class Color final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto red() const -> double; + + [[nodiscard]] auto green() const -> double; + + [[nodiscard]] auto blue() const -> double; + + [[nodiscard]] auto alpha() const -> double; + + auto red(double red) -> Color&; + + auto green(double green) -> Color&; + + auto blue(double blue) -> Color&; + + auto alpha(double alpha) -> Color&; +}; + +class DocumentColorOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentColorOptions&; +}; + +class FoldingRangeOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> FoldingRangeOptions&; +}; + +class DeclarationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> DeclarationOptions&; +}; + +class Position final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto line() const -> long; + + [[nodiscard]] auto character() const -> long; + + auto line(long line) -> Position&; + + auto character(long character) -> Position&; +}; + +class SelectionRangeOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> SelectionRangeOptions&; +}; + +class CallHierarchyOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> CallHierarchyOptions&; +}; + +class SemanticTokensOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto legend() const -> SemanticTokensLegend; + + [[nodiscard]] auto range() const + -> std::optional>; + + [[nodiscard]] auto full() const -> std::optional< + std::variant>; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto legend(SemanticTokensLegend legend) -> SemanticTokensOptions&; + + auto range(std::optional> range) + -> SemanticTokensOptions&; + + auto full( + std::optional> + full) -> SemanticTokensOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> SemanticTokensOptions&; +}; + +class SemanticTokensEdit final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto start() const -> long; + + [[nodiscard]] auto deleteCount() const -> long; + + [[nodiscard]] auto data() const -> std::optional>; + + auto start(long start) -> SemanticTokensEdit&; + + auto deleteCount(long deleteCount) -> SemanticTokensEdit&; + + auto data(std::optional> data) -> SemanticTokensEdit&; +}; + +class LinkedEditingRangeOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> LinkedEditingRangeOptions&; +}; + +class FileCreate final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + auto uri(std::string uri) -> FileCreate&; +}; + +class TextDocumentEdit final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto textDocument() const + -> OptionalVersionedTextDocumentIdentifier; + + [[nodiscard]] auto edits() const + -> Vector>; + + auto textDocument(OptionalVersionedTextDocumentIdentifier textDocument) + -> TextDocumentEdit&; + + auto edits(Vector> + edits) -> TextDocumentEdit&; +}; + +class CreateFile final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto options() const -> std::optional; + + [[nodiscard]] auto annotationId() const + -> std::optional; + + auto kind(std::string kind) -> CreateFile&; + + auto uri(std::string uri) -> CreateFile&; + + auto options(std::optional options) -> CreateFile&; + + auto annotationId(std::optional annotationId) + -> CreateFile&; +}; + +class RenameFile final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto oldUri() const -> std::string; + + [[nodiscard]] auto newUri() const -> std::string; + + [[nodiscard]] auto options() const -> std::optional; + + [[nodiscard]] auto annotationId() const + -> std::optional; + + auto kind(std::string kind) -> RenameFile&; + + auto oldUri(std::string oldUri) -> RenameFile&; + + auto newUri(std::string newUri) -> RenameFile&; + + auto options(std::optional options) -> RenameFile&; + + auto annotationId(std::optional annotationId) + -> RenameFile&; +}; + +class DeleteFile final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto options() const -> std::optional; + + [[nodiscard]] auto annotationId() const + -> std::optional; + + auto kind(std::string kind) -> DeleteFile&; + + auto uri(std::string uri) -> DeleteFile&; + + auto options(std::optional options) -> DeleteFile&; + + auto annotationId(std::optional annotationId) + -> DeleteFile&; +}; + +class ChangeAnnotation final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto label() const -> std::string; + + [[nodiscard]] auto needsConfirmation() const -> std::optional; + + [[nodiscard]] auto description() const -> std::optional; + + auto label(std::string label) -> ChangeAnnotation&; + + auto needsConfirmation(std::optional needsConfirmation) + -> ChangeAnnotation&; + + auto description(std::optional description) -> ChangeAnnotation&; +}; + +class FileOperationFilter final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto scheme() const -> std::optional; + + [[nodiscard]] auto pattern() const -> FileOperationPattern; + + auto scheme(std::optional scheme) -> FileOperationFilter&; + + auto pattern(FileOperationPattern pattern) -> FileOperationFilter&; +}; + +class FileRename final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto oldUri() const -> std::string; + + [[nodiscard]] auto newUri() const -> std::string; + + auto oldUri(std::string oldUri) -> FileRename&; + + auto newUri(std::string newUri) -> FileRename&; +}; + +class FileDelete final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + auto uri(std::string uri) -> FileDelete&; +}; + +class MonikerOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> MonikerOptions&; +}; + +class TypeHierarchyOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> TypeHierarchyOptions&; +}; + +class InlineValueContext final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto frameId() const -> int; + + [[nodiscard]] auto stoppedLocation() const -> Range; + + auto frameId(int frameId) -> InlineValueContext&; + + auto stoppedLocation(Range stoppedLocation) -> InlineValueContext&; +}; + +class InlineValueText final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto text() const -> std::string; + + auto range(Range range) -> InlineValueText&; + + auto text(std::string text) -> InlineValueText&; +}; + +class InlineValueVariableLookup final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto variableName() const -> std::optional; + + [[nodiscard]] auto caseSensitiveLookup() const -> bool; + + auto range(Range range) -> InlineValueVariableLookup&; + + auto variableName(std::optional variableName) + -> InlineValueVariableLookup&; + + auto caseSensitiveLookup(bool caseSensitiveLookup) + -> InlineValueVariableLookup&; +}; + +class InlineValueEvaluatableExpression final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto expression() const -> std::optional; + + auto range(Range range) -> InlineValueEvaluatableExpression&; + + auto expression(std::optional expression) + -> InlineValueEvaluatableExpression&; +}; + +class InlineValueOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> InlineValueOptions&; +}; + +class InlayHintLabelPart final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto value() const -> std::string; + + [[nodiscard]] auto tooltip() const -> std::optional< + std::variant>; + + [[nodiscard]] auto location() const -> std::optional; + + [[nodiscard]] auto command() const -> std::optional; + + auto value(std::string value) -> InlayHintLabelPart&; + + auto tooltip( + std::optional> + tooltip) -> InlayHintLabelPart&; + + auto location(std::optional location) -> InlayHintLabelPart&; + + auto command(std::optional command) -> InlayHintLabelPart&; +}; + +class MarkupContent final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> MarkupKind; + + [[nodiscard]] auto value() const -> std::string; + + auto kind(MarkupKind kind) -> MarkupContent&; + + auto value(std::string value) -> MarkupContent&; +}; + +class InlayHintOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto resolveProvider(std::optional resolveProvider) + -> InlayHintOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> InlayHintOptions&; +}; + +class RelatedFullDocumentDiagnosticReport final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto relatedDocuments() const -> std::optional>>; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto resultId() const -> std::optional; + + [[nodiscard]] auto items() const -> Vector; + + auto relatedDocuments( + std::optional< + Map>> + relatedDocuments) -> RelatedFullDocumentDiagnosticReport&; + + auto kind(std::string kind) -> RelatedFullDocumentDiagnosticReport&; + + auto resultId(std::optional resultId) + -> RelatedFullDocumentDiagnosticReport&; + + auto items(Vector items) -> RelatedFullDocumentDiagnosticReport&; +}; + +class RelatedUnchangedDocumentDiagnosticReport final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto relatedDocuments() const -> std::optional>>; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto resultId() const -> std::string; + + auto relatedDocuments( + std::optional< + Map>> + relatedDocuments) -> RelatedUnchangedDocumentDiagnosticReport&; + + auto kind(std::string kind) -> RelatedUnchangedDocumentDiagnosticReport&; + + auto resultId(std::string resultId) + -> RelatedUnchangedDocumentDiagnosticReport&; +}; + +class FullDocumentDiagnosticReport final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto resultId() const -> std::optional; + + [[nodiscard]] auto items() const -> Vector; + + auto kind(std::string kind) -> FullDocumentDiagnosticReport&; + + auto resultId(std::optional resultId) + -> FullDocumentDiagnosticReport&; + + auto items(Vector items) -> FullDocumentDiagnosticReport&; +}; + +class UnchangedDocumentDiagnosticReport final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto resultId() const -> std::string; + + auto kind(std::string kind) -> UnchangedDocumentDiagnosticReport&; + + auto resultId(std::string resultId) -> UnchangedDocumentDiagnosticReport&; +}; + +class DiagnosticOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto identifier() const -> std::optional; + + [[nodiscard]] auto interFileDependencies() const -> bool; + + [[nodiscard]] auto workspaceDiagnostics() const -> bool; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto identifier(std::optional identifier) -> DiagnosticOptions&; + + auto interFileDependencies(bool interFileDependencies) -> DiagnosticOptions&; + + auto workspaceDiagnostics(bool workspaceDiagnostics) -> DiagnosticOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DiagnosticOptions&; +}; + +class PreviousResultId final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto value() const -> std::string; + + auto uri(std::string uri) -> PreviousResultId&; + + auto value(std::string value) -> PreviousResultId&; +}; + +class NotebookDocument final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto notebookType() const -> std::string; + + [[nodiscard]] auto version() const -> int; + + [[nodiscard]] auto metadata() const -> std::optional; + + [[nodiscard]] auto cells() const -> Vector; + + auto uri(std::string uri) -> NotebookDocument&; + + auto notebookType(std::string notebookType) -> NotebookDocument&; + + auto version(int version) -> NotebookDocument&; + + auto metadata(std::optional metadata) -> NotebookDocument&; + + auto cells(Vector cells) -> NotebookDocument&; +}; + +class TextDocumentItem final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto languageId() const -> LanguageKind; + + [[nodiscard]] auto version() const -> int; + + [[nodiscard]] auto text() const -> std::string; + + auto uri(std::string uri) -> TextDocumentItem&; + + auto languageId(LanguageKind languageId) -> TextDocumentItem&; + + auto version(int version) -> TextDocumentItem&; + + auto text(std::string text) -> TextDocumentItem&; +}; + +class NotebookDocumentSyncOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebookSelector() const + -> Vector>; + + [[nodiscard]] auto save() const -> std::optional; + + auto notebookSelector( + Vector> + notebookSelector) -> NotebookDocumentSyncOptions&; + + auto save(std::optional save) -> NotebookDocumentSyncOptions&; +}; + +class VersionedNotebookDocumentIdentifier final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto version() const -> int; + + [[nodiscard]] auto uri() const -> std::string; + + auto version(int version) -> VersionedNotebookDocumentIdentifier&; + + auto uri(std::string uri) -> VersionedNotebookDocumentIdentifier&; +}; + +class NotebookDocumentChangeEvent final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto metadata() const -> std::optional; + + [[nodiscard]] auto cells() const + -> std::optional; + + auto metadata(std::optional metadata) + -> NotebookDocumentChangeEvent&; + + auto cells(std::optional cells) + -> NotebookDocumentChangeEvent&; +}; + +class NotebookDocumentIdentifier final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + auto uri(std::string uri) -> NotebookDocumentIdentifier&; +}; + +class InlineCompletionContext final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto triggerKind() const -> InlineCompletionTriggerKind; + + [[nodiscard]] auto selectedCompletionInfo() const + -> std::optional; + + auto triggerKind(InlineCompletionTriggerKind triggerKind) + -> InlineCompletionContext&; + + auto selectedCompletionInfo( + std::optional selectedCompletionInfo) + -> InlineCompletionContext&; +}; + +class StringValue final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto value() const -> std::string; + + auto kind(std::string kind) -> StringValue&; + + auto value(std::string value) -> StringValue&; +}; + +class InlineCompletionOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> InlineCompletionOptions&; +}; + +class TextDocumentContentOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto schemes() const -> Vector; + + auto schemes(Vector schemes) -> TextDocumentContentOptions&; +}; + +class Registration final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto id() const -> std::string; + + [[nodiscard]] auto method() const -> std::string; + + [[nodiscard]] auto registerOptions() const -> std::optional; + + auto id(std::string id) -> Registration&; + + auto method(std::string method) -> Registration&; + + auto registerOptions(std::optional registerOptions) -> Registration&; +}; + +class Unregistration final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto id() const -> std::string; + + [[nodiscard]] auto method() const -> std::string; + + auto id(std::string id) -> Unregistration&; + + auto method(std::string method) -> Unregistration&; +}; + +class _InitializeParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto processId() const + -> std::variant; + + [[nodiscard]] auto clientInfo() const -> std::optional; + + [[nodiscard]] auto locale() const -> std::optional; + + [[nodiscard]] auto rootPath() const -> std::optional< + std::variant>; + + [[nodiscard]] auto rootUri() const + -> std::variant; + + [[nodiscard]] auto capabilities() const -> ClientCapabilities; + + [[nodiscard]] auto initializationOptions() const -> std::optional; + + [[nodiscard]] auto trace() const -> std::optional; + + [[nodiscard]] auto workDoneToken() const -> std::optional; + + auto processId(std::variant processId) + -> _InitializeParams&; + + auto clientInfo(std::optional clientInfo) -> _InitializeParams&; + + auto locale(std::optional locale) -> _InitializeParams&; + + auto rootPath( + std::optional> + rootPath) -> _InitializeParams&; + + auto rootUri( + std::variant rootUri) + -> _InitializeParams&; + + auto capabilities(ClientCapabilities capabilities) -> _InitializeParams&; + + auto initializationOptions(std::optional initializationOptions) + -> _InitializeParams&; + + auto trace(std::optional trace) -> _InitializeParams&; + + auto workDoneToken(std::optional workDoneToken) + -> _InitializeParams&; +}; + +class WorkspaceFoldersInitializeParams final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workspaceFolders() const -> std::optional< + std::variant, std::nullptr_t>>; + + auto workspaceFolders( + std::optional< + std::variant, std::nullptr_t>> + workspaceFolders) -> WorkspaceFoldersInitializeParams&; +}; + +class ServerCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto positionEncoding() const + -> std::optional; + + [[nodiscard]] auto textDocumentSync() const + -> std::optional>; + + [[nodiscard]] auto notebookDocumentSync() const + -> std::optional>; + + [[nodiscard]] auto completionProvider() const + -> std::optional; + + [[nodiscard]] auto hoverProvider() const + -> std::optional>; + + [[nodiscard]] auto signatureHelpProvider() const + -> std::optional; + + [[nodiscard]] auto declarationProvider() const + -> std::optional>; + + [[nodiscard]] auto definitionProvider() const + -> std::optional>; + + [[nodiscard]] auto typeDefinitionProvider() const + -> std::optional>; + + [[nodiscard]] auto implementationProvider() const + -> std::optional>; + + [[nodiscard]] auto referencesProvider() const + -> std::optional>; + + [[nodiscard]] auto documentHighlightProvider() const -> std::optional< + std::variant>; + + [[nodiscard]] auto documentSymbolProvider() const -> std::optional< + std::variant>; + + [[nodiscard]] auto codeActionProvider() const + -> std::optional>; + + [[nodiscard]] auto codeLensProvider() const -> std::optional; + + [[nodiscard]] auto documentLinkProvider() const + -> std::optional; + + [[nodiscard]] auto colorProvider() const + -> std::optional>; + + [[nodiscard]] auto workspaceSymbolProvider() const -> std::optional< + std::variant>; + + [[nodiscard]] auto documentFormattingProvider() const -> std::optional< + std::variant>; + + [[nodiscard]] auto documentRangeFormattingProvider() const -> std::optional< + std::variant>; + + [[nodiscard]] auto documentOnTypeFormattingProvider() const + -> std::optional; + + [[nodiscard]] auto renameProvider() const + -> std::optional>; + + [[nodiscard]] auto foldingRangeProvider() const + -> std::optional>; + + [[nodiscard]] auto selectionRangeProvider() const + -> std::optional>; + + [[nodiscard]] auto executeCommandProvider() const + -> std::optional; + + [[nodiscard]] auto callHierarchyProvider() const + -> std::optional>; + + [[nodiscard]] auto linkedEditingRangeProvider() const -> std::optional< + std::variant>; + + [[nodiscard]] auto semanticTokensProvider() const + -> std::optional>; + + [[nodiscard]] auto monikerProvider() const + -> std::optional>; + + [[nodiscard]] auto typeHierarchyProvider() const + -> std::optional>; + + [[nodiscard]] auto inlineValueProvider() const + -> std::optional>; + + [[nodiscard]] auto inlayHintProvider() const + -> std::optional>; + + [[nodiscard]] auto diagnosticProvider() const + -> std::optional>; + + [[nodiscard]] auto inlineCompletionProvider() const -> std::optional< + std::variant>; + + [[nodiscard]] auto workspace() const -> std::optional; + + [[nodiscard]] auto experimental() const -> std::optional; + + auto positionEncoding(std::optional positionEncoding) + -> ServerCapabilities&; + + auto textDocumentSync( + std::optional> + textDocumentSync) -> ServerCapabilities&; + + auto notebookDocumentSync( + std::optional> + notebookDocumentSync) -> ServerCapabilities&; + + auto completionProvider(std::optional completionProvider) + -> ServerCapabilities&; + + auto hoverProvider( + std::optional> + hoverProvider) -> ServerCapabilities&; + + auto signatureHelpProvider( + std::optional signatureHelpProvider) + -> ServerCapabilities&; + + auto declarationProvider( + std::optional> + declarationProvider) -> ServerCapabilities&; + + auto definitionProvider( + std::optional> + definitionProvider) -> ServerCapabilities&; + + auto typeDefinitionProvider( + std::optional> + typeDefinitionProvider) -> ServerCapabilities&; + + auto implementationProvider( + std::optional> + implementationProvider) -> ServerCapabilities&; + + auto referencesProvider( + std::optional> + referencesProvider) -> ServerCapabilities&; + + auto documentHighlightProvider( + std::optional< + std::variant> + documentHighlightProvider) -> ServerCapabilities&; + + auto documentSymbolProvider( + std::optional> + documentSymbolProvider) -> ServerCapabilities&; + + auto codeActionProvider( + std::optional> + codeActionProvider) -> ServerCapabilities&; + + auto codeLensProvider(std::optional codeLensProvider) + -> ServerCapabilities&; + + auto documentLinkProvider( + std::optional documentLinkProvider) + -> ServerCapabilities&; + + auto colorProvider( + std::optional> + colorProvider) -> ServerCapabilities&; + + auto workspaceSymbolProvider( + std::optional> + workspaceSymbolProvider) -> ServerCapabilities&; + + auto documentFormattingProvider( + std::optional< + std::variant> + documentFormattingProvider) -> ServerCapabilities&; + + auto documentRangeFormattingProvider( + std::optional< + std::variant> + documentRangeFormattingProvider) -> ServerCapabilities&; + + auto documentOnTypeFormattingProvider( + std::optional + documentOnTypeFormattingProvider) -> ServerCapabilities&; + + auto renameProvider( + std::optional> + renameProvider) -> ServerCapabilities&; + + auto foldingRangeProvider( + std::optional> + foldingRangeProvider) -> ServerCapabilities&; + + auto selectionRangeProvider( + std::optional> + selectionRangeProvider) -> ServerCapabilities&; + + auto executeCommandProvider( + std::optional executeCommandProvider) + -> ServerCapabilities&; + + auto callHierarchyProvider( + std::optional> + callHierarchyProvider) -> ServerCapabilities&; + + auto linkedEditingRangeProvider( + std::optional< + std::variant> + linkedEditingRangeProvider) -> ServerCapabilities&; + + auto semanticTokensProvider( + std::optional> + semanticTokensProvider) -> ServerCapabilities&; + + auto monikerProvider( + std::optional> + monikerProvider) -> ServerCapabilities&; + + auto typeHierarchyProvider( + std::optional> + typeHierarchyProvider) -> ServerCapabilities&; + + auto inlineValueProvider( + std::optional> + inlineValueProvider) -> ServerCapabilities&; + + auto inlayHintProvider( + std::optional> + inlayHintProvider) -> ServerCapabilities&; + + auto diagnosticProvider( + std::optional> + diagnosticProvider) -> ServerCapabilities&; + + auto inlineCompletionProvider( + std::optional> + inlineCompletionProvider) -> ServerCapabilities&; + + auto workspace(std::optional workspace) + -> ServerCapabilities&; + + auto experimental(std::optional experimental) -> ServerCapabilities&; +}; + +class ServerInfo final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto name() const -> std::string; + + [[nodiscard]] auto version() const -> std::optional; + + auto name(std::string name) -> ServerInfo&; + + auto version(std::optional version) -> ServerInfo&; +}; + +class VersionedTextDocumentIdentifier final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto version() const -> int; + + [[nodiscard]] auto uri() const -> std::string; + + auto version(int version) -> VersionedTextDocumentIdentifier&; + + auto uri(std::string uri) -> VersionedTextDocumentIdentifier&; +}; + +class SaveOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto includeText() const -> std::optional; + + auto includeText(std::optional includeText) -> SaveOptions&; +}; + +class FileEvent final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto type() const -> FileChangeType; + + auto uri(std::string uri) -> FileEvent&; + + auto type(FileChangeType type) -> FileEvent&; +}; + +class FileSystemWatcher final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto globPattern() const -> GlobPattern; + + [[nodiscard]] auto kind() const -> std::optional; + + auto globPattern(GlobPattern globPattern) -> FileSystemWatcher&; + + auto kind(std::optional kind) -> FileSystemWatcher&; +}; + +class Diagnostic final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto severity() const -> std::optional; + + [[nodiscard]] auto code() const + -> std::optional>; + + [[nodiscard]] auto codeDescription() const -> std::optional; + + [[nodiscard]] auto source() const -> std::optional; + + [[nodiscard]] auto message() const -> std::string; + + [[nodiscard]] auto tags() const -> std::optional>; + + [[nodiscard]] auto relatedInformation() const + -> std::optional>; + + [[nodiscard]] auto data() const -> std::optional; + + auto range(Range range) -> Diagnostic&; + + auto severity(std::optional severity) -> Diagnostic&; + + auto code(std::optional> code) + -> Diagnostic&; + + auto codeDescription(std::optional codeDescription) + -> Diagnostic&; + + auto source(std::optional source) -> Diagnostic&; + + auto message(std::string message) -> Diagnostic&; + + auto tags(std::optional> tags) -> Diagnostic&; + + auto relatedInformation( + std::optional> relatedInformation) + -> Diagnostic&; + + auto data(std::optional data) -> Diagnostic&; +}; + +class CompletionContext final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto triggerKind() const -> CompletionTriggerKind; + + [[nodiscard]] auto triggerCharacter() const -> std::optional; + + auto triggerKind(CompletionTriggerKind triggerKind) -> CompletionContext&; + + auto triggerCharacter(std::optional triggerCharacter) + -> CompletionContext&; +}; + +class CompletionItemLabelDetails final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto detail() const -> std::optional; + + [[nodiscard]] auto description() const -> std::optional; + + auto detail(std::optional detail) -> CompletionItemLabelDetails&; + + auto description(std::optional description) + -> CompletionItemLabelDetails&; +}; + +class InsertReplaceEdit final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto newText() const -> std::string; + + [[nodiscard]] auto insert() const -> Range; + + [[nodiscard]] auto replace() const -> Range; + + auto newText(std::string newText) -> InsertReplaceEdit&; + + auto insert(Range insert) -> InsertReplaceEdit&; + + auto replace(Range replace) -> InsertReplaceEdit&; +}; + +class CompletionItemDefaults final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto commitCharacters() const + -> std::optional>; + + [[nodiscard]] auto editRange() const -> std::optional< + std::variant>; + + [[nodiscard]] auto insertTextFormat() const + -> std::optional; + + [[nodiscard]] auto insertTextMode() const -> std::optional; + + [[nodiscard]] auto data() const -> std::optional; + + auto commitCharacters(std::optional> commitCharacters) + -> CompletionItemDefaults&; + + auto editRange( + std::optional< + std::variant> + editRange) -> CompletionItemDefaults&; + + auto insertTextFormat(std::optional insertTextFormat) + -> CompletionItemDefaults&; + + auto insertTextMode(std::optional insertTextMode) + -> CompletionItemDefaults&; + + auto data(std::optional data) -> CompletionItemDefaults&; +}; + +class CompletionItemApplyKinds final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto commitCharacters() const -> std::optional; + + [[nodiscard]] auto data() const -> std::optional; + + auto commitCharacters(std::optional commitCharacters) + -> CompletionItemApplyKinds&; + + auto data(std::optional data) -> CompletionItemApplyKinds&; +}; + +class CompletionOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto triggerCharacters() const + -> std::optional>; + + [[nodiscard]] auto allCommitCharacters() const + -> std::optional>; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto completionItem() const + -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto triggerCharacters(std::optional> triggerCharacters) + -> CompletionOptions&; + + auto allCommitCharacters( + std::optional> allCommitCharacters) + -> CompletionOptions&; + + auto resolveProvider(std::optional resolveProvider) + -> CompletionOptions&; + + auto completionItem(std::optional completionItem) + -> CompletionOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> CompletionOptions&; +}; + +class HoverOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) -> HoverOptions&; +}; + +class SignatureHelpContext final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto triggerKind() const -> SignatureHelpTriggerKind; + + [[nodiscard]] auto triggerCharacter() const -> std::optional; + + [[nodiscard]] auto isRetrigger() const -> bool; + + [[nodiscard]] auto activeSignatureHelp() const + -> std::optional; + + auto triggerKind(SignatureHelpTriggerKind triggerKind) + -> SignatureHelpContext&; + + auto triggerCharacter(std::optional triggerCharacter) + -> SignatureHelpContext&; + + auto isRetrigger(bool isRetrigger) -> SignatureHelpContext&; + + auto activeSignatureHelp(std::optional activeSignatureHelp) + -> SignatureHelpContext&; +}; + +class SignatureInformation final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto label() const -> std::string; + + [[nodiscard]] auto documentation() const -> std::optional< + std::variant>; + + [[nodiscard]] auto parameters() const + -> std::optional>; + + [[nodiscard]] auto activeParameter() const + -> std::optional>; + + auto label(std::string label) -> SignatureInformation&; + + auto documentation( + std::optional> + documentation) -> SignatureInformation&; + + auto parameters(std::optional> parameters) + -> SignatureInformation&; + + auto activeParameter( + std::optional> + activeParameter) -> SignatureInformation&; +}; + +class SignatureHelpOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto triggerCharacters() const + -> std::optional>; + + [[nodiscard]] auto retriggerCharacters() const + -> std::optional>; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto triggerCharacters(std::optional> triggerCharacters) + -> SignatureHelpOptions&; + + auto retriggerCharacters( + std::optional> retriggerCharacters) + -> SignatureHelpOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> SignatureHelpOptions&; +}; + +class DefinitionOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> DefinitionOptions&; +}; + +class ReferenceContext final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto includeDeclaration() const -> bool; + + auto includeDeclaration(bool includeDeclaration) -> ReferenceContext&; +}; + +class ReferenceOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> ReferenceOptions&; +}; + +class DocumentHighlightOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentHighlightOptions&; +}; + +class BaseSymbolInformation final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto name() const -> std::string; + + [[nodiscard]] auto kind() const -> SymbolKind; + + [[nodiscard]] auto tags() const -> std::optional>; + + [[nodiscard]] auto containerName() const -> std::optional; + + auto name(std::string name) -> BaseSymbolInformation&; + + auto kind(SymbolKind kind) -> BaseSymbolInformation&; + + auto tags(std::optional> tags) -> BaseSymbolInformation&; + + auto containerName(std::optional containerName) + -> BaseSymbolInformation&; +}; + +class DocumentSymbolOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto label() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto label(std::optional label) -> DocumentSymbolOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentSymbolOptions&; +}; + +class CodeActionContext final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto diagnostics() const -> Vector; + + [[nodiscard]] auto only() const -> std::optional>; + + [[nodiscard]] auto triggerKind() const + -> std::optional; + + auto diagnostics(Vector diagnostics) -> CodeActionContext&; + + auto only(std::optional> only) -> CodeActionContext&; + + auto triggerKind(std::optional triggerKind) + -> CodeActionContext&; +}; + +class CodeActionDisabled final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto reason() const -> std::string; + + auto reason(std::string reason) -> CodeActionDisabled&; +}; + +class CodeActionOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto codeActionKinds() const + -> std::optional>; + + [[nodiscard]] auto documentation() const + -> std::optional>; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto codeActionKinds(std::optional> codeActionKinds) + -> CodeActionOptions&; + + auto documentation( + std::optional> documentation) + -> CodeActionOptions&; + + auto resolveProvider(std::optional resolveProvider) + -> CodeActionOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> CodeActionOptions&; +}; + +class LocationUriOnly final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + auto uri(std::string uri) -> LocationUriOnly&; +}; + +class WorkspaceSymbolOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto resolveProvider(std::optional resolveProvider) + -> WorkspaceSymbolOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> WorkspaceSymbolOptions&; +}; + +class CodeLensOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto resolveProvider(std::optional resolveProvider) -> CodeLensOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> CodeLensOptions&; +}; + +class DocumentLinkOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto resolveProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto resolveProvider(std::optional resolveProvider) + -> DocumentLinkOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentLinkOptions&; +}; + +class FormattingOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto tabSize() const -> long; + + [[nodiscard]] auto insertSpaces() const -> bool; + + [[nodiscard]] auto trimTrailingWhitespace() const -> std::optional; + + [[nodiscard]] auto insertFinalNewline() const -> std::optional; + + [[nodiscard]] auto trimFinalNewlines() const -> std::optional; + + auto tabSize(long tabSize) -> FormattingOptions&; + + auto insertSpaces(bool insertSpaces) -> FormattingOptions&; + + auto trimTrailingWhitespace(std::optional trimTrailingWhitespace) + -> FormattingOptions&; + + auto insertFinalNewline(std::optional insertFinalNewline) + -> FormattingOptions&; + + auto trimFinalNewlines(std::optional trimFinalNewlines) + -> FormattingOptions&; +}; + +class DocumentFormattingOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentFormattingOptions&; +}; + +class DocumentRangeFormattingOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto rangesSupport() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto rangesSupport(std::optional rangesSupport) + -> DocumentRangeFormattingOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> DocumentRangeFormattingOptions&; +}; + +class DocumentOnTypeFormattingOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto firstTriggerCharacter() const -> std::string; + + [[nodiscard]] auto moreTriggerCharacter() const + -> std::optional>; + + auto firstTriggerCharacter(std::string firstTriggerCharacter) + -> DocumentOnTypeFormattingOptions&; + + auto moreTriggerCharacter( + std::optional> moreTriggerCharacter) + -> DocumentOnTypeFormattingOptions&; +}; + +class RenameOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto prepareProvider() const -> std::optional; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto prepareProvider(std::optional prepareProvider) -> RenameOptions&; + + auto workDoneProgress(std::optional workDoneProgress) -> RenameOptions&; +}; + +class PrepareRenamePlaceholder final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto placeholder() const -> std::string; + + auto range(Range range) -> PrepareRenamePlaceholder&; + + auto placeholder(std::string placeholder) -> PrepareRenamePlaceholder&; +}; + +class PrepareRenameDefaultBehavior final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto defaultBehavior() const -> bool; + + auto defaultBehavior(bool defaultBehavior) -> PrepareRenameDefaultBehavior&; +}; + +class ExecuteCommandOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto commands() const -> Vector; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + auto commands(Vector commands) -> ExecuteCommandOptions&; + + auto workDoneProgress(std::optional workDoneProgress) + -> ExecuteCommandOptions&; +}; + +class WorkspaceEditMetadata final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto isRefactoring() const -> std::optional; + + auto isRefactoring(std::optional isRefactoring) + -> WorkspaceEditMetadata&; +}; + +class SemanticTokensLegend final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto tokenTypes() const -> Vector; + + [[nodiscard]] auto tokenModifiers() const -> Vector; + + auto tokenTypes(Vector tokenTypes) -> SemanticTokensLegend&; + + auto tokenModifiers(Vector tokenModifiers) + -> SemanticTokensLegend&; +}; + +class SemanticTokensFullDelta final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto delta() const -> std::optional; + + auto delta(std::optional delta) -> SemanticTokensFullDelta&; +}; + +class OptionalVersionedTextDocumentIdentifier final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto version() const + -> std::variant; + + [[nodiscard]] auto uri() const -> std::string; + + auto version(std::variant version) + -> OptionalVersionedTextDocumentIdentifier&; + + auto uri(std::string uri) -> OptionalVersionedTextDocumentIdentifier&; +}; + +class AnnotatedTextEdit final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto annotationId() const -> ChangeAnnotationIdentifier; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto newText() const -> std::string; + + auto annotationId(ChangeAnnotationIdentifier annotationId) + -> AnnotatedTextEdit&; + + auto range(Range range) -> AnnotatedTextEdit&; + + auto newText(std::string newText) -> AnnotatedTextEdit&; +}; + +class SnippetTextEdit final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto snippet() const -> StringValue; + + [[nodiscard]] auto annotationId() const + -> std::optional; + + auto range(Range range) -> SnippetTextEdit&; + + auto snippet(StringValue snippet) -> SnippetTextEdit&; + + auto annotationId(std::optional annotationId) + -> SnippetTextEdit&; +}; + +class ResourceOperation final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto annotationId() const + -> std::optional; + + auto kind(std::string kind) -> ResourceOperation&; + + auto annotationId(std::optional annotationId) + -> ResourceOperation&; +}; + +class CreateFileOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto overwrite() const -> std::optional; + + [[nodiscard]] auto ignoreIfExists() const -> std::optional; + + auto overwrite(std::optional overwrite) -> CreateFileOptions&; + + auto ignoreIfExists(std::optional ignoreIfExists) -> CreateFileOptions&; +}; + +class RenameFileOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto overwrite() const -> std::optional; + + [[nodiscard]] auto ignoreIfExists() const -> std::optional; + + auto overwrite(std::optional overwrite) -> RenameFileOptions&; + + auto ignoreIfExists(std::optional ignoreIfExists) -> RenameFileOptions&; +}; + +class DeleteFileOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto recursive() const -> std::optional; + + [[nodiscard]] auto ignoreIfNotExists() const -> std::optional; + + auto recursive(std::optional recursive) -> DeleteFileOptions&; + + auto ignoreIfNotExists(std::optional ignoreIfNotExists) + -> DeleteFileOptions&; +}; + +class FileOperationPattern final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto glob() const -> std::string; + + [[nodiscard]] auto matches() const -> std::optional; + + [[nodiscard]] auto options() const + -> std::optional; + + auto glob(std::string glob) -> FileOperationPattern&; + + auto matches(std::optional matches) + -> FileOperationPattern&; + + auto options(std::optional options) + -> FileOperationPattern&; +}; + +class WorkspaceFullDocumentDiagnosticReport final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto version() const + -> std::variant; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto resultId() const -> std::optional; + + [[nodiscard]] auto items() const -> Vector; + + auto uri(std::string uri) -> WorkspaceFullDocumentDiagnosticReport&; + + auto version(std::variant version) + -> WorkspaceFullDocumentDiagnosticReport&; + + auto kind(std::string kind) -> WorkspaceFullDocumentDiagnosticReport&; + + auto resultId(std::optional resultId) + -> WorkspaceFullDocumentDiagnosticReport&; + + auto items(Vector items) + -> WorkspaceFullDocumentDiagnosticReport&; +}; + +class WorkspaceUnchangedDocumentDiagnosticReport final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto uri() const -> std::string; + + [[nodiscard]] auto version() const + -> std::variant; + + [[nodiscard]] auto kind() const -> std::string; + + [[nodiscard]] auto resultId() const -> std::string; + + auto uri(std::string uri) -> WorkspaceUnchangedDocumentDiagnosticReport&; + + auto version(std::variant version) + -> WorkspaceUnchangedDocumentDiagnosticReport&; + + auto kind(std::string kind) -> WorkspaceUnchangedDocumentDiagnosticReport&; + + auto resultId(std::string resultId) + -> WorkspaceUnchangedDocumentDiagnosticReport&; +}; + +class NotebookCell final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> NotebookCellKind; + + [[nodiscard]] auto document() const -> std::string; + + [[nodiscard]] auto metadata() const -> std::optional; + + [[nodiscard]] auto executionSummary() const + -> std::optional; + + auto kind(NotebookCellKind kind) -> NotebookCell&; + + auto document(std::string document) -> NotebookCell&; + + auto metadata(std::optional metadata) -> NotebookCell&; + + auto executionSummary(std::optional executionSummary) + -> NotebookCell&; +}; + +class NotebookDocumentFilterWithNotebook final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebook() const + -> std::variant; + + [[nodiscard]] auto cells() const + -> std::optional>; + + auto notebook( + std::variant + notebook) -> NotebookDocumentFilterWithNotebook&; + + auto cells(std::optional> cells) + -> NotebookDocumentFilterWithNotebook&; +}; + +class NotebookDocumentFilterWithCells final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebook() const -> std::optional< + std::variant>; + + [[nodiscard]] auto cells() const -> Vector; + + auto notebook( + std::optional< + std::variant> + notebook) -> NotebookDocumentFilterWithCells&; + + auto cells(Vector cells) + -> NotebookDocumentFilterWithCells&; +}; + +class NotebookDocumentCellChanges final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto structure() const + -> std::optional; + + [[nodiscard]] auto data() const -> std::optional>; + + [[nodiscard]] auto textContent() const + -> std::optional>; + + auto structure(std::optional structure) + -> NotebookDocumentCellChanges&; + + auto data(std::optional> data) + -> NotebookDocumentCellChanges&; + + auto textContent( + std::optional> textContent) + -> NotebookDocumentCellChanges&; +}; + +class SelectedCompletionInfo final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto text() const -> std::string; + + auto range(Range range) -> SelectedCompletionInfo&; + + auto text(std::string text) -> SelectedCompletionInfo&; +}; + +class ClientInfo final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto name() const -> std::string; + + [[nodiscard]] auto version() const -> std::optional; + + auto name(std::string name) -> ClientInfo&; + + auto version(std::optional version) -> ClientInfo&; +}; + +class ClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workspace() const + -> std::optional; + + [[nodiscard]] auto textDocument() const + -> std::optional; + + [[nodiscard]] auto notebookDocument() const + -> std::optional; + + [[nodiscard]] auto window() const -> std::optional; + + [[nodiscard]] auto general() const + -> std::optional; + + [[nodiscard]] auto experimental() const -> std::optional; + + auto workspace(std::optional workspace) + -> ClientCapabilities&; + + auto textDocument(std::optional textDocument) + -> ClientCapabilities&; + + auto notebookDocument( + std::optional notebookDocument) + -> ClientCapabilities&; + + auto window(std::optional window) + -> ClientCapabilities&; + + auto general(std::optional general) + -> ClientCapabilities&; + + auto experimental(std::optional experimental) -> ClientCapabilities&; +}; + +class TextDocumentSyncOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto openClose() const -> std::optional; + + [[nodiscard]] auto change() const -> std::optional; + + [[nodiscard]] auto willSave() const -> std::optional; + + [[nodiscard]] auto willSaveWaitUntil() const -> std::optional; + + [[nodiscard]] auto save() const + -> std::optional>; + + auto openClose(std::optional openClose) -> TextDocumentSyncOptions&; + + auto change(std::optional change) + -> TextDocumentSyncOptions&; + + auto willSave(std::optional willSave) -> TextDocumentSyncOptions&; + + auto willSaveWaitUntil(std::optional willSaveWaitUntil) + -> TextDocumentSyncOptions&; + + auto save(std::optional> save) + -> TextDocumentSyncOptions&; +}; + +class WorkspaceOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workspaceFolders() const + -> std::optional; + + [[nodiscard]] auto fileOperations() const + -> std::optional; + + [[nodiscard]] auto textDocumentContent() const + -> std::optional>; + + auto workspaceFolders( + std::optional workspaceFolders) + -> WorkspaceOptions&; + + auto fileOperations(std::optional fileOperations) + -> WorkspaceOptions&; + + auto textDocumentContent( + std::optional> + textDocumentContent) -> WorkspaceOptions&; +}; + +class TextDocumentContentChangePartial final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const -> Range; + + [[nodiscard]] auto rangeLength() const -> std::optional; + + [[nodiscard]] auto text() const -> std::string; + + auto range(Range range) -> TextDocumentContentChangePartial&; + + auto rangeLength(std::optional rangeLength) + -> TextDocumentContentChangePartial&; + + auto text(std::string text) -> TextDocumentContentChangePartial&; +}; + +class TextDocumentContentChangeWholeDocument final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto text() const -> std::string; + + auto text(std::string text) -> TextDocumentContentChangeWholeDocument&; +}; + +class CodeDescription final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto href() const -> std::string; + + auto href(std::string href) -> CodeDescription&; +}; + +class DiagnosticRelatedInformation final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto location() const -> Location; + + [[nodiscard]] auto message() const -> std::string; + + auto location(Location location) -> DiagnosticRelatedInformation&; + + auto message(std::string message) -> DiagnosticRelatedInformation&; +}; + +class EditRangeWithInsertReplace final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto insert() const -> Range; + + [[nodiscard]] auto replace() const -> Range; + + auto insert(Range insert) -> EditRangeWithInsertReplace&; + + auto replace(Range replace) -> EditRangeWithInsertReplace&; +}; + +class ServerCompletionItemOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto labelDetailsSupport() const -> std::optional; + + auto labelDetailsSupport(std::optional labelDetailsSupport) + -> ServerCompletionItemOptions&; +}; + +class MarkedStringWithLanguage final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto language() const -> std::string; + + [[nodiscard]] auto value() const -> std::string; + + auto language(std::string language) -> MarkedStringWithLanguage&; + + auto value(std::string value) -> MarkedStringWithLanguage&; +}; + +class ParameterInformation final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto label() const + -> std::variant>; + + [[nodiscard]] auto documentation() const -> std::optional< + std::variant>; + + auto label( + std::variant> label) + -> ParameterInformation&; + + auto documentation( + std::optional> + documentation) -> ParameterInformation&; +}; + +class CodeActionKindDocumentation final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto kind() const -> CodeActionKind; + + [[nodiscard]] auto command() const -> Command; + + auto kind(CodeActionKind kind) -> CodeActionKindDocumentation&; + + auto command(Command command) -> CodeActionKindDocumentation&; +}; + +class NotebookCellTextDocumentFilter final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebook() const + -> std::variant; + + [[nodiscard]] auto language() const -> std::optional; + + auto notebook( + std::variant + notebook) -> NotebookCellTextDocumentFilter&; + + auto language(std::optional language) + -> NotebookCellTextDocumentFilter&; +}; + +class FileOperationPatternOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto ignoreCase() const -> std::optional; + + auto ignoreCase(std::optional ignoreCase) + -> FileOperationPatternOptions&; +}; + +class ExecutionSummary final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto executionOrder() const -> long; + + [[nodiscard]] auto success() const -> std::optional; + + auto executionOrder(long executionOrder) -> ExecutionSummary&; + + auto success(std::optional success) -> ExecutionSummary&; +}; + +class NotebookCellLanguage final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto language() const -> std::string; + + auto language(std::string language) -> NotebookCellLanguage&; +}; + +class NotebookDocumentCellChangeStructure final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto array() const -> NotebookCellArrayChange; + + [[nodiscard]] auto didOpen() const -> std::optional>; + + [[nodiscard]] auto didClose() const + -> std::optional>; + + auto array(NotebookCellArrayChange array) + -> NotebookDocumentCellChangeStructure&; + + auto didOpen(std::optional> didOpen) + -> NotebookDocumentCellChangeStructure&; + + auto didClose(std::optional> didClose) + -> NotebookDocumentCellChangeStructure&; +}; + +class NotebookDocumentCellContentChanges final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto document() const -> VersionedTextDocumentIdentifier; + + [[nodiscard]] auto changes() const -> Vector; + + auto document(VersionedTextDocumentIdentifier document) + -> NotebookDocumentCellContentChanges&; + + auto changes(Vector changes) + -> NotebookDocumentCellContentChanges&; +}; + +class WorkspaceClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto applyEdit() const -> std::optional; + + [[nodiscard]] auto workspaceEdit() const + -> std::optional; + + [[nodiscard]] auto didChangeConfiguration() const + -> std::optional; + + [[nodiscard]] auto didChangeWatchedFiles() const + -> std::optional; + + [[nodiscard]] auto symbol() const + -> std::optional; + + [[nodiscard]] auto executeCommand() const + -> std::optional; + + [[nodiscard]] auto workspaceFolders() const -> std::optional; + + [[nodiscard]] auto configuration() const -> std::optional; + + [[nodiscard]] auto semanticTokens() const + -> std::optional; + + [[nodiscard]] auto codeLens() const + -> std::optional; + + [[nodiscard]] auto fileOperations() const + -> std::optional; + + [[nodiscard]] auto inlineValue() const + -> std::optional; + + [[nodiscard]] auto inlayHint() const + -> std::optional; + + [[nodiscard]] auto diagnostics() const + -> std::optional; + + [[nodiscard]] auto foldingRange() const + -> std::optional; + + [[nodiscard]] auto textDocumentContent() const + -> std::optional; + + auto applyEdit(std::optional applyEdit) -> WorkspaceClientCapabilities&; + + auto workspaceEdit( + std::optional workspaceEdit) + -> WorkspaceClientCapabilities&; + + auto didChangeConfiguration( + std::optional + didChangeConfiguration) -> WorkspaceClientCapabilities&; + + auto didChangeWatchedFiles( + std::optional + didChangeWatchedFiles) -> WorkspaceClientCapabilities&; + + auto symbol(std::optional symbol) + -> WorkspaceClientCapabilities&; + + auto executeCommand( + std::optional executeCommand) + -> WorkspaceClientCapabilities&; + + auto workspaceFolders(std::optional workspaceFolders) + -> WorkspaceClientCapabilities&; + + auto configuration(std::optional configuration) + -> WorkspaceClientCapabilities&; + + auto semanticTokens( + std::optional semanticTokens) + -> WorkspaceClientCapabilities&; + + auto codeLens(std::optional codeLens) + -> WorkspaceClientCapabilities&; + + auto fileOperations( + std::optional fileOperations) + -> WorkspaceClientCapabilities&; + + auto inlineValue( + std::optional inlineValue) + -> WorkspaceClientCapabilities&; + + auto inlayHint(std::optional inlayHint) + -> WorkspaceClientCapabilities&; + + auto diagnostics( + std::optional diagnostics) + -> WorkspaceClientCapabilities&; + + auto foldingRange( + std::optional foldingRange) + -> WorkspaceClientCapabilities&; + + auto textDocumentContent( + std::optional textDocumentContent) + -> WorkspaceClientCapabilities&; +}; + +class TextDocumentClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto synchronization() const + -> std::optional; + + [[nodiscard]] auto filters() const + -> std::optional; + + [[nodiscard]] auto completion() const + -> std::optional; + + [[nodiscard]] auto hover() const -> std::optional; + + [[nodiscard]] auto signatureHelp() const + -> std::optional; + + [[nodiscard]] auto declaration() const + -> std::optional; + + [[nodiscard]] auto definition() const + -> std::optional; + + [[nodiscard]] auto typeDefinition() const + -> std::optional; + + [[nodiscard]] auto implementation() const + -> std::optional; + + [[nodiscard]] auto references() const + -> std::optional; + + [[nodiscard]] auto documentHighlight() const + -> std::optional; + + [[nodiscard]] auto documentSymbol() const + -> std::optional; + + [[nodiscard]] auto codeAction() const + -> std::optional; + + [[nodiscard]] auto codeLens() const + -> std::optional; + + [[nodiscard]] auto documentLink() const + -> std::optional; + + [[nodiscard]] auto colorProvider() const + -> std::optional; + + [[nodiscard]] auto formatting() const + -> std::optional; + + [[nodiscard]] auto rangeFormatting() const + -> std::optional; + + [[nodiscard]] auto onTypeFormatting() const + -> std::optional; + + [[nodiscard]] auto rename() const -> std::optional; + + [[nodiscard]] auto foldingRange() const + -> std::optional; + + [[nodiscard]] auto selectionRange() const + -> std::optional; + + [[nodiscard]] auto publishDiagnostics() const + -> std::optional; + + [[nodiscard]] auto callHierarchy() const + -> std::optional; + + [[nodiscard]] auto semanticTokens() const + -> std::optional; + + [[nodiscard]] auto linkedEditingRange() const + -> std::optional; + + [[nodiscard]] auto moniker() const + -> std::optional; + + [[nodiscard]] auto typeHierarchy() const + -> std::optional; + + [[nodiscard]] auto inlineValue() const + -> std::optional; + + [[nodiscard]] auto inlayHint() const + -> std::optional; + + [[nodiscard]] auto diagnostic() const + -> std::optional; + + [[nodiscard]] auto inlineCompletion() const + -> std::optional; + + auto synchronization( + std::optional synchronization) + -> TextDocumentClientCapabilities&; + + auto filters(std::optional filters) + -> TextDocumentClientCapabilities&; + + auto completion(std::optional completion) + -> TextDocumentClientCapabilities&; + + auto hover(std::optional hover) + -> TextDocumentClientCapabilities&; + + auto signatureHelp( + std::optional signatureHelp) + -> TextDocumentClientCapabilities&; + + auto declaration(std::optional declaration) + -> TextDocumentClientCapabilities&; + + auto definition(std::optional definition) + -> TextDocumentClientCapabilities&; + + auto typeDefinition( + std::optional typeDefinition) + -> TextDocumentClientCapabilities&; + + auto implementation( + std::optional implementation) + -> TextDocumentClientCapabilities&; + + auto references(std::optional references) + -> TextDocumentClientCapabilities&; + + auto documentHighlight( + std::optional documentHighlight) + -> TextDocumentClientCapabilities&; + + auto documentSymbol( + std::optional documentSymbol) + -> TextDocumentClientCapabilities&; + + auto codeAction(std::optional codeAction) + -> TextDocumentClientCapabilities&; + + auto codeLens(std::optional codeLens) + -> TextDocumentClientCapabilities&; + + auto documentLink(std::optional documentLink) + -> TextDocumentClientCapabilities&; + + auto colorProvider( + std::optional colorProvider) + -> TextDocumentClientCapabilities&; + + auto formatting( + std::optional formatting) + -> TextDocumentClientCapabilities&; + + auto rangeFormatting( + std::optional rangeFormatting) + -> TextDocumentClientCapabilities&; + + auto onTypeFormatting( + std::optional + onTypeFormatting) -> TextDocumentClientCapabilities&; + + auto rename(std::optional rename) + -> TextDocumentClientCapabilities&; + + auto foldingRange(std::optional foldingRange) + -> TextDocumentClientCapabilities&; + + auto selectionRange( + std::optional selectionRange) + -> TextDocumentClientCapabilities&; + + auto publishDiagnostics( + std::optional publishDiagnostics) + -> TextDocumentClientCapabilities&; + + auto callHierarchy( + std::optional callHierarchy) + -> TextDocumentClientCapabilities&; + + auto semanticTokens( + std::optional semanticTokens) + -> TextDocumentClientCapabilities&; + + auto linkedEditingRange( + std::optional linkedEditingRange) + -> TextDocumentClientCapabilities&; + + auto moniker(std::optional moniker) + -> TextDocumentClientCapabilities&; + + auto typeHierarchy( + std::optional typeHierarchy) + -> TextDocumentClientCapabilities&; + + auto inlineValue(std::optional inlineValue) + -> TextDocumentClientCapabilities&; + + auto inlayHint(std::optional inlayHint) + -> TextDocumentClientCapabilities&; + + auto diagnostic(std::optional diagnostic) + -> TextDocumentClientCapabilities&; + + auto inlineCompletion( + std::optional inlineCompletion) + -> TextDocumentClientCapabilities&; +}; + +class NotebookDocumentClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto synchronization() const + -> NotebookDocumentSyncClientCapabilities; + + auto synchronization(NotebookDocumentSyncClientCapabilities synchronization) + -> NotebookDocumentClientCapabilities&; +}; + +class WindowClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto workDoneProgress() const -> std::optional; + + [[nodiscard]] auto showMessage() const + -> std::optional; + + [[nodiscard]] auto showDocument() const + -> std::optional; + + auto workDoneProgress(std::optional workDoneProgress) + -> WindowClientCapabilities&; + + auto showMessage( + std::optional showMessage) + -> WindowClientCapabilities&; + + auto showDocument(std::optional showDocument) + -> WindowClientCapabilities&; +}; + +class GeneralClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto staleRequestSupport() const + -> std::optional; + + [[nodiscard]] auto regularExpressions() const + -> std::optional; + + [[nodiscard]] auto markdown() const + -> std::optional; + + [[nodiscard]] auto positionEncodings() const + -> std::optional>; + + auto staleRequestSupport( + std::optional staleRequestSupport) + -> GeneralClientCapabilities&; + + auto regularExpressions( + std::optional regularExpressions) + -> GeneralClientCapabilities&; + + auto markdown(std::optional markdown) + -> GeneralClientCapabilities&; + + auto positionEncodings( + std::optional> positionEncodings) + -> GeneralClientCapabilities&; +}; + +class WorkspaceFoldersServerCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto supported() const -> std::optional; + + [[nodiscard]] auto changeNotifications() const + -> std::optional>; + + auto supported(std::optional supported) + -> WorkspaceFoldersServerCapabilities&; + + auto changeNotifications( + std::optional> + changeNotifications) -> WorkspaceFoldersServerCapabilities&; +}; + +class FileOperationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto didCreate() const + -> std::optional; + + [[nodiscard]] auto willCreate() const + -> std::optional; + + [[nodiscard]] auto didRename() const + -> std::optional; + + [[nodiscard]] auto willRename() const + -> std::optional; + + [[nodiscard]] auto didDelete() const + -> std::optional; + + [[nodiscard]] auto willDelete() const + -> std::optional; + + auto didCreate(std::optional didCreate) + -> FileOperationOptions&; + + auto willCreate(std::optional willCreate) + -> FileOperationOptions&; + + auto didRename(std::optional didRename) + -> FileOperationOptions&; + + auto willRename(std::optional willRename) + -> FileOperationOptions&; + + auto didDelete(std::optional didDelete) + -> FileOperationOptions&; + + auto willDelete(std::optional willDelete) + -> FileOperationOptions&; +}; + +class RelativePattern final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto baseUri() const + -> std::variant; + + [[nodiscard]] auto pattern() const -> Pattern; + + auto baseUri( + std::variant baseUri) + -> RelativePattern&; + + auto pattern(Pattern pattern) -> RelativePattern&; +}; + +class TextDocumentFilterLanguage final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto language() const -> std::string; + + [[nodiscard]] auto scheme() const -> std::optional; + + [[nodiscard]] auto pattern() const -> std::optional; + + auto language(std::string language) -> TextDocumentFilterLanguage&; + + auto scheme(std::optional scheme) -> TextDocumentFilterLanguage&; + + auto pattern(std::optional pattern) + -> TextDocumentFilterLanguage&; +}; + +class TextDocumentFilterScheme final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto language() const -> std::optional; + + [[nodiscard]] auto scheme() const -> std::string; + + [[nodiscard]] auto pattern() const -> std::optional; + + auto language(std::optional language) + -> TextDocumentFilterScheme&; + + auto scheme(std::string scheme) -> TextDocumentFilterScheme&; + + auto pattern(std::optional pattern) -> TextDocumentFilterScheme&; +}; + +class TextDocumentFilterPattern final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto language() const -> std::optional; + + [[nodiscard]] auto scheme() const -> std::optional; + + [[nodiscard]] auto pattern() const -> GlobPattern; + + auto language(std::optional language) + -> TextDocumentFilterPattern&; + + auto scheme(std::optional scheme) -> TextDocumentFilterPattern&; + + auto pattern(GlobPattern pattern) -> TextDocumentFilterPattern&; +}; + +class NotebookDocumentFilterNotebookType final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebookType() const -> std::string; + + [[nodiscard]] auto scheme() const -> std::optional; + + [[nodiscard]] auto pattern() const -> std::optional; + + auto notebookType(std::string notebookType) + -> NotebookDocumentFilterNotebookType&; + + auto scheme(std::optional scheme) + -> NotebookDocumentFilterNotebookType&; + + auto pattern(std::optional pattern) + -> NotebookDocumentFilterNotebookType&; +}; + +class NotebookDocumentFilterScheme final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebookType() const -> std::optional; + + [[nodiscard]] auto scheme() const -> std::string; + + [[nodiscard]] auto pattern() const -> std::optional; + + auto notebookType(std::optional notebookType) + -> NotebookDocumentFilterScheme&; + + auto scheme(std::string scheme) -> NotebookDocumentFilterScheme&; + + auto pattern(std::optional pattern) + -> NotebookDocumentFilterScheme&; +}; + +class NotebookDocumentFilterPattern final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto notebookType() const -> std::optional; + + [[nodiscard]] auto scheme() const -> std::optional; + + [[nodiscard]] auto pattern() const -> GlobPattern; + + auto notebookType(std::optional notebookType) + -> NotebookDocumentFilterPattern&; + + auto scheme(std::optional scheme) + -> NotebookDocumentFilterPattern&; + + auto pattern(GlobPattern pattern) -> NotebookDocumentFilterPattern&; +}; + +class NotebookCellArrayChange final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto start() const -> long; + + [[nodiscard]] auto deleteCount() const -> long; + + [[nodiscard]] auto cells() const -> std::optional>; + + auto start(long start) -> NotebookCellArrayChange&; + + auto deleteCount(long deleteCount) -> NotebookCellArrayChange&; + + auto cells(std::optional> cells) + -> NotebookCellArrayChange&; +}; + +class WorkspaceEditClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentChanges() const -> std::optional; + + [[nodiscard]] auto resourceOperations() const + -> std::optional>; + + [[nodiscard]] auto failureHandling() const + -> std::optional; + + [[nodiscard]] auto normalizesLineEndings() const -> std::optional; + + [[nodiscard]] auto changeAnnotationSupport() const + -> std::optional; + + [[nodiscard]] auto metadataSupport() const -> std::optional; + + [[nodiscard]] auto snippetEditSupport() const -> std::optional; + + auto documentChanges(std::optional documentChanges) + -> WorkspaceEditClientCapabilities&; + + auto resourceOperations( + std::optional> resourceOperations) + -> WorkspaceEditClientCapabilities&; + + auto failureHandling(std::optional failureHandling) + -> WorkspaceEditClientCapabilities&; + + auto normalizesLineEndings(std::optional normalizesLineEndings) + -> WorkspaceEditClientCapabilities&; + + auto changeAnnotationSupport( + std::optional changeAnnotationSupport) + -> WorkspaceEditClientCapabilities&; + + auto metadataSupport(std::optional metadataSupport) + -> WorkspaceEditClientCapabilities&; + + auto snippetEditSupport(std::optional snippetEditSupport) + -> WorkspaceEditClientCapabilities&; +}; + +class DidChangeConfigurationClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DidChangeConfigurationClientCapabilities&; +}; + +class DidChangeWatchedFilesClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto relativePatternSupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DidChangeWatchedFilesClientCapabilities&; + + auto relativePatternSupport(std::optional relativePatternSupport) + -> DidChangeWatchedFilesClientCapabilities&; +}; + +class WorkspaceSymbolClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto symbolKind() const + -> std::optional; + + [[nodiscard]] auto tagSupport() const + -> std::optional; + + [[nodiscard]] auto resolveSupport() const + -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> WorkspaceSymbolClientCapabilities&; + + auto symbolKind(std::optional symbolKind) + -> WorkspaceSymbolClientCapabilities&; + + auto tagSupport(std::optional tagSupport) + -> WorkspaceSymbolClientCapabilities&; + + auto resolveSupport(std::optional resolveSupport) + -> WorkspaceSymbolClientCapabilities&; +}; + +class ExecuteCommandClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> ExecuteCommandClientCapabilities&; +}; + +class SemanticTokensWorkspaceClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto refreshSupport() const -> std::optional; + + auto refreshSupport(std::optional refreshSupport) + -> SemanticTokensWorkspaceClientCapabilities&; +}; + +class CodeLensWorkspaceClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto refreshSupport() const -> std::optional; + + auto refreshSupport(std::optional refreshSupport) + -> CodeLensWorkspaceClientCapabilities&; +}; + +class FileOperationClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto didCreate() const -> std::optional; + + [[nodiscard]] auto willCreate() const -> std::optional; + + [[nodiscard]] auto didRename() const -> std::optional; + + [[nodiscard]] auto willRename() const -> std::optional; + + [[nodiscard]] auto didDelete() const -> std::optional; + + [[nodiscard]] auto willDelete() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> FileOperationClientCapabilities&; + + auto didCreate(std::optional didCreate) + -> FileOperationClientCapabilities&; + + auto willCreate(std::optional willCreate) + -> FileOperationClientCapabilities&; + + auto didRename(std::optional didRename) + -> FileOperationClientCapabilities&; + + auto willRename(std::optional willRename) + -> FileOperationClientCapabilities&; + + auto didDelete(std::optional didDelete) + -> FileOperationClientCapabilities&; + + auto willDelete(std::optional willDelete) + -> FileOperationClientCapabilities&; +}; + +class InlineValueWorkspaceClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto refreshSupport() const -> std::optional; + + auto refreshSupport(std::optional refreshSupport) + -> InlineValueWorkspaceClientCapabilities&; +}; + +class InlayHintWorkspaceClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto refreshSupport() const -> std::optional; + + auto refreshSupport(std::optional refreshSupport) + -> InlayHintWorkspaceClientCapabilities&; +}; + +class DiagnosticWorkspaceClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto refreshSupport() const -> std::optional; + + auto refreshSupport(std::optional refreshSupport) + -> DiagnosticWorkspaceClientCapabilities&; +}; + +class FoldingRangeWorkspaceClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto refreshSupport() const -> std::optional; + + auto refreshSupport(std::optional refreshSupport) + -> FoldingRangeWorkspaceClientCapabilities&; +}; + +class TextDocumentContentClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> TextDocumentContentClientCapabilities&; +}; + +class TextDocumentSyncClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto willSave() const -> std::optional; + + [[nodiscard]] auto willSaveWaitUntil() const -> std::optional; + + [[nodiscard]] auto didSave() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> TextDocumentSyncClientCapabilities&; + + auto willSave(std::optional willSave) + -> TextDocumentSyncClientCapabilities&; + + auto willSaveWaitUntil(std::optional willSaveWaitUntil) + -> TextDocumentSyncClientCapabilities&; + + auto didSave(std::optional didSave) + -> TextDocumentSyncClientCapabilities&; +}; + +class TextDocumentFilterClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto relativePatternSupport() const -> std::optional; + + auto relativePatternSupport(std::optional relativePatternSupport) + -> TextDocumentFilterClientCapabilities&; +}; + +class CompletionClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto completionItem() const + -> std::optional; + + [[nodiscard]] auto completionItemKind() const + -> std::optional; + + [[nodiscard]] auto insertTextMode() const -> std::optional; + + [[nodiscard]] auto contextSupport() const -> std::optional; + + [[nodiscard]] auto completionList() const + -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> CompletionClientCapabilities&; + + auto completionItem(std::optional completionItem) + -> CompletionClientCapabilities&; + + auto completionItemKind( + std::optional completionItemKind) + -> CompletionClientCapabilities&; + + auto insertTextMode(std::optional insertTextMode) + -> CompletionClientCapabilities&; + + auto contextSupport(std::optional contextSupport) + -> CompletionClientCapabilities&; + + auto completionList(std::optional completionList) + -> CompletionClientCapabilities&; +}; + +class HoverClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto contentFormat() const -> std::optional>; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> HoverClientCapabilities&; + + auto contentFormat(std::optional> contentFormat) + -> HoverClientCapabilities&; +}; + +class SignatureHelpClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto signatureInformation() const + -> std::optional; + + [[nodiscard]] auto contextSupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> SignatureHelpClientCapabilities&; + + auto signatureInformation( + std::optional signatureInformation) + -> SignatureHelpClientCapabilities&; + + auto contextSupport(std::optional contextSupport) + -> SignatureHelpClientCapabilities&; +}; + +class DeclarationClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto linkSupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DeclarationClientCapabilities&; + + auto linkSupport(std::optional linkSupport) + -> DeclarationClientCapabilities&; +}; + +class DefinitionClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto linkSupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DefinitionClientCapabilities&; + + auto linkSupport(std::optional linkSupport) + -> DefinitionClientCapabilities&; +}; + +class TypeDefinitionClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto linkSupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> TypeDefinitionClientCapabilities&; + + auto linkSupport(std::optional linkSupport) + -> TypeDefinitionClientCapabilities&; +}; + +class ImplementationClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto linkSupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> ImplementationClientCapabilities&; + + auto linkSupport(std::optional linkSupport) + -> ImplementationClientCapabilities&; +}; + +class ReferenceClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> ReferenceClientCapabilities&; +}; + +class DocumentHighlightClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DocumentHighlightClientCapabilities&; +}; + +class DocumentSymbolClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto symbolKind() const + -> std::optional; + + [[nodiscard]] auto hierarchicalDocumentSymbolSupport() const + -> std::optional; + + [[nodiscard]] auto tagSupport() const + -> std::optional; + + [[nodiscard]] auto labelSupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DocumentSymbolClientCapabilities&; + + auto symbolKind(std::optional symbolKind) + -> DocumentSymbolClientCapabilities&; + + auto hierarchicalDocumentSymbolSupport( + std::optional hierarchicalDocumentSymbolSupport) + -> DocumentSymbolClientCapabilities&; + + auto tagSupport(std::optional tagSupport) + -> DocumentSymbolClientCapabilities&; + + auto labelSupport(std::optional labelSupport) + -> DocumentSymbolClientCapabilities&; +}; + +class CodeActionClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto codeActionLiteralSupport() const + -> std::optional; + + [[nodiscard]] auto isPreferredSupport() const -> std::optional; + + [[nodiscard]] auto disabledSupport() const -> std::optional; + + [[nodiscard]] auto dataSupport() const -> std::optional; + + [[nodiscard]] auto resolveSupport() const + -> std::optional; + + [[nodiscard]] auto honorsChangeAnnotations() const -> std::optional; + + [[nodiscard]] auto documentationSupport() const -> std::optional; + + [[nodiscard]] auto tagSupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> CodeActionClientCapabilities&; + + auto codeActionLiteralSupport( + std::optional codeActionLiteralSupport) + -> CodeActionClientCapabilities&; + + auto isPreferredSupport(std::optional isPreferredSupport) + -> CodeActionClientCapabilities&; + + auto disabledSupport(std::optional disabledSupport) + -> CodeActionClientCapabilities&; + + auto dataSupport(std::optional dataSupport) + -> CodeActionClientCapabilities&; + + auto resolveSupport( + std::optional resolveSupport) + -> CodeActionClientCapabilities&; + + auto honorsChangeAnnotations(std::optional honorsChangeAnnotations) + -> CodeActionClientCapabilities&; + + auto documentationSupport(std::optional documentationSupport) + -> CodeActionClientCapabilities&; + + auto tagSupport(std::optional tagSupport) + -> CodeActionClientCapabilities&; +}; + +class CodeLensClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto resolveSupport() const + -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> CodeLensClientCapabilities&; + + auto resolveSupport( + std::optional resolveSupport) + -> CodeLensClientCapabilities&; +}; + +class DocumentLinkClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto tooltipSupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DocumentLinkClientCapabilities&; + + auto tooltipSupport(std::optional tooltipSupport) + -> DocumentLinkClientCapabilities&; +}; + +class DocumentColorClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DocumentColorClientCapabilities&; +}; + +class DocumentFormattingClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DocumentFormattingClientCapabilities&; +}; + +class DocumentRangeFormattingClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto rangesSupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DocumentRangeFormattingClientCapabilities&; + + auto rangesSupport(std::optional rangesSupport) + -> DocumentRangeFormattingClientCapabilities&; +}; + +class DocumentOnTypeFormattingClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DocumentOnTypeFormattingClientCapabilities&; +}; + +class RenameClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto prepareSupport() const -> std::optional; + + [[nodiscard]] auto prepareSupportDefaultBehavior() const + -> std::optional; + + [[nodiscard]] auto honorsChangeAnnotations() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> RenameClientCapabilities&; + + auto prepareSupport(std::optional prepareSupport) + -> RenameClientCapabilities&; + + auto prepareSupportDefaultBehavior( + std::optional + prepareSupportDefaultBehavior) -> RenameClientCapabilities&; + + auto honorsChangeAnnotations(std::optional honorsChangeAnnotations) + -> RenameClientCapabilities&; +}; + +class FoldingRangeClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto rangeLimit() const -> std::optional; + + [[nodiscard]] auto lineFoldingOnly() const -> std::optional; + + [[nodiscard]] auto foldingRangeKind() const + -> std::optional; + + [[nodiscard]] auto foldingRange() const + -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> FoldingRangeClientCapabilities&; + + auto rangeLimit(std::optional rangeLimit) + -> FoldingRangeClientCapabilities&; + + auto lineFoldingOnly(std::optional lineFoldingOnly) + -> FoldingRangeClientCapabilities&; + + auto foldingRangeKind( + std::optional foldingRangeKind) + -> FoldingRangeClientCapabilities&; + + auto foldingRange(std::optional foldingRange) + -> FoldingRangeClientCapabilities&; +}; + +class SelectionRangeClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> SelectionRangeClientCapabilities&; +}; + +class PublishDiagnosticsClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto versionSupport() const -> std::optional; + + [[nodiscard]] auto relatedInformation() const -> std::optional; + + [[nodiscard]] auto tagSupport() const + -> std::optional; + + [[nodiscard]] auto codeDescriptionSupport() const -> std::optional; + + [[nodiscard]] auto dataSupport() const -> std::optional; + + auto versionSupport(std::optional versionSupport) + -> PublishDiagnosticsClientCapabilities&; + + auto relatedInformation(std::optional relatedInformation) + -> PublishDiagnosticsClientCapabilities&; + + auto tagSupport(std::optional tagSupport) + -> PublishDiagnosticsClientCapabilities&; + + auto codeDescriptionSupport(std::optional codeDescriptionSupport) + -> PublishDiagnosticsClientCapabilities&; + + auto dataSupport(std::optional dataSupport) + -> PublishDiagnosticsClientCapabilities&; +}; + +class CallHierarchyClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> CallHierarchyClientCapabilities&; +}; + +class SemanticTokensClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto requests() const -> ClientSemanticTokensRequestOptions; + + [[nodiscard]] auto tokenTypes() const -> Vector; + + [[nodiscard]] auto tokenModifiers() const -> Vector; + + [[nodiscard]] auto formats() const -> Vector; + + [[nodiscard]] auto overlappingTokenSupport() const -> std::optional; + + [[nodiscard]] auto multilineTokenSupport() const -> std::optional; + + [[nodiscard]] auto serverCancelSupport() const -> std::optional; + + [[nodiscard]] auto augmentsSyntaxTokens() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> SemanticTokensClientCapabilities&; + + auto requests(ClientSemanticTokensRequestOptions requests) + -> SemanticTokensClientCapabilities&; + + auto tokenTypes(Vector tokenTypes) + -> SemanticTokensClientCapabilities&; + + auto tokenModifiers(Vector tokenModifiers) + -> SemanticTokensClientCapabilities&; + + auto formats(Vector formats) + -> SemanticTokensClientCapabilities&; + + auto overlappingTokenSupport(std::optional overlappingTokenSupport) + -> SemanticTokensClientCapabilities&; + + auto multilineTokenSupport(std::optional multilineTokenSupport) + -> SemanticTokensClientCapabilities&; + + auto serverCancelSupport(std::optional serverCancelSupport) + -> SemanticTokensClientCapabilities&; + + auto augmentsSyntaxTokens(std::optional augmentsSyntaxTokens) + -> SemanticTokensClientCapabilities&; +}; + +class LinkedEditingRangeClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> LinkedEditingRangeClientCapabilities&; +}; + +class MonikerClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> MonikerClientCapabilities&; +}; + +class TypeHierarchyClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> TypeHierarchyClientCapabilities&; +}; + +class InlineValueClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> InlineValueClientCapabilities&; +}; + +class InlayHintClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto resolveSupport() const + -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> InlayHintClientCapabilities&; + + auto resolveSupport( + std::optional resolveSupport) + -> InlayHintClientCapabilities&; +}; + +class DiagnosticClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto relatedDocumentSupport() const -> std::optional; + + [[nodiscard]] auto relatedInformation() const -> std::optional; + + [[nodiscard]] auto tagSupport() const + -> std::optional; + + [[nodiscard]] auto codeDescriptionSupport() const -> std::optional; + + [[nodiscard]] auto dataSupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> DiagnosticClientCapabilities&; + + auto relatedDocumentSupport(std::optional relatedDocumentSupport) + -> DiagnosticClientCapabilities&; + + auto relatedInformation(std::optional relatedInformation) + -> DiagnosticClientCapabilities&; + + auto tagSupport(std::optional tagSupport) + -> DiagnosticClientCapabilities&; + + auto codeDescriptionSupport(std::optional codeDescriptionSupport) + -> DiagnosticClientCapabilities&; + + auto dataSupport(std::optional dataSupport) + -> DiagnosticClientCapabilities&; +}; + +class InlineCompletionClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> InlineCompletionClientCapabilities&; +}; + +class NotebookDocumentSyncClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto dynamicRegistration() const -> std::optional; + + [[nodiscard]] auto executionSummarySupport() const -> std::optional; + + auto dynamicRegistration(std::optional dynamicRegistration) + -> NotebookDocumentSyncClientCapabilities&; + + auto executionSummarySupport(std::optional executionSummarySupport) + -> NotebookDocumentSyncClientCapabilities&; +}; + +class ShowMessageRequestClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto messageActionItem() const + -> std::optional; + + auto messageActionItem( + std::optional messageActionItem) + -> ShowMessageRequestClientCapabilities&; +}; + +class ShowDocumentClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto support() const -> bool; + + auto support(bool support) -> ShowDocumentClientCapabilities&; +}; + +class StaleRequestSupportOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto cancel() const -> bool; + + [[nodiscard]] auto retryOnContentModified() const -> Vector; + + auto cancel(bool cancel) -> StaleRequestSupportOptions&; + + auto retryOnContentModified(Vector retryOnContentModified) + -> StaleRequestSupportOptions&; +}; + +class RegularExpressionsClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto engine() const -> RegularExpressionEngineKind; + + [[nodiscard]] auto version() const -> std::optional; + + auto engine(RegularExpressionEngineKind engine) + -> RegularExpressionsClientCapabilities&; + + auto version(std::optional version) + -> RegularExpressionsClientCapabilities&; +}; + +class MarkdownClientCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto parser() const -> std::string; + + [[nodiscard]] auto version() const -> std::optional; + + [[nodiscard]] auto allowedTags() const -> std::optional>; + + auto parser(std::string parser) -> MarkdownClientCapabilities&; + + auto version(std::optional version) + -> MarkdownClientCapabilities&; + + auto allowedTags(std::optional> allowedTags) + -> MarkdownClientCapabilities&; +}; + +class ChangeAnnotationsSupportOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto groupsOnLabel() const -> std::optional; + + auto groupsOnLabel(std::optional groupsOnLabel) + -> ChangeAnnotationsSupportOptions&; +}; + +class ClientSymbolKindOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto valueSet() const -> std::optional>; + + auto valueSet(std::optional> valueSet) + -> ClientSymbolKindOptions&; +}; + +class ClientSymbolTagOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto valueSet() const -> Vector; + + auto valueSet(Vector valueSet) -> ClientSymbolTagOptions&; +}; + +class ClientSymbolResolveOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto properties() const -> Vector; + + auto properties(Vector properties) + -> ClientSymbolResolveOptions&; +}; + +class ClientCompletionItemOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto snippetSupport() const -> std::optional; + + [[nodiscard]] auto commitCharactersSupport() const -> std::optional; + + [[nodiscard]] auto documentationFormat() const + -> std::optional>; + + [[nodiscard]] auto deprecatedSupport() const -> std::optional; + + [[nodiscard]] auto preselectSupport() const -> std::optional; + + [[nodiscard]] auto tagSupport() const + -> std::optional; + + [[nodiscard]] auto insertReplaceSupport() const -> std::optional; + + [[nodiscard]] auto resolveSupport() const + -> std::optional; + + [[nodiscard]] auto insertTextModeSupport() const + -> std::optional; + + [[nodiscard]] auto labelDetailsSupport() const -> std::optional; + + auto snippetSupport(std::optional snippetSupport) + -> ClientCompletionItemOptions&; + + auto commitCharactersSupport(std::optional commitCharactersSupport) + -> ClientCompletionItemOptions&; + + auto documentationFormat( + std::optional> documentationFormat) + -> ClientCompletionItemOptions&; + + auto deprecatedSupport(std::optional deprecatedSupport) + -> ClientCompletionItemOptions&; + + auto preselectSupport(std::optional preselectSupport) + -> ClientCompletionItemOptions&; + + auto tagSupport(std::optional tagSupport) + -> ClientCompletionItemOptions&; + + auto insertReplaceSupport(std::optional insertReplaceSupport) + -> ClientCompletionItemOptions&; + + auto resolveSupport( + std::optional resolveSupport) + -> ClientCompletionItemOptions&; + + auto insertTextModeSupport( + std::optional + insertTextModeSupport) -> ClientCompletionItemOptions&; + + auto labelDetailsSupport(std::optional labelDetailsSupport) + -> ClientCompletionItemOptions&; +}; + +class ClientCompletionItemOptionsKind final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto valueSet() const + -> std::optional>; + + auto valueSet(std::optional> valueSet) + -> ClientCompletionItemOptionsKind&; +}; + +class CompletionListCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto itemDefaults() const -> std::optional>; + + [[nodiscard]] auto applyKindSupport() const -> std::optional; + + auto itemDefaults(std::optional> itemDefaults) + -> CompletionListCapabilities&; + + auto applyKindSupport(std::optional applyKindSupport) + -> CompletionListCapabilities&; +}; + +class ClientSignatureInformationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto documentationFormat() const + -> std::optional>; + + [[nodiscard]] auto parameterInformation() const + -> std::optional; + + [[nodiscard]] auto activeParameterSupport() const -> std::optional; + + [[nodiscard]] auto noActiveParameterSupport() const -> std::optional; + + auto documentationFormat( + std::optional> documentationFormat) + -> ClientSignatureInformationOptions&; + + auto parameterInformation( + std::optional + parameterInformation) -> ClientSignatureInformationOptions&; + + auto activeParameterSupport(std::optional activeParameterSupport) + -> ClientSignatureInformationOptions&; + + auto noActiveParameterSupport(std::optional noActiveParameterSupport) + -> ClientSignatureInformationOptions&; +}; + +class ClientCodeActionLiteralOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto codeActionKind() const -> ClientCodeActionKindOptions; + + auto codeActionKind(ClientCodeActionKindOptions codeActionKind) + -> ClientCodeActionLiteralOptions&; +}; + +class ClientCodeActionResolveOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto properties() const -> Vector; + + auto properties(Vector properties) + -> ClientCodeActionResolveOptions&; +}; + +class CodeActionTagOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto valueSet() const -> Vector; + + auto valueSet(Vector valueSet) -> CodeActionTagOptions&; +}; + +class ClientCodeLensResolveOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto properties() const -> Vector; + + auto properties(Vector properties) + -> ClientCodeLensResolveOptions&; +}; + +class ClientFoldingRangeKindOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto valueSet() const + -> std::optional>; + + auto valueSet(std::optional> valueSet) + -> ClientFoldingRangeKindOptions&; +}; + +class ClientFoldingRangeOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto collapsedText() const -> std::optional; + + auto collapsedText(std::optional collapsedText) + -> ClientFoldingRangeOptions&; +}; + +class DiagnosticsCapabilities final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto relatedInformation() const -> std::optional; + + [[nodiscard]] auto tagSupport() const + -> std::optional; + + [[nodiscard]] auto codeDescriptionSupport() const -> std::optional; + + [[nodiscard]] auto dataSupport() const -> std::optional; + + auto relatedInformation(std::optional relatedInformation) + -> DiagnosticsCapabilities&; + + auto tagSupport(std::optional tagSupport) + -> DiagnosticsCapabilities&; + + auto codeDescriptionSupport(std::optional codeDescriptionSupport) + -> DiagnosticsCapabilities&; + + auto dataSupport(std::optional dataSupport) -> DiagnosticsCapabilities&; +}; + +class ClientSemanticTokensRequestOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto range() const + -> std::optional>; + + [[nodiscard]] auto full() const -> std::optional< + std::variant>; + + auto range(std::optional> range) + -> ClientSemanticTokensRequestOptions&; + + auto full(std::optional> + full) -> ClientSemanticTokensRequestOptions&; +}; + +class ClientInlayHintResolveOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto properties() const -> Vector; + + auto properties(Vector properties) + -> ClientInlayHintResolveOptions&; +}; + +class ClientShowMessageActionItemOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto additionalPropertiesSupport() const -> std::optional; + + auto additionalPropertiesSupport( + std::optional additionalPropertiesSupport) + -> ClientShowMessageActionItemOptions&; +}; + +class CompletionItemTagOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto valueSet() const -> Vector; + + auto valueSet(Vector valueSet) + -> CompletionItemTagOptions&; +}; + +class ClientCompletionItemResolveOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto properties() const -> Vector; + + auto properties(Vector properties) + -> ClientCompletionItemResolveOptions&; +}; + +class ClientCompletionItemInsertTextModeOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto valueSet() const -> Vector; + + auto valueSet(Vector valueSet) + -> ClientCompletionItemInsertTextModeOptions&; +}; + +class ClientSignatureParameterInformationOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto labelOffsetSupport() const -> std::optional; + + auto labelOffsetSupport(std::optional labelOffsetSupport) + -> ClientSignatureParameterInformationOptions&; +}; + +class ClientCodeActionKindOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto valueSet() const -> Vector; + + auto valueSet(Vector valueSet) + -> ClientCodeActionKindOptions&; +}; + +class ClientDiagnosticsTagOptions final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto valueSet() const -> Vector; + + auto valueSet(Vector valueSet) -> ClientDiagnosticsTagOptions&; +}; + +class ClientSemanticTokensRequestFullDelta final : public LSPObject { + public: + using LSPObject::LSPObject; + + explicit operator bool() const; + + [[nodiscard]] auto delta() const -> std::optional; + + auto delta(std::optional delta) + -> ClientSemanticTokensRequestFullDelta&; +}; +} // namespace cxx::lsp diff --git a/tests/api_tests/CMakeLists.txt b/tests/api_tests/CMakeLists.txt index 39d003c6..3b2d969e 100644 --- a/tests/api_tests/CMakeLists.txt +++ b/tests/api_tests/CMakeLists.txt @@ -3,17 +3,6 @@ if (CMAKE_SYSTEM_NAME STREQUAL "WASI") return() endif() -include(FetchContent) - -set(INSTALL_GTEST OFF CACHE BOOL "" FORCE) - -FetchContent_Declare( - googletest - URL https://github.com/google/googletest/archive/refs/tags/v1.15.2.tar.gz -) - -FetchContent_MakeAvailable(googletest) - aux_source_directory(. SOURCES) add_executable(test_api ${SOURCES}) @@ -21,5 +10,4 @@ target_link_libraries(test_api GTest::gtest_main cxx-parser) -include(GoogleTest) gtest_discover_tests(test_api)