qt/qtlanguageserver/src/languageserver/qlanguageserverspectypes_p.h

Revision control

Copy as Markdown

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant
// this file was generated by the generate.ts script
#ifndef QLANGUAGESERVERSPECTYPES_P_H
#define QLANGUAGESERVERSPECTYPES_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include <QtLanguageServer/qtlanguageserverglobal.h>
#include <QtLanguageServer/private/qlanguageserverprespectypes_p.h>
#include <QtJsonRpc/private/qtypedjson_p.h>
#include <QtCore/QByteArray>
#include <QtCore/QList>
#include <QtCore/QJsonValue>
#include <QtCore/QJsonObject>
#include <QtCore/QString>
#include <QtCore/QMap>
#include <optional>
#include <variant>
QT_BEGIN_NAMESPACE
namespace QLspSpecification {
Q_NAMESPACE_EXPORT(Q_LANGUAGESERVER_EXPORT)
enum class ErrorCodes {
// Defined by JSON RPC
ParseError = -32700,
InvalidRequest = -32600,
MethodNotFound = -32601,
InvalidParams = -32602,
InternalError = -32603,
jsonrpcReservedErrorRangeStart = -32099,
/** @deprecated use jsonrpcReservedErrorRangeStart */
serverErrorStart = jsonrpcReservedErrorRangeStart,
ServerNotInitialized = -32002,
UnknownErrorCode = -32001,
jsonrpcReservedErrorRangeEnd = -32000,
/** @deprecated use jsonrpcReservedErrorRangeEnd */
serverErrorEnd = jsonrpcReservedErrorRangeEnd,
lspReservedErrorRangeStart = -32899,
ContentModified = -32801,
RequestCancelled = -32800,
lspReservedErrorRangeEnd = -32800
};
Q_ENUM_NS(ErrorCodes)
enum class ApplyKind { Replace = 1, Merge = 2 };
Q_ENUM_NS(ApplyKind)
enum class CodeActionKind {
Empty,
QuickFix,
Refactor,
RefactorExtract,
RefactorInline,
RefactorMove,
RefactorRewrite,
Source,
SourceOrganizeImports,
SourceFixAll,
Notebook
};
Q_ENUM_NS(CodeActionKind)
enum class CodeActionTag { LLMGenerated = 1 };
Q_ENUM_NS(CodeActionTag)
enum class CodeActionTriggerKind { Invoked = 1, Automatic = 2 };
Q_ENUM_NS(CodeActionTriggerKind)
enum class CompletionItemKind {
Text = 1,
Method = 2,
Function = 3,
Constructor = 4,
Field = 5,
Variable = 6,
Class = 7,
Interface = 8,
Module = 9,
Property = 10,
Unit = 11,
Value = 12,
Enum = 13,
Keyword = 14,
Snippet = 15,
Color = 16,
File = 17,
Reference = 18,
Folder = 19,
EnumMember = 20,
Constant = 21,
Struct = 22,
Event = 23,
Operator = 24,
TypeParameter = 25
};
Q_ENUM_NS(CompletionItemKind)
enum class CompletionItemTag { Deprecated = 1 };
Q_ENUM_NS(CompletionItemTag)
enum class CompletionTriggerKind {
Invoked = 1,
TriggerCharacter = 2,
TriggerForIncompleteCompletions = 3
};
Q_ENUM_NS(CompletionTriggerKind)
enum class DiagnosticSeverity { Error = 1, Warning = 2, Information = 3, Hint = 4 };
Q_ENUM_NS(DiagnosticSeverity)
enum class DiagnosticTag { Unnecessary = 1, Deprecated = 2 };
Q_ENUM_NS(DiagnosticTag)
enum class DocumentDiagnosticReportKind { Full, Unchanged };
Q_ENUM_NS(DocumentDiagnosticReportKind)
enum class DocumentHighlightKind { Text = 1, Read = 2, Write = 3 };
Q_ENUM_NS(DocumentHighlightKind)
enum class FailureHandlingKind { Abort, Transactional, TextOnlyTransactional, Undo };
Q_ENUM_NS(FailureHandlingKind)
enum class FileChangeType { Created = 1, Changed = 2, Deleted = 3 };
Q_ENUM_NS(FileChangeType)
enum class FileOperationPatternKind { File, Folder };
Q_ENUM_NS(FileOperationPatternKind)
enum class FoldingRangeKind { Comment, Imports, Region };
Q_ENUM_NS(FoldingRangeKind)
enum class InlayHintKind { Type = 1, Parameter = 2 };
Q_ENUM_NS(InlayHintKind)
enum class InlineCompletionTriggerKind { Invoked = 1, Automatic = 2 };
Q_ENUM_NS(InlineCompletionTriggerKind)
enum class InsertTextFormat { PlainText = 1, Snippet = 2 };
Q_ENUM_NS(InsertTextFormat)
enum class InsertTextMode { AsIs = 1, AdjustIndentation = 2 };
Q_ENUM_NS(InsertTextMode)
enum class LSPErrorCodes {
RequestFailed = -32803,
ServerCancelled = -32802,
ContentModified = -32801,
RequestCancelled = -32800
};
Q_ENUM_NS(LSPErrorCodes)
enum class LanguageKind {
ABAP,
WindowsBat,
BibTeX,
Clojure,
Coffeescript,
C,
CPP,
CSharp,
CSS,
D,
Delphi,
Diff,
Dart,
Dockerfile,
Elixir,
Erlang,
FSharp,
GitCommit,
GitRebase,
Go,
Groovy,
Handlebars,
Haskell,
HTML,
Ini,
Java,
JavaScript,
JavaScriptReact,
JSON,
LaTeX,
Less,
Lua,
Makefile,
Markdown,
ObjectiveC,
ObjectiveCPP,
Pascal,
Perl,
Perl6,
PHP,
Plaintext,
Powershell,
Pug,
Python,
R,
Razor,
Ruby,
Rust,
SCSS,
SASS,
Scala,
ShaderLab,
ShellScript,
SQL,
Swift,
TypeScript,
TypeScriptReact,
TeX,
VisualBasic,
XML,
XSL,
YAML
};
Q_ENUM_NS(LanguageKind)
enum class MarkupKind { PlainText, Markdown };
Q_ENUM_NS(MarkupKind)
enum class MessageType { Error = 1, Warning = 2, Info = 3, Log = 4, Debug = 5 };
Q_ENUM_NS(MessageType)
enum class MonikerKind { Import, Export, Local };
Q_ENUM_NS(MonikerKind)
enum class NotebookCellKind { Markup = 1, Code = 2 };
Q_ENUM_NS(NotebookCellKind)
enum class PositionEncodingKind { UTF8, UTF16, UTF32 };
Q_ENUM_NS(PositionEncodingKind)
enum class PrepareSupportDefaultBehavior { Identifier = 1 };
Q_ENUM_NS(PrepareSupportDefaultBehavior)
enum class ResourceOperationKind { Create, Rename, Delete };
Q_ENUM_NS(ResourceOperationKind)
enum class SemanticTokenModifiers {
Declaration,
Definition,
Readonly,
Static,
Deprecated,
Abstract,
Async,
Modification,
Documentation,
DefaultLibrary
};
Q_ENUM_NS(SemanticTokenModifiers)
enum class SemanticTokenTypes {
Namespace,
Type,
Class,
Enum,
Interface,
Struct,
TypeParameter,
Parameter,
Variable,
Property,
EnumMember,
Event,
Function,
Method,
Macro,
Keyword,
Modifier,
Comment,
String,
Number,
Regexp,
Operator,
Decorator,
Label
};
Q_ENUM_NS(SemanticTokenTypes)
enum class SignatureHelpTriggerKind { Invoked = 1, TriggerCharacter = 2, ContentChange = 3 };
Q_ENUM_NS(SignatureHelpTriggerKind)
enum class SymbolKind {
File = 1,
Module = 2,
Namespace = 3,
Package = 4,
Class = 5,
Method = 6,
Property = 7,
Field = 8,
Constructor = 9,
Enum = 10,
Interface = 11,
Function = 12,
Variable = 13,
Constant = 14,
String = 15,
Number = 16,
Boolean = 17,
Array = 18,
Object = 19,
Key = 20,
Null = 21,
EnumMember = 22,
Struct = 23,
Event = 24,
Operator = 25,
TypeParameter = 26
};
Q_ENUM_NS(SymbolKind)
enum class SymbolTag { Deprecated = 1 };
Q_ENUM_NS(SymbolTag)
enum class TextDocumentSaveReason { Manual = 1, AfterDelay = 2, FocusOut = 3 };
Q_ENUM_NS(TextDocumentSaveReason)
enum class TextDocumentSyncKind { None = 0, Full = 1, Incremental = 2 };
Q_ENUM_NS(TextDocumentSyncKind)
enum class TokenFormat { Relative };
Q_ENUM_NS(TokenFormat)
enum class TraceValue { Off, Messages, Verbose };
Q_ENUM_NS(TraceValue)
enum class UniquenessLevel { Document, Project, Group, Scheme, Global };
Q_ENUM_NS(UniquenessLevel)
enum class WatchKind { Create = 1, Change = 2, Delete = 4 };
Q_ENUM_NS(WatchKind)
class Q_LANGUAGESERVER_EXPORT Position
{
public:
unsigned int line = { };
unsigned int character = { };
template <typename W>
void walk(W &w)
{
field(w, "line", line);
field(w, "character", character);
}
};
class Q_LANGUAGESERVER_EXPORT Range
{
public:
Position start = { };
Position end = { };
template <typename W>
void walk(W &w)
{
field(w, "start", start);
field(w, "end", end);
}
};
class Q_LANGUAGESERVER_EXPORT SelectionRange
{
public:
SelectionRange() = default;
SelectionRange(const Range &r) : range(r) { }
SelectionRange(const SelectionRange &o) : range(o.range)
{
if (o.parent)
parent = std::make_unique<SelectionRange>(*o.parent);
}
SelectionRange &operator=(const SelectionRange &o)
{
range = o.range;
if (o.parent)
parent = std::make_unique<SelectionRange>(*o.parent);
return *this;
}
SelectionRange(SelectionRange &&) noexcept = default;
SelectionRange &operator=(SelectionRange &&) noexcept = default;
Range range = { };
std::unique_ptr<SelectionRange> parent;
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "parent", parent);
}
};
class Q_LANGUAGESERVER_EXPORT RangePlaceHolder
{
public:
Range range = { };
QByteArray placeholder = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "placeholder", placeholder);
}
};
class Q_LANGUAGESERVER_EXPORT DefaultBehaviorStruct
{
public:
bool defaultBehavior = { };
template <typename W>
void walk(W &w)
{
field(w, "defaultBehavior", defaultBehavior);
}
};
class Q_LANGUAGESERVER_EXPORT TextEdit
{
public:
Range range = { };
QByteArray newText = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "newText", newText);
}
};
using ChangeAnnotationIdentifier = QByteArray;
class Q_LANGUAGESERVER_EXPORT AnnotatedTextEdit : public TextEdit
{
public:
ChangeAnnotationIdentifier annotationId = { };
template <typename W>
void walk(W &w)
{
TextEdit::walk(w);
field(w, "annotationId", annotationId);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentIdentifier
{
public:
QByteArray uri = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
}
};
class Q_LANGUAGESERVER_EXPORT OptionalVersionedTextDocumentIdentifier
: public TextDocumentIdentifier
{
public:
std::variant<std::nullptr_t, int> version = { };
template <typename W>
void walk(W &w)
{
TextDocumentIdentifier::walk(w);
field(w, "version", version);
}
};
class Q_LANGUAGESERVER_EXPORT StringValue
{
public:
static constexpr QByteArrayView kind = "snippet";
QByteArray value = { };
template <typename W>
void walk(W &w)
{
field(w, "kind", kind);
field(w, "value", value);
}
};
class Q_LANGUAGESERVER_EXPORT SnippetTextEdit
{
public:
Range range = { };
StringValue snippet = { };
std::optional<ChangeAnnotationIdentifier> annotationId = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "snippet", snippet);
field(w, "annotationId", annotationId);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentEdit
{
public:
OptionalVersionedTextDocumentIdentifier textDocument = { };
QList<std::variant<TextEdit, AnnotatedTextEdit, SnippetTextEdit>> edits = { };
template <typename W>
void walk(W &w)
{
field(w, "textDocument", textDocument);
field(w, "edits", edits);
}
};
class Q_LANGUAGESERVER_EXPORT ResourceOperation
{
public:
QByteArray kind = { };
std::optional<ChangeAnnotationIdentifier> annotationId = { };
template <typename W>
void walk(W &w)
{
field(w, "kind", kind);
field(w, "annotationId", annotationId);
}
};
class Q_LANGUAGESERVER_EXPORT CreateFileOptions
{
public:
std::optional<bool> overwrite = { };
std::optional<bool> ignoreIfExists = { };
template <typename W>
void walk(W &w)
{
field(w, "overwrite", overwrite);
field(w, "ignoreIfExists", ignoreIfExists);
}
};
class Q_LANGUAGESERVER_EXPORT CreateFile : public ResourceOperation
{
public:
static constexpr QByteArrayView kind = "create";
QByteArray uri = { };
std::optional<CreateFileOptions> options = { };
template <typename W>
void walk(W &w)
{
ResourceOperation::walk(w);
field(w, "kind", kind);
field(w, "uri", uri);
field(w, "options", options);
}
};
class Q_LANGUAGESERVER_EXPORT RenameFileOptions
{
public:
std::optional<bool> overwrite = { };
std::optional<bool> ignoreIfExists = { };
template <typename W>
void walk(W &w)
{
field(w, "overwrite", overwrite);
field(w, "ignoreIfExists", ignoreIfExists);
}
};
class Q_LANGUAGESERVER_EXPORT RenameFile : public ResourceOperation
{
public:
static constexpr QByteArrayView kind = "rename";
QByteArray oldUri = { };
QByteArray newUri = { };
std::optional<RenameFileOptions> options = { };
template <typename W>
void walk(W &w)
{
ResourceOperation::walk(w);
field(w, "kind", kind);
field(w, "oldUri", oldUri);
field(w, "newUri", newUri);
field(w, "options", options);
}
};
class Q_LANGUAGESERVER_EXPORT DeleteFileOptions
{
public:
std::optional<bool> recursive = { };
std::optional<bool> ignoreIfNotExists = { };
template <typename W>
void walk(W &w)
{
field(w, "recursive", recursive);
field(w, "ignoreIfNotExists", ignoreIfNotExists);
}
};
class Q_LANGUAGESERVER_EXPORT DeleteFile : public ResourceOperation
{
public:
static constexpr QByteArrayView kind = "delete";
QByteArray uri = { };
std::optional<DeleteFileOptions> options = { };
template <typename W>
void walk(W &w)
{
ResourceOperation::walk(w);
field(w, "kind", kind);
field(w, "uri", uri);
field(w, "options", options);
}
};
class Q_LANGUAGESERVER_EXPORT ChangeAnnotation
{
public:
QByteArray label = { };
std::optional<bool> needsConfirmation = { };
std::optional<QByteArray> description = { };
template <typename W>
void walk(W &w)
{
field(w, "label", label);
field(w, "needsConfirmation", needsConfirmation);
field(w, "description", description);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceEdit
{
public:
std::optional<QMap<QByteArray, QList<TextEdit>>> changes = { };
using DocumentChange = std::variant<TextDocumentEdit, CreateFile, RenameFile, DeleteFile>;
std::optional<QList<DocumentChange>> documentChanges = { };
std::optional<QMap<ChangeAnnotationIdentifier, ChangeAnnotation>> changeAnnotations = { };
template <typename W>
void walk(W &w)
{
field(w, "changes", changes);
field(w, "documentChanges", documentChanges);
field(w, "changeAnnotations", changeAnnotations);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceEditMetadata
{
public:
std::optional<bool> isRefactoring = { };
template <typename W>
void walk(W &w)
{
field(w, "isRefactoring", isRefactoring);
}
};
class Q_LANGUAGESERVER_EXPORT ApplyWorkspaceEditParams
{
public:
std::optional<QByteArray> label = { };
WorkspaceEdit edit = { };
std::optional<WorkspaceEditMetadata> metadata = { };
template <typename W>
void walk(W &w)
{
field(w, "label", label);
field(w, "edit", edit);
field(w, "metadata", metadata);
}
};
class Q_LANGUAGESERVER_EXPORT ApplyWorkspaceEditResult
{
public:
bool applied = { };
std::optional<QByteArray> failureReason = { };
std::optional<unsigned int> failedChange = { };
template <typename W>
void walk(W &w)
{
field(w, "applied", applied);
field(w, "failureReason", failureReason);
field(w, "failedChange", failedChange);
}
};
class Q_LANGUAGESERVER_EXPORT BaseSymbolInformation
{
public:
QByteArray name = { };
SymbolKind kind = { };
std::optional<QList<SymbolTag>> tags = { };
std::optional<QByteArray> containerName = { };
template <typename W>
void walk(W &w)
{
field(w, "name", name);
field(w, "kind", kind);
field(w, "tags", tags);
field(w, "containerName", containerName);
}
};
class Q_LANGUAGESERVER_EXPORT CallHierarchyClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT CallHierarchyItem
{
public:
QByteArray name = { };
SymbolKind kind = { };
std::optional<QList<SymbolTag>> tags = { };
std::optional<QByteArray> detail = { };
QByteArray uri = { };
Range range = { };
Range selectionRange = { };
std::optional<QJsonValue> data = { };
template <typename W>
void walk(W &w)
{
field(w, "name", name);
field(w, "kind", kind);
field(w, "tags", tags);
field(w, "detail", detail);
field(w, "uri", uri);
field(w, "range", range);
field(w, "selectionRange", selectionRange);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT CallHierarchyIncomingCall
{
public:
CallHierarchyItem from = { };
QList<Range> fromRanges = { };
template <typename W>
void walk(W &w)
{
field(w, "from", from);
field(w, "fromRanges", fromRanges);
}
};
using ProgressToken = std::variant<int, QByteArray>;
class Q_LANGUAGESERVER_EXPORT WorkDoneProgressParams
{
public:
std::optional<ProgressToken> workDoneToken = { };
template <typename W>
void walk(W &w)
{
field(w, "workDoneToken", workDoneToken);
}
};
class Q_LANGUAGESERVER_EXPORT PartialResultParams
{
public:
std::optional<ProgressToken> partialResultToken = { };
template <typename W>
void walk(W &w)
{
field(w, "partialResultToken", partialResultToken);
}
};
class Q_LANGUAGESERVER_EXPORT CallHierarchyIncomingCallsParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
CallHierarchyItem item = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "item", item);
}
};
class Q_LANGUAGESERVER_EXPORT WorkDoneProgressOptions
{
public:
std::optional<bool> workDoneProgress = { };
template <typename W>
void walk(W &w)
{
field(w, "workDoneProgress", workDoneProgress);
}
};
class Q_LANGUAGESERVER_EXPORT CallHierarchyOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT CallHierarchyOutgoingCall
{
public:
CallHierarchyItem to = { };
QList<Range> fromRanges = { };
template <typename W>
void walk(W &w)
{
field(w, "to", to);
field(w, "fromRanges", fromRanges);
}
};
class Q_LANGUAGESERVER_EXPORT CallHierarchyOutgoingCallsParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
CallHierarchyItem item = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "item", item);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentPositionParams
{
public:
TextDocumentIdentifier textDocument = { };
Position position = { };
template <typename W>
void walk(W &w)
{
field(w, "textDocument", textDocument);
field(w, "position", position);
}
};
class Q_LANGUAGESERVER_EXPORT CallHierarchyPrepareParams : public TextDocumentPositionParams,
public WorkDoneProgressParams
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
}
};
using Pattern = QByteArray;
class Q_LANGUAGESERVER_EXPORT WorkspaceFolder
{
public:
QByteArray uri = { };
QByteArray name = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
field(w, "name", name);
}
};
class Q_LANGUAGESERVER_EXPORT RelativePattern
{
public:
std::variant<WorkspaceFolder, QByteArray> baseUri = { };
Pattern pattern = { };
template <typename W>
void walk(W &w)
{
field(w, "baseUri", baseUri);
field(w, "pattern", pattern);
}
};
using GlobPattern = std::variant<Pattern, RelativePattern>;
class Q_LANGUAGESERVER_EXPORT TextDocumentFilterLanguage
{
public:
QByteArray language = { };
std::optional<QByteArray> scheme = { };
std::optional<GlobPattern> pattern = { };
template <typename W>
void walk(W &w)
{
field(w, "language", language);
field(w, "scheme", scheme);
field(w, "pattern", pattern);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentFilterScheme
{
public:
std::optional<QByteArray> language = { };
QByteArray scheme = { };
std::optional<GlobPattern> pattern = { };
template <typename W>
void walk(W &w)
{
field(w, "language", language);
field(w, "scheme", scheme);
field(w, "pattern", pattern);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentFilterPattern
{
public:
std::optional<QByteArray> language = { };
std::optional<QByteArray> scheme = { };
GlobPattern pattern = { };
template <typename W>
void walk(W &w)
{
field(w, "language", language);
field(w, "scheme", scheme);
field(w, "pattern", pattern);
}
};
using TextDocumentFilter = std::variant<TextDocumentFilterLanguage, TextDocumentFilterScheme,
TextDocumentFilterPattern>;
class Q_LANGUAGESERVER_EXPORT NotebookDocumentFilterNotebookType
{
public:
QByteArray notebookType = { };
std::optional<QByteArray> scheme = { };
std::optional<GlobPattern> pattern = { };
template <typename W>
void walk(W &w)
{
field(w, "notebookType", notebookType);
field(w, "scheme", scheme);
field(w, "pattern", pattern);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentFilterScheme
{
public:
std::optional<QByteArray> notebookType = { };
QByteArray scheme = { };
std::optional<GlobPattern> pattern = { };
template <typename W>
void walk(W &w)
{
field(w, "notebookType", notebookType);
field(w, "scheme", scheme);
field(w, "pattern", pattern);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentFilterPattern
{
public:
std::optional<QByteArray> notebookType = { };
std::optional<QByteArray> scheme = { };
GlobPattern pattern = { };
template <typename W>
void walk(W &w)
{
field(w, "notebookType", notebookType);
field(w, "scheme", scheme);
field(w, "pattern", pattern);
}
};
using NotebookDocumentFilter =
std::variant<NotebookDocumentFilterNotebookType, NotebookDocumentFilterScheme,
NotebookDocumentFilterPattern>;
class Q_LANGUAGESERVER_EXPORT NotebookCellTextDocumentFilter
{
public:
std::variant<QByteArray, NotebookDocumentFilter> notebook = { };
std::optional<QByteArray> language = { };
template <typename W>
void walk(W &w)
{
field(w, "notebook", notebook);
field(w, "language", language);
}
};
using DocumentFilter = std::variant<TextDocumentFilter, NotebookCellTextDocumentFilter>;
using DocumentSelector = QList<DocumentFilter>;
class Q_LANGUAGESERVER_EXPORT TextDocumentRegistrationOptions
{
public:
std::variant<std::nullptr_t, DocumentSelector> documentSelector = { };
template <typename W>
void walk(W &w)
{
field(w, "documentSelector", documentSelector);
}
};
class Q_LANGUAGESERVER_EXPORT StaticRegistrationOptions
{
public:
std::optional<QByteArray> id = { };
template <typename W>
void walk(W &w)
{
field(w, "id", id);
}
};
class Q_LANGUAGESERVER_EXPORT CallHierarchyRegistrationOptions
: public TextDocumentRegistrationOptions,
public CallHierarchyOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
CallHierarchyOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT CancelParams
{
public:
std::variant<int, QByteArray> id = { };
template <typename W>
void walk(W &w)
{
field(w, "id", id);
}
};
class Q_LANGUAGESERVER_EXPORT ChangeAnnotationsSupportOptions
{
public:
std::optional<bool> groupsOnLabel = { };
template <typename W>
void walk(W &w)
{
field(w, "groupsOnLabel", groupsOnLabel);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceEditClientCapabilities
{
public:
std::optional<bool> documentChanges = { };
std::optional<QList<ResourceOperationKind>> resourceOperations = { };
std::optional<FailureHandlingKind> failureHandling = { };
std::optional<bool> normalizesLineEndings = { };
std::optional<ChangeAnnotationsSupportOptions> changeAnnotationSupport = { };
std::optional<bool> metadataSupport = { };
std::optional<bool> snippetEditSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "documentChanges", documentChanges);
field(w, "resourceOperations", resourceOperations);
field(w, "failureHandling", failureHandling);
field(w, "normalizesLineEndings", normalizesLineEndings);
field(w, "changeAnnotationSupport", changeAnnotationSupport);
field(w, "metadataSupport", metadataSupport);
field(w, "snippetEditSupport", snippetEditSupport);
}
};
class Q_LANGUAGESERVER_EXPORT DidChangeConfigurationClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT DidChangeWatchedFilesClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> relativePatternSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "relativePatternSupport", relativePatternSupport);
}
};
class Q_LANGUAGESERVER_EXPORT ClientSymbolKindOptions
{
public:
std::optional<QList<SymbolKind>> valueSet = { };
template <typename W>
void walk(W &w)
{
field(w, "valueSet", valueSet);
}
};
class Q_LANGUAGESERVER_EXPORT ClientSymbolTagOptions
{
public:
QList<SymbolTag> valueSet = { };
template <typename W>
void walk(W &w)
{
field(w, "valueSet", valueSet);
}
};
class Q_LANGUAGESERVER_EXPORT ClientSymbolResolveOptions
{
public:
QList<QByteArray> properties = { };
template <typename W>
void walk(W &w)
{
field(w, "properties", properties);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceSymbolClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<ClientSymbolKindOptions> symbolKind = { };
std::optional<ClientSymbolTagOptions> tagSupport = { };
std::optional<ClientSymbolResolveOptions> resolveSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "symbolKind", symbolKind);
field(w, "tagSupport", tagSupport);
field(w, "resolveSupport", resolveSupport);
}
};
class Q_LANGUAGESERVER_EXPORT ExecuteCommandClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensWorkspaceClientCapabilities
{
public:
std::optional<bool> refreshSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "refreshSupport", refreshSupport);
}
};
class Q_LANGUAGESERVER_EXPORT CodeLensWorkspaceClientCapabilities
{
public:
std::optional<bool> refreshSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "refreshSupport", refreshSupport);
}
};
class Q_LANGUAGESERVER_EXPORT FileOperationClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> didCreate = { };
std::optional<bool> willCreate = { };
std::optional<bool> didRename = { };
std::optional<bool> willRename = { };
std::optional<bool> didDelete = { };
std::optional<bool> willDelete = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "didCreate", didCreate);
field(w, "willCreate", willCreate);
field(w, "didRename", didRename);
field(w, "willRename", willRename);
field(w, "didDelete", didDelete);
field(w, "willDelete", willDelete);
}
};
class Q_LANGUAGESERVER_EXPORT InlineValueWorkspaceClientCapabilities
{
public:
std::optional<bool> refreshSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "refreshSupport", refreshSupport);
}
};
class Q_LANGUAGESERVER_EXPORT InlayHintWorkspaceClientCapabilities
{
public:
std::optional<bool> refreshSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "refreshSupport", refreshSupport);
}
};
class Q_LANGUAGESERVER_EXPORT DiagnosticWorkspaceClientCapabilities
{
public:
std::optional<bool> refreshSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "refreshSupport", refreshSupport);
}
};
class Q_LANGUAGESERVER_EXPORT FoldingRangeWorkspaceClientCapabilities
{
public:
std::optional<bool> refreshSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "refreshSupport", refreshSupport);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentContentClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceClientCapabilities
{
public:
std::optional<bool> applyEdit = { };
std::optional<WorkspaceEditClientCapabilities> workspaceEdit = { };
std::optional<DidChangeConfigurationClientCapabilities> didChangeConfiguration = { };
std::optional<DidChangeWatchedFilesClientCapabilities> didChangeWatchedFiles = { };
std::optional<WorkspaceSymbolClientCapabilities> symbol = { };
std::optional<ExecuteCommandClientCapabilities> executeCommand = { };
std::optional<bool> workspaceFolders = { };
std::optional<bool> configuration = { };
std::optional<SemanticTokensWorkspaceClientCapabilities> semanticTokens = { };
std::optional<CodeLensWorkspaceClientCapabilities> codeLens = { };
std::optional<FileOperationClientCapabilities> fileOperations = { };
std::optional<InlineValueWorkspaceClientCapabilities> inlineValue = { };
std::optional<InlayHintWorkspaceClientCapabilities> inlayHint = { };
std::optional<DiagnosticWorkspaceClientCapabilities> diagnostics = { };
std::optional<FoldingRangeWorkspaceClientCapabilities> foldingRange = { };
std::optional<TextDocumentContentClientCapabilities> textDocumentContent = { };
template <typename W>
void walk(W &w)
{
field(w, "applyEdit", applyEdit);
field(w, "workspaceEdit", workspaceEdit);
field(w, "didChangeConfiguration", didChangeConfiguration);
field(w, "didChangeWatchedFiles", didChangeWatchedFiles);
field(w, "symbol", symbol);
field(w, "executeCommand", executeCommand);
field(w, "workspaceFolders", workspaceFolders);
field(w, "configuration", configuration);
field(w, "semanticTokens", semanticTokens);
field(w, "codeLens", codeLens);
field(w, "fileOperations", fileOperations);
field(w, "inlineValue", inlineValue);
field(w, "inlayHint", inlayHint);
field(w, "diagnostics", diagnostics);
field(w, "foldingRange", foldingRange);
field(w, "textDocumentContent", textDocumentContent);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentSyncClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> willSave = { };
std::optional<bool> willSaveWaitUntil = { };
std::optional<bool> didSave = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "willSave", willSave);
field(w, "willSaveWaitUntil", willSaveWaitUntil);
field(w, "didSave", didSave);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentFilterClientCapabilities
{
public:
std::optional<bool> relativePatternSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "relativePatternSupport", relativePatternSupport);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionItemTagOptions
{
public:
QList<CompletionItemTag> valueSet = { };
template <typename W>
void walk(W &w)
{
field(w, "valueSet", valueSet);
}
};
class Q_LANGUAGESERVER_EXPORT ClientCompletionItemResolveOptions
{
public:
QList<QByteArray> properties = { };
template <typename W>
void walk(W &w)
{
field(w, "properties", properties);
}
};
class Q_LANGUAGESERVER_EXPORT ClientCompletionItemInsertTextModeOptions
{
public:
QList<InsertTextMode> valueSet = { };
template <typename W>
void walk(W &w)
{
field(w, "valueSet", valueSet);
}
};
class Q_LANGUAGESERVER_EXPORT ClientCompletionItemOptions
{
public:
std::optional<bool> snippetSupport = { };
std::optional<bool> commitCharactersSupport = { };
std::optional<QList<MarkupKind>> documentationFormat = { };
std::optional<bool> deprecatedSupport = { };
std::optional<bool> preselectSupport = { };
std::optional<CompletionItemTagOptions> tagSupport = { };
std::optional<bool> insertReplaceSupport = { };
std::optional<ClientCompletionItemResolveOptions> resolveSupport = { };
std::optional<ClientCompletionItemInsertTextModeOptions> insertTextModeSupport = { };
std::optional<bool> labelDetailsSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "snippetSupport", snippetSupport);
field(w, "commitCharactersSupport", commitCharactersSupport);
field(w, "documentationFormat", documentationFormat);
field(w, "deprecatedSupport", deprecatedSupport);
field(w, "preselectSupport", preselectSupport);
field(w, "tagSupport", tagSupport);
field(w, "insertReplaceSupport", insertReplaceSupport);
field(w, "resolveSupport", resolveSupport);
field(w, "insertTextModeSupport", insertTextModeSupport);
field(w, "labelDetailsSupport", labelDetailsSupport);
}
};
class Q_LANGUAGESERVER_EXPORT ClientCompletionItemOptionsKind
{
public:
std::optional<QList<CompletionItemKind>> valueSet = { };
template <typename W>
void walk(W &w)
{
field(w, "valueSet", valueSet);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionListCapabilities
{
public:
std::optional<QList<QByteArray>> itemDefaults = { };
std::optional<bool> applyKindSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "itemDefaults", itemDefaults);
field(w, "applyKindSupport", applyKindSupport);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<ClientCompletionItemOptions> completionItem = { };
std::optional<ClientCompletionItemOptionsKind> completionItemKind = { };
std::optional<InsertTextMode> insertTextMode = { };
std::optional<bool> contextSupport = { };
std::optional<CompletionListCapabilities> completionList = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "completionItem", completionItem);
field(w, "completionItemKind", completionItemKind);
field(w, "insertTextMode", insertTextMode);
field(w, "contextSupport", contextSupport);
field(w, "completionList", completionList);
}
};
class Q_LANGUAGESERVER_EXPORT HoverClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<QList<MarkupKind>> contentFormat = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "contentFormat", contentFormat);
}
};
class Q_LANGUAGESERVER_EXPORT ClientSignatureParameterInformationOptions
{
public:
std::optional<bool> labelOffsetSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "labelOffsetSupport", labelOffsetSupport);
}
};
class Q_LANGUAGESERVER_EXPORT ClientSignatureInformationOptions
{
public:
std::optional<QList<MarkupKind>> documentationFormat = { };
std::optional<ClientSignatureParameterInformationOptions> parameterInformation = { };
std::optional<bool> activeParameterSupport = { };
std::optional<bool> noActiveParameterSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "documentationFormat", documentationFormat);
field(w, "parameterInformation", parameterInformation);
field(w, "activeParameterSupport", activeParameterSupport);
field(w, "noActiveParameterSupport", noActiveParameterSupport);
}
};
class Q_LANGUAGESERVER_EXPORT SignatureHelpClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<ClientSignatureInformationOptions> signatureInformation = { };
std::optional<bool> contextSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "signatureInformation", signatureInformation);
field(w, "contextSupport", contextSupport);
}
};
class Q_LANGUAGESERVER_EXPORT DeclarationClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> linkSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "linkSupport", linkSupport);
}
};
class Q_LANGUAGESERVER_EXPORT DefinitionClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> linkSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "linkSupport", linkSupport);
}
};
class Q_LANGUAGESERVER_EXPORT TypeDefinitionClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> linkSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "linkSupport", linkSupport);
}
};
class Q_LANGUAGESERVER_EXPORT ImplementationClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> linkSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "linkSupport", linkSupport);
}
};
class Q_LANGUAGESERVER_EXPORT ReferenceClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentHighlightClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentSymbolClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<ClientSymbolKindOptions> symbolKind = { };
std::optional<bool> hierarchicalDocumentSymbolSupport = { };
std::optional<ClientSymbolTagOptions> tagSupport = { };
std::optional<bool> labelSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "symbolKind", symbolKind);
field(w, "hierarchicalDocumentSymbolSupport", hierarchicalDocumentSymbolSupport);
field(w, "tagSupport", tagSupport);
field(w, "labelSupport", labelSupport);
}
};
class Q_LANGUAGESERVER_EXPORT ClientCodeActionKindOptions
{
public:
QList<CodeActionKind> valueSet = { };
template <typename W>
void walk(W &w)
{
field(w, "valueSet", valueSet);
}
};
class Q_LANGUAGESERVER_EXPORT ClientCodeActionLiteralOptions
{
public:
ClientCodeActionKindOptions codeActionKind = { };
template <typename W>
void walk(W &w)
{
field(w, "codeActionKind", codeActionKind);
}
};
class Q_LANGUAGESERVER_EXPORT ClientCodeActionResolveOptions
{
public:
QList<QByteArray> properties = { };
template <typename W>
void walk(W &w)
{
field(w, "properties", properties);
}
};
class Q_LANGUAGESERVER_EXPORT CodeActionTagOptions
{
public:
QList<CodeActionTag> valueSet = { };
template <typename W>
void walk(W &w)
{
field(w, "valueSet", valueSet);
}
};
class Q_LANGUAGESERVER_EXPORT CodeActionClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<ClientCodeActionLiteralOptions> codeActionLiteralSupport = { };
std::optional<bool> isPreferredSupport = { };
std::optional<bool> disabledSupport = { };
std::optional<bool> dataSupport = { };
std::optional<ClientCodeActionResolveOptions> resolveSupport = { };
std::optional<bool> honorsChangeAnnotations = { };
std::optional<bool> documentationSupport = { };
std::optional<CodeActionTagOptions> tagSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "codeActionLiteralSupport", codeActionLiteralSupport);
field(w, "isPreferredSupport", isPreferredSupport);
field(w, "disabledSupport", disabledSupport);
field(w, "dataSupport", dataSupport);
field(w, "resolveSupport", resolveSupport);
field(w, "honorsChangeAnnotations", honorsChangeAnnotations);
field(w, "documentationSupport", documentationSupport);
field(w, "tagSupport", tagSupport);
}
};
class Q_LANGUAGESERVER_EXPORT ClientCodeLensResolveOptions
{
public:
QList<QByteArray> properties = { };
template <typename W>
void walk(W &w)
{
field(w, "properties", properties);
}
};
class Q_LANGUAGESERVER_EXPORT CodeLensClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<ClientCodeLensResolveOptions> resolveSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "resolveSupport", resolveSupport);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentLinkClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> tooltipSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "tooltipSupport", tooltipSupport);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentColorClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentFormattingClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentRangeFormattingClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> rangesSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "rangesSupport", rangesSupport);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentOnTypeFormattingClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT RenameClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> prepareSupport = { };
std::optional<PrepareSupportDefaultBehavior> prepareSupportDefaultBehavior = { };
std::optional<bool> honorsChangeAnnotations = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "prepareSupport", prepareSupport);
field(w, "prepareSupportDefaultBehavior", prepareSupportDefaultBehavior);
field(w, "honorsChangeAnnotations", honorsChangeAnnotations);
}
};
class Q_LANGUAGESERVER_EXPORT ClientFoldingRangeKindOptions
{
public:
std::optional<QList<FoldingRangeKind>> valueSet = { };
template <typename W>
void walk(W &w)
{
field(w, "valueSet", valueSet);
}
};
class Q_LANGUAGESERVER_EXPORT ClientFoldingRangeOptions
{
public:
std::optional<bool> collapsedText = { };
template <typename W>
void walk(W &w)
{
field(w, "collapsedText", collapsedText);
}
};
class Q_LANGUAGESERVER_EXPORT FoldingRangeClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<unsigned int> rangeLimit = { };
std::optional<bool> lineFoldingOnly = { };
std::optional<ClientFoldingRangeKindOptions> foldingRangeKind = { };
std::optional<ClientFoldingRangeOptions> foldingRange = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "rangeLimit", rangeLimit);
field(w, "lineFoldingOnly", lineFoldingOnly);
field(w, "foldingRangeKind", foldingRangeKind);
field(w, "foldingRange", foldingRange);
}
};
class Q_LANGUAGESERVER_EXPORT SelectionRangeClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT ClientDiagnosticsTagOptions
{
public:
QList<DiagnosticTag> valueSet = { };
template <typename W>
void walk(W &w)
{
field(w, "valueSet", valueSet);
}
};
class Q_LANGUAGESERVER_EXPORT DiagnosticsCapabilities
{
public:
std::optional<bool> relatedInformation = { };
std::optional<ClientDiagnosticsTagOptions> tagSupport = { };
std::optional<bool> codeDescriptionSupport = { };
std::optional<bool> dataSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "relatedInformation", relatedInformation);
field(w, "tagSupport", tagSupport);
field(w, "codeDescriptionSupport", codeDescriptionSupport);
field(w, "dataSupport", dataSupport);
}
};
class Q_LANGUAGESERVER_EXPORT PublishDiagnosticsClientCapabilities : public DiagnosticsCapabilities
{
public:
std::optional<bool> versionSupport = { };
template <typename W>
void walk(W &w)
{
DiagnosticsCapabilities::walk(w);
field(w, "versionSupport", versionSupport);
}
};
class Q_LANGUAGESERVER_EXPORT ClientSemanticTokensRequestFullDelta
{
public:
std::optional<bool> delta = { };
template <typename W>
void walk(W &w)
{
field(w, "delta", delta);
}
};
class Q_LANGUAGESERVER_EXPORT ClientSemanticTokensRequestOptions
{
public:
std::optional<std::variant<bool, QJsonObject>> range = { };
std::optional<std::variant<bool, ClientSemanticTokensRequestFullDelta>> full = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "full", full);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
ClientSemanticTokensRequestOptions requests = { };
QList<QByteArray> tokenTypes = { };
QList<QByteArray> tokenModifiers = { };
QList<TokenFormat> formats = { };
std::optional<bool> overlappingTokenSupport = { };
std::optional<bool> multilineTokenSupport = { };
std::optional<bool> serverCancelSupport = { };
std::optional<bool> augmentsSyntaxTokens = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "requests", requests);
field(w, "tokenTypes", tokenTypes);
field(w, "tokenModifiers", tokenModifiers);
field(w, "formats", formats);
field(w, "overlappingTokenSupport", overlappingTokenSupport);
field(w, "multilineTokenSupport", multilineTokenSupport);
field(w, "serverCancelSupport", serverCancelSupport);
field(w, "augmentsSyntaxTokens", augmentsSyntaxTokens);
}
};
class Q_LANGUAGESERVER_EXPORT LinkedEditingRangeClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT MonikerClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT TypeHierarchyClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT InlineValueClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT ClientInlayHintResolveOptions
{
public:
QList<QByteArray> properties = { };
template <typename W>
void walk(W &w)
{
field(w, "properties", properties);
}
};
class Q_LANGUAGESERVER_EXPORT InlayHintClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<ClientInlayHintResolveOptions> resolveSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "resolveSupport", resolveSupport);
}
};
class Q_LANGUAGESERVER_EXPORT DiagnosticClientCapabilities : public DiagnosticsCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> relatedDocumentSupport = { };
std::optional<bool> markupMessageSupport = { };
template <typename W>
void walk(W &w)
{
DiagnosticsCapabilities::walk(w);
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "relatedDocumentSupport", relatedDocumentSupport);
field(w, "markupMessageSupport", markupMessageSupport);
}
};
class Q_LANGUAGESERVER_EXPORT InlineCompletionClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentClientCapabilities
{
public:
std::optional<TextDocumentSyncClientCapabilities> synchronization = { };
std::optional<TextDocumentFilterClientCapabilities> filters = { };
std::optional<CompletionClientCapabilities> completion = { };
std::optional<HoverClientCapabilities> hover = { };
std::optional<SignatureHelpClientCapabilities> signatureHelp = { };
std::optional<DeclarationClientCapabilities> declaration = { };
std::optional<DefinitionClientCapabilities> definition = { };
std::optional<TypeDefinitionClientCapabilities> typeDefinition = { };
std::optional<ImplementationClientCapabilities> implementation = { };
std::optional<ReferenceClientCapabilities> references = { };
std::optional<DocumentHighlightClientCapabilities> documentHighlight = { };
std::optional<DocumentSymbolClientCapabilities> documentSymbol = { };
std::optional<CodeActionClientCapabilities> codeAction = { };
std::optional<CodeLensClientCapabilities> codeLens = { };
std::optional<DocumentLinkClientCapabilities> documentLink = { };
std::optional<DocumentColorClientCapabilities> colorProvider = { };
std::optional<DocumentFormattingClientCapabilities> formatting = { };
std::optional<DocumentRangeFormattingClientCapabilities> rangeFormatting = { };
std::optional<DocumentOnTypeFormattingClientCapabilities> onTypeFormatting = { };
std::optional<RenameClientCapabilities> rename = { };
std::optional<FoldingRangeClientCapabilities> foldingRange = { };
std::optional<SelectionRangeClientCapabilities> selectionRange = { };
std::optional<PublishDiagnosticsClientCapabilities> publishDiagnostics = { };
std::optional<CallHierarchyClientCapabilities> callHierarchy = { };
std::optional<SemanticTokensClientCapabilities> semanticTokens = { };
std::optional<LinkedEditingRangeClientCapabilities> linkedEditingRange = { };
std::optional<MonikerClientCapabilities> moniker = { };
std::optional<TypeHierarchyClientCapabilities> typeHierarchy = { };
std::optional<InlineValueClientCapabilities> inlineValue = { };
std::optional<InlayHintClientCapabilities> inlayHint = { };
std::optional<DiagnosticClientCapabilities> diagnostic = { };
std::optional<InlineCompletionClientCapabilities> inlineCompletion = { };
template <typename W>
void walk(W &w)
{
field(w, "synchronization", synchronization);
field(w, "filters", filters);
field(w, "completion", completion);
field(w, "hover", hover);
field(w, "signatureHelp", signatureHelp);
field(w, "declaration", declaration);
field(w, "definition", definition);
field(w, "typeDefinition", typeDefinition);
field(w, "implementation", implementation);
field(w, "references", references);
field(w, "documentHighlight", documentHighlight);
field(w, "documentSymbol", documentSymbol);
field(w, "codeAction", codeAction);
field(w, "codeLens", codeLens);
field(w, "documentLink", documentLink);
field(w, "colorProvider", colorProvider);
field(w, "formatting", formatting);
field(w, "rangeFormatting", rangeFormatting);
field(w, "onTypeFormatting", onTypeFormatting);
field(w, "rename", rename);
field(w, "foldingRange", foldingRange);
field(w, "selectionRange", selectionRange);
field(w, "publishDiagnostics", publishDiagnostics);
field(w, "callHierarchy", callHierarchy);
field(w, "semanticTokens", semanticTokens);
field(w, "linkedEditingRange", linkedEditingRange);
field(w, "moniker", moniker);
field(w, "typeHierarchy", typeHierarchy);
field(w, "inlineValue", inlineValue);
field(w, "inlayHint", inlayHint);
field(w, "diagnostic", diagnostic);
field(w, "inlineCompletion", inlineCompletion);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentSyncClientCapabilities
{
public:
std::optional<bool> dynamicRegistration = { };
std::optional<bool> executionSummarySupport = { };
template <typename W>
void walk(W &w)
{
field(w, "dynamicRegistration", dynamicRegistration);
field(w, "executionSummarySupport", executionSummarySupport);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentClientCapabilities
{
public:
NotebookDocumentSyncClientCapabilities synchronization = { };
template <typename W>
void walk(W &w)
{
field(w, "synchronization", synchronization);
}
};
class Q_LANGUAGESERVER_EXPORT ClientShowMessageActionItemOptions
{
public:
std::optional<bool> additionalPropertiesSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "additionalPropertiesSupport", additionalPropertiesSupport);
}
};
class Q_LANGUAGESERVER_EXPORT ShowMessageRequestClientCapabilities
{
public:
std::optional<ClientShowMessageActionItemOptions> messageActionItem = { };
template <typename W>
void walk(W &w)
{
field(w, "messageActionItem", messageActionItem);
}
};
class Q_LANGUAGESERVER_EXPORT ShowDocumentClientCapabilities
{
public:
bool support = { };
template <typename W>
void walk(W &w)
{
field(w, "support", support);
}
};
class Q_LANGUAGESERVER_EXPORT WindowClientCapabilities
{
public:
std::optional<bool> workDoneProgress = { };
std::optional<ShowMessageRequestClientCapabilities> showMessage = { };
std::optional<ShowDocumentClientCapabilities> showDocument = { };
template <typename W>
void walk(W &w)
{
field(w, "workDoneProgress", workDoneProgress);
field(w, "showMessage", showMessage);
field(w, "showDocument", showDocument);
}
};
class Q_LANGUAGESERVER_EXPORT StaleRequestSupportOptions
{
public:
bool cancel = { };
QList<QByteArray> retryOnContentModified = { };
template <typename W>
void walk(W &w)
{
field(w, "cancel", cancel);
field(w, "retryOnContentModified", retryOnContentModified);
}
};
using RegularExpressionEngineKind = QByteArray;
class Q_LANGUAGESERVER_EXPORT RegularExpressionsClientCapabilities
{
public:
RegularExpressionEngineKind engine = { };
std::optional<QByteArray> version = { };
template <typename W>
void walk(W &w)
{
field(w, "engine", engine);
field(w, "version", version);
}
};
class Q_LANGUAGESERVER_EXPORT MarkdownClientCapabilities
{
public:
QByteArray parser = { };
std::optional<QByteArray> version = { };
std::optional<QList<QByteArray>> allowedTags = { };
template <typename W>
void walk(W &w)
{
field(w, "parser", parser);
field(w, "version", version);
field(w, "allowedTags", allowedTags);
}
};
class Q_LANGUAGESERVER_EXPORT GeneralClientCapabilities
{
public:
std::optional<StaleRequestSupportOptions> staleRequestSupport = { };
std::optional<RegularExpressionsClientCapabilities> regularExpressions = { };
std::optional<MarkdownClientCapabilities> markdown = { };
std::optional<QList<PositionEncodingKind>> positionEncodings = { };
template <typename W>
void walk(W &w)
{
field(w, "staleRequestSupport", staleRequestSupport);
field(w, "regularExpressions", regularExpressions);
field(w, "markdown", markdown);
field(w, "positionEncodings", positionEncodings);
}
};
class Q_LANGUAGESERVER_EXPORT ClientCapabilities
{
public:
std::optional<WorkspaceClientCapabilities> workspace = { };
std::optional<TextDocumentClientCapabilities> textDocument = { };
std::optional<NotebookDocumentClientCapabilities> notebookDocument = { };
std::optional<WindowClientCapabilities> window = { };
std::optional<GeneralClientCapabilities> general = { };
std::optional<QJsonValue> experimental = { };
template <typename W>
void walk(W &w)
{
field(w, "workspace", workspace);
field(w, "textDocument", textDocument);
field(w, "notebookDocument", notebookDocument);
field(w, "window", window);
field(w, "general", general);
field(w, "experimental", experimental);
}
};
class Q_LANGUAGESERVER_EXPORT ClientInfo
{
public:
QByteArray name = { };
std::optional<QByteArray> version = { };
template <typename W>
void walk(W &w)
{
field(w, "name", name);
field(w, "version", version);
}
};
class Q_LANGUAGESERVER_EXPORT CodeDescription
{
public:
QByteArray href = { };
template <typename W>
void walk(W &w)
{
field(w, "href", href);
}
};
class Q_LANGUAGESERVER_EXPORT MarkupContent
{
public:
MarkupKind kind = { };
QByteArray value = { };
template <typename W>
void walk(W &w)
{
field(w, "kind", kind);
field(w, "value", value);
}
};
class Q_LANGUAGESERVER_EXPORT Location
{
public:
QByteArray uri = { };
Range range = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
field(w, "range", range);
}
};
class Q_LANGUAGESERVER_EXPORT DiagnosticRelatedInformation
{
public:
Location location = { };
QByteArray message = { };
template <typename W>
void walk(W &w)
{
field(w, "location", location);
field(w, "message", message);
}
};
class Q_LANGUAGESERVER_EXPORT Diagnostic
{
public:
Range range = { };
std::optional<DiagnosticSeverity> severity = { };
std::optional<std::variant<int, QByteArray>> code = { };
std::optional<CodeDescription> codeDescription = { };
std::optional<QByteArray> source = { };
std::variant<QByteArray, MarkupContent> message = { };
std::optional<QList<DiagnosticTag>> tags = { };
std::optional<QList<DiagnosticRelatedInformation>> relatedInformation = { };
std::optional<QJsonValue> data = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "severity", severity);
field(w, "code", code);
field(w, "codeDescription", codeDescription);
field(w, "source", source);
field(w, "message", message);
field(w, "tags", tags);
field(w, "relatedInformation", relatedInformation);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT CodeActionDisabled
{
public:
QByteArray reason = { };
template <typename W>
void walk(W &w)
{
field(w, "reason", reason);
}
};
class Q_LANGUAGESERVER_EXPORT Command
{
public:
QByteArray title = { };
std::optional<QByteArray> tooltip = { };
QByteArray command = { };
std::optional<QList<QJsonValue>> arguments = { };
template <typename W>
void walk(W &w)
{
field(w, "title", title);
field(w, "tooltip", tooltip);
field(w, "command", command);
field(w, "arguments", arguments);
}
};
class Q_LANGUAGESERVER_EXPORT CodeAction
{
public:
QByteArray title = { };
std::optional<CodeActionKind> kind = { };
std::optional<QList<Diagnostic>> diagnostics = { };
std::optional<bool> isPreferred = { };
std::optional<CodeActionDisabled> disabled = { };
std::optional<WorkspaceEdit> edit = { };
std::optional<Command> command = { };
std::optional<QJsonValue> data = { };
std::optional<QList<CodeActionTag>> tags = { };
template <typename W>
void walk(W &w)
{
field(w, "title", title);
field(w, "kind", kind);
field(w, "diagnostics", diagnostics);
field(w, "isPreferred", isPreferred);
field(w, "disabled", disabled);
field(w, "edit", edit);
field(w, "command", command);
field(w, "data", data);
field(w, "tags", tags);
}
};
class Q_LANGUAGESERVER_EXPORT CodeActionContext
{
public:
QList<Diagnostic> diagnostics = { };
std::optional<QList<CodeActionKind>> only = { };
std::optional<CodeActionTriggerKind> triggerKind = { };
template <typename W>
void walk(W &w)
{
field(w, "diagnostics", diagnostics);
field(w, "only", only);
field(w, "triggerKind", triggerKind);
}
};
class Q_LANGUAGESERVER_EXPORT CodeActionKindDocumentation
{
public:
CodeActionKind kind = { };
Command command = { };
template <typename W>
void walk(W &w)
{
field(w, "kind", kind);
field(w, "command", command);
}
};
class Q_LANGUAGESERVER_EXPORT CodeActionOptions : public WorkDoneProgressOptions
{
public:
std::optional<QList<CodeActionKind>> codeActionKinds = { };
std::optional<QList<CodeActionKindDocumentation>> documentation = { };
std::optional<bool> resolveProvider = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "codeActionKinds", codeActionKinds);
field(w, "documentation", documentation);
field(w, "resolveProvider", resolveProvider);
}
};
class Q_LANGUAGESERVER_EXPORT CodeActionParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
Range range = { };
CodeActionContext context = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
field(w, "range", range);
field(w, "context", context);
}
};
class Q_LANGUAGESERVER_EXPORT CodeActionRegistrationOptions
: public TextDocumentRegistrationOptions,
public CodeActionOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
CodeActionOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT CodeLens
{
public:
Range range = { };
std::optional<Command> command = { };
std::optional<QJsonValue> data = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "command", command);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT CodeLensOptions : public WorkDoneProgressOptions
{
public:
std::optional<bool> resolveProvider = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "resolveProvider", resolveProvider);
}
};
class Q_LANGUAGESERVER_EXPORT CodeLensParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
}
};
class Q_LANGUAGESERVER_EXPORT CodeLensRegistrationOptions : public TextDocumentRegistrationOptions,
public CodeLensOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
CodeLensOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT Color
{
public:
double red = { };
double green = { };
double blue = { };
double alpha = { };
template <typename W>
void walk(W &w)
{
field(w, "red", red);
field(w, "green", green);
field(w, "blue", blue);
field(w, "alpha", alpha);
}
};
class Q_LANGUAGESERVER_EXPORT ColorInformation
{
public:
Range range = { };
Color color = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "color", color);
}
};
class Q_LANGUAGESERVER_EXPORT ColorPresentation
{
public:
QByteArray label = { };
std::optional<TextEdit> textEdit = { };
std::optional<QList<TextEdit>> additionalTextEdits = { };
template <typename W>
void walk(W &w)
{
field(w, "label", label);
field(w, "textEdit", textEdit);
field(w, "additionalTextEdits", additionalTextEdits);
}
};
class Q_LANGUAGESERVER_EXPORT ColorPresentationParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
Color color = { };
Range range = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
field(w, "color", color);
field(w, "range", range);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionContext
{
public:
CompletionTriggerKind triggerKind = { };
std::optional<QByteArray> triggerCharacter = { };
template <typename W>
void walk(W &w)
{
field(w, "triggerKind", triggerKind);
field(w, "triggerCharacter", triggerCharacter);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionItemLabelDetails
{
public:
std::optional<QByteArray> detail = { };
std::optional<QByteArray> description = { };
template <typename W>
void walk(W &w)
{
field(w, "detail", detail);
field(w, "description", description);
}
};
class Q_LANGUAGESERVER_EXPORT InsertReplaceEdit
{
public:
QByteArray newText = { };
Range insert = { };
Range replace = { };
template <typename W>
void walk(W &w)
{
field(w, "newText", newText);
field(w, "insert", insert);
field(w, "replace", replace);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionItem
{
public:
QByteArray label = { };
std::optional<CompletionItemLabelDetails> labelDetails = { };
std::optional<CompletionItemKind> kind = { };
std::optional<QList<CompletionItemTag>> tags = { };
std::optional<QByteArray> detail = { };
std::optional<std::variant<QByteArray, MarkupContent>> documentation = { };
std::optional<bool> deprecated = { };
std::optional<bool> preselect = { };
std::optional<QByteArray> sortText = { };
std::optional<QByteArray> filterText = { };
std::optional<QByteArray> insertText = { };
std::optional<InsertTextFormat> insertTextFormat = { };
std::optional<InsertTextMode> insertTextMode = { };
std::optional<std::variant<TextEdit, InsertReplaceEdit>> textEdit = { };
std::optional<QByteArray> textEditText = { };
std::optional<QList<TextEdit>> additionalTextEdits = { };
std::optional<QList<QByteArray>> commitCharacters = { };
std::optional<Command> command = { };
std::optional<QJsonValue> data = { };
template <typename W>
void walk(W &w)
{
field(w, "label", label);
field(w, "labelDetails", labelDetails);
field(w, "kind", kind);
field(w, "tags", tags);
field(w, "detail", detail);
field(w, "documentation", documentation);
field(w, "deprecated", deprecated);
field(w, "preselect", preselect);
field(w, "sortText", sortText);
field(w, "filterText", filterText);
field(w, "insertText", insertText);
field(w, "insertTextFormat", insertTextFormat);
field(w, "insertTextMode", insertTextMode);
field(w, "textEdit", textEdit);
field(w, "textEditText", textEditText);
field(w, "additionalTextEdits", additionalTextEdits);
field(w, "commitCharacters", commitCharacters);
field(w, "command", command);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionItemApplyKinds
{
public:
std::optional<ApplyKind> commitCharacters = { };
std::optional<ApplyKind> data = { };
template <typename W>
void walk(W &w)
{
field(w, "commitCharacters", commitCharacters);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT EditRangeWithInsertReplace
{
public:
Range insert = { };
Range replace = { };
template <typename W>
void walk(W &w)
{
field(w, "insert", insert);
field(w, "replace", replace);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionItemDefaults
{
public:
std::optional<QList<QByteArray>> commitCharacters = { };
std::optional<std::variant<Range, EditRangeWithInsertReplace>> editRange = { };
std::optional<InsertTextFormat> insertTextFormat = { };
std::optional<InsertTextMode> insertTextMode = { };
std::optional<QJsonValue> data = { };
template <typename W>
void walk(W &w)
{
field(w, "commitCharacters", commitCharacters);
field(w, "editRange", editRange);
field(w, "insertTextFormat", insertTextFormat);
field(w, "insertTextMode", insertTextMode);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionList
{
public:
bool isIncomplete = { };
std::optional<CompletionItemDefaults> itemDefaults = { };
std::optional<CompletionItemApplyKinds> applyKind = { };
QList<CompletionItem> items = { };
template <typename W>
void walk(W &w)
{
field(w, "isIncomplete", isIncomplete);
field(w, "itemDefaults", itemDefaults);
field(w, "applyKind", applyKind);
field(w, "items", items);
}
};
class Q_LANGUAGESERVER_EXPORT ServerCompletionItemOptions
{
public:
std::optional<bool> labelDetailsSupport = { };
template <typename W>
void walk(W &w)
{
field(w, "labelDetailsSupport", labelDetailsSupport);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionOptions : public WorkDoneProgressOptions
{
public:
std::optional<QList<QByteArray>> triggerCharacters = { };
std::optional<QList<QByteArray>> allCommitCharacters = { };
std::optional<bool> resolveProvider = { };
std::optional<ServerCompletionItemOptions> completionItem = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "triggerCharacters", triggerCharacters);
field(w, "allCommitCharacters", allCommitCharacters);
field(w, "resolveProvider", resolveProvider);
field(w, "completionItem", completionItem);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionParams : public TextDocumentPositionParams,
public WorkDoneProgressParams,
public PartialResultParams
{
public:
std::optional<CompletionContext> context = { };
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "context", context);
}
};
class Q_LANGUAGESERVER_EXPORT CompletionRegistrationOptions
: public TextDocumentRegistrationOptions,
public CompletionOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
CompletionOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT ConfigurationItem
{
public:
std::optional<QByteArray> scopeUri = { };
std::optional<QByteArray> section = { };
template <typename W>
void walk(W &w)
{
field(w, "scopeUri", scopeUri);
field(w, "section", section);
}
};
class Q_LANGUAGESERVER_EXPORT ConfigurationParams
{
public:
QList<ConfigurationItem> items = { };
template <typename W>
void walk(W &w)
{
field(w, "items", items);
}
};
class Q_LANGUAGESERVER_EXPORT FileCreate
{
public:
QByteArray uri = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
}
};
class Q_LANGUAGESERVER_EXPORT CreateFilesParams
{
public:
QList<FileCreate> files = { };
template <typename W>
void walk(W &w)
{
field(w, "files", files);
}
};
using Declaration = std::variant<Location, QList<Location>>;
class Q_LANGUAGESERVER_EXPORT LocationLink
{
public:
std::optional<Range> originSelectionRange = { };
QByteArray targetUri = { };
Range targetRange = { };
Range targetSelectionRange = { };
template <typename W>
void walk(W &w)
{
field(w, "originSelectionRange", originSelectionRange);
field(w, "targetUri", targetUri);
field(w, "targetRange", targetRange);
field(w, "targetSelectionRange", targetSelectionRange);
}
};
using DeclarationLink = LocationLink;
class Q_LANGUAGESERVER_EXPORT DeclarationOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DeclarationParams : public TextDocumentPositionParams,
public WorkDoneProgressParams,
public PartialResultParams
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DeclarationRegistrationOptions
: public DeclarationOptions,
public TextDocumentRegistrationOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
DeclarationOptions::walk(w);
TextDocumentRegistrationOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
using Definition = std::variant<Location, QList<Location>>;
using DefinitionLink = LocationLink;
class Q_LANGUAGESERVER_EXPORT DefinitionOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DefinitionParams : public TextDocumentPositionParams,
public WorkDoneProgressParams,
public PartialResultParams
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DefinitionRegistrationOptions
: public TextDocumentRegistrationOptions,
public DefinitionOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
DefinitionOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT FileDelete
{
public:
QByteArray uri = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
}
};
class Q_LANGUAGESERVER_EXPORT DeleteFilesParams
{
public:
QList<FileDelete> files = { };
template <typename W>
void walk(W &w)
{
field(w, "files", files);
}
};
class Q_LANGUAGESERVER_EXPORT DiagnosticOptions : public WorkDoneProgressOptions
{
public:
std::optional<QByteArray> identifier = { };
bool interFileDependencies = { };
bool workspaceDiagnostics = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "identifier", identifier);
field(w, "interFileDependencies", interFileDependencies);
field(w, "workspaceDiagnostics", workspaceDiagnostics);
}
};
class Q_LANGUAGESERVER_EXPORT DiagnosticRegistrationOptions
: public TextDocumentRegistrationOptions,
public DiagnosticOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
DiagnosticOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DiagnosticServerCancellationData
{
public:
bool retriggerRequest = { };
template <typename W>
void walk(W &w)
{
field(w, "retriggerRequest", retriggerRequest);
}
};
class Q_LANGUAGESERVER_EXPORT DidChangeConfigurationParams
{
public:
QJsonValue settings = { };
template <typename W>
void walk(W &w)
{
field(w, "settings", settings);
}
};
class Q_LANGUAGESERVER_EXPORT DidChangeConfigurationRegistrationOptions
{
public:
std::optional<std::variant<QByteArray, QList<QByteArray>>> section = { };
template <typename W>
void walk(W &w)
{
field(w, "section", section);
}
};
class Q_LANGUAGESERVER_EXPORT VersionedNotebookDocumentIdentifier
{
public:
int version = { };
QByteArray uri = { };
template <typename W>
void walk(W &w)
{
field(w, "version", version);
field(w, "uri", uri);
}
};
class Q_LANGUAGESERVER_EXPORT ExecutionSummary
{
public:
unsigned int executionOrder = { };
std::optional<bool> success = { };
template <typename W>
void walk(W &w)
{
field(w, "executionOrder", executionOrder);
field(w, "success", success);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookCell
{
public:
NotebookCellKind kind = { };
QByteArray document = { };
std::optional<QJsonObject> metadata = { };
std::optional<ExecutionSummary> executionSummary = { };
template <typename W>
void walk(W &w)
{
field(w, "kind", kind);
field(w, "document", document);
field(w, "metadata", metadata);
field(w, "executionSummary", executionSummary);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookCellArrayChange
{
public:
unsigned int start = { };
unsigned int deleteCount = { };
std::optional<QList<NotebookCell>> cells = { };
template <typename W>
void walk(W &w)
{
field(w, "start", start);
field(w, "deleteCount", deleteCount);
field(w, "cells", cells);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentItem
{
public:
QByteArray uri = { };
LanguageKind languageId = { };
int version = { };
QByteArray text = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
field(w, "languageId", languageId);
field(w, "version", version);
field(w, "text", text);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentCellChangeStructure
{
public:
NotebookCellArrayChange array = { };
std::optional<QList<TextDocumentItem>> didOpen = { };
std::optional<QList<TextDocumentIdentifier>> didClose = { };
template <typename W>
void walk(W &w)
{
field(w, "array", array);
field(w, "didOpen", didOpen);
field(w, "didClose", didClose);
}
};
class Q_LANGUAGESERVER_EXPORT VersionedTextDocumentIdentifier : public TextDocumentIdentifier
{
public:
int version = { };
template <typename W>
void walk(W &w)
{
TextDocumentIdentifier::walk(w);
field(w, "version", version);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentContentChangePartial
{
public:
Range range = { };
std::optional<unsigned int> rangeLength = { };
QByteArray text = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "rangeLength", rangeLength);
field(w, "text", text);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentContentChangeWholeDocument
{
public:
QByteArray text = { };
template <typename W>
void walk(W &w)
{
field(w, "text", text);
}
};
using TextDocumentContentChangeEvent =
std::variant<TextDocumentContentChangePartial, TextDocumentContentChangeWholeDocument>;
class Q_LANGUAGESERVER_EXPORT NotebookDocumentCellContentChanges
{
public:
VersionedTextDocumentIdentifier document = { };
QList<TextDocumentContentChangeEvent> changes = { };
template <typename W>
void walk(W &w)
{
field(w, "document", document);
field(w, "changes", changes);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentCellChanges
{
public:
std::optional<NotebookDocumentCellChangeStructure> structure = { };
std::optional<QList<NotebookCell>> data = { };
std::optional<QList<NotebookDocumentCellContentChanges>> textContent = { };
template <typename W>
void walk(W &w)
{
field(w, "structure", structure);
field(w, "data", data);
field(w, "textContent", textContent);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentChangeEvent
{
public:
std::optional<QJsonObject> metadata = { };
std::optional<NotebookDocumentCellChanges> cells = { };
template <typename W>
void walk(W &w)
{
field(w, "metadata", metadata);
field(w, "cells", cells);
}
};
class Q_LANGUAGESERVER_EXPORT DidChangeNotebookDocumentParams
{
public:
VersionedNotebookDocumentIdentifier notebookDocument = { };
NotebookDocumentChangeEvent change = { };
template <typename W>
void walk(W &w)
{
field(w, "notebookDocument", notebookDocument);
field(w, "change", change);
}
};
class Q_LANGUAGESERVER_EXPORT DidChangeTextDocumentParams
{
public:
VersionedTextDocumentIdentifier textDocument = { };
QList<TextDocumentContentChangeEvent> contentChanges = { };
template <typename W>
void walk(W &w)
{
field(w, "textDocument", textDocument);
field(w, "contentChanges", contentChanges);
}
};
class Q_LANGUAGESERVER_EXPORT FileEvent
{
public:
QByteArray uri = { };
FileChangeType type = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
field(w, "type", type);
}
};
class Q_LANGUAGESERVER_EXPORT DidChangeWatchedFilesParams
{
public:
QList<FileEvent> changes = { };
template <typename W>
void walk(W &w)
{
field(w, "changes", changes);
}
};
class Q_LANGUAGESERVER_EXPORT FileSystemWatcher
{
public:
GlobPattern globPattern = { };
std::optional<WatchKind> kind = { };
template <typename W>
void walk(W &w)
{
field(w, "globPattern", globPattern);
field(w, "kind", kind);
}
};
class Q_LANGUAGESERVER_EXPORT DidChangeWatchedFilesRegistrationOptions
{
public:
QList<FileSystemWatcher> watchers = { };
template <typename W>
void walk(W &w)
{
field(w, "watchers", watchers);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceFoldersChangeEvent
{
public:
QList<WorkspaceFolder> added = { };
QList<WorkspaceFolder> removed = { };
template <typename W>
void walk(W &w)
{
field(w, "added", added);
field(w, "removed", removed);
}
};
class Q_LANGUAGESERVER_EXPORT DidChangeWorkspaceFoldersParams
{
public:
WorkspaceFoldersChangeEvent event = { };
template <typename W>
void walk(W &w)
{
field(w, "event", event);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentIdentifier
{
public:
QByteArray uri = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
}
};
class Q_LANGUAGESERVER_EXPORT DidCloseNotebookDocumentParams
{
public:
NotebookDocumentIdentifier notebookDocument = { };
QList<TextDocumentIdentifier> cellTextDocuments = { };
template <typename W>
void walk(W &w)
{
field(w, "notebookDocument", notebookDocument);
field(w, "cellTextDocuments", cellTextDocuments);
}
};
class Q_LANGUAGESERVER_EXPORT DidCloseTextDocumentParams
{
public:
TextDocumentIdentifier textDocument = { };
template <typename W>
void walk(W &w)
{
field(w, "textDocument", textDocument);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocument
{
public:
QByteArray uri = { };
QByteArray notebookType = { };
int version = { };
std::optional<QJsonObject> metadata = { };
QList<NotebookCell> cells = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
field(w, "notebookType", notebookType);
field(w, "version", version);
field(w, "metadata", metadata);
field(w, "cells", cells);
}
};
class Q_LANGUAGESERVER_EXPORT DidOpenNotebookDocumentParams
{
public:
NotebookDocument notebookDocument = { };
QList<TextDocumentItem> cellTextDocuments = { };
template <typename W>
void walk(W &w)
{
field(w, "notebookDocument", notebookDocument);
field(w, "cellTextDocuments", cellTextDocuments);
}
};
class Q_LANGUAGESERVER_EXPORT DidOpenTextDocumentParams
{
public:
TextDocumentItem textDocument = { };
template <typename W>
void walk(W &w)
{
field(w, "textDocument", textDocument);
}
};
class Q_LANGUAGESERVER_EXPORT DidSaveNotebookDocumentParams
{
public:
NotebookDocumentIdentifier notebookDocument = { };
template <typename W>
void walk(W &w)
{
field(w, "notebookDocument", notebookDocument);
}
};
class Q_LANGUAGESERVER_EXPORT DidSaveTextDocumentParams
{
public:
TextDocumentIdentifier textDocument = { };
std::optional<QByteArray> text = { };
template <typename W>
void walk(W &w)
{
field(w, "textDocument", textDocument);
field(w, "text", text);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentColorOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentColorParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentColorRegistrationOptions
: public TextDocumentRegistrationOptions,
public DocumentColorOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
DocumentColorOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentDiagnosticParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
std::optional<QByteArray> identifier = { };
std::optional<QByteArray> previousResultId = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
field(w, "identifier", identifier);
field(w, "previousResultId", previousResultId);
}
};
class Q_LANGUAGESERVER_EXPORT FullDocumentDiagnosticReport
{
public:
static constexpr QByteArrayView kind = "full";
std::optional<QByteArray> resultId = { };
QList<Diagnostic> items = { };
template <typename W>
void walk(W &w)
{
field(w, "kind", kind);
field(w, "resultId", resultId);
field(w, "items", items);
}
};
class Q_LANGUAGESERVER_EXPORT UnchangedDocumentDiagnosticReport
{
public:
static constexpr QByteArrayView kind = "unchanged";
QByteArray resultId = { };
template <typename W>
void walk(W &w)
{
field(w, "kind", kind);
field(w, "resultId", resultId);
}
};
class Q_LANGUAGESERVER_EXPORT RelatedFullDocumentDiagnosticReport
: public FullDocumentDiagnosticReport
{
public:
std::optional<
QMap<QByteArray,
std::variant<FullDocumentDiagnosticReport, UnchangedDocumentDiagnosticReport>>>
relatedDocuments = { };
template <typename W>
void walk(W &w)
{
FullDocumentDiagnosticReport::walk(w);
field(w, "relatedDocuments", relatedDocuments);
}
};
class Q_LANGUAGESERVER_EXPORT RelatedUnchangedDocumentDiagnosticReport
: public UnchangedDocumentDiagnosticReport
{
public:
std::optional<
QMap<QByteArray,
std::variant<FullDocumentDiagnosticReport, UnchangedDocumentDiagnosticReport>>>
relatedDocuments = { };
template <typename W>
void walk(W &w)
{
UnchangedDocumentDiagnosticReport::walk(w);
field(w, "relatedDocuments", relatedDocuments);
}
};
using DocumentDiagnosticReport =
std::variant<RelatedFullDocumentDiagnosticReport, RelatedUnchangedDocumentDiagnosticReport>;
class Q_LANGUAGESERVER_EXPORT DocumentDiagnosticReportPartialResult
{
public:
QMap<QByteArray, std::variant<FullDocumentDiagnosticReport, UnchangedDocumentDiagnosticReport>>
relatedDocuments = { };
template <typename W>
void walk(W &w)
{
field(w, "relatedDocuments", relatedDocuments);
}
};
using DocumentDiagnosticReportProgress =
std::variant<DocumentDiagnosticReport, DocumentDiagnosticReportPartialResult>;
class Q_LANGUAGESERVER_EXPORT DocumentFormattingOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT FormattingOptions
{
public:
unsigned int tabSize = { };
bool insertSpaces = { };
std::optional<bool> trimTrailingWhitespace = { };
std::optional<bool> insertFinalNewline = { };
std::optional<bool> trimFinalNewlines = { };
template <typename W>
void walk(W &w)
{
field(w, "tabSize", tabSize);
field(w, "insertSpaces", insertSpaces);
field(w, "trimTrailingWhitespace", trimTrailingWhitespace);
field(w, "insertFinalNewline", insertFinalNewline);
field(w, "trimFinalNewlines", trimFinalNewlines);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentFormattingParams : public WorkDoneProgressParams
{
public:
TextDocumentIdentifier textDocument = { };
FormattingOptions options = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
field(w, "textDocument", textDocument);
field(w, "options", options);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentFormattingRegistrationOptions
: public TextDocumentRegistrationOptions,
public DocumentFormattingOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
DocumentFormattingOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentHighlight
{
public:
Range range = { };
std::optional<DocumentHighlightKind> kind = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "kind", kind);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentHighlightOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentHighlightParams : public TextDocumentPositionParams,
public WorkDoneProgressParams,
public PartialResultParams
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentHighlightRegistrationOptions
: public TextDocumentRegistrationOptions,
public DocumentHighlightOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
DocumentHighlightOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentLink
{
public:
Range range = { };
std::optional<QByteArray> target = { };
std::optional<QByteArray> tooltip = { };
std::optional<QJsonValue> data = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "target", target);
field(w, "tooltip", tooltip);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentLinkOptions : public WorkDoneProgressOptions
{
public:
std::optional<bool> resolveProvider = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "resolveProvider", resolveProvider);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentLinkParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentLinkRegistrationOptions
: public TextDocumentRegistrationOptions,
public DocumentLinkOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
DocumentLinkOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentOnTypeFormattingOptions
{
public:
QByteArray firstTriggerCharacter = { };
std::optional<QList<QByteArray>> moreTriggerCharacter = { };
template <typename W>
void walk(W &w)
{
field(w, "firstTriggerCharacter", firstTriggerCharacter);
field(w, "moreTriggerCharacter", moreTriggerCharacter);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentOnTypeFormattingParams
{
public:
TextDocumentIdentifier textDocument = { };
Position position = { };
QByteArray ch = { };
FormattingOptions options = { };
template <typename W>
void walk(W &w)
{
field(w, "textDocument", textDocument);
field(w, "position", position);
field(w, "ch", ch);
field(w, "options", options);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentOnTypeFormattingRegistrationOptions
: public TextDocumentRegistrationOptions,
public DocumentOnTypeFormattingOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
DocumentOnTypeFormattingOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentRangeFormattingOptions : public WorkDoneProgressOptions
{
public:
std::optional<bool> rangesSupport = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "rangesSupport", rangesSupport);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentRangeFormattingParams : public WorkDoneProgressParams
{
public:
TextDocumentIdentifier textDocument = { };
Range range = { };
FormattingOptions options = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
field(w, "textDocument", textDocument);
field(w, "range", range);
field(w, "options", options);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentRangeFormattingRegistrationOptions
: public TextDocumentRegistrationOptions,
public DocumentRangeFormattingOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
DocumentRangeFormattingOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentRangesFormattingParams : public WorkDoneProgressParams
{
public:
TextDocumentIdentifier textDocument = { };
QList<Range> ranges = { };
FormattingOptions options = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
field(w, "textDocument", textDocument);
field(w, "ranges", ranges);
field(w, "options", options);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentSymbol
{
public:
QByteArray name = { };
std::optional<QByteArray> detail = { };
SymbolKind kind = { };
std::optional<QList<SymbolTag>> tags = { };
std::optional<bool> deprecated = { };
Range range = { };
Range selectionRange = { };
std::optional<QList<DocumentSymbol>> children = { };
template <typename W>
void walk(W &w)
{
field(w, "name", name);
field(w, "detail", detail);
field(w, "kind", kind);
field(w, "tags", tags);
field(w, "deprecated", deprecated);
field(w, "range", range);
field(w, "selectionRange", selectionRange);
field(w, "children", children);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentSymbolOptions : public WorkDoneProgressOptions
{
public:
std::optional<QByteArray> label = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "label", label);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentSymbolParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
}
};
class Q_LANGUAGESERVER_EXPORT DocumentSymbolRegistrationOptions
: public TextDocumentRegistrationOptions,
public DocumentSymbolOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
DocumentSymbolOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT ExecuteCommandOptions : public WorkDoneProgressOptions
{
public:
QList<QByteArray> commands = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "commands", commands);
}
};
class Q_LANGUAGESERVER_EXPORT ExecuteCommandParams : public WorkDoneProgressParams
{
public:
QByteArray command = { };
std::optional<QList<QJsonValue>> arguments = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
field(w, "command", command);
field(w, "arguments", arguments);
}
};
class Q_LANGUAGESERVER_EXPORT ExecuteCommandRegistrationOptions : public ExecuteCommandOptions
{
public:
template <typename W>
void walk(W &w)
{
ExecuteCommandOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT FileOperationPatternOptions
{
public:
std::optional<bool> ignoreCase = { };
template <typename W>
void walk(W &w)
{
field(w, "ignoreCase", ignoreCase);
}
};
class Q_LANGUAGESERVER_EXPORT FileOperationPattern
{
public:
QByteArray glob = { };
std::optional<FileOperationPatternKind> matches = { };
std::optional<FileOperationPatternOptions> options = { };
template <typename W>
void walk(W &w)
{
field(w, "glob", glob);
field(w, "matches", matches);
field(w, "options", options);
}
};
class Q_LANGUAGESERVER_EXPORT FileOperationFilter
{
public:
std::optional<QByteArray> scheme = { };
FileOperationPattern pattern = { };
template <typename W>
void walk(W &w)
{
field(w, "scheme", scheme);
field(w, "pattern", pattern);
}
};
class Q_LANGUAGESERVER_EXPORT FileOperationRegistrationOptions
{
public:
QList<FileOperationFilter> filters = { };
template <typename W>
void walk(W &w)
{
field(w, "filters", filters);
}
};
class Q_LANGUAGESERVER_EXPORT FileOperationOptions
{
public:
std::optional<FileOperationRegistrationOptions> didCreate = { };
std::optional<FileOperationRegistrationOptions> willCreate = { };
std::optional<FileOperationRegistrationOptions> didRename = { };
std::optional<FileOperationRegistrationOptions> willRename = { };
std::optional<FileOperationRegistrationOptions> didDelete = { };
std::optional<FileOperationRegistrationOptions> willDelete = { };
template <typename W>
void walk(W &w)
{
field(w, "didCreate", didCreate);
field(w, "willCreate", willCreate);
field(w, "didRename", didRename);
field(w, "willRename", willRename);
field(w, "didDelete", didDelete);
field(w, "willDelete", willDelete);
}
};
class Q_LANGUAGESERVER_EXPORT FileRename
{
public:
QByteArray oldUri = { };
QByteArray newUri = { };
template <typename W>
void walk(W &w)
{
field(w, "oldUri", oldUri);
field(w, "newUri", newUri);
}
};
class Q_LANGUAGESERVER_EXPORT FoldingRange
{
public:
unsigned int startLine = { };
std::optional<unsigned int> startCharacter = { };
unsigned int endLine = { };
std::optional<unsigned int> endCharacter = { };
std::optional<FoldingRangeKind> kind = { };
std::optional<QByteArray> collapsedText = { };
template <typename W>
void walk(W &w)
{
field(w, "startLine", startLine);
field(w, "startCharacter", startCharacter);
field(w, "endLine", endLine);
field(w, "endCharacter", endCharacter);
field(w, "kind", kind);
field(w, "collapsedText", collapsedText);
}
};
class Q_LANGUAGESERVER_EXPORT FoldingRangeOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT FoldingRangeParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
}
};
class Q_LANGUAGESERVER_EXPORT FoldingRangeRegistrationOptions
: public TextDocumentRegistrationOptions,
public FoldingRangeOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
FoldingRangeOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT Hover
{
public:
std::variant<MarkupContent, MarkedString, QList<MarkedString>> contents = { };
std::optional<Range> range = { };
template <typename W>
void walk(W &w)
{
field(w, "contents", contents);
field(w, "range", range);
}
};
class Q_LANGUAGESERVER_EXPORT HoverOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT HoverParams : public TextDocumentPositionParams,
public WorkDoneProgressParams
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT HoverRegistrationOptions : public TextDocumentRegistrationOptions,
public HoverOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
HoverOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT ImplementationOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT ImplementationParams : public TextDocumentPositionParams,
public WorkDoneProgressParams,
public PartialResultParams
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT ImplementationRegistrationOptions
: public TextDocumentRegistrationOptions,
public ImplementationOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
ImplementationOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT InitializeError
{
public:
bool retry = { };
template <typename W>
void walk(W &w)
{
field(w, "retry", retry);
}
};
class Q_LANGUAGESERVER_EXPORT _InitializeParams : public WorkDoneProgressParams
{
public:
std::variant<std::nullptr_t, int> processId = { };
std::optional<ClientInfo> clientInfo = { };
std::optional<QByteArray> locale = { };
std::optional<std::variant<std::nullptr_t, QByteArray>> rootPath = { };
std::variant<std::nullptr_t, QByteArray> rootUri = { };
ClientCapabilities capabilities = { };
std::optional<QJsonValue> initializationOptions = { };
std::optional<TraceValue> trace = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
field(w, "processId", processId);
field(w, "clientInfo", clientInfo);
field(w, "locale", locale);
field(w, "rootPath", rootPath);
field(w, "rootUri", rootUri);
field(w, "capabilities", capabilities);
field(w, "initializationOptions", initializationOptions);
field(w, "trace", trace);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceFoldersInitializeParams
{
public:
std::optional<std::variant<std::nullptr_t, QList<WorkspaceFolder>>> workspaceFolders = { };
template <typename W>
void walk(W &w)
{
field(w, "workspaceFolders", workspaceFolders);
}
};
class Q_LANGUAGESERVER_EXPORT InitializeParams : public _InitializeParams,
public WorkspaceFoldersInitializeParams
{
public:
template <typename W>
void walk(W &w)
{
_InitializeParams::walk(w);
WorkspaceFoldersInitializeParams::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT SaveOptions
{
public:
std::optional<bool> includeText = { };
template <typename W>
void walk(W &w)
{
field(w, "includeText", includeText);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentSyncOptions
{
public:
std::optional<bool> openClose = { };
std::optional<TextDocumentSyncKind> change = { };
std::optional<bool> willSave = { };
std::optional<bool> willSaveWaitUntil = { };
std::optional<std::variant<bool, SaveOptions>> save = { };
template <typename W>
void walk(W &w)
{
field(w, "openClose", openClose);
field(w, "change", change);
field(w, "willSave", willSave);
field(w, "willSaveWaitUntil", willSaveWaitUntil);
field(w, "save", save);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookCellLanguage
{
public:
QByteArray language = { };
template <typename W>
void walk(W &w)
{
field(w, "language", language);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentFilterWithNotebook
{
public:
std::variant<QByteArray, NotebookDocumentFilter> notebook = { };
std::optional<QList<NotebookCellLanguage>> cells = { };
template <typename W>
void walk(W &w)
{
field(w, "notebook", notebook);
field(w, "cells", cells);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentFilterWithCells
{
public:
std::optional<std::variant<QByteArray, NotebookDocumentFilter>> notebook = { };
QList<NotebookCellLanguage> cells = { };
template <typename W>
void walk(W &w)
{
field(w, "notebook", notebook);
field(w, "cells", cells);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentSyncOptions
{
public:
QList<std::variant<NotebookDocumentFilterWithNotebook, NotebookDocumentFilterWithCells>>
notebookSelector = { };
std::optional<bool> save = { };
template <typename W>
void walk(W &w)
{
field(w, "notebookSelector", notebookSelector);
field(w, "save", save);
}
};
class Q_LANGUAGESERVER_EXPORT NotebookDocumentSyncRegistrationOptions
: public NotebookDocumentSyncOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
NotebookDocumentSyncOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT SignatureHelpOptions : public WorkDoneProgressOptions
{
public:
std::optional<QList<QByteArray>> triggerCharacters = { };
std::optional<QList<QByteArray>> retriggerCharacters = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "triggerCharacters", triggerCharacters);
field(w, "retriggerCharacters", retriggerCharacters);
}
};
class Q_LANGUAGESERVER_EXPORT TypeDefinitionOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT TypeDefinitionRegistrationOptions
: public TextDocumentRegistrationOptions,
public TypeDefinitionOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
TypeDefinitionOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT ReferenceOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceSymbolOptions : public WorkDoneProgressOptions
{
public:
std::optional<bool> resolveProvider = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "resolveProvider", resolveProvider);
}
};
class Q_LANGUAGESERVER_EXPORT RenameOptions : public WorkDoneProgressOptions
{
public:
std::optional<bool> prepareProvider = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "prepareProvider", prepareProvider);
}
};
class Q_LANGUAGESERVER_EXPORT SelectionRangeOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT SelectionRangeRegistrationOptions
: public SelectionRangeOptions,
public TextDocumentRegistrationOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
SelectionRangeOptions::walk(w);
TextDocumentRegistrationOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT LinkedEditingRangeOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT LinkedEditingRangeRegistrationOptions
: public TextDocumentRegistrationOptions,
public LinkedEditingRangeOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
LinkedEditingRangeOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensLegend
{
public:
QList<QByteArray> tokenTypes = { };
QList<QByteArray> tokenModifiers = { };
template <typename W>
void walk(W &w)
{
field(w, "tokenTypes", tokenTypes);
field(w, "tokenModifiers", tokenModifiers);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensFullDelta
{
public:
std::optional<bool> delta = { };
template <typename W>
void walk(W &w)
{
field(w, "delta", delta);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensOptions : public WorkDoneProgressOptions
{
public:
SemanticTokensLegend legend = { };
std::optional<std::variant<bool, QJsonObject>> range = { };
std::optional<std::variant<bool, SemanticTokensFullDelta>> full = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "legend", legend);
field(w, "range", range);
field(w, "full", full);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensRegistrationOptions
: public TextDocumentRegistrationOptions,
public SemanticTokensOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
SemanticTokensOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT MonikerOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT MonikerRegistrationOptions : public TextDocumentRegistrationOptions,
public MonikerOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
MonikerOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT TypeHierarchyOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT TypeHierarchyRegistrationOptions
: public TextDocumentRegistrationOptions,
public TypeHierarchyOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
TypeHierarchyOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT InlineValueOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT InlineValueRegistrationOptions
: public InlineValueOptions,
public TextDocumentRegistrationOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
InlineValueOptions::walk(w);
TextDocumentRegistrationOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT InlayHintOptions : public WorkDoneProgressOptions
{
public:
std::optional<bool> resolveProvider = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
field(w, "resolveProvider", resolveProvider);
}
};
class Q_LANGUAGESERVER_EXPORT InlayHintRegistrationOptions : public InlayHintOptions,
public TextDocumentRegistrationOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
InlayHintOptions::walk(w);
TextDocumentRegistrationOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT InlineCompletionOptions : public WorkDoneProgressOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkDoneProgressOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceFoldersServerCapabilities
{
public:
std::optional<bool> supported = { };
std::optional<std::variant<QByteArray, bool>> changeNotifications = { };
template <typename W>
void walk(W &w)
{
field(w, "supported", supported);
field(w, "changeNotifications", changeNotifications);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentContentOptions
{
public:
QList<QByteArray> schemes = { };
template <typename W>
void walk(W &w)
{
field(w, "schemes", schemes);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentContentRegistrationOptions
: public TextDocumentContentOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentContentOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceOptions
{
public:
std::optional<WorkspaceFoldersServerCapabilities> workspaceFolders = { };
std::optional<FileOperationOptions> fileOperations = { };
std::optional<std::variant<TextDocumentContentOptions, TextDocumentContentRegistrationOptions>>
textDocumentContent = { };
template <typename W>
void walk(W &w)
{
field(w, "workspaceFolders", workspaceFolders);
field(w, "fileOperations", fileOperations);
field(w, "textDocumentContent", textDocumentContent);
}
};
class Q_LANGUAGESERVER_EXPORT ServerCapabilities
{
public:
std::optional<PositionEncodingKind> positionEncoding = { };
std::optional<std::variant<TextDocumentSyncOptions, TextDocumentSyncKind>>
textDocumentSync = { };
std::optional<
std::variant<NotebookDocumentSyncOptions, NotebookDocumentSyncRegistrationOptions>>
notebookDocumentSync = { };
std::optional<CompletionOptions> completionProvider = { };
std::optional<std::variant<bool, HoverOptions>> hoverProvider = { };
std::optional<SignatureHelpOptions> signatureHelpProvider = { };
std::optional<std::variant<bool, DeclarationOptions, DeclarationRegistrationOptions>>
declarationProvider = { };
std::optional<std::variant<bool, DefinitionOptions>> definitionProvider = { };
std::optional<std::variant<bool, TypeDefinitionOptions, TypeDefinitionRegistrationOptions>>
typeDefinitionProvider = { };
std::optional<std::variant<bool, ImplementationOptions, ImplementationRegistrationOptions>>
implementationProvider = { };
std::optional<std::variant<bool, ReferenceOptions>> referencesProvider = { };
std::optional<std::variant<bool, DocumentHighlightOptions>> documentHighlightProvider = { };
std::optional<std::variant<bool, DocumentSymbolOptions>> documentSymbolProvider = { };
std::optional<std::variant<bool, CodeActionOptions>> codeActionProvider = { };
std::optional<CodeLensOptions> codeLensProvider = { };
std::optional<DocumentLinkOptions> documentLinkProvider = { };
std::optional<std::variant<bool, DocumentColorOptions, DocumentColorRegistrationOptions>>
colorProvider = { };
std::optional<std::variant<bool, WorkspaceSymbolOptions>> workspaceSymbolProvider = { };
std::optional<std::variant<bool, DocumentFormattingOptions>> documentFormattingProvider = { };
std::optional<std::variant<bool, DocumentRangeFormattingOptions>>
documentRangeFormattingProvider = { };
std::optional<DocumentOnTypeFormattingOptions> documentOnTypeFormattingProvider = { };
std::optional<std::variant<bool, RenameOptions>> renameProvider = { };
std::optional<std::variant<bool, FoldingRangeOptions, FoldingRangeRegistrationOptions>>
foldingRangeProvider = { };
std::optional<std::variant<bool, SelectionRangeOptions, SelectionRangeRegistrationOptions>>
selectionRangeProvider = { };
std::optional<ExecuteCommandOptions> executeCommandProvider = { };
std::optional<std::variant<bool, CallHierarchyOptions, CallHierarchyRegistrationOptions>>
callHierarchyProvider = { };
std::optional<
std::variant<bool, LinkedEditingRangeOptions, LinkedEditingRangeRegistrationOptions>>
linkedEditingRangeProvider = { };
std::optional<std::variant<SemanticTokensOptions, SemanticTokensRegistrationOptions>>
semanticTokensProvider = { };
std::optional<std::variant<bool, MonikerOptions, MonikerRegistrationOptions>>
monikerProvider = { };
std::optional<std::variant<bool, TypeHierarchyOptions, TypeHierarchyRegistrationOptions>>
typeHierarchyProvider = { };
std::optional<std::variant<bool, InlineValueOptions, InlineValueRegistrationOptions>>
inlineValueProvider = { };
std::optional<std::variant<bool, InlayHintOptions, InlayHintRegistrationOptions>>
inlayHintProvider = { };
std::optional<std::variant<DiagnosticOptions, DiagnosticRegistrationOptions>>
diagnosticProvider = { };
std::optional<std::variant<bool, InlineCompletionOptions>> inlineCompletionProvider = { };
std::optional<WorkspaceOptions> workspace = { };
std::optional<QJsonValue> experimental = { };
template <typename W>
void walk(W &w)
{
field(w, "positionEncoding", positionEncoding);
field(w, "textDocumentSync", textDocumentSync);
field(w, "notebookDocumentSync", notebookDocumentSync);
field(w, "completionProvider", completionProvider);
field(w, "hoverProvider", hoverProvider);
field(w, "signatureHelpProvider", signatureHelpProvider);
field(w, "declarationProvider", declarationProvider);
field(w, "definitionProvider", definitionProvider);
field(w, "typeDefinitionProvider", typeDefinitionProvider);
field(w, "implementationProvider", implementationProvider);
field(w, "referencesProvider", referencesProvider);
field(w, "documentHighlightProvider", documentHighlightProvider);
field(w, "documentSymbolProvider", documentSymbolProvider);
field(w, "codeActionProvider", codeActionProvider);
field(w, "codeLensProvider", codeLensProvider);
field(w, "documentLinkProvider", documentLinkProvider);
field(w, "colorProvider", colorProvider);
field(w, "workspaceSymbolProvider", workspaceSymbolProvider);
field(w, "documentFormattingProvider", documentFormattingProvider);
field(w, "documentRangeFormattingProvider", documentRangeFormattingProvider);
field(w, "documentOnTypeFormattingProvider", documentOnTypeFormattingProvider);
field(w, "renameProvider", renameProvider);
field(w, "foldingRangeProvider", foldingRangeProvider);
field(w, "selectionRangeProvider", selectionRangeProvider);
field(w, "executeCommandProvider", executeCommandProvider);
field(w, "callHierarchyProvider", callHierarchyProvider);
field(w, "linkedEditingRangeProvider", linkedEditingRangeProvider);
field(w, "semanticTokensProvider", semanticTokensProvider);
field(w, "monikerProvider", monikerProvider);
field(w, "typeHierarchyProvider", typeHierarchyProvider);
field(w, "inlineValueProvider", inlineValueProvider);
field(w, "inlayHintProvider", inlayHintProvider);
field(w, "diagnosticProvider", diagnosticProvider);
field(w, "inlineCompletionProvider", inlineCompletionProvider);
field(w, "workspace", workspace);
field(w, "experimental", experimental);
}
};
class Q_LANGUAGESERVER_EXPORT ServerInfo
{
public:
QByteArray name = { };
std::optional<QByteArray> version = { };
template <typename W>
void walk(W &w)
{
field(w, "name", name);
field(w, "version", version);
}
};
class Q_LANGUAGESERVER_EXPORT InitializeResult
{
public:
ServerCapabilities capabilities = { };
std::optional<ServerInfo> serverInfo = { };
template <typename W>
void walk(W &w)
{
field(w, "capabilities", capabilities);
field(w, "serverInfo", serverInfo);
}
};
class Q_LANGUAGESERVER_EXPORT InitializedParams
{
public:
template <typename W>
void walk(W &)
{
}
};
class Q_LANGUAGESERVER_EXPORT InlayHintLabelPart
{
public:
QByteArray value = { };
std::optional<std::variant<QByteArray, MarkupContent>> tooltip = { };
std::optional<Location> location = { };
std::optional<Command> command = { };
template <typename W>
void walk(W &w)
{
field(w, "value", value);
field(w, "tooltip", tooltip);
field(w, "location", location);
field(w, "command", command);
}
};
class Q_LANGUAGESERVER_EXPORT InlayHint
{
public:
Position position = { };
std::variant<QByteArray, QList<InlayHintLabelPart>> label = { };
std::optional<InlayHintKind> kind = { };
std::optional<QList<TextEdit>> textEdits = { };
std::optional<std::variant<QByteArray, MarkupContent>> tooltip = { };
std::optional<bool> paddingLeft = { };
std::optional<bool> paddingRight = { };
std::optional<QJsonValue> data = { };
template <typename W>
void walk(W &w)
{
field(w, "position", position);
field(w, "label", label);
field(w, "kind", kind);
field(w, "textEdits", textEdits);
field(w, "tooltip", tooltip);
field(w, "paddingLeft", paddingLeft);
field(w, "paddingRight", paddingRight);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT InlayHintParams : public WorkDoneProgressParams
{
public:
TextDocumentIdentifier textDocument = { };
Range range = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
field(w, "textDocument", textDocument);
field(w, "range", range);
}
};
class Q_LANGUAGESERVER_EXPORT SelectedCompletionInfo
{
public:
Range range = { };
QByteArray text = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "text", text);
}
};
class Q_LANGUAGESERVER_EXPORT InlineCompletionContext
{
public:
InlineCompletionTriggerKind triggerKind = { };
std::optional<SelectedCompletionInfo> selectedCompletionInfo = { };
template <typename W>
void walk(W &w)
{
field(w, "triggerKind", triggerKind);
field(w, "selectedCompletionInfo", selectedCompletionInfo);
}
};
class Q_LANGUAGESERVER_EXPORT InlineCompletionItem
{
public:
std::variant<QByteArray, StringValue> insertText = { };
std::optional<QByteArray> filterText = { };
std::optional<Range> range = { };
std::optional<Command> command = { };
template <typename W>
void walk(W &w)
{
field(w, "insertText", insertText);
field(w, "filterText", filterText);
field(w, "range", range);
field(w, "command", command);
}
};
class Q_LANGUAGESERVER_EXPORT InlineCompletionList
{
public:
QList<InlineCompletionItem> items = { };
template <typename W>
void walk(W &w)
{
field(w, "items", items);
}
};
class Q_LANGUAGESERVER_EXPORT InlineCompletionParams : public TextDocumentPositionParams,
public WorkDoneProgressParams
{
public:
InlineCompletionContext context = { };
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
field(w, "context", context);
}
};
class Q_LANGUAGESERVER_EXPORT InlineCompletionRegistrationOptions
: public InlineCompletionOptions,
public TextDocumentRegistrationOptions,
public StaticRegistrationOptions
{
public:
template <typename W>
void walk(W &w)
{
InlineCompletionOptions::walk(w);
TextDocumentRegistrationOptions::walk(w);
StaticRegistrationOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT InlineValueText
{
public:
Range range = { };
QByteArray text = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "text", text);
}
};
class Q_LANGUAGESERVER_EXPORT InlineValueVariableLookup
{
public:
Range range = { };
std::optional<QByteArray> variableName = { };
bool caseSensitiveLookup = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "variableName", variableName);
field(w, "caseSensitiveLookup", caseSensitiveLookup);
}
};
class Q_LANGUAGESERVER_EXPORT InlineValueEvaluatableExpression
{
public:
Range range = { };
std::optional<QByteArray> expression = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "expression", expression);
}
};
using InlineValue =
std::variant<InlineValueText, InlineValueVariableLookup, InlineValueEvaluatableExpression>;
class Q_LANGUAGESERVER_EXPORT InlineValueContext
{
public:
int frameId = { };
Range stoppedLocation = { };
template <typename W>
void walk(W &w)
{
field(w, "frameId", frameId);
field(w, "stoppedLocation", stoppedLocation);
}
};
class Q_LANGUAGESERVER_EXPORT InlineValueParams : public WorkDoneProgressParams
{
public:
TextDocumentIdentifier textDocument = { };
Range range = { };
InlineValueContext context = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
field(w, "textDocument", textDocument);
field(w, "range", range);
field(w, "context", context);
}
};
class Q_LANGUAGESERVER_EXPORT LinkedEditingRangeParams : public TextDocumentPositionParams,
public WorkDoneProgressParams
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT LinkedEditingRanges
{
public:
QList<Range> ranges = { };
std::optional<QByteArray> wordPattern = { };
template <typename W>
void walk(W &w)
{
field(w, "ranges", ranges);
field(w, "wordPattern", wordPattern);
}
};
class Q_LANGUAGESERVER_EXPORT LocationUriOnly
{
public:
QByteArray uri = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
}
};
class Q_LANGUAGESERVER_EXPORT LogMessageParams
{
public:
MessageType type = { };
QByteArray message = { };
template <typename W>
void walk(W &w)
{
field(w, "type", type);
field(w, "message", message);
}
};
class Q_LANGUAGESERVER_EXPORT LogTraceParams
{
public:
QByteArray message = { };
std::optional<QByteArray> verbose = { };
template <typename W>
void walk(W &w)
{
field(w, "message", message);
field(w, "verbose", verbose);
}
};
class Q_LANGUAGESERVER_EXPORT MarkedStringWithLanguage
{
public:
QByteArray language = { };
QByteArray value = { };
template <typename W>
void walk(W &w)
{
field(w, "language", language);
field(w, "value", value);
}
};
class Q_LANGUAGESERVER_EXPORT MessageActionItem
{
public:
QByteArray title = { };
template <typename W>
void walk(W &w)
{
field(w, "title", title);
}
};
class Q_LANGUAGESERVER_EXPORT Moniker
{
public:
QByteArray scheme = { };
QByteArray identifier = { };
UniquenessLevel unique = { };
std::optional<MonikerKind> kind = { };
template <typename W>
void walk(W &w)
{
field(w, "scheme", scheme);
field(w, "identifier", identifier);
field(w, "unique", unique);
field(w, "kind", kind);
}
};
class Q_LANGUAGESERVER_EXPORT MonikerParams : public TextDocumentPositionParams,
public WorkDoneProgressParams,
public PartialResultParams
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT ParameterInformation
{
public:
std::variant<QByteArray, std::tuple<unsigned int, unsigned int>> label = { };
std::optional<std::variant<QByteArray, MarkupContent>> documentation = { };
template <typename W>
void walk(W &w)
{
field(w, "label", label);
field(w, "documentation", documentation);
}
};
class Q_LANGUAGESERVER_EXPORT PrepareRenameDefaultBehavior
{
public:
bool defaultBehavior = { };
template <typename W>
void walk(W &w)
{
field(w, "defaultBehavior", defaultBehavior);
}
};
class Q_LANGUAGESERVER_EXPORT PrepareRenameParams : public TextDocumentPositionParams,
public WorkDoneProgressParams
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT PrepareRenamePlaceholder
{
public:
Range range = { };
QByteArray placeholder = { };
template <typename W>
void walk(W &w)
{
field(w, "range", range);
field(w, "placeholder", placeholder);
}
};
using PrepareRenameResult =
std::variant<Range, PrepareRenamePlaceholder, PrepareRenameDefaultBehavior>;
class Q_LANGUAGESERVER_EXPORT PreviousResultId
{
public:
QByteArray uri = { };
QByteArray value = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
field(w, "value", value);
}
};
class Q_LANGUAGESERVER_EXPORT WorkDoneProgressBegin
{
public:
static constexpr QByteArrayView kind = "begin";
QByteArray title = { };
std::optional<bool> cancellable = { };
std::optional<QByteArray> message = { };
std::optional<unsigned int> percentage = { };
template <typename W>
void walk(W &w)
{
field(w, "kind", kind);
field(w, "title", title);
field(w, "cancellable", cancellable);
field(w, "message", message);
field(w, "percentage", percentage);
}
};
class Q_LANGUAGESERVER_EXPORT WorkDoneProgressReport
{
public:
static constexpr QByteArrayView kind = "report";
std::optional<bool> cancellable = { };
std::optional<QByteArray> message = { };
std::optional<unsigned int> percentage = { };
template <typename W>
void walk(W &w)
{
field(w, "kind", kind);
field(w, "cancellable", cancellable);
field(w, "message", message);
field(w, "percentage", percentage);
}
};
class Q_LANGUAGESERVER_EXPORT WorkDoneProgressEnd
{
public:
static constexpr QByteArrayView kind = "end";
std::optional<QByteArray> message = { };
template <typename W>
void walk(W &w)
{
field(w, "kind", kind);
field(w, "message", message);
}
};
class Q_LANGUAGESERVER_EXPORT ProgressParams
{
public:
ProgressToken token = { };
std::variant<WorkDoneProgressBegin, WorkDoneProgressReport, WorkDoneProgressEnd> value = { };
template <typename W>
void walk(W &w)
{
field(w, "token", token);
field(w, "value", value);
}
};
class Q_LANGUAGESERVER_EXPORT PublishDiagnosticsParams
{
public:
QByteArray uri = { };
std::optional<int> version = { };
QList<Diagnostic> diagnostics = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
field(w, "version", version);
field(w, "diagnostics", diagnostics);
}
};
class Q_LANGUAGESERVER_EXPORT ReferenceContext
{
public:
bool includeDeclaration = { };
template <typename W>
void walk(W &w)
{
field(w, "includeDeclaration", includeDeclaration);
}
};
class Q_LANGUAGESERVER_EXPORT ReferenceParams : public TextDocumentPositionParams,
public WorkDoneProgressParams,
public PartialResultParams
{
public:
ReferenceContext context = { };
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "context", context);
}
};
class Q_LANGUAGESERVER_EXPORT ReferenceRegistrationOptions : public TextDocumentRegistrationOptions,
public ReferenceOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
ReferenceOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT Registration
{
public:
QByteArray id = { };
QByteArray method = { };
std::optional<QJsonValue> registerOptions = { };
template <typename W>
void walk(W &w)
{
field(w, "id", id);
field(w, "method", method);
field(w, "registerOptions", registerOptions);
}
};
class Q_LANGUAGESERVER_EXPORT RegistrationParams
{
public:
QList<Registration> registrations = { };
template <typename W>
void walk(W &w)
{
field(w, "registrations", registrations);
}
};
class Q_LANGUAGESERVER_EXPORT RenameFilesParams
{
public:
QList<FileRename> files = { };
template <typename W>
void walk(W &w)
{
field(w, "files", files);
}
};
class Q_LANGUAGESERVER_EXPORT RenameParams : public TextDocumentPositionParams,
public WorkDoneProgressParams
{
public:
QByteArray newName = { };
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
field(w, "newName", newName);
}
};
class Q_LANGUAGESERVER_EXPORT RenameRegistrationOptions : public TextDocumentRegistrationOptions,
public RenameOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
RenameOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT SelectionRangeParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
QList<Position> positions = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
field(w, "positions", positions);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokens
{
public:
std::optional<QByteArray> resultId = { };
QList<unsigned int> data = { };
template <typename W>
void walk(W &w)
{
field(w, "resultId", resultId);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensEdit
{
public:
unsigned int start = { };
unsigned int deleteCount = { };
std::optional<QList<unsigned int>> data = { };
template <typename W>
void walk(W &w)
{
field(w, "start", start);
field(w, "deleteCount", deleteCount);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensDelta
{
public:
std::optional<QByteArray> resultId = { };
QList<SemanticTokensEdit> edits = { };
template <typename W>
void walk(W &w)
{
field(w, "resultId", resultId);
field(w, "edits", edits);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensDeltaParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
QByteArray previousResultId = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
field(w, "previousResultId", previousResultId);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensDeltaPartialResult
{
public:
QList<SemanticTokensEdit> edits = { };
template <typename W>
void walk(W &w)
{
field(w, "edits", edits);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensPartialResult
{
public:
QList<unsigned int> data = { };
template <typename W>
void walk(W &w)
{
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT SemanticTokensRangeParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TextDocumentIdentifier textDocument = { };
Range range = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "textDocument", textDocument);
field(w, "range", range);
}
};
class Q_LANGUAGESERVER_EXPORT SetTraceParams
{
public:
TraceValue value = { };
template <typename W>
void walk(W &w)
{
field(w, "value", value);
}
};
class Q_LANGUAGESERVER_EXPORT ShowDocumentParams
{
public:
QByteArray uri = { };
std::optional<bool> external = { };
std::optional<bool> takeFocus = { };
std::optional<Range> selection = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
field(w, "external", external);
field(w, "takeFocus", takeFocus);
field(w, "selection", selection);
}
};
class Q_LANGUAGESERVER_EXPORT ShowDocumentResult
{
public:
bool success = { };
template <typename W>
void walk(W &w)
{
field(w, "success", success);
}
};
class Q_LANGUAGESERVER_EXPORT ShowMessageParams
{
public:
MessageType type = { };
QByteArray message = { };
template <typename W>
void walk(W &w)
{
field(w, "type", type);
field(w, "message", message);
}
};
class Q_LANGUAGESERVER_EXPORT ShowMessageRequestParams
{
public:
MessageType type = { };
QByteArray message = { };
std::optional<QList<MessageActionItem>> actions = { };
template <typename W>
void walk(W &w)
{
field(w, "type", type);
field(w, "message", message);
field(w, "actions", actions);
}
};
class Q_LANGUAGESERVER_EXPORT SignatureInformation
{
public:
QByteArray label = { };
std::optional<std::variant<QByteArray, MarkupContent>> documentation = { };
std::optional<QList<ParameterInformation>> parameters = { };
std::optional<std::variant<std::nullptr_t, unsigned int>> activeParameter = { };
template <typename W>
void walk(W &w)
{
field(w, "label", label);
field(w, "documentation", documentation);
field(w, "parameters", parameters);
field(w, "activeParameter", activeParameter);
}
};
class Q_LANGUAGESERVER_EXPORT SignatureHelp
{
public:
QList<SignatureInformation> signatures = { };
std::optional<unsigned int> activeSignature = { };
std::optional<std::variant<std::nullptr_t, unsigned int>> activeParameter = { };
template <typename W>
void walk(W &w)
{
field(w, "signatures", signatures);
field(w, "activeSignature", activeSignature);
field(w, "activeParameter", activeParameter);
}
};
class Q_LANGUAGESERVER_EXPORT SignatureHelpContext
{
public:
SignatureHelpTriggerKind triggerKind = { };
std::optional<QByteArray> triggerCharacter = { };
bool isRetrigger = { };
std::optional<SignatureHelp> activeSignatureHelp = { };
template <typename W>
void walk(W &w)
{
field(w, "triggerKind", triggerKind);
field(w, "triggerCharacter", triggerCharacter);
field(w, "isRetrigger", isRetrigger);
field(w, "activeSignatureHelp", activeSignatureHelp);
}
};
class Q_LANGUAGESERVER_EXPORT SignatureHelpParams : public TextDocumentPositionParams,
public WorkDoneProgressParams
{
public:
std::optional<SignatureHelpContext> context = { };
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
field(w, "context", context);
}
};
class Q_LANGUAGESERVER_EXPORT SignatureHelpRegistrationOptions
: public TextDocumentRegistrationOptions,
public SignatureHelpOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
SignatureHelpOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT SymbolInformation : public BaseSymbolInformation
{
public:
std::optional<bool> deprecated = { };
Location location = { };
template <typename W>
void walk(W &w)
{
BaseSymbolInformation::walk(w);
field(w, "deprecated", deprecated);
field(w, "location", location);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentChangeRegistrationOptions
: public TextDocumentRegistrationOptions
{
public:
TextDocumentSyncKind syncKind = { };
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
field(w, "syncKind", syncKind);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentContentParams
{
public:
QByteArray uri = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentContentRefreshParams
{
public:
QByteArray uri = { };
template <typename W>
void walk(W &w)
{
field(w, "uri", uri);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentContentResult
{
public:
QByteArray text = { };
template <typename W>
void walk(W &w)
{
field(w, "text", text);
}
};
class Q_LANGUAGESERVER_EXPORT TextDocumentSaveRegistrationOptions
: public TextDocumentRegistrationOptions,
public SaveOptions
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentRegistrationOptions::walk(w);
SaveOptions::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT TypeDefinitionParams : public TextDocumentPositionParams,
public WorkDoneProgressParams,
public PartialResultParams
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT TypeHierarchyItem
{
public:
QByteArray name = { };
SymbolKind kind = { };
std::optional<QList<SymbolTag>> tags = { };
std::optional<QByteArray> detail = { };
QByteArray uri = { };
Range range = { };
Range selectionRange = { };
std::optional<QJsonValue> data = { };
template <typename W>
void walk(W &w)
{
field(w, "name", name);
field(w, "kind", kind);
field(w, "tags", tags);
field(w, "detail", detail);
field(w, "uri", uri);
field(w, "range", range);
field(w, "selectionRange", selectionRange);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT TypeHierarchyPrepareParams : public TextDocumentPositionParams,
public WorkDoneProgressParams
{
public:
template <typename W>
void walk(W &w)
{
TextDocumentPositionParams::walk(w);
WorkDoneProgressParams::walk(w);
}
};
class Q_LANGUAGESERVER_EXPORT TypeHierarchySubtypesParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TypeHierarchyItem item = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "item", item);
}
};
class Q_LANGUAGESERVER_EXPORT TypeHierarchySupertypesParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
TypeHierarchyItem item = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "item", item);
}
};
class Q_LANGUAGESERVER_EXPORT Unregistration
{
public:
QByteArray id = { };
QByteArray method = { };
template <typename W>
void walk(W &w)
{
field(w, "id", id);
field(w, "method", method);
}
};
class Q_LANGUAGESERVER_EXPORT UnregistrationParams
{
public:
QList<Unregistration> unregisterations = { };
template <typename W>
void walk(W &w)
{
field(w, "unregisterations", unregisterations);
}
};
class Q_LANGUAGESERVER_EXPORT WillSaveTextDocumentParams
{
public:
TextDocumentIdentifier textDocument = { };
TextDocumentSaveReason reason = { };
template <typename W>
void walk(W &w)
{
field(w, "textDocument", textDocument);
field(w, "reason", reason);
}
};
class Q_LANGUAGESERVER_EXPORT WorkDoneProgressCancelParams
{
public:
ProgressToken token = { };
template <typename W>
void walk(W &w)
{
field(w, "token", token);
}
};
class Q_LANGUAGESERVER_EXPORT WorkDoneProgressCreateParams
{
public:
ProgressToken token = { };
template <typename W>
void walk(W &w)
{
field(w, "token", token);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceDiagnosticParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
std::optional<QByteArray> identifier = { };
QList<PreviousResultId> previousResultIds = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "identifier", identifier);
field(w, "previousResultIds", previousResultIds);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceFullDocumentDiagnosticReport
: public FullDocumentDiagnosticReport
{
public:
QByteArray uri = { };
std::variant<std::nullptr_t, int> version = { };
template <typename W>
void walk(W &w)
{
FullDocumentDiagnosticReport::walk(w);
field(w, "uri", uri);
field(w, "version", version);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceUnchangedDocumentDiagnosticReport
: public UnchangedDocumentDiagnosticReport
{
public:
QByteArray uri = { };
std::variant<std::nullptr_t, int> version = { };
template <typename W>
void walk(W &w)
{
UnchangedDocumentDiagnosticReport::walk(w);
field(w, "uri", uri);
field(w, "version", version);
}
};
using WorkspaceDocumentDiagnosticReport = std::variant<WorkspaceFullDocumentDiagnosticReport,
WorkspaceUnchangedDocumentDiagnosticReport>;
class Q_LANGUAGESERVER_EXPORT WorkspaceDiagnosticReport
{
public:
QList<WorkspaceDocumentDiagnosticReport> items = { };
template <typename W>
void walk(W &w)
{
field(w, "items", items);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceDiagnosticReportPartialResult
{
public:
QList<WorkspaceDocumentDiagnosticReport> items = { };
template <typename W>
void walk(W &w)
{
field(w, "items", items);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceSymbol : public BaseSymbolInformation
{
public:
std::variant<Location, LocationUriOnly> location = { };
std::optional<QJsonValue> data = { };
template <typename W>
void walk(W &w)
{
BaseSymbolInformation::walk(w);
field(w, "location", location);
field(w, "data", data);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceSymbolParams : public WorkDoneProgressParams,
public PartialResultParams
{
public:
QByteArray query = { };
template <typename W>
void walk(W &w)
{
WorkDoneProgressParams::walk(w);
PartialResultParams::walk(w);
field(w, "query", query);
}
};
class Q_LANGUAGESERVER_EXPORT WorkspaceSymbolRegistrationOptions : public WorkspaceSymbolOptions
{
public:
template <typename W>
void walk(W &w)
{
WorkspaceSymbolOptions::walk(w);
}
};
} // namespace QLspSpecification
namespace QTypedJson {
template <>
inline QString enumToString<QLspSpecification::ErrorCodes>(QLspSpecification::ErrorCodes value)
{
return enumToIntString<QLspSpecification::ErrorCodes>(value);
}
template <>
inline QString enumToString<QLspSpecification::ApplyKind>(QLspSpecification::ApplyKind value)
{
return enumToIntString<QLspSpecification::ApplyKind>(value);
}
template <>
inline QString
enumToString<QLspSpecification::CodeActionKind>(QLspSpecification::CodeActionKind value)
{
switch (value) {
case QLspSpecification::CodeActionKind::Empty:
return QLatin1String("");
case QLspSpecification::CodeActionKind::QuickFix:
return QLatin1String("quickfix");
case QLspSpecification::CodeActionKind::Refactor:
return QLatin1String("refactor");
case QLspSpecification::CodeActionKind::RefactorExtract:
return QLatin1String("refactor.extract");
case QLspSpecification::CodeActionKind::RefactorInline:
return QLatin1String("refactor.inline");
case QLspSpecification::CodeActionKind::RefactorMove:
return QLatin1String("refactor.move");
case QLspSpecification::CodeActionKind::RefactorRewrite:
return QLatin1String("refactor.rewrite");
case QLspSpecification::CodeActionKind::Source:
return QLatin1String("source");
case QLspSpecification::CodeActionKind::SourceOrganizeImports:
return QLatin1String("source.organizeImports");
case QLspSpecification::CodeActionKind::SourceFixAll:
return QLatin1String("source.fixAll");
case QLspSpecification::CodeActionKind::Notebook:
return QLatin1String("notebook");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::CodeActionKind
enumFromString<QLspSpecification::CodeActionKind>(const QString &string)
{
if (string.compare(QLatin1String(""), Qt::CaseInsensitive) == 0)
return QLspSpecification::CodeActionKind::Empty;
else if (string.compare(QLatin1String("quickfix"), Qt::CaseInsensitive) == 0)
return QLspSpecification::CodeActionKind::QuickFix;
else if (string.compare(QLatin1String("refactor"), Qt::CaseInsensitive) == 0)
return QLspSpecification::CodeActionKind::Refactor;
else if (string.compare(QLatin1String("refactor.extract"), Qt::CaseInsensitive) == 0)
return QLspSpecification::CodeActionKind::RefactorExtract;
else if (string.compare(QLatin1String("refactor.inline"), Qt::CaseInsensitive) == 0)
return QLspSpecification::CodeActionKind::RefactorInline;
else if (string.compare(QLatin1String("refactor.move"), Qt::CaseInsensitive) == 0)
return QLspSpecification::CodeActionKind::RefactorMove;
else if (string.compare(QLatin1String("refactor.rewrite"), Qt::CaseInsensitive) == 0)
return QLspSpecification::CodeActionKind::RefactorRewrite;
else if (string.compare(QLatin1String("source"), Qt::CaseInsensitive) == 0)
return QLspSpecification::CodeActionKind::Source;
else if (string.compare(QLatin1String("source.organizeImports"), Qt::CaseInsensitive) == 0)
return QLspSpecification::CodeActionKind::SourceOrganizeImports;
else if (string.compare(QLatin1String("source.fixAll"), Qt::CaseInsensitive) == 0)
return QLspSpecification::CodeActionKind::SourceFixAll;
else if (string.compare(QLatin1String("notebook"), Qt::CaseInsensitive) == 0)
return QLspSpecification::CodeActionKind::Notebook;
return QLspSpecification::CodeActionKind{ };
}
template <>
inline QString
enumToString<QLspSpecification::CodeActionTag>(QLspSpecification::CodeActionTag value)
{
return enumToIntString<QLspSpecification::CodeActionTag>(value);
}
template <>
inline QString enumToString<QLspSpecification::CodeActionTriggerKind>(
QLspSpecification::CodeActionTriggerKind value)
{
return enumToIntString<QLspSpecification::CodeActionTriggerKind>(value);
}
template <>
inline QString
enumToString<QLspSpecification::CompletionItemKind>(QLspSpecification::CompletionItemKind value)
{
return enumToIntString<QLspSpecification::CompletionItemKind>(value);
}
template <>
inline QString
enumToString<QLspSpecification::CompletionItemTag>(QLspSpecification::CompletionItemTag value)
{
return enumToIntString<QLspSpecification::CompletionItemTag>(value);
}
template <>
inline QString enumToString<QLspSpecification::CompletionTriggerKind>(
QLspSpecification::CompletionTriggerKind value)
{
return enumToIntString<QLspSpecification::CompletionTriggerKind>(value);
}
template <>
inline QString
enumToString<QLspSpecification::DiagnosticSeverity>(QLspSpecification::DiagnosticSeverity value)
{
return enumToIntString<QLspSpecification::DiagnosticSeverity>(value);
}
template <>
inline QString
enumToString<QLspSpecification::DiagnosticTag>(QLspSpecification::DiagnosticTag value)
{
return enumToIntString<QLspSpecification::DiagnosticTag>(value);
}
template <>
inline QString enumToString<QLspSpecification::DocumentDiagnosticReportKind>(
QLspSpecification::DocumentDiagnosticReportKind value)
{
switch (value) {
case QLspSpecification::DocumentDiagnosticReportKind::Full:
return QLatin1String("full");
case QLspSpecification::DocumentDiagnosticReportKind::Unchanged:
return QLatin1String("unchanged");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::DocumentDiagnosticReportKind
enumFromString<QLspSpecification::DocumentDiagnosticReportKind>(const QString &string)
{
if (string.compare(QLatin1String("full"), Qt::CaseInsensitive) == 0)
return QLspSpecification::DocumentDiagnosticReportKind::Full;
else if (string.compare(QLatin1String("unchanged"), Qt::CaseInsensitive) == 0)
return QLspSpecification::DocumentDiagnosticReportKind::Unchanged;
return QLspSpecification::DocumentDiagnosticReportKind{ };
}
template <>
inline QString enumToString<QLspSpecification::DocumentHighlightKind>(
QLspSpecification::DocumentHighlightKind value)
{
return enumToIntString<QLspSpecification::DocumentHighlightKind>(value);
}
template <>
inline QString
enumToString<QLspSpecification::FailureHandlingKind>(QLspSpecification::FailureHandlingKind value)
{
switch (value) {
case QLspSpecification::FailureHandlingKind::Abort:
return QLatin1String("abort");
case QLspSpecification::FailureHandlingKind::Transactional:
return QLatin1String("transactional");
case QLspSpecification::FailureHandlingKind::TextOnlyTransactional:
return QLatin1String("textOnlyTransactional");
case QLspSpecification::FailureHandlingKind::Undo:
return QLatin1String("undo");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::FailureHandlingKind
enumFromString<QLspSpecification::FailureHandlingKind>(const QString &string)
{
if (string.compare(QLatin1String("abort"), Qt::CaseInsensitive) == 0)
return QLspSpecification::FailureHandlingKind::Abort;
else if (string.compare(QLatin1String("transactional"), Qt::CaseInsensitive) == 0)
return QLspSpecification::FailureHandlingKind::Transactional;
else if (string.compare(QLatin1String("textOnlyTransactional"), Qt::CaseInsensitive) == 0)
return QLspSpecification::FailureHandlingKind::TextOnlyTransactional;
else if (string.compare(QLatin1String("undo"), Qt::CaseInsensitive) == 0)
return QLspSpecification::FailureHandlingKind::Undo;
return QLspSpecification::FailureHandlingKind{ };
}
template <>
inline QString
enumToString<QLspSpecification::FileChangeType>(QLspSpecification::FileChangeType value)
{
return enumToIntString<QLspSpecification::FileChangeType>(value);
}
template <>
inline QString enumToString<QLspSpecification::FileOperationPatternKind>(
QLspSpecification::FileOperationPatternKind value)
{
switch (value) {
case QLspSpecification::FileOperationPatternKind::File:
return QLatin1String("file");
case QLspSpecification::FileOperationPatternKind::Folder:
return QLatin1String("folder");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::FileOperationPatternKind
enumFromString<QLspSpecification::FileOperationPatternKind>(const QString &string)
{
if (string.compare(QLatin1String("file"), Qt::CaseInsensitive) == 0)
return QLspSpecification::FileOperationPatternKind::File;
else if (string.compare(QLatin1String("folder"), Qt::CaseInsensitive) == 0)
return QLspSpecification::FileOperationPatternKind::Folder;
return QLspSpecification::FileOperationPatternKind{ };
}
template <>
inline QString
enumToString<QLspSpecification::FoldingRangeKind>(QLspSpecification::FoldingRangeKind value)
{
switch (value) {
case QLspSpecification::FoldingRangeKind::Comment:
return QLatin1String("comment");
case QLspSpecification::FoldingRangeKind::Imports:
return QLatin1String("imports");
case QLspSpecification::FoldingRangeKind::Region:
return QLatin1String("region");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::FoldingRangeKind
enumFromString<QLspSpecification::FoldingRangeKind>(const QString &string)
{
if (string.compare(QLatin1String("comment"), Qt::CaseInsensitive) == 0)
return QLspSpecification::FoldingRangeKind::Comment;
else if (string.compare(QLatin1String("imports"), Qt::CaseInsensitive) == 0)
return QLspSpecification::FoldingRangeKind::Imports;
else if (string.compare(QLatin1String("region"), Qt::CaseInsensitive) == 0)
return QLspSpecification::FoldingRangeKind::Region;
return QLspSpecification::FoldingRangeKind{ };
}
template <>
inline QString
enumToString<QLspSpecification::InlayHintKind>(QLspSpecification::InlayHintKind value)
{
return enumToIntString<QLspSpecification::InlayHintKind>(value);
}
template <>
inline QString enumToString<QLspSpecification::InlineCompletionTriggerKind>(
QLspSpecification::InlineCompletionTriggerKind value)
{
return enumToIntString<QLspSpecification::InlineCompletionTriggerKind>(value);
}
template <>
inline QString
enumToString<QLspSpecification::InsertTextFormat>(QLspSpecification::InsertTextFormat value)
{
return enumToIntString<QLspSpecification::InsertTextFormat>(value);
}
template <>
inline QString
enumToString<QLspSpecification::InsertTextMode>(QLspSpecification::InsertTextMode value)
{
return enumToIntString<QLspSpecification::InsertTextMode>(value);
}
template <>
inline QString
enumToString<QLspSpecification::LSPErrorCodes>(QLspSpecification::LSPErrorCodes value)
{
return enumToIntString<QLspSpecification::LSPErrorCodes>(value);
}
template <>
inline QString enumToString<QLspSpecification::LanguageKind>(QLspSpecification::LanguageKind value)
{
switch (value) {
case QLspSpecification::LanguageKind::ABAP:
return QLatin1String("abap");
case QLspSpecification::LanguageKind::WindowsBat:
return QLatin1String("bat");
case QLspSpecification::LanguageKind::BibTeX:
return QLatin1String("bibtex");
case QLspSpecification::LanguageKind::Clojure:
return QLatin1String("clojure");
case QLspSpecification::LanguageKind::Coffeescript:
return QLatin1String("coffeescript");
case QLspSpecification::LanguageKind::C:
return QLatin1String("c");
case QLspSpecification::LanguageKind::CPP:
return QLatin1String("cpp");
case QLspSpecification::LanguageKind::CSharp:
return QLatin1String("csharp");
case QLspSpecification::LanguageKind::CSS:
return QLatin1String("css");
case QLspSpecification::LanguageKind::D:
return QLatin1String("d");
case QLspSpecification::LanguageKind::Delphi:
return QLatin1String("pascal");
case QLspSpecification::LanguageKind::Diff:
return QLatin1String("diff");
case QLspSpecification::LanguageKind::Dart:
return QLatin1String("dart");
case QLspSpecification::LanguageKind::Dockerfile:
return QLatin1String("dockerfile");
case QLspSpecification::LanguageKind::Elixir:
return QLatin1String("elixir");
case QLspSpecification::LanguageKind::Erlang:
return QLatin1String("erlang");
case QLspSpecification::LanguageKind::FSharp:
return QLatin1String("fsharp");
case QLspSpecification::LanguageKind::GitCommit:
return QLatin1String("git-commit");
case QLspSpecification::LanguageKind::GitRebase:
return QLatin1String("git-rebase");
case QLspSpecification::LanguageKind::Go:
return QLatin1String("go");
case QLspSpecification::LanguageKind::Groovy:
return QLatin1String("groovy");
case QLspSpecification::LanguageKind::Handlebars:
return QLatin1String("handlebars");
case QLspSpecification::LanguageKind::Haskell:
return QLatin1String("haskell");
case QLspSpecification::LanguageKind::HTML:
return QLatin1String("html");
case QLspSpecification::LanguageKind::Ini:
return QLatin1String("ini");
case QLspSpecification::LanguageKind::Java:
return QLatin1String("java");
case QLspSpecification::LanguageKind::JavaScript:
return QLatin1String("javascript");
case QLspSpecification::LanguageKind::JavaScriptReact:
return QLatin1String("javascriptreact");
case QLspSpecification::LanguageKind::JSON:
return QLatin1String("json");
case QLspSpecification::LanguageKind::LaTeX:
return QLatin1String("latex");
case QLspSpecification::LanguageKind::Less:
return QLatin1String("less");
case QLspSpecification::LanguageKind::Lua:
return QLatin1String("lua");
case QLspSpecification::LanguageKind::Makefile:
return QLatin1String("makefile");
case QLspSpecification::LanguageKind::Markdown:
return QLatin1String("markdown");
case QLspSpecification::LanguageKind::ObjectiveC:
return QLatin1String("objective-c");
case QLspSpecification::LanguageKind::ObjectiveCPP:
return QLatin1String("objective-cpp");
case QLspSpecification::LanguageKind::Pascal:
return QLatin1String("pascal");
case QLspSpecification::LanguageKind::Perl:
return QLatin1String("perl");
case QLspSpecification::LanguageKind::Perl6:
return QLatin1String("perl6");
case QLspSpecification::LanguageKind::PHP:
return QLatin1String("php");
case QLspSpecification::LanguageKind::Plaintext:
return QLatin1String("plaintext");
case QLspSpecification::LanguageKind::Powershell:
return QLatin1String("powershell");
case QLspSpecification::LanguageKind::Pug:
return QLatin1String("jade");
case QLspSpecification::LanguageKind::Python:
return QLatin1String("python");
case QLspSpecification::LanguageKind::R:
return QLatin1String("r");
case QLspSpecification::LanguageKind::Razor:
return QLatin1String("razor");
case QLspSpecification::LanguageKind::Ruby:
return QLatin1String("ruby");
case QLspSpecification::LanguageKind::Rust:
return QLatin1String("rust");
case QLspSpecification::LanguageKind::SCSS:
return QLatin1String("scss");
case QLspSpecification::LanguageKind::SASS:
return QLatin1String("sass");
case QLspSpecification::LanguageKind::Scala:
return QLatin1String("scala");
case QLspSpecification::LanguageKind::ShaderLab:
return QLatin1String("shaderlab");
case QLspSpecification::LanguageKind::ShellScript:
return QLatin1String("shellscript");
case QLspSpecification::LanguageKind::SQL:
return QLatin1String("sql");
case QLspSpecification::LanguageKind::Swift:
return QLatin1String("swift");
case QLspSpecification::LanguageKind::TypeScript:
return QLatin1String("typescript");
case QLspSpecification::LanguageKind::TypeScriptReact:
return QLatin1String("typescriptreact");
case QLspSpecification::LanguageKind::TeX:
return QLatin1String("tex");
case QLspSpecification::LanguageKind::VisualBasic:
return QLatin1String("vb");
case QLspSpecification::LanguageKind::XML:
return QLatin1String("xml");
case QLspSpecification::LanguageKind::XSL:
return QLatin1String("xsl");
case QLspSpecification::LanguageKind::YAML:
return QLatin1String("yaml");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::LanguageKind
enumFromString<QLspSpecification::LanguageKind>(const QString &string)
{
if (string.compare(QLatin1String("abap"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::ABAP;
else if (string.compare(QLatin1String("bat"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::WindowsBat;
else if (string.compare(QLatin1String("bibtex"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::BibTeX;
else if (string.compare(QLatin1String("clojure"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Clojure;
else if (string.compare(QLatin1String("coffeescript"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Coffeescript;
else if (string.compare(QLatin1String("c"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::C;
else if (string.compare(QLatin1String("cpp"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::CPP;
else if (string.compare(QLatin1String("csharp"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::CSharp;
else if (string.compare(QLatin1String("css"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::CSS;
else if (string.compare(QLatin1String("d"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::D;
else if (string.compare(QLatin1String("pascal"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Delphi;
else if (string.compare(QLatin1String("diff"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Diff;
else if (string.compare(QLatin1String("dart"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Dart;
else if (string.compare(QLatin1String("dockerfile"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Dockerfile;
else if (string.compare(QLatin1String("elixir"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Elixir;
else if (string.compare(QLatin1String("erlang"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Erlang;
else if (string.compare(QLatin1String("fsharp"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::FSharp;
else if (string.compare(QLatin1String("git-commit"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::GitCommit;
else if (string.compare(QLatin1String("git-rebase"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::GitRebase;
else if (string.compare(QLatin1String("go"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Go;
else if (string.compare(QLatin1String("groovy"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Groovy;
else if (string.compare(QLatin1String("handlebars"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Handlebars;
else if (string.compare(QLatin1String("haskell"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Haskell;
else if (string.compare(QLatin1String("html"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::HTML;
else if (string.compare(QLatin1String("ini"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Ini;
else if (string.compare(QLatin1String("java"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Java;
else if (string.compare(QLatin1String("javascript"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::JavaScript;
else if (string.compare(QLatin1String("javascriptreact"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::JavaScriptReact;
else if (string.compare(QLatin1String("json"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::JSON;
else if (string.compare(QLatin1String("latex"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::LaTeX;
else if (string.compare(QLatin1String("less"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Less;
else if (string.compare(QLatin1String("lua"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Lua;
else if (string.compare(QLatin1String("makefile"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Makefile;
else if (string.compare(QLatin1String("markdown"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Markdown;
else if (string.compare(QLatin1String("objective-c"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::ObjectiveC;
else if (string.compare(QLatin1String("objective-cpp"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::ObjectiveCPP;
else if (string.compare(QLatin1String("pascal"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Pascal;
else if (string.compare(QLatin1String("perl"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Perl;
else if (string.compare(QLatin1String("perl6"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Perl6;
else if (string.compare(QLatin1String("php"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::PHP;
else if (string.compare(QLatin1String("plaintext"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Plaintext;
else if (string.compare(QLatin1String("powershell"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Powershell;
else if (string.compare(QLatin1String("jade"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Pug;
else if (string.compare(QLatin1String("python"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Python;
else if (string.compare(QLatin1String("r"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::R;
else if (string.compare(QLatin1String("razor"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Razor;
else if (string.compare(QLatin1String("ruby"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Ruby;
else if (string.compare(QLatin1String("rust"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Rust;
else if (string.compare(QLatin1String("scss"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::SCSS;
else if (string.compare(QLatin1String("sass"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::SASS;
else if (string.compare(QLatin1String("scala"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Scala;
else if (string.compare(QLatin1String("shaderlab"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::ShaderLab;
else if (string.compare(QLatin1String("shellscript"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::ShellScript;
else if (string.compare(QLatin1String("sql"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::SQL;
else if (string.compare(QLatin1String("swift"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::Swift;
else if (string.compare(QLatin1String("typescript"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::TypeScript;
else if (string.compare(QLatin1String("typescriptreact"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::TypeScriptReact;
else if (string.compare(QLatin1String("tex"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::TeX;
else if (string.compare(QLatin1String("vb"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::VisualBasic;
else if (string.compare(QLatin1String("xml"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::XML;
else if (string.compare(QLatin1String("xsl"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::XSL;
else if (string.compare(QLatin1String("yaml"), Qt::CaseInsensitive) == 0)
return QLspSpecification::LanguageKind::YAML;
return QLspSpecification::LanguageKind{ };
}
template <>
inline QString enumToString<QLspSpecification::MarkupKind>(QLspSpecification::MarkupKind value)
{
switch (value) {
case QLspSpecification::MarkupKind::PlainText:
return QLatin1String("plaintext");
case QLspSpecification::MarkupKind::Markdown:
return QLatin1String("markdown");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::MarkupKind
enumFromString<QLspSpecification::MarkupKind>(const QString &string)
{
if (string.compare(QLatin1String("plaintext"), Qt::CaseInsensitive) == 0)
return QLspSpecification::MarkupKind::PlainText;
else if (string.compare(QLatin1String("markdown"), Qt::CaseInsensitive) == 0)
return QLspSpecification::MarkupKind::Markdown;
return QLspSpecification::MarkupKind{ };
}
template <>
inline QString enumToString<QLspSpecification::MessageType>(QLspSpecification::MessageType value)
{
return enumToIntString<QLspSpecification::MessageType>(value);
}
template <>
inline QString enumToString<QLspSpecification::MonikerKind>(QLspSpecification::MonikerKind value)
{
switch (value) {
case QLspSpecification::MonikerKind::Import:
return QLatin1String("import");
case QLspSpecification::MonikerKind::Export:
return QLatin1String("export");
case QLspSpecification::MonikerKind::Local:
return QLatin1String("local");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::MonikerKind
enumFromString<QLspSpecification::MonikerKind>(const QString &string)
{
if (string.compare(QLatin1String("import"), Qt::CaseInsensitive) == 0)
return QLspSpecification::MonikerKind::Import;
else if (string.compare(QLatin1String("export"), Qt::CaseInsensitive) == 0)
return QLspSpecification::MonikerKind::Export;
else if (string.compare(QLatin1String("local"), Qt::CaseInsensitive) == 0)
return QLspSpecification::MonikerKind::Local;
return QLspSpecification::MonikerKind{ };
}
template <>
inline QString
enumToString<QLspSpecification::NotebookCellKind>(QLspSpecification::NotebookCellKind value)
{
return enumToIntString<QLspSpecification::NotebookCellKind>(value);
}
template <>
inline QString
enumToString<QLspSpecification::PositionEncodingKind>(QLspSpecification::PositionEncodingKind value)
{
switch (value) {
case QLspSpecification::PositionEncodingKind::UTF8:
return QLatin1String("utf-8");
case QLspSpecification::PositionEncodingKind::UTF16:
return QLatin1String("utf-16");
case QLspSpecification::PositionEncodingKind::UTF32:
return QLatin1String("utf-32");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::PositionEncodingKind
enumFromString<QLspSpecification::PositionEncodingKind>(const QString &string)
{
if (string.compare(QLatin1String("utf-8"), Qt::CaseInsensitive) == 0)
return QLspSpecification::PositionEncodingKind::UTF8;
else if (string.compare(QLatin1String("utf-16"), Qt::CaseInsensitive) == 0)
return QLspSpecification::PositionEncodingKind::UTF16;
else if (string.compare(QLatin1String("utf-32"), Qt::CaseInsensitive) == 0)
return QLspSpecification::PositionEncodingKind::UTF32;
return QLspSpecification::PositionEncodingKind{ };
}
template <>
inline QString enumToString<QLspSpecification::PrepareSupportDefaultBehavior>(
QLspSpecification::PrepareSupportDefaultBehavior value)
{
return enumToIntString<QLspSpecification::PrepareSupportDefaultBehavior>(value);
}
template <>
inline QString enumToString<QLspSpecification::ResourceOperationKind>(
QLspSpecification::ResourceOperationKind value)
{
switch (value) {
case QLspSpecification::ResourceOperationKind::Create:
return QLatin1String("create");
case QLspSpecification::ResourceOperationKind::Rename:
return QLatin1String("rename");
case QLspSpecification::ResourceOperationKind::Delete:
return QLatin1String("delete");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::ResourceOperationKind
enumFromString<QLspSpecification::ResourceOperationKind>(const QString &string)
{
if (string.compare(QLatin1String("create"), Qt::CaseInsensitive) == 0)
return QLspSpecification::ResourceOperationKind::Create;
else if (string.compare(QLatin1String("rename"), Qt::CaseInsensitive) == 0)
return QLspSpecification::ResourceOperationKind::Rename;
else if (string.compare(QLatin1String("delete"), Qt::CaseInsensitive) == 0)
return QLspSpecification::ResourceOperationKind::Delete;
return QLspSpecification::ResourceOperationKind{ };
}
template <>
inline QString enumToString<QLspSpecification::SemanticTokenModifiers>(
QLspSpecification::SemanticTokenModifiers value)
{
switch (value) {
case QLspSpecification::SemanticTokenModifiers::Declaration:
return QLatin1String("declaration");
case QLspSpecification::SemanticTokenModifiers::Definition:
return QLatin1String("definition");
case QLspSpecification::SemanticTokenModifiers::Readonly:
return QLatin1String("readonly");
case QLspSpecification::SemanticTokenModifiers::Static:
return QLatin1String("static");
case QLspSpecification::SemanticTokenModifiers::Deprecated:
return QLatin1String("deprecated");
case QLspSpecification::SemanticTokenModifiers::Abstract:
return QLatin1String("abstract");
case QLspSpecification::SemanticTokenModifiers::Async:
return QLatin1String("async");
case QLspSpecification::SemanticTokenModifiers::Modification:
return QLatin1String("modification");
case QLspSpecification::SemanticTokenModifiers::Documentation:
return QLatin1String("documentation");
case QLspSpecification::SemanticTokenModifiers::DefaultLibrary:
return QLatin1String("defaultLibrary");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::SemanticTokenModifiers
enumFromString<QLspSpecification::SemanticTokenModifiers>(const QString &string)
{
if (string.compare(QLatin1String("declaration"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenModifiers::Declaration;
else if (string.compare(QLatin1String("definition"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenModifiers::Definition;
else if (string.compare(QLatin1String("readonly"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenModifiers::Readonly;
else if (string.compare(QLatin1String("static"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenModifiers::Static;
else if (string.compare(QLatin1String("deprecated"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenModifiers::Deprecated;
else if (string.compare(QLatin1String("abstract"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenModifiers::Abstract;
else if (string.compare(QLatin1String("async"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenModifiers::Async;
else if (string.compare(QLatin1String("modification"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenModifiers::Modification;
else if (string.compare(QLatin1String("documentation"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenModifiers::Documentation;
else if (string.compare(QLatin1String("defaultLibrary"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenModifiers::DefaultLibrary;
return QLspSpecification::SemanticTokenModifiers{ };
}
template <>
inline QString
enumToString<QLspSpecification::SemanticTokenTypes>(QLspSpecification::SemanticTokenTypes value)
{
switch (value) {
case QLspSpecification::SemanticTokenTypes::Namespace:
return QLatin1String("namespace");
case QLspSpecification::SemanticTokenTypes::Type:
return QLatin1String("type");
case QLspSpecification::SemanticTokenTypes::Class:
return QLatin1String("class");
case QLspSpecification::SemanticTokenTypes::Enum:
return QLatin1String("enum");
case QLspSpecification::SemanticTokenTypes::Interface:
return QLatin1String("interface");
case QLspSpecification::SemanticTokenTypes::Struct:
return QLatin1String("struct");
case QLspSpecification::SemanticTokenTypes::TypeParameter:
return QLatin1String("typeParameter");
case QLspSpecification::SemanticTokenTypes::Parameter:
return QLatin1String("parameter");
case QLspSpecification::SemanticTokenTypes::Variable:
return QLatin1String("variable");
case QLspSpecification::SemanticTokenTypes::Property:
return QLatin1String("property");
case QLspSpecification::SemanticTokenTypes::EnumMember:
return QLatin1String("enumMember");
case QLspSpecification::SemanticTokenTypes::Event:
return QLatin1String("event");
case QLspSpecification::SemanticTokenTypes::Function:
return QLatin1String("function");
case QLspSpecification::SemanticTokenTypes::Method:
return QLatin1String("method");
case QLspSpecification::SemanticTokenTypes::Macro:
return QLatin1String("macro");
case QLspSpecification::SemanticTokenTypes::Keyword:
return QLatin1String("keyword");
case QLspSpecification::SemanticTokenTypes::Modifier:
return QLatin1String("modifier");
case QLspSpecification::SemanticTokenTypes::Comment:
return QLatin1String("comment");
case QLspSpecification::SemanticTokenTypes::String:
return QLatin1String("string");
case QLspSpecification::SemanticTokenTypes::Number:
return QLatin1String("number");
case QLspSpecification::SemanticTokenTypes::Regexp:
return QLatin1String("regexp");
case QLspSpecification::SemanticTokenTypes::Operator:
return QLatin1String("operator");
case QLspSpecification::SemanticTokenTypes::Decorator:
return QLatin1String("decorator");
case QLspSpecification::SemanticTokenTypes::Label:
return QLatin1String("label");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::SemanticTokenTypes
enumFromString<QLspSpecification::SemanticTokenTypes>(const QString &string)
{
if (string.compare(QLatin1String("namespace"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Namespace;
else if (string.compare(QLatin1String("type"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Type;
else if (string.compare(QLatin1String("class"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Class;
else if (string.compare(QLatin1String("enum"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Enum;
else if (string.compare(QLatin1String("interface"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Interface;
else if (string.compare(QLatin1String("struct"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Struct;
else if (string.compare(QLatin1String("typeParameter"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::TypeParameter;
else if (string.compare(QLatin1String("parameter"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Parameter;
else if (string.compare(QLatin1String("variable"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Variable;
else if (string.compare(QLatin1String("property"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Property;
else if (string.compare(QLatin1String("enumMember"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::EnumMember;
else if (string.compare(QLatin1String("event"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Event;
else if (string.compare(QLatin1String("function"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Function;
else if (string.compare(QLatin1String("method"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Method;
else if (string.compare(QLatin1String("macro"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Macro;
else if (string.compare(QLatin1String("keyword"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Keyword;
else if (string.compare(QLatin1String("modifier"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Modifier;
else if (string.compare(QLatin1String("comment"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Comment;
else if (string.compare(QLatin1String("string"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::String;
else if (string.compare(QLatin1String("number"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Number;
else if (string.compare(QLatin1String("regexp"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Regexp;
else if (string.compare(QLatin1String("operator"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Operator;
else if (string.compare(QLatin1String("decorator"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Decorator;
else if (string.compare(QLatin1String("label"), Qt::CaseInsensitive) == 0)
return QLspSpecification::SemanticTokenTypes::Label;
return QLspSpecification::SemanticTokenTypes{ };
}
template <>
inline QString enumToString<QLspSpecification::SignatureHelpTriggerKind>(
QLspSpecification::SignatureHelpTriggerKind value)
{
return enumToIntString<QLspSpecification::SignatureHelpTriggerKind>(value);
}
template <>
inline QString enumToString<QLspSpecification::SymbolKind>(QLspSpecification::SymbolKind value)
{
return enumToIntString<QLspSpecification::SymbolKind>(value);
}
template <>
inline QString enumToString<QLspSpecification::SymbolTag>(QLspSpecification::SymbolTag value)
{
return enumToIntString<QLspSpecification::SymbolTag>(value);
}
template <>
inline QString enumToString<QLspSpecification::TextDocumentSaveReason>(
QLspSpecification::TextDocumentSaveReason value)
{
return enumToIntString<QLspSpecification::TextDocumentSaveReason>(value);
}
template <>
inline QString
enumToString<QLspSpecification::TextDocumentSyncKind>(QLspSpecification::TextDocumentSyncKind value)
{
return enumToIntString<QLspSpecification::TextDocumentSyncKind>(value);
}
template <>
inline QString enumToString<QLspSpecification::TokenFormat>(QLspSpecification::TokenFormat value)
{
switch (value) {
case QLspSpecification::TokenFormat::Relative:
return QLatin1String("relative");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::TokenFormat
enumFromString<QLspSpecification::TokenFormat>(const QString &string)
{
if (string.compare(QLatin1String("relative"), Qt::CaseInsensitive) == 0)
return QLspSpecification::TokenFormat::Relative;
return QLspSpecification::TokenFormat{ };
}
template <>
inline QString enumToString<QLspSpecification::TraceValue>(QLspSpecification::TraceValue value)
{
switch (value) {
case QLspSpecification::TraceValue::Off:
return QLatin1String("off");
case QLspSpecification::TraceValue::Messages:
return QLatin1String("messages");
case QLspSpecification::TraceValue::Verbose:
return QLatin1String("verbose");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::TraceValue
enumFromString<QLspSpecification::TraceValue>(const QString &string)
{
if (string.compare(QLatin1String("off"), Qt::CaseInsensitive) == 0)
return QLspSpecification::TraceValue::Off;
else if (string.compare(QLatin1String("messages"), Qt::CaseInsensitive) == 0)
return QLspSpecification::TraceValue::Messages;
else if (string.compare(QLatin1String("verbose"), Qt::CaseInsensitive) == 0)
return QLspSpecification::TraceValue::Verbose;
return QLspSpecification::TraceValue{ };
}
template <>
inline QString
enumToString<QLspSpecification::UniquenessLevel>(QLspSpecification::UniquenessLevel value)
{
switch (value) {
case QLspSpecification::UniquenessLevel::Document:
return QLatin1String("document");
case QLspSpecification::UniquenessLevel::Project:
return QLatin1String("project");
case QLspSpecification::UniquenessLevel::Group:
return QLatin1String("group");
case QLspSpecification::UniquenessLevel::Scheme:
return QLatin1String("scheme");
case QLspSpecification::UniquenessLevel::Global:
return QLatin1String("global");
default:
return QString::number(int(value));
}
}
template <>
inline QLspSpecification::UniquenessLevel
enumFromString<QLspSpecification::UniquenessLevel>(const QString &string)
{
if (string.compare(QLatin1String("document"), Qt::CaseInsensitive) == 0)
return QLspSpecification::UniquenessLevel::Document;
else if (string.compare(QLatin1String("project"), Qt::CaseInsensitive) == 0)
return QLspSpecification::UniquenessLevel::Project;
else if (string.compare(QLatin1String("group"), Qt::CaseInsensitive) == 0)
return QLspSpecification::UniquenessLevel::Group;
else if (string.compare(QLatin1String("scheme"), Qt::CaseInsensitive) == 0)
return QLspSpecification::UniquenessLevel::Scheme;
else if (string.compare(QLatin1String("global"), Qt::CaseInsensitive) == 0)
return QLspSpecification::UniquenessLevel::Global;
return QLspSpecification::UniquenessLevel{ };
}
template <>
inline QString enumToString<QLspSpecification::WatchKind>(QLspSpecification::WatchKind value)
{
return enumToIntString<QLspSpecification::WatchKind>(value);
}
} // namespace QTypedJson
QT_END_NAMESPACE
#endif // QLANGUAGESERVERSPECTYPES_P_H