1// Copyright (C) 2021 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4// this file was generated by the generate.ts script
5
6#ifndef QLANGUAGESERVERSPECTYPES_P_H
7#define QLANGUAGESERVERSPECTYPES_P_H
8
9//
10// W A R N I N G
11// -------------
12//
13// This file is not part of the Qt API. It exists purely as an
14// implementation detail. This header file may change from version to
15// version without notice, or even be removed.
16//
17// We mean it.
18//
19
20#include <QtLanguageServer/qtlanguageserverglobal.h>
21#include <QtLanguageServer/private/qlanguageserverprespectypes_p.h>
22#include <QtJsonRpc/private/qtypedjson_p.h>
23#include <QtCore/QByteArray>
24#include <QtCore/QList>
25#include <QtCore/QJsonValue>
26#include <QtCore/QJsonObject>
27#include <QtCore/QString>
28
29#include <optional>
30#include <variant>
31
32QT_BEGIN_NAMESPACE
33namespace QLspSpecification {
34Q_NAMESPACE_EXPORT(Q_LANGUAGESERVER_EXPORT)
35
36enum class TraceValue { Off, Messages, Verbose };
37Q_ENUM_NS(TraceValue)
38
39enum class ErrorCodes {
40 // Defined by JSON RPC
41 ParseError = -32700,
42 InvalidRequest = -32600,
43 MethodNotFound = -32601,
44 InvalidParams = -32602,
45 InternalError = -32603,
46
47 jsonrpcReservedErrorRangeStart = -32099,
48 /** @deprecated use jsonrpcReservedErrorRangeStart */
49 serverErrorStart = jsonrpcReservedErrorRangeStart,
50
51 ServerNotInitialized = -32002,
52 UnknownErrorCode = -32001,
53
54 jsonrpcReservedErrorRangeEnd = -32000,
55 /** @deprecated use jsonrpcReservedErrorRangeEnd */
56 serverErrorEnd = jsonrpcReservedErrorRangeEnd,
57
58 lspReservedErrorRangeStart = -32899,
59
60 ContentModified = -32801,
61 RequestCancelled = -32800,
62
63 lspReservedErrorRangeEnd = -32800
64};
65Q_ENUM_NS(ErrorCodes)
66
67enum class DiagnosticSeverity { Error = 1, Warning = 2, Information = 3, Hint = 4 };
68Q_ENUM_NS(DiagnosticSeverity)
69
70enum class DiagnosticTag { Unnecessary = 1, Deprecated = 2 };
71Q_ENUM_NS(DiagnosticTag)
72
73enum class ResourceOperationKind { Create, Rename, Delete };
74Q_ENUM_NS(ResourceOperationKind)
75
76enum class FailureHandlingKind { Abort, Transactional, TextOnlyTransactional, Undo };
77Q_ENUM_NS(FailureHandlingKind)
78
79enum class MarkupKind { PlainText, Markdown };
80Q_ENUM_NS(MarkupKind)
81
82enum class InitializeErrorCode { UnknownProtocolVersion = 1 };
83Q_ENUM_NS(InitializeErrorCode)
84
85enum class MessageType { Error = 1, Warning = 2, Info = 3, Log = 4 };
86Q_ENUM_NS(MessageType)
87
88enum class WatchKind { Create = 1, Change = 2, Delete = 4 };
89Q_ENUM_NS(WatchKind)
90
91enum class FileChangeType { Created = 1, Changed = 2, Deleted = 3 };
92Q_ENUM_NS(FileChangeType)
93
94enum class FileOperationPatternKind { File, Folder };
95Q_ENUM_NS(FileOperationPatternKind)
96
97enum class TextDocumentSyncKind { None = 0, Full = 1, Incremental = 2 };
98Q_ENUM_NS(TextDocumentSyncKind)
99
100enum class TextDocumentSaveReason { Manual = 1, AfterDelay = 2, FocusOut = 3 };
101Q_ENUM_NS(TextDocumentSaveReason)
102
103enum class CompletionTriggerKind {
104 Invoked = 1,
105 TriggerCharacter = 2,
106 TriggerForIncompleteCompletions = 3
107};
108Q_ENUM_NS(CompletionTriggerKind)
109
110enum class InsertTextFormat { PlainText = 1, Snippet = 2 };
111Q_ENUM_NS(InsertTextFormat)
112
113enum class CompletionItemTag { Deprecated = 1 };
114Q_ENUM_NS(CompletionItemTag)
115
116enum class InsertTextMode { AsIs = 1, AdjustIndentation = 2 };
117Q_ENUM_NS(InsertTextMode)
118
119enum class CompletionItemKind {
120 Text = 1,
121 Method = 2,
122 Function = 3,
123 Constructor = 4,
124 Field = 5,
125 Variable = 6,
126 Class = 7,
127 Interface = 8,
128 Module = 9,
129 Property = 10,
130 Unit = 11,
131 Value = 12,
132 Enum = 13,
133 Keyword = 14,
134 Snippet = 15,
135 Color = 16,
136 File = 17,
137 Reference = 18,
138 Folder = 19,
139 EnumMember = 20,
140 Constant = 21,
141 Struct = 22,
142 Event = 23,
143 Operator = 24,
144 TypeParameter = 25
145};
146Q_ENUM_NS(CompletionItemKind)
147
148enum class SignatureHelpTriggerKind { Invoked = 1, TriggerCharacter = 2, ContentChange = 3 };
149Q_ENUM_NS(SignatureHelpTriggerKind)
150
151enum class DocumentHighlightKind { Text = 1, Read = 2, Write = 3 };
152Q_ENUM_NS(DocumentHighlightKind)
153
154enum class SymbolKind {
155 File = 1,
156 Module = 2,
157 Namespace = 3,
158 Package = 4,
159 Class = 5,
160 Method = 6,
161 Property = 7,
162 Field = 8,
163 Constructor = 9,
164 Enum = 10,
165 Interface = 11,
166 Function = 12,
167 Variable = 13,
168 Constant = 14,
169 String = 15,
170 Number = 16,
171 Boolean = 17,
172 Array = 18,
173 Object = 19,
174 Key = 20,
175 Null = 21,
176 EnumMember = 22,
177 Struct = 23,
178 Event = 24,
179 Operator = 25,
180 TypeParameter = 26
181};
182Q_ENUM_NS(SymbolKind)
183
184enum class SymbolTag { Deprecated = 1 };
185Q_ENUM_NS(SymbolTag)
186
187enum class CodeActionKind {
188 Empty,
189 QuickFix,
190 Refactor,
191 RefactorExtract,
192 RefactorInline,
193 RefactorRewrite,
194 Source,
195 SourceOrganizeImports
196};
197Q_ENUM_NS(CodeActionKind)
198
199enum class PrepareSupportDefaultBehavior { Identifier = 1 };
200Q_ENUM_NS(PrepareSupportDefaultBehavior)
201
202enum class FoldingRangeKind { Comment, Imports, Region };
203Q_ENUM_NS(FoldingRangeKind)
204
205enum class SemanticTokenTypes {
206 Namespace,
207 Type,
208 Class,
209 Enum,
210 Interface,
211 Struct,
212 TypeParameter,
213 Parameter,
214 Variable,
215 Property,
216 EnumMember,
217 Event,
218 Function,
219 Method,
220 Macro,
221 Keyword,
222 Modifier,
223 Comment,
224 String,
225 Number,
226 Regexp,
227 Operator
228};
229Q_ENUM_NS(SemanticTokenTypes)
230
231enum class SemanticTokenModifiers {
232 Declaration,
233 Definition,
234 Readonly,
235 Static,
236 Deprecated,
237 Abstract,
238 Async,
239 Modification,
240 Documentation,
241 DefaultLibrary
242};
243Q_ENUM_NS(SemanticTokenModifiers)
244
245enum class TokenFormat { Relative };
246Q_ENUM_NS(TokenFormat)
247
248enum class UniquenessLevel { Document, Project, Group, Scheme, Global };
249Q_ENUM_NS(UniquenessLevel)
250
251enum class MonikerKind { Import, Export, Local };
252Q_ENUM_NS(MonikerKind)
253
254class Q_LANGUAGESERVER_EXPORT ResponseError
255{
256public:
257 int code = {};
258 QByteArray message = {};
259 std::optional<QJsonValue> data = {};
260
261 template<typename W>
262 void walk(W &w)
263 {
264 field(w, "code", code);
265 field(w, "message", message);
266 field(w, "data", data);
267 }
268};
269
270class Q_LANGUAGESERVER_EXPORT CancelParams
271{
272public:
273 std::variant<QByteArray, int> id = {};
274
275 template<typename W>
276 void walk(W &w)
277 {
278 field(w, "id", id);
279 }
280};
281
282class Q_LANGUAGESERVER_EXPORT RegularExpressionsClientCapabilities
283{
284public:
285 QByteArray engine = {};
286 std::optional<QByteArray> version = {};
287
288 template<typename W>
289 void walk(W &w)
290 {
291 field(w, "engine", engine);
292 field(w, "version", version);
293 }
294};
295
296class Q_LANGUAGESERVER_EXPORT Position
297{
298public:
299 int line = {};
300 int character = {};
301
302 template<typename W>
303 void walk(W &w)
304 {
305 field(w, "line", line);
306 field(w, "character", character);
307 }
308};
309
310class Q_LANGUAGESERVER_EXPORT Range
311{
312public:
313 Position start = {};
314 Position end = {};
315
316 template<typename W>
317 void walk(W &w)
318 {
319 field(w, "start", start);
320 field(w, "end", end);
321 }
322};
323
324class Q_LANGUAGESERVER_EXPORT TextDocumentContentChangeEvent
325{
326public:
327 std::optional<Range> range = {};
328 std::optional<int> rangeLength = {};
329 QByteArray text = {};
330
331 template<typename W>
332 void walk(W &w)
333 {
334 field(w, "range", range);
335 field(w, "rangeLength", rangeLength);
336 field(w, "text", text);
337 }
338};
339
340class Q_LANGUAGESERVER_EXPORT SelectionRange
341{
342public:
343 SelectionRange() = default;
344 SelectionRange(const Range &r) : range(r) { }
345 SelectionRange(const SelectionRange &o) : range(o.range)
346 {
347 if (o.parent)
348 parent = std::make_unique<SelectionRange>(args&: *o.parent);
349 }
350 SelectionRange &operator=(const SelectionRange &o)
351 {
352 range = o.range;
353 if (o.parent)
354 parent = std::make_unique<SelectionRange>(args&: *o.parent);
355 return *this;
356 }
357 SelectionRange(SelectionRange &&) noexcept = default;
358 SelectionRange &operator=(SelectionRange &&) noexcept = default;
359
360 Range range = {};
361 std::unique_ptr<SelectionRange> parent;
362
363 template<typename W>
364 void walk(W &w)
365 {
366 field(w, "range", range);
367 field(w, "parent", parent);
368 }
369};
370
371class Q_LANGUAGESERVER_EXPORT RangePlaceHolder
372{
373public:
374 Range range = {};
375 QByteArray placeholder = {};
376
377 template<typename W>
378 void walk(W &w)
379 {
380 field(w, "range", range);
381 field(w, "placeholder", placeholder);
382 }
383};
384
385class Q_LANGUAGESERVER_EXPORT DefaultBehaviorStruct
386{
387public:
388 bool defaultBehavior = {};
389
390 template<typename W>
391 void walk(W &w)
392 {
393 field(w, "defaultBehavior", defaultBehavior);
394 }
395};
396class Q_LANGUAGESERVER_EXPORT Location
397{
398public:
399 QByteArray uri = {};
400 Range range = {};
401
402 template<typename W>
403 void walk(W &w)
404 {
405 field(w, "uri", uri);
406 field(w, "range", range);
407 }
408};
409
410class Q_LANGUAGESERVER_EXPORT LocationLink
411{
412public:
413 std::optional<Range> originSelectionRange = {};
414 QByteArray targetUri = {};
415 Range targetRange = {};
416 Range targetSelectionRange = {};
417
418 template<typename W>
419 void walk(W &w)
420 {
421 field(w, "originSelectionRange", originSelectionRange);
422 field(w, "targetUri", targetUri);
423 field(w, "targetRange", targetRange);
424 field(w, "targetSelectionRange", targetSelectionRange);
425 }
426};
427
428class Q_LANGUAGESERVER_EXPORT DiagnosticRelatedInformation
429{
430public:
431 Location location = {};
432 QByteArray message = {};
433
434 template<typename W>
435 void walk(W &w)
436 {
437 field(w, "location", location);
438 field(w, "message", message);
439 }
440};
441
442class Q_LANGUAGESERVER_EXPORT CodeDescription
443{
444public:
445 QByteArray href = {};
446
447 template<typename W>
448 void walk(W &w)
449 {
450 field(w, "href", href);
451 }
452};
453
454class Q_LANGUAGESERVER_EXPORT Diagnostic
455{
456public:
457 Range range = {};
458 std::optional<DiagnosticSeverity> severity = {};
459 std::optional<std::variant<QByteArray, int>> code = {};
460 std::optional<CodeDescription> codeDescription = {};
461 std::optional<QByteArray> source = {};
462 QByteArray message = {};
463 std::optional<QList<DiagnosticTag>> tags = {};
464 std::optional<QList<DiagnosticRelatedInformation>> relatedInformation = {};
465 std::optional<QJsonValue> data = {};
466
467 template<typename W>
468 void walk(W &w)
469 {
470 field(w, "range", range);
471 field(w, "severity", severity);
472 field(w, "code", code);
473 field(w, "codeDescription", codeDescription);
474 field(w, "source", source);
475 field(w, "message", message);
476 field(w, "tags", tags);
477 field(w, "relatedInformation", relatedInformation);
478 field(w, "data", data);
479 }
480};
481
482class Q_LANGUAGESERVER_EXPORT Command
483{
484public:
485 QByteArray title = {};
486 QByteArray command = {};
487 std::optional<QList<QJsonValue>> arguments = {};
488
489 template<typename W>
490 void walk(W &w)
491 {
492 field(w, "title", title);
493 field(w, "command", command);
494 field(w, "arguments", arguments);
495 }
496};
497
498class Q_LANGUAGESERVER_EXPORT TextEdit
499{
500public:
501 Range range = {};
502 QByteArray newText = {};
503
504 template<typename W>
505 void walk(W &w)
506 {
507 field(w, "range", range);
508 field(w, "newText", newText);
509 }
510};
511
512class Q_LANGUAGESERVER_EXPORT ChangeAnnotation
513{
514public:
515 QByteArray label = {};
516 std::optional<bool> needsConfirmation = {};
517 std::optional<QByteArray> description = {};
518
519 template<typename W>
520 void walk(W &w)
521 {
522 field(w, "label", label);
523 field(w, "needsConfirmation", needsConfirmation);
524 field(w, "description", description);
525 }
526};
527
528class Q_LANGUAGESERVER_EXPORT AnnotatedTextEdit : public TextEdit
529{
530public:
531 QByteArray annotationId = {};
532
533 template<typename W>
534 void walk(W &w)
535 {
536 TextEdit::walk(w);
537 field(w, "annotationId", annotationId);
538 }
539};
540
541class Q_LANGUAGESERVER_EXPORT TextDocumentIdentifier
542{
543public:
544 QByteArray uri = {};
545
546 template<typename W>
547 void walk(W &w)
548 {
549 field(w, "uri", uri);
550 }
551};
552
553class Q_LANGUAGESERVER_EXPORT OptionalVersionedTextDocumentIdentifier
554 : public TextDocumentIdentifier
555{
556public:
557 std::variant<int, std::nullptr_t> version = nullptr;
558
559 template<typename W>
560 void walk(W &w)
561 {
562 TextDocumentIdentifier::walk(w);
563 field(w, "version", version);
564 }
565};
566
567class Q_LANGUAGESERVER_EXPORT TextDocumentEdit
568{
569public:
570 OptionalVersionedTextDocumentIdentifier textDocument = {};
571 QList<std::variant<TextEdit, AnnotatedTextEdit>> edits = {};
572
573 template<typename W>
574 void walk(W &w)
575 {
576 field(w, "textDocument", textDocument);
577 field(w, "edits", edits);
578 }
579};
580
581class Q_LANGUAGESERVER_EXPORT CreateFileOptions
582{
583public:
584 std::optional<bool> overwrite = {};
585 std::optional<bool> ignoreIfExists = {};
586
587 template<typename W>
588 void walk(W &w)
589 {
590 field(w, "overwrite", overwrite);
591 field(w, "ignoreIfExists", ignoreIfExists);
592 }
593};
594
595class Q_LANGUAGESERVER_EXPORT CreateFile
596{
597public:
598 QByteArray kind = {};
599 QByteArray uri = {};
600 std::optional<CreateFileOptions> options = {};
601 std::optional<QByteArray> annotationId = {};
602
603 template<typename W>
604 void walk(W &w)
605 {
606 field(w, "kind", kind);
607 field(w, "uri", uri);
608 field(w, "options", options);
609 field(w, "annotationId", annotationId);
610 }
611};
612
613class Q_LANGUAGESERVER_EXPORT RenameFileOptions
614{
615public:
616 std::optional<bool> overwrite = {};
617 std::optional<bool> ignoreIfExists = {};
618
619 template<typename W>
620 void walk(W &w)
621 {
622 field(w, "overwrite", overwrite);
623 field(w, "ignoreIfExists", ignoreIfExists);
624 }
625};
626
627class Q_LANGUAGESERVER_EXPORT RenameFile
628{
629public:
630 QByteArray kind = {};
631 QByteArray oldUri = {};
632 QByteArray newUri = {};
633 std::optional<RenameFileOptions> options = {};
634 std::optional<QByteArray> annotationId = {};
635
636 template<typename W>
637 void walk(W &w)
638 {
639 field(w, "kind", kind);
640 field(w, "oldUri", oldUri);
641 field(w, "newUri", newUri);
642 field(w, "options", options);
643 field(w, "annotationId", annotationId);
644 }
645};
646
647class Q_LANGUAGESERVER_EXPORT DeleteFileOptions
648{
649public:
650 std::optional<bool> recursive = {};
651 std::optional<bool> ignoreIfNotExists = {};
652
653 template<typename W>
654 void walk(W &w)
655 {
656 field(w, "recursive", recursive);
657 field(w, "ignoreIfNotExists", ignoreIfNotExists);
658 }
659};
660
661class Q_LANGUAGESERVER_EXPORT DeleteFile
662{
663public:
664 QByteArray kind = {};
665 QByteArray uri = {};
666 std::optional<DeleteFileOptions> options = {};
667 std::optional<QByteArray> annotationId = {};
668
669 template<typename W>
670 void walk(W &w)
671 {
672 field(w, "kind", kind);
673 field(w, "uri", uri);
674 field(w, "options", options);
675 field(w, "annotationId", annotationId);
676 }
677};
678
679class Q_LANGUAGESERVER_EXPORT WorkspaceEdit
680{
681public:
682 std::optional<QJsonObject> changes = {};
683 using DocumentChange = std::variant<TextDocumentEdit, CreateFile, RenameFile, DeleteFile>;
684 std::optional<QList<DocumentChange>> documentChanges = {};
685 std::optional<QJsonObject> changeAnnotations = {};
686
687 template<typename W>
688 void walk(W &w)
689 {
690 field(w, "changes", changes);
691 field(w, "documentChanges", documentChanges);
692 field(w, "changeAnnotations", changeAnnotations);
693 }
694};
695
696class Q_LANGUAGESERVER_EXPORT WorkspaceEditClientCapabilities
697{
698public:
699 std::optional<bool> documentChanges = {};
700 std::optional<QList<ResourceOperationKind>> resourceOperations = {};
701 std::optional<FailureHandlingKind> failureHandling = {};
702 std::optional<bool> normalizesLineEndings = {};
703 std::optional<QJsonObject> changeAnnotationSupport = {};
704
705 template<typename W>
706 void walk(W &w)
707 {
708 field(w, "documentChanges", documentChanges);
709 field(w, "resourceOperations", resourceOperations);
710 field(w, "failureHandling", failureHandling);
711 field(w, "normalizesLineEndings", normalizesLineEndings);
712 field(w, "changeAnnotationSupport", changeAnnotationSupport);
713 }
714};
715
716class Q_LANGUAGESERVER_EXPORT TextDocumentItem
717{
718public:
719 QByteArray uri = {};
720 QByteArray languageId = {};
721 int version = {};
722 QByteArray text = {};
723
724 template<typename W>
725 void walk(W &w)
726 {
727 field(w, "uri", uri);
728 field(w, "languageId", languageId);
729 field(w, "version", version);
730 field(w, "text", text);
731 }
732};
733
734class Q_LANGUAGESERVER_EXPORT VersionedTextDocumentIdentifier : public TextDocumentIdentifier
735{
736public:
737 int version = {};
738
739 template<typename W>
740 void walk(W &w)
741 {
742 TextDocumentIdentifier::walk(w);
743 field(w, "version", version);
744 }
745};
746
747class Q_LANGUAGESERVER_EXPORT TextDocumentPositionParams
748{
749public:
750 TextDocumentIdentifier textDocument = {};
751 Position position = {};
752
753 template<typename W>
754 void walk(W &w)
755 {
756 field(w, "textDocument", textDocument);
757 field(w, "position", position);
758 }
759};
760
761class Q_LANGUAGESERVER_EXPORT DocumentFilter
762{
763public:
764 std::optional<QByteArray> language = {};
765 std::optional<QByteArray> scheme = {};
766 std::optional<QByteArray> pattern = {};
767
768 template<typename W>
769 void walk(W &w)
770 {
771 field(w, "language", language);
772 field(w, "scheme", scheme);
773 field(w, "pattern", pattern);
774 }
775};
776
777using DocumentSelector = QList<DocumentFilter>;
778
779class Q_LANGUAGESERVER_EXPORT StaticRegistrationOptions
780{
781public:
782 std::optional<QByteArray> id = {};
783
784 template<typename W>
785 void walk(W &w)
786 {
787 field(w, "id", id);
788 }
789};
790
791class Q_LANGUAGESERVER_EXPORT TextDocumentRegistrationOptions
792{
793public:
794 std::variant<DocumentSelector, std::nullptr_t> documentSelector = nullptr;
795
796 template<typename W>
797 void walk(W &w)
798 {
799 field(w, "documentSelector", documentSelector);
800 }
801};
802
803class Q_LANGUAGESERVER_EXPORT MarkupContent
804{
805public:
806 MarkupKind kind = {};
807 QByteArray value = {};
808
809 template<typename W>
810 void walk(W &w)
811 {
812 field(w, "kind", kind);
813 field(w, "value", value);
814 }
815};
816
817class Q_LANGUAGESERVER_EXPORT MarkdownClientCapabilities
818{
819public:
820 QByteArray parser = {};
821 std::optional<QByteArray> version = {};
822
823 template<typename W>
824 void walk(W &w)
825 {
826 field(w, "parser", parser);
827 field(w, "version", version);
828 }
829};
830
831class Q_LANGUAGESERVER_EXPORT WorkDoneProgressBegin
832{
833public:
834 QByteArray kind = {};
835 QByteArray title = {};
836 std::optional<bool> cancellable = {};
837 std::optional<QByteArray> message = {};
838 std::optional<int> percentage = {};
839
840 template<typename W>
841 void walk(W &w)
842 {
843 field(w, "kind", kind);
844 field(w, "title", title);
845 field(w, "cancellable", cancellable);
846 field(w, "message", message);
847 field(w, "percentage", percentage);
848 }
849};
850
851class Q_LANGUAGESERVER_EXPORT WorkDoneProgressReport
852{
853public:
854 QByteArray kind = {};
855 std::optional<bool> cancellable = {};
856 std::optional<QByteArray> message = {};
857 std::optional<int> percentage = {};
858
859 template<typename W>
860 void walk(W &w)
861 {
862 field(w, "kind", kind);
863 field(w, "cancellable", cancellable);
864 field(w, "message", message);
865 field(w, "percentage", percentage);
866 }
867};
868
869class Q_LANGUAGESERVER_EXPORT WorkDoneProgressEnd
870{
871public:
872 QByteArray kind = {};
873 std::optional<QByteArray> message = {};
874
875 template<typename W>
876 void walk(W &w)
877 {
878 field(w, "kind", kind);
879 field(w, "message", message);
880 }
881};
882
883class Q_LANGUAGESERVER_EXPORT WorkDoneProgressParams
884{
885public:
886 std::optional<ProgressToken> workDoneToken = {};
887
888 template<typename W>
889 void walk(W &w)
890 {
891 field(w, "workDoneToken", workDoneToken);
892 }
893};
894
895class Q_LANGUAGESERVER_EXPORT WorkDoneProgressOptions
896{
897public:
898 std::optional<bool> workDoneProgress = {};
899
900 template<typename W>
901 void walk(W &w)
902 {
903 field(w, "workDoneProgress", workDoneProgress);
904 }
905};
906
907class Q_LANGUAGESERVER_EXPORT PartialResultParams
908{
909public:
910 std::optional<ProgressToken> partialResultToken = {};
911
912 template<typename W>
913 void walk(W &w)
914 {
915 field(w, "partialResultToken", partialResultToken);
916 }
917};
918
919class Q_LANGUAGESERVER_EXPORT TextDocumentSyncClientCapabilities
920{
921public:
922 std::optional<bool> dynamicRegistration = {};
923 std::optional<bool> willSave = {};
924 std::optional<bool> willSaveWaitUntil = {};
925 std::optional<bool> didSave = {};
926
927 template<typename W>
928 void walk(W &w)
929 {
930 field(w, "dynamicRegistration", dynamicRegistration);
931 field(w, "willSave", willSave);
932 field(w, "willSaveWaitUntil", willSaveWaitUntil);
933 field(w, "didSave", didSave);
934 }
935};
936
937class Q_LANGUAGESERVER_EXPORT PublishDiagnosticsClientCapabilities
938{
939public:
940 std::optional<bool> relatedInformation = {};
941 std::optional<QJsonObject> tagSupport = {};
942 std::optional<bool> versionSupport = {};
943 std::optional<bool> codeDescriptionSupport = {};
944 std::optional<bool> dataSupport = {};
945
946 template<typename W>
947 void walk(W &w)
948 {
949 field(w, "relatedInformation", relatedInformation);
950 field(w, "tagSupport", tagSupport);
951 field(w, "versionSupport", versionSupport);
952 field(w, "codeDescriptionSupport", codeDescriptionSupport);
953 field(w, "dataSupport", dataSupport);
954 }
955};
956
957class Q_LANGUAGESERVER_EXPORT CompletionClientCapabilities
958{
959public:
960 std::optional<bool> dynamicRegistration = {};
961 std::optional<QJsonObject> completionItem = {};
962 std::optional<QJsonObject> completionItemKind = {};
963 std::optional<bool> contextSupport = {};
964
965 template<typename W>
966 void walk(W &w)
967 {
968 field(w, "dynamicRegistration", dynamicRegistration);
969 field(w, "completionItem", completionItem);
970 field(w, "completionItemKind", completionItemKind);
971 field(w, "contextSupport", contextSupport);
972 }
973};
974
975class Q_LANGUAGESERVER_EXPORT HoverClientCapabilities
976{
977public:
978 std::optional<bool> dynamicRegistration = {};
979 std::optional<QList<MarkupKind>> contentFormat = {};
980
981 template<typename W>
982 void walk(W &w)
983 {
984 field(w, "dynamicRegistration", dynamicRegistration);
985 field(w, "contentFormat", contentFormat);
986 }
987};
988
989class Q_LANGUAGESERVER_EXPORT SignatureHelpClientCapabilities
990{
991public:
992 std::optional<bool> dynamicRegistration = {};
993 std::optional<QJsonObject> signatureInformation = {};
994 std::optional<bool> contextSupport = {};
995
996 template<typename W>
997 void walk(W &w)
998 {
999 field(w, "dynamicRegistration", dynamicRegistration);
1000 field(w, "signatureInformation", signatureInformation);
1001 field(w, "contextSupport", contextSupport);
1002 }
1003};
1004
1005class Q_LANGUAGESERVER_EXPORT DeclarationClientCapabilities
1006{
1007public:
1008 std::optional<bool> dynamicRegistration = {};
1009 std::optional<bool> linkSupport = {};
1010
1011 template<typename W>
1012 void walk(W &w)
1013 {
1014 field(w, "dynamicRegistration", dynamicRegistration);
1015 field(w, "linkSupport", linkSupport);
1016 }
1017};
1018
1019class Q_LANGUAGESERVER_EXPORT DefinitionClientCapabilities
1020{
1021public:
1022 std::optional<bool> dynamicRegistration = {};
1023 std::optional<bool> linkSupport = {};
1024
1025 template<typename W>
1026 void walk(W &w)
1027 {
1028 field(w, "dynamicRegistration", dynamicRegistration);
1029 field(w, "linkSupport", linkSupport);
1030 }
1031};
1032
1033class Q_LANGUAGESERVER_EXPORT TypeDefinitionClientCapabilities
1034{
1035public:
1036 std::optional<bool> dynamicRegistration = {};
1037 std::optional<bool> linkSupport = {};
1038
1039 template<typename W>
1040 void walk(W &w)
1041 {
1042 field(w, "dynamicRegistration", dynamicRegistration);
1043 field(w, "linkSupport", linkSupport);
1044 }
1045};
1046
1047class Q_LANGUAGESERVER_EXPORT ImplementationClientCapabilities
1048{
1049public:
1050 std::optional<bool> dynamicRegistration = {};
1051 std::optional<bool> linkSupport = {};
1052
1053 template<typename W>
1054 void walk(W &w)
1055 {
1056 field(w, "dynamicRegistration", dynamicRegistration);
1057 field(w, "linkSupport", linkSupport);
1058 }
1059};
1060
1061class Q_LANGUAGESERVER_EXPORT ReferenceClientCapabilities
1062{
1063public:
1064 std::optional<bool> dynamicRegistration = {};
1065
1066 template<typename W>
1067 void walk(W &w)
1068 {
1069 field(w, "dynamicRegistration", dynamicRegistration);
1070 }
1071};
1072
1073class Q_LANGUAGESERVER_EXPORT DocumentHighlightClientCapabilities
1074{
1075public:
1076 std::optional<bool> dynamicRegistration = {};
1077
1078 template<typename W>
1079 void walk(W &w)
1080 {
1081 field(w, "dynamicRegistration", dynamicRegistration);
1082 }
1083};
1084
1085class Q_LANGUAGESERVER_EXPORT DocumentSymbolClientCapabilities
1086{
1087public:
1088 std::optional<bool> dynamicRegistration = {};
1089 std::optional<QJsonObject> symbolKind = {};
1090 std::optional<bool> hierarchicalDocumentSymbolSupport = {};
1091 std::optional<QJsonObject> tagSupport = {};
1092 std::optional<bool> labelSupport = {};
1093
1094 template<typename W>
1095 void walk(W &w)
1096 {
1097 field(w, "dynamicRegistration", dynamicRegistration);
1098 field(w, "symbolKind", symbolKind);
1099 field(w, "hierarchicalDocumentSymbolSupport", hierarchicalDocumentSymbolSupport);
1100 field(w, "tagSupport", tagSupport);
1101 field(w, "labelSupport", labelSupport);
1102 }
1103};
1104
1105class Q_LANGUAGESERVER_EXPORT CodeActionClientCapabilities
1106{
1107public:
1108 std::optional<bool> dynamicRegistration = {};
1109 std::optional<QJsonObject> codeActionLiteralSupport = {};
1110 std::optional<bool> isPreferredSupport = {};
1111 std::optional<bool> disabledSupport = {};
1112 std::optional<bool> dataSupport = {};
1113 std::optional<QJsonObject> resolveSupport = {};
1114 std::optional<bool> honorsChangeAnnotations = {};
1115
1116 template<typename W>
1117 void walk(W &w)
1118 {
1119 field(w, "dynamicRegistration", dynamicRegistration);
1120 field(w, "codeActionLiteralSupport", codeActionLiteralSupport);
1121 field(w, "isPreferredSupport", isPreferredSupport);
1122 field(w, "disabledSupport", disabledSupport);
1123 field(w, "dataSupport", dataSupport);
1124 field(w, "resolveSupport", resolveSupport);
1125 field(w, "honorsChangeAnnotations", honorsChangeAnnotations);
1126 }
1127};
1128
1129class Q_LANGUAGESERVER_EXPORT CodeLensClientCapabilities
1130{
1131public:
1132 std::optional<bool> dynamicRegistration = {};
1133
1134 template<typename W>
1135 void walk(W &w)
1136 {
1137 field(w, "dynamicRegistration", dynamicRegistration);
1138 }
1139};
1140
1141class Q_LANGUAGESERVER_EXPORT DocumentLinkClientCapabilities
1142{
1143public:
1144 std::optional<bool> dynamicRegistration = {};
1145 std::optional<bool> tooltipSupport = {};
1146
1147 template<typename W>
1148 void walk(W &w)
1149 {
1150 field(w, "dynamicRegistration", dynamicRegistration);
1151 field(w, "tooltipSupport", tooltipSupport);
1152 }
1153};
1154
1155class Q_LANGUAGESERVER_EXPORT DocumentColorClientCapabilities
1156{
1157public:
1158 std::optional<bool> dynamicRegistration = {};
1159
1160 template<typename W>
1161 void walk(W &w)
1162 {
1163 field(w, "dynamicRegistration", dynamicRegistration);
1164 }
1165};
1166
1167class Q_LANGUAGESERVER_EXPORT DocumentFormattingClientCapabilities
1168{
1169public:
1170 std::optional<bool> dynamicRegistration = {};
1171
1172 template<typename W>
1173 void walk(W &w)
1174 {
1175 field(w, "dynamicRegistration", dynamicRegistration);
1176 }
1177};
1178
1179class Q_LANGUAGESERVER_EXPORT DocumentRangeFormattingClientCapabilities
1180{
1181public:
1182 std::optional<bool> dynamicRegistration = {};
1183
1184 template<typename W>
1185 void walk(W &w)
1186 {
1187 field(w, "dynamicRegistration", dynamicRegistration);
1188 }
1189};
1190
1191class Q_LANGUAGESERVER_EXPORT DocumentOnTypeFormattingClientCapabilities
1192{
1193public:
1194 std::optional<bool> dynamicRegistration = {};
1195
1196 template<typename W>
1197 void walk(W &w)
1198 {
1199 field(w, "dynamicRegistration", dynamicRegistration);
1200 }
1201};
1202
1203class Q_LANGUAGESERVER_EXPORT RenameClientCapabilities
1204{
1205public:
1206 std::optional<bool> dynamicRegistration = {};
1207 std::optional<bool> prepareSupport = {};
1208 std::optional<QJsonValue> prepareSupportDefaultBehavior = {};
1209 std::optional<bool> honorsChangeAnnotations = {};
1210
1211 template<typename W>
1212 void walk(W &w)
1213 {
1214 field(w, "dynamicRegistration", dynamicRegistration);
1215 field(w, "prepareSupport", prepareSupport);
1216 field(w, "prepareSupportDefaultBehavior", prepareSupportDefaultBehavior);
1217 field(w, "honorsChangeAnnotations", honorsChangeAnnotations);
1218 }
1219};
1220
1221class Q_LANGUAGESERVER_EXPORT FoldingRangeClientCapabilities
1222{
1223public:
1224 std::optional<bool> dynamicRegistration = {};
1225 std::optional<int> rangeLimit = {};
1226 std::optional<bool> lineFoldingOnly = {};
1227
1228 template<typename W>
1229 void walk(W &w)
1230 {
1231 field(w, "dynamicRegistration", dynamicRegistration);
1232 field(w, "rangeLimit", rangeLimit);
1233 field(w, "lineFoldingOnly", lineFoldingOnly);
1234 }
1235};
1236
1237class Q_LANGUAGESERVER_EXPORT SelectionRangeClientCapabilities
1238{
1239public:
1240 std::optional<bool> dynamicRegistration = {};
1241
1242 template<typename W>
1243 void walk(W &w)
1244 {
1245 field(w, "dynamicRegistration", dynamicRegistration);
1246 }
1247};
1248
1249class Q_LANGUAGESERVER_EXPORT CallHierarchyClientCapabilities
1250{
1251public:
1252 std::optional<bool> dynamicRegistration = {};
1253
1254 template<typename W>
1255 void walk(W &w)
1256 {
1257 field(w, "dynamicRegistration", dynamicRegistration);
1258 }
1259};
1260
1261class Q_LANGUAGESERVER_EXPORT SemanticTokensClientCapabilities
1262{
1263public:
1264 std::optional<bool> dynamicRegistration = {};
1265
1266 class Q_LANGUAGESERVER_EXPORT Requests
1267 {
1268 public:
1269 std::optional<std::variant<bool, QJsonObject>> range = {};
1270 std::optional<std::variant<bool, QJsonObject>> full = {};
1271
1272 template<typename W>
1273 void walk(W &w)
1274 {
1275 field(w, "range", range);
1276 field(w, "full", full);
1277 }
1278 };
1279
1280 Requests requests = {};
1281 QList<QByteArray> tokenTypes = {};
1282 QList<QByteArray> tokenModifiers = {};
1283 QList<QByteArray> formats = {};
1284 std::optional<bool> overlappingTokenSupport = {};
1285 std::optional<bool> multilineTokenSupport = {};
1286
1287 template<typename W>
1288 void walk(W &w)
1289 {
1290 field(w, "dynamicRegistration", dynamicRegistration);
1291 field(w, "requests", requests);
1292 field(w, "tokenTypes", tokenTypes);
1293 field(w, "tokenModifiers", tokenModifiers);
1294 field(w, "formats", formats);
1295 field(w, "overlappingTokenSupport", overlappingTokenSupport);
1296 field(w, "multilineTokenSupport", multilineTokenSupport);
1297 }
1298};
1299
1300class Q_LANGUAGESERVER_EXPORT LinkedEditingRangeClientCapabilities
1301{
1302public:
1303 std::optional<bool> dynamicRegistration = {};
1304
1305 template<typename W>
1306 void walk(W &w)
1307 {
1308 field(w, "dynamicRegistration", dynamicRegistration);
1309 }
1310};
1311
1312class Q_LANGUAGESERVER_EXPORT MonikerClientCapabilities
1313{
1314public:
1315 std::optional<bool> dynamicRegistration = {};
1316
1317 template<typename W>
1318 void walk(W &w)
1319 {
1320 field(w, "dynamicRegistration", dynamicRegistration);
1321 }
1322};
1323
1324class Q_LANGUAGESERVER_EXPORT TextDocumentClientCapabilities
1325{
1326public:
1327 std::optional<TextDocumentSyncClientCapabilities> synchronization = {};
1328 std::optional<CompletionClientCapabilities> completion = {};
1329 std::optional<HoverClientCapabilities> hover = {};
1330 std::optional<SignatureHelpClientCapabilities> signatureHelp = {};
1331 std::optional<DeclarationClientCapabilities> declaration = {};
1332 std::optional<DefinitionClientCapabilities> definition = {};
1333 std::optional<TypeDefinitionClientCapabilities> typeDefinition = {};
1334 std::optional<ImplementationClientCapabilities> implementation = {};
1335 std::optional<ReferenceClientCapabilities> references = {};
1336 std::optional<DocumentHighlightClientCapabilities> documentHighlight = {};
1337 std::optional<DocumentSymbolClientCapabilities> documentSymbol = {};
1338 std::optional<CodeActionClientCapabilities> codeAction = {};
1339 std::optional<CodeLensClientCapabilities> codeLens = {};
1340 std::optional<DocumentLinkClientCapabilities> documentLink = {};
1341 std::optional<DocumentColorClientCapabilities> colorProvider = {};
1342 std::optional<DocumentFormattingClientCapabilities> formatting = {};
1343 std::optional<DocumentRangeFormattingClientCapabilities> rangeFormatting = {};
1344 std::optional<DocumentOnTypeFormattingClientCapabilities> onTypeFormatting = {};
1345 std::optional<RenameClientCapabilities> rename = {};
1346 std::optional<PublishDiagnosticsClientCapabilities> publishDiagnostics = {};
1347 std::optional<FoldingRangeClientCapabilities> foldingRange = {};
1348 std::optional<SelectionRangeClientCapabilities> selectionRange = {};
1349 std::optional<LinkedEditingRangeClientCapabilities> linkedEditingRange = {};
1350 std::optional<CallHierarchyClientCapabilities> callHierarchy = {};
1351 std::optional<SemanticTokensClientCapabilities> semanticTokens = {};
1352 std::optional<MonikerClientCapabilities> moniker = {};
1353
1354 template<typename W>
1355 void walk(W &w)
1356 {
1357 field(w, "synchronization", synchronization);
1358 field(w, "completion", completion);
1359 field(w, "hover", hover);
1360 field(w, "signatureHelp", signatureHelp);
1361 field(w, "declaration", declaration);
1362 field(w, "definition", definition);
1363 field(w, "typeDefinition", typeDefinition);
1364 field(w, "implementation", implementation);
1365 field(w, "references", references);
1366 field(w, "documentHighlight", documentHighlight);
1367 field(w, "documentSymbol", documentSymbol);
1368 field(w, "codeAction", codeAction);
1369 field(w, "codeLens", codeLens);
1370 field(w, "documentLink", documentLink);
1371 field(w, "colorProvider", colorProvider);
1372 field(w, "formatting", formatting);
1373 field(w, "rangeFormatting", rangeFormatting);
1374 field(w, "onTypeFormatting", onTypeFormatting);
1375 field(w, "rename", rename);
1376 field(w, "publishDiagnostics", publishDiagnostics);
1377 field(w, "foldingRange", foldingRange);
1378 field(w, "selectionRange", selectionRange);
1379 field(w, "linkedEditingRange", linkedEditingRange);
1380 field(w, "callHierarchy", callHierarchy);
1381 field(w, "semanticTokens", semanticTokens);
1382 field(w, "moniker", moniker);
1383 }
1384};
1385
1386class Q_LANGUAGESERVER_EXPORT ShowMessageRequestClientCapabilities
1387{
1388public:
1389 std::optional<QJsonObject> messageActionItem = {};
1390
1391 template<typename W>
1392 void walk(W &w)
1393 {
1394 field(w, "messageActionItem", messageActionItem);
1395 }
1396};
1397
1398class Q_LANGUAGESERVER_EXPORT ShowDocumentClientCapabilities
1399{
1400public:
1401 bool support = {};
1402
1403 template<typename W>
1404 void walk(W &w)
1405 {
1406 field(w, "support", support);
1407 }
1408};
1409
1410class Q_LANGUAGESERVER_EXPORT DidChangeConfigurationClientCapabilities
1411{
1412public:
1413 std::optional<bool> dynamicRegistration = {};
1414
1415 template<typename W>
1416 void walk(W &w)
1417 {
1418 field(w, "dynamicRegistration", dynamicRegistration);
1419 }
1420};
1421
1422class Q_LANGUAGESERVER_EXPORT ClientCapabilities
1423{
1424public:
1425 std::optional<QJsonObject> workspace = {};
1426 std::optional<TextDocumentClientCapabilities> textDocument = {};
1427 std::optional<QJsonObject> window = {};
1428 std::optional<QJsonObject> general = {};
1429 std::optional<QJsonValue> experimental = {};
1430
1431 template<typename W>
1432 void walk(W &w)
1433 {
1434 field(w, "workspace", workspace);
1435 field(w, "textDocument", textDocument);
1436 field(w, "window", window);
1437 field(w, "general", general);
1438 field(w, "experimental", experimental);
1439 }
1440};
1441
1442class Q_LANGUAGESERVER_EXPORT WorkspaceFolder
1443{
1444public:
1445 QByteArray uri = {};
1446 QByteArray name = {};
1447
1448 template<typename W>
1449 void walk(W &w)
1450 {
1451 field(w, "uri", uri);
1452 field(w, "name", name);
1453 }
1454};
1455
1456class Q_LANGUAGESERVER_EXPORT InitializeParams : public WorkDoneProgressParams
1457{
1458public:
1459 std::variant<int, std::nullptr_t> processId = nullptr;
1460 std::optional<QJsonObject> clientInfo = {};
1461 std::optional<QByteArray> locale = {};
1462 std::optional<std::variant<QByteArray, std::nullptr_t>> rootPath = nullptr;
1463 std::variant<QByteArray, std::nullptr_t> rootUri = nullptr;
1464 std::optional<QJsonValue> initializationOptions = {};
1465 ClientCapabilities capabilities = {};
1466 std::optional<TraceValue> trace = {};
1467 std::optional<std::variant<QList<WorkspaceFolder>, std::nullptr_t>> workspaceFolders = nullptr;
1468
1469 template<typename W>
1470 void walk(W &w)
1471 {
1472 WorkDoneProgressParams::walk(w);
1473 field(w, "processId", processId);
1474 field(w, "clientInfo", clientInfo);
1475 field(w, "locale", locale);
1476 field(w, "rootPath", rootPath);
1477 field(w, "rootUri", rootUri);
1478 field(w, "initializationOptions", initializationOptions);
1479 field(w, "capabilities", capabilities);
1480 field(w, "trace", trace);
1481 field(w, "workspaceFolders", workspaceFolders);
1482 }
1483};
1484
1485class Q_LANGUAGESERVER_EXPORT WorkspaceFoldersServerCapabilities
1486{
1487public:
1488 std::optional<bool> supported = {};
1489 std::optional<std::variant<QByteArray, bool>> changeNotifications = {};
1490
1491 template<typename W>
1492 void walk(W &w)
1493 {
1494 field(w, "supported", supported);
1495 field(w, "changeNotifications", changeNotifications);
1496 }
1497};
1498
1499class Q_LANGUAGESERVER_EXPORT WorkspaceSymbolOptions : public WorkDoneProgressOptions
1500{
1501public:
1502 template<typename W>
1503 void walk(W &w)
1504 {
1505 WorkDoneProgressOptions::walk(w);
1506 }
1507};
1508
1509class Q_LANGUAGESERVER_EXPORT ExecuteCommandOptions : public WorkDoneProgressOptions
1510{
1511public:
1512 QList<QByteArray> commands = {};
1513
1514 template<typename W>
1515 void walk(W &w)
1516 {
1517 WorkDoneProgressOptions::walk(w);
1518 field(w, "commands", commands);
1519 }
1520};
1521
1522class Q_LANGUAGESERVER_EXPORT FileOperationPatternOptions
1523{
1524public:
1525 std::optional<bool> ignoreCase = {};
1526
1527 template<typename W>
1528 void walk(W &w)
1529 {
1530 field(w, "ignoreCase", ignoreCase);
1531 }
1532};
1533
1534class Q_LANGUAGESERVER_EXPORT FileOperationPattern
1535{
1536public:
1537 QByteArray glob = {};
1538 std::optional<FileOperationPatternKind> matches = {};
1539 std::optional<FileOperationPatternOptions> options = {};
1540
1541 template<typename W>
1542 void walk(W &w)
1543 {
1544 field(w, "glob", glob);
1545 field(w, "matches", matches);
1546 field(w, "options", options);
1547 }
1548};
1549
1550class Q_LANGUAGESERVER_EXPORT FileOperationFilter
1551{
1552public:
1553 std::optional<QByteArray> scheme = {};
1554 FileOperationPattern pattern = {};
1555
1556 template<typename W>
1557 void walk(W &w)
1558 {
1559 field(w, "scheme", scheme);
1560 field(w, "pattern", pattern);
1561 }
1562};
1563
1564class Q_LANGUAGESERVER_EXPORT FileOperationRegistrationOptions
1565{
1566public:
1567 QList<FileOperationFilter> filters = {};
1568
1569 template<typename W>
1570 void walk(W &w)
1571 {
1572 field(w, "filters", filters);
1573 }
1574};
1575
1576class Q_LANGUAGESERVER_EXPORT TextDocumentSyncOptions
1577{
1578public:
1579 std::optional<bool> openClose = {};
1580 std::optional<TextDocumentSyncKind> change = {};
1581
1582 template<typename W>
1583 void walk(W &w)
1584 {
1585 field(w, "openClose", openClose);
1586 field(w, "change", change);
1587 }
1588};
1589
1590class Q_LANGUAGESERVER_EXPORT CompletionOptions : public WorkDoneProgressOptions
1591{
1592public:
1593 std::optional<QList<QByteArray>> triggerCharacters = {};
1594 std::optional<QList<QByteArray>> allCommitCharacters = {};
1595 std::optional<bool> resolveProvider = {};
1596
1597 template<typename W>
1598 void walk(W &w)
1599 {
1600 WorkDoneProgressOptions::walk(w);
1601 field(w, "triggerCharacters", triggerCharacters);
1602 field(w, "allCommitCharacters", allCommitCharacters);
1603 field(w, "resolveProvider", resolveProvider);
1604 }
1605};
1606
1607class Q_LANGUAGESERVER_EXPORT HoverOptions : public WorkDoneProgressOptions
1608{
1609public:
1610 template<typename W>
1611 void walk(W &w)
1612 {
1613 WorkDoneProgressOptions::walk(w);
1614 }
1615};
1616
1617class Q_LANGUAGESERVER_EXPORT SignatureHelpOptions : public WorkDoneProgressOptions
1618{
1619public:
1620 std::optional<QList<QByteArray>> triggerCharacters = {};
1621 std::optional<QList<QByteArray>> retriggerCharacters = {};
1622
1623 template<typename W>
1624 void walk(W &w)
1625 {
1626 WorkDoneProgressOptions::walk(w);
1627 field(w, "triggerCharacters", triggerCharacters);
1628 field(w, "retriggerCharacters", retriggerCharacters);
1629 }
1630};
1631
1632class Q_LANGUAGESERVER_EXPORT DeclarationOptions : public WorkDoneProgressOptions
1633{
1634public:
1635 template<typename W>
1636 void walk(W &w)
1637 {
1638 WorkDoneProgressOptions::walk(w);
1639 }
1640};
1641
1642class Q_LANGUAGESERVER_EXPORT DeclarationRegistrationOptions : public DeclarationOptions,
1643 TextDocumentRegistrationOptions,
1644 StaticRegistrationOptions
1645{
1646public:
1647 template<typename W>
1648 void walk(W &w)
1649 {
1650 DeclarationOptions::walk(w);
1651 TextDocumentRegistrationOptions::walk(w);
1652 StaticRegistrationOptions::walk(w);
1653 }
1654};
1655
1656class Q_LANGUAGESERVER_EXPORT DefinitionOptions : public WorkDoneProgressOptions
1657{
1658public:
1659 template<typename W>
1660 void walk(W &w)
1661 {
1662 WorkDoneProgressOptions::walk(w);
1663 }
1664};
1665
1666class Q_LANGUAGESERVER_EXPORT TypeDefinitionOptions : public WorkDoneProgressOptions
1667{
1668public:
1669 template<typename W>
1670 void walk(W &w)
1671 {
1672 WorkDoneProgressOptions::walk(w);
1673 }
1674};
1675
1676class Q_LANGUAGESERVER_EXPORT TypeDefinitionRegistrationOptions
1677 : public TextDocumentRegistrationOptions,
1678 TypeDefinitionOptions,
1679 StaticRegistrationOptions
1680{
1681public:
1682 template<typename W>
1683 void walk(W &w)
1684 {
1685 TextDocumentRegistrationOptions::walk(w);
1686 TypeDefinitionOptions::walk(w);
1687 StaticRegistrationOptions::walk(w);
1688 }
1689};
1690
1691class Q_LANGUAGESERVER_EXPORT ImplementationOptions : public WorkDoneProgressOptions
1692{
1693public:
1694 template<typename W>
1695 void walk(W &w)
1696 {
1697 WorkDoneProgressOptions::walk(w);
1698 }
1699};
1700
1701class Q_LANGUAGESERVER_EXPORT ImplementationRegistrationOptions
1702 : public TextDocumentRegistrationOptions,
1703 ImplementationOptions,
1704 StaticRegistrationOptions
1705{
1706public:
1707 template<typename W>
1708 void walk(W &w)
1709 {
1710 TextDocumentRegistrationOptions::walk(w);
1711 ImplementationOptions::walk(w);
1712 StaticRegistrationOptions::walk(w);
1713 }
1714};
1715
1716class Q_LANGUAGESERVER_EXPORT ReferenceOptions : public WorkDoneProgressOptions
1717{
1718public:
1719 template<typename W>
1720 void walk(W &w)
1721 {
1722 WorkDoneProgressOptions::walk(w);
1723 }
1724};
1725
1726class Q_LANGUAGESERVER_EXPORT DocumentHighlightOptions : public WorkDoneProgressOptions
1727{
1728public:
1729 template<typename W>
1730 void walk(W &w)
1731 {
1732 WorkDoneProgressOptions::walk(w);
1733 }
1734};
1735
1736class Q_LANGUAGESERVER_EXPORT DocumentSymbolOptions : public WorkDoneProgressOptions
1737{
1738public:
1739 std::optional<QByteArray> label = {};
1740
1741 template<typename W>
1742 void walk(W &w)
1743 {
1744 WorkDoneProgressOptions::walk(w);
1745 field(w, "label", label);
1746 }
1747};
1748
1749class Q_LANGUAGESERVER_EXPORT CodeActionOptions : public WorkDoneProgressOptions
1750{
1751public:
1752 std::optional<QList<QByteArray>> codeActionKinds = {};
1753 std::optional<bool> resolveProvider = {};
1754
1755 template<typename W>
1756 void walk(W &w)
1757 {
1758 WorkDoneProgressOptions::walk(w);
1759 field(w, "codeActionKinds", codeActionKinds);
1760 field(w, "resolveProvider", resolveProvider);
1761 }
1762};
1763
1764class Q_LANGUAGESERVER_EXPORT CodeLensOptions : public WorkDoneProgressOptions
1765{
1766public:
1767 std::optional<bool> resolveProvider = {};
1768
1769 template<typename W>
1770 void walk(W &w)
1771 {
1772 WorkDoneProgressOptions::walk(w);
1773 field(w, "resolveProvider", resolveProvider);
1774 }
1775};
1776
1777class Q_LANGUAGESERVER_EXPORT DocumentLinkOptions : public WorkDoneProgressOptions
1778{
1779public:
1780 std::optional<bool> resolveProvider = {};
1781
1782 template<typename W>
1783 void walk(W &w)
1784 {
1785 WorkDoneProgressOptions::walk(w);
1786 field(w, "resolveProvider", resolveProvider);
1787 }
1788};
1789
1790class Q_LANGUAGESERVER_EXPORT DocumentColorOptions : public WorkDoneProgressOptions
1791{
1792public:
1793 template<typename W>
1794 void walk(W &w)
1795 {
1796 WorkDoneProgressOptions::walk(w);
1797 }
1798};
1799
1800class Q_LANGUAGESERVER_EXPORT DocumentColorRegistrationOptions
1801 : public TextDocumentRegistrationOptions,
1802 StaticRegistrationOptions,
1803 DocumentColorOptions
1804{
1805public:
1806 template<typename W>
1807 void walk(W &w)
1808 {
1809 TextDocumentRegistrationOptions::walk(w);
1810 StaticRegistrationOptions::walk(w);
1811 DocumentColorOptions::walk(w);
1812 }
1813};
1814
1815class Q_LANGUAGESERVER_EXPORT DocumentFormattingOptions : public WorkDoneProgressOptions
1816{
1817public:
1818 template<typename W>
1819 void walk(W &w)
1820 {
1821 WorkDoneProgressOptions::walk(w);
1822 }
1823};
1824
1825class Q_LANGUAGESERVER_EXPORT DocumentRangeFormattingOptions : public WorkDoneProgressOptions
1826{
1827public:
1828 template<typename W>
1829 void walk(W &w)
1830 {
1831 WorkDoneProgressOptions::walk(w);
1832 }
1833};
1834
1835class Q_LANGUAGESERVER_EXPORT DocumentOnTypeFormattingOptions
1836{
1837public:
1838 QByteArray firstTriggerCharacter = {};
1839 std::optional<QList<QByteArray>> moreTriggerCharacter = {};
1840
1841 template<typename W>
1842 void walk(W &w)
1843 {
1844 field(w, "firstTriggerCharacter", firstTriggerCharacter);
1845 field(w, "moreTriggerCharacter", moreTriggerCharacter);
1846 }
1847};
1848
1849class Q_LANGUAGESERVER_EXPORT RenameOptions : public WorkDoneProgressOptions
1850{
1851public:
1852 std::optional<bool> prepareProvider = {};
1853
1854 template<typename W>
1855 void walk(W &w)
1856 {
1857 WorkDoneProgressOptions::walk(w);
1858 field(w, "prepareProvider", prepareProvider);
1859 }
1860};
1861
1862class Q_LANGUAGESERVER_EXPORT FoldingRangeOptions : public WorkDoneProgressOptions
1863{
1864public:
1865 template<typename W>
1866 void walk(W &w)
1867 {
1868 WorkDoneProgressOptions::walk(w);
1869 }
1870};
1871
1872class Q_LANGUAGESERVER_EXPORT FoldingRangeRegistrationOptions
1873 : public TextDocumentRegistrationOptions,
1874 FoldingRangeOptions,
1875 StaticRegistrationOptions
1876{
1877public:
1878 template<typename W>
1879 void walk(W &w)
1880 {
1881 TextDocumentRegistrationOptions::walk(w);
1882 FoldingRangeOptions::walk(w);
1883 StaticRegistrationOptions::walk(w);
1884 }
1885};
1886
1887class Q_LANGUAGESERVER_EXPORT SelectionRangeOptions : public WorkDoneProgressOptions
1888{
1889public:
1890 template<typename W>
1891 void walk(W &w)
1892 {
1893 WorkDoneProgressOptions::walk(w);
1894 }
1895};
1896
1897class Q_LANGUAGESERVER_EXPORT SelectionRangeRegistrationOptions : public SelectionRangeOptions,
1898 TextDocumentRegistrationOptions,
1899 StaticRegistrationOptions
1900{
1901public:
1902 template<typename W>
1903 void walk(W &w)
1904 {
1905 SelectionRangeOptions::walk(w);
1906 TextDocumentRegistrationOptions::walk(w);
1907 StaticRegistrationOptions::walk(w);
1908 }
1909};
1910
1911class Q_LANGUAGESERVER_EXPORT CallHierarchyOptions : public WorkDoneProgressOptions
1912{
1913public:
1914 template<typename W>
1915 void walk(W &w)
1916 {
1917 WorkDoneProgressOptions::walk(w);
1918 }
1919};
1920
1921class Q_LANGUAGESERVER_EXPORT CallHierarchyRegistrationOptions
1922 : public TextDocumentRegistrationOptions,
1923 CallHierarchyOptions,
1924 StaticRegistrationOptions
1925{
1926public:
1927 template<typename W>
1928 void walk(W &w)
1929 {
1930 TextDocumentRegistrationOptions::walk(w);
1931 CallHierarchyOptions::walk(w);
1932 StaticRegistrationOptions::walk(w);
1933 }
1934};
1935
1936class Q_LANGUAGESERVER_EXPORT SemanticTokensLegend
1937{
1938public:
1939 QList<QByteArray> tokenTypes = {};
1940 QList<QByteArray> tokenModifiers = {};
1941
1942 template<typename W>
1943 void walk(W &w)
1944 {
1945 field(w, "tokenTypes", tokenTypes);
1946 field(w, "tokenModifiers", tokenModifiers);
1947 }
1948};
1949
1950class Q_LANGUAGESERVER_EXPORT SemanticTokensOptions : public WorkDoneProgressOptions
1951{
1952public:
1953 SemanticTokensLegend legend = {};
1954 std::optional<std::variant<bool, QJsonObject>> range = {};
1955 std::optional<std::variant<bool, QJsonObject>> full = {};
1956
1957 template<typename W>
1958 void walk(W &w)
1959 {
1960 WorkDoneProgressOptions::walk(w);
1961 field(w, "legend", legend);
1962 field(w, "range", range);
1963 field(w, "full", full);
1964 }
1965};
1966
1967class Q_LANGUAGESERVER_EXPORT SemanticTokensRegistrationOptions
1968 : public TextDocumentRegistrationOptions,
1969 SemanticTokensOptions,
1970 StaticRegistrationOptions
1971{
1972public:
1973 template<typename W>
1974 void walk(W &w)
1975 {
1976 TextDocumentRegistrationOptions::walk(w);
1977 SemanticTokensOptions::walk(w);
1978 StaticRegistrationOptions::walk(w);
1979 }
1980};
1981
1982class Q_LANGUAGESERVER_EXPORT LinkedEditingRangeOptions : public WorkDoneProgressOptions
1983{
1984public:
1985 template<typename W>
1986 void walk(W &w)
1987 {
1988 WorkDoneProgressOptions::walk(w);
1989 }
1990};
1991
1992class Q_LANGUAGESERVER_EXPORT LinkedEditingRangeRegistrationOptions
1993 : public TextDocumentRegistrationOptions,
1994 LinkedEditingRangeOptions,
1995 StaticRegistrationOptions
1996{
1997public:
1998 template<typename W>
1999 void walk(W &w)
2000 {
2001 TextDocumentRegistrationOptions::walk(w);
2002 LinkedEditingRangeOptions::walk(w);
2003 StaticRegistrationOptions::walk(w);
2004 }
2005};
2006
2007class Q_LANGUAGESERVER_EXPORT MonikerOptions : public WorkDoneProgressOptions
2008{
2009public:
2010 template<typename W>
2011 void walk(W &w)
2012 {
2013 WorkDoneProgressOptions::walk(w);
2014 }
2015};
2016
2017class Q_LANGUAGESERVER_EXPORT MonikerRegistrationOptions : public TextDocumentRegistrationOptions,
2018 MonikerOptions
2019{
2020public:
2021 template<typename W>
2022 void walk(W &w)
2023 {
2024 TextDocumentRegistrationOptions::walk(w);
2025 MonikerOptions::walk(w);
2026 }
2027};
2028
2029class Q_LANGUAGESERVER_EXPORT ServerCapabilities
2030{
2031public:
2032 std::optional<std::variant<TextDocumentSyncOptions, TextDocumentSyncKind>>
2033 textDocumentSync = {};
2034 std::optional<CompletionOptions> completionProvider = {};
2035 std::optional<std::variant<bool, HoverOptions>> hoverProvider = {};
2036 std::optional<SignatureHelpOptions> signatureHelpProvider = {};
2037 std::optional<std::variant<bool, DeclarationOptions, DeclarationRegistrationOptions>>
2038 declarationProvider = {};
2039 std::optional<std::variant<bool, DefinitionOptions>> definitionProvider = {};
2040 std::optional<std::variant<bool, TypeDefinitionOptions, TypeDefinitionRegistrationOptions>>
2041 typeDefinitionProvider = {};
2042 std::optional<std::variant<bool, ImplementationOptions, ImplementationRegistrationOptions>>
2043 implementationProvider = {};
2044 std::optional<std::variant<bool, ReferenceOptions>> referencesProvider = {};
2045 std::optional<std::variant<bool, DocumentHighlightOptions>> documentHighlightProvider = {};
2046 std::optional<std::variant<bool, DocumentSymbolOptions>> documentSymbolProvider = {};
2047 std::optional<std::variant<bool, CodeActionOptions>> codeActionProvider = {};
2048 std::optional<CodeLensOptions> codeLensProvider = {};
2049 std::optional<DocumentLinkOptions> documentLinkProvider = {};
2050 std::optional<std::variant<bool, DocumentColorOptions, DocumentColorRegistrationOptions>>
2051 colorProvider = {};
2052 std::optional<std::variant<bool, DocumentFormattingOptions>> documentFormattingProvider = {};
2053 std::optional<std::variant<bool, DocumentRangeFormattingOptions>>
2054 documentRangeFormattingProvider = {};
2055 std::optional<DocumentOnTypeFormattingOptions> documentOnTypeFormattingProvider = {};
2056 std::optional<std::variant<bool, RenameOptions>> renameProvider = {};
2057 std::optional<std::variant<bool, FoldingRangeOptions, FoldingRangeRegistrationOptions>>
2058 foldingRangeProvider = {};
2059 std::optional<ExecuteCommandOptions> executeCommandProvider = {};
2060 std::optional<std::variant<bool, SelectionRangeOptions, SelectionRangeRegistrationOptions>>
2061 selectionRangeProvider = {};
2062 std::optional<
2063 std::variant<bool, LinkedEditingRangeOptions, LinkedEditingRangeRegistrationOptions>>
2064 linkedEditingRangeProvider = {};
2065 std::optional<std::variant<bool, CallHierarchyOptions, CallHierarchyRegistrationOptions>>
2066 callHierarchyProvider = {};
2067 std::optional<std::variant<SemanticTokensOptions, SemanticTokensRegistrationOptions>>
2068 semanticTokensProvider = {};
2069 std::optional<std::variant<bool, MonikerOptions, MonikerRegistrationOptions>>
2070 monikerProvider = {};
2071 std::optional<std::variant<bool, WorkspaceSymbolOptions>> workspaceSymbolProvider = {};
2072 std::optional<QJsonObject> workspace = {};
2073 std::optional<QJsonValue> experimental = {};
2074
2075 template<typename W>
2076 void walk(W &w)
2077 {
2078 field(w, "textDocumentSync", textDocumentSync);
2079 field(w, "completionProvider", completionProvider);
2080 field(w, "hoverProvider", hoverProvider);
2081 field(w, "signatureHelpProvider", signatureHelpProvider);
2082 field(w, "declarationProvider", declarationProvider);
2083 field(w, "definitionProvider", definitionProvider);
2084 field(w, "typeDefinitionProvider", typeDefinitionProvider);
2085 field(w, "implementationProvider", implementationProvider);
2086 field(w, "referencesProvider", referencesProvider);
2087 field(w, "documentHighlightProvider", documentHighlightProvider);
2088 field(w, "documentSymbolProvider", documentSymbolProvider);
2089 field(w, "codeActionProvider", codeActionProvider);
2090 field(w, "codeLensProvider", codeLensProvider);
2091 field(w, "documentLinkProvider", documentLinkProvider);
2092 field(w, "colorProvider", colorProvider);
2093 field(w, "documentFormattingProvider", documentFormattingProvider);
2094 field(w, "documentRangeFormattingProvider", documentRangeFormattingProvider);
2095 field(w, "documentOnTypeFormattingProvider", documentOnTypeFormattingProvider);
2096 field(w, "renameProvider", renameProvider);
2097 field(w, "foldingRangeProvider", foldingRangeProvider);
2098 field(w, "executeCommandProvider", executeCommandProvider);
2099 field(w, "selectionRangeProvider", selectionRangeProvider);
2100 field(w, "linkedEditingRangeProvider", linkedEditingRangeProvider);
2101 field(w, "callHierarchyProvider", callHierarchyProvider);
2102 field(w, "semanticTokensProvider", semanticTokensProvider);
2103 field(w, "monikerProvider", monikerProvider);
2104 field(w, "workspaceSymbolProvider", workspaceSymbolProvider);
2105 field(w, "workspace", workspace);
2106 field(w, "experimental", experimental);
2107 }
2108};
2109
2110class Q_LANGUAGESERVER_EXPORT InitializeResult
2111{
2112public:
2113 ServerCapabilities capabilities = {};
2114 std::optional<QJsonObject> serverInfo = {};
2115
2116 template<typename W>
2117 void walk(W &w)
2118 {
2119 field(w, "capabilities", capabilities);
2120 field(w, "serverInfo", serverInfo);
2121 }
2122};
2123
2124class Q_LANGUAGESERVER_EXPORT InitializeError
2125{
2126public:
2127 bool retry = {};
2128
2129 template<typename W>
2130 void walk(W &w)
2131 {
2132 field(w, "retry", retry);
2133 }
2134};
2135
2136class Q_LANGUAGESERVER_EXPORT InitializedParams
2137{
2138public:
2139 template<typename W>
2140 void walk(W &)
2141 {
2142 }
2143};
2144
2145class Q_LANGUAGESERVER_EXPORT LogTraceParams
2146{
2147public:
2148 QByteArray message = {};
2149 std::optional<QByteArray> verbose = {};
2150
2151 template<typename W>
2152 void walk(W &w)
2153 {
2154 field(w, "message", message);
2155 field(w, "verbose", verbose);
2156 }
2157};
2158
2159class Q_LANGUAGESERVER_EXPORT SetTraceParams
2160{
2161public:
2162 TraceValue value = {};
2163
2164 template<typename W>
2165 void walk(W &w)
2166 {
2167 field(w, "value", value);
2168 }
2169};
2170
2171class Q_LANGUAGESERVER_EXPORT ShowMessageParams
2172{
2173public:
2174 MessageType type = {};
2175 QByteArray message = {};
2176
2177 template<typename W>
2178 void walk(W &w)
2179 {
2180 field(w, "type", type);
2181 field(w, "message", message);
2182 }
2183};
2184
2185class Q_LANGUAGESERVER_EXPORT MessageActionItem
2186{
2187public:
2188 QByteArray title = {};
2189
2190 template<typename W>
2191 void walk(W &w)
2192 {
2193 field(w, "title", title);
2194 }
2195};
2196
2197class Q_LANGUAGESERVER_EXPORT ShowMessageRequestParams
2198{
2199public:
2200 MessageType type = {};
2201 QByteArray message = {};
2202 std::optional<QList<MessageActionItem>> actions = {};
2203
2204 template<typename W>
2205 void walk(W &w)
2206 {
2207 field(w, "type", type);
2208 field(w, "message", message);
2209 field(w, "actions", actions);
2210 }
2211};
2212
2213class Q_LANGUAGESERVER_EXPORT ShowDocumentParams
2214{
2215public:
2216 QByteArray uri = {};
2217 std::optional<bool> external = {};
2218 std::optional<bool> takeFocus = {};
2219 std::optional<Range> selection = {};
2220
2221 template<typename W>
2222 void walk(W &w)
2223 {
2224 field(w, "uri", uri);
2225 field(w, "external", external);
2226 field(w, "takeFocus", takeFocus);
2227 field(w, "selection", selection);
2228 }
2229};
2230
2231class Q_LANGUAGESERVER_EXPORT ShowDocumentResult
2232{
2233public:
2234 bool success = {};
2235
2236 template<typename W>
2237 void walk(W &w)
2238 {
2239 field(w, "success", success);
2240 }
2241};
2242
2243class Q_LANGUAGESERVER_EXPORT LogMessageParams
2244{
2245public:
2246 MessageType type = {};
2247 QByteArray message = {};
2248
2249 template<typename W>
2250 void walk(W &w)
2251 {
2252 field(w, "type", type);
2253 field(w, "message", message);
2254 }
2255};
2256
2257class Q_LANGUAGESERVER_EXPORT WorkDoneProgressCreateParams
2258{
2259public:
2260 ProgressToken token = {};
2261
2262 template<typename W>
2263 void walk(W &w)
2264 {
2265 field(w, "token", token);
2266 }
2267};
2268
2269class Q_LANGUAGESERVER_EXPORT WorkDoneProgressCancelParams
2270{
2271public:
2272 ProgressToken token = {};
2273
2274 template<typename W>
2275 void walk(W &w)
2276 {
2277 field(w, "token", token);
2278 }
2279};
2280
2281class Q_LANGUAGESERVER_EXPORT Registration
2282{
2283public:
2284 QByteArray id = {};
2285 QByteArray method = {};
2286 std::optional<QJsonValue> registerOptions = {};
2287
2288 template<typename W>
2289 void walk(W &w)
2290 {
2291 field(w, "id", id);
2292 field(w, "method", method);
2293 field(w, "registerOptions", registerOptions);
2294 }
2295};
2296
2297class Q_LANGUAGESERVER_EXPORT RegistrationParams
2298{
2299public:
2300 QList<Registration> registrations = {};
2301
2302 template<typename W>
2303 void walk(W &w)
2304 {
2305 field(w, "registrations", registrations);
2306 }
2307};
2308
2309class Q_LANGUAGESERVER_EXPORT Unregistration
2310{
2311public:
2312 QByteArray id = {};
2313 QByteArray method = {};
2314
2315 template<typename W>
2316 void walk(W &w)
2317 {
2318 field(w, "id", id);
2319 field(w, "method", method);
2320 }
2321};
2322
2323class Q_LANGUAGESERVER_EXPORT UnregistrationParams
2324{
2325public:
2326 QList<Unregistration> unregisterations = {};
2327
2328 template<typename W>
2329 void walk(W &w)
2330 {
2331 field(w, "unregisterations", unregisterations);
2332 }
2333};
2334
2335class Q_LANGUAGESERVER_EXPORT WorkspaceFoldersChangeEvent
2336{
2337public:
2338 QList<WorkspaceFolder> added = {};
2339 QList<WorkspaceFolder> removed = {};
2340
2341 template<typename W>
2342 void walk(W &w)
2343 {
2344 field(w, "added", added);
2345 field(w, "removed", removed);
2346 }
2347};
2348
2349class Q_LANGUAGESERVER_EXPORT DidChangeWorkspaceFoldersParams
2350{
2351public:
2352 WorkspaceFoldersChangeEvent event = {};
2353
2354 template<typename W>
2355 void walk(W &w)
2356 {
2357 field(w, "event", event);
2358 }
2359};
2360
2361class Q_LANGUAGESERVER_EXPORT DidChangeConfigurationParams
2362{
2363public:
2364 QJsonValue settings = {};
2365
2366 template<typename W>
2367 void walk(W &w)
2368 {
2369 field(w, "settings", settings);
2370 }
2371};
2372
2373class Q_LANGUAGESERVER_EXPORT ConfigurationItem
2374{
2375public:
2376 std::optional<QByteArray> scopeUri = {};
2377 std::optional<QByteArray> section = {};
2378
2379 template<typename W>
2380 void walk(W &w)
2381 {
2382 field(w, "scopeUri", scopeUri);
2383 field(w, "section", section);
2384 }
2385};
2386
2387class Q_LANGUAGESERVER_EXPORT ConfigurationParams
2388{
2389public:
2390 QList<ConfigurationItem> items = {};
2391
2392 template<typename W>
2393 void walk(W &w)
2394 {
2395 field(w, "items", items);
2396 }
2397};
2398
2399class Q_LANGUAGESERVER_EXPORT DidChangeWatchedFilesClientCapabilities
2400{
2401public:
2402 std::optional<bool> dynamicRegistration = {};
2403
2404 template<typename W>
2405 void walk(W &w)
2406 {
2407 field(w, "dynamicRegistration", dynamicRegistration);
2408 }
2409};
2410
2411class Q_LANGUAGESERVER_EXPORT FileSystemWatcher
2412{
2413public:
2414 QByteArray globPattern = {};
2415 std::optional<int> kind = {};
2416
2417 template<typename W>
2418 void walk(W &w)
2419 {
2420 field(w, "globPattern", globPattern);
2421 field(w, "kind", kind);
2422 }
2423};
2424
2425class Q_LANGUAGESERVER_EXPORT DidChangeWatchedFilesRegistrationOptions
2426{
2427public:
2428 QList<FileSystemWatcher> watchers = {};
2429
2430 template<typename W>
2431 void walk(W &w)
2432 {
2433 field(w, "watchers", watchers);
2434 }
2435};
2436
2437class Q_LANGUAGESERVER_EXPORT FileEvent
2438{
2439public:
2440 QByteArray uri = {};
2441 int type = {};
2442
2443 template<typename W>
2444 void walk(W &w)
2445 {
2446 field(w, "uri", uri);
2447 field(w, "type", type);
2448 }
2449};
2450
2451class Q_LANGUAGESERVER_EXPORT DidChangeWatchedFilesParams
2452{
2453public:
2454 QList<FileEvent> changes = {};
2455
2456 template<typename W>
2457 void walk(W &w)
2458 {
2459 field(w, "changes", changes);
2460 }
2461};
2462
2463class Q_LANGUAGESERVER_EXPORT WorkspaceSymbolClientCapabilities
2464{
2465public:
2466 std::optional<bool> dynamicRegistration = {};
2467 std::optional<QJsonObject> symbolKind = {};
2468 std::optional<QJsonObject> tagSupport = {};
2469
2470 template<typename W>
2471 void walk(W &w)
2472 {
2473 field(w, "dynamicRegistration", dynamicRegistration);
2474 field(w, "symbolKind", symbolKind);
2475 field(w, "tagSupport", tagSupport);
2476 }
2477};
2478
2479class Q_LANGUAGESERVER_EXPORT WorkspaceSymbolRegistrationOptions : public WorkspaceSymbolOptions
2480{
2481public:
2482 template<typename W>
2483 void walk(W &w)
2484 {
2485 WorkspaceSymbolOptions::walk(w);
2486 }
2487};
2488
2489class Q_LANGUAGESERVER_EXPORT WorkspaceSymbolParams : public WorkDoneProgressParams,
2490 PartialResultParams
2491{
2492public:
2493 QByteArray query = {};
2494
2495 template<typename W>
2496 void walk(W &w)
2497 {
2498 WorkDoneProgressParams::walk(w);
2499 PartialResultParams::walk(w);
2500 field(w, "query", query);
2501 }
2502};
2503
2504class Q_LANGUAGESERVER_EXPORT ExecuteCommandClientCapabilities
2505{
2506public:
2507 std::optional<bool> dynamicRegistration = {};
2508
2509 template<typename W>
2510 void walk(W &w)
2511 {
2512 field(w, "dynamicRegistration", dynamicRegistration);
2513 }
2514};
2515
2516class Q_LANGUAGESERVER_EXPORT ExecuteCommandRegistrationOptions : public ExecuteCommandOptions
2517{
2518public:
2519 template<typename W>
2520 void walk(W &w)
2521 {
2522 ExecuteCommandOptions::walk(w);
2523 }
2524};
2525
2526class Q_LANGUAGESERVER_EXPORT ExecuteCommandParams : public WorkDoneProgressParams
2527{
2528public:
2529 QByteArray command = {};
2530 std::optional<QList<QJsonValue>> arguments = {};
2531
2532 template<typename W>
2533 void walk(W &w)
2534 {
2535 WorkDoneProgressParams::walk(w);
2536 field(w, "command", command);
2537 field(w, "arguments", arguments);
2538 }
2539};
2540
2541class Q_LANGUAGESERVER_EXPORT ApplyWorkspaceEditParams
2542{
2543public:
2544 std::optional<QByteArray> label = {};
2545 WorkspaceEdit edit = {};
2546
2547 template<typename W>
2548 void walk(W &w)
2549 {
2550 field(w, "label", label);
2551 field(w, "edit", edit);
2552 }
2553};
2554
2555class Q_LANGUAGESERVER_EXPORT ApplyWorkspaceEditResponse
2556{
2557public:
2558 bool applied = {};
2559 std::optional<QByteArray> failureReason = {};
2560 std::optional<int> failedChange = {};
2561
2562 template<typename W>
2563 void walk(W &w)
2564 {
2565 field(w, "applied", applied);
2566 field(w, "failureReason", failureReason);
2567 field(w, "failedChange", failedChange);
2568 }
2569};
2570
2571class Q_LANGUAGESERVER_EXPORT FileCreate
2572{
2573public:
2574 QByteArray uri = {};
2575
2576 template<typename W>
2577 void walk(W &w)
2578 {
2579 field(w, "uri", uri);
2580 }
2581};
2582
2583class Q_LANGUAGESERVER_EXPORT CreateFilesParams
2584{
2585public:
2586 QList<FileCreate> files = {};
2587
2588 template<typename W>
2589 void walk(W &w)
2590 {
2591 field(w, "files", files);
2592 }
2593};
2594
2595class Q_LANGUAGESERVER_EXPORT FileRename
2596{
2597public:
2598 QByteArray oldUri = {};
2599 QByteArray newUri = {};
2600
2601 template<typename W>
2602 void walk(W &w)
2603 {
2604 field(w, "oldUri", oldUri);
2605 field(w, "newUri", newUri);
2606 }
2607};
2608
2609class Q_LANGUAGESERVER_EXPORT RenameFilesParams
2610{
2611public:
2612 QList<FileRename> files = {};
2613
2614 template<typename W>
2615 void walk(W &w)
2616 {
2617 field(w, "files", files);
2618 }
2619};
2620
2621class Q_LANGUAGESERVER_EXPORT FileDelete
2622{
2623public:
2624 QByteArray uri = {};
2625
2626 template<typename W>
2627 void walk(W &w)
2628 {
2629 field(w, "uri", uri);
2630 }
2631};
2632
2633class Q_LANGUAGESERVER_EXPORT DeleteFilesParams
2634{
2635public:
2636 QList<FileDelete> files = {};
2637
2638 template<typename W>
2639 void walk(W &w)
2640 {
2641 field(w, "files", files);
2642 }
2643};
2644
2645class Q_LANGUAGESERVER_EXPORT DidOpenTextDocumentParams
2646{
2647public:
2648 TextDocumentItem textDocument = {};
2649
2650 template<typename W>
2651 void walk(W &w)
2652 {
2653 field(w, "textDocument", textDocument);
2654 }
2655};
2656
2657class Q_LANGUAGESERVER_EXPORT TextDocumentChangeRegistrationOptions
2658 : public TextDocumentRegistrationOptions
2659{
2660public:
2661 TextDocumentSyncKind syncKind = {};
2662
2663 template<typename W>
2664 void walk(W &w)
2665 {
2666 TextDocumentRegistrationOptions::walk(w);
2667 field(w, "syncKind", syncKind);
2668 }
2669};
2670
2671class Q_LANGUAGESERVER_EXPORT DidChangeTextDocumentParams
2672{
2673public:
2674 VersionedTextDocumentIdentifier textDocument = {};
2675 QList<TextDocumentContentChangeEvent> contentChanges = {};
2676
2677 template<typename W>
2678 void walk(W &w)
2679 {
2680 field(w, "textDocument", textDocument);
2681 field(w, "contentChanges", contentChanges);
2682 }
2683};
2684
2685class Q_LANGUAGESERVER_EXPORT WillSaveTextDocumentParams
2686{
2687public:
2688 TextDocumentIdentifier textDocument = {};
2689 TextDocumentSaveReason reason = {};
2690
2691 template<typename W>
2692 void walk(W &w)
2693 {
2694 field(w, "textDocument", textDocument);
2695 field(w, "reason", reason);
2696 }
2697};
2698
2699class Q_LANGUAGESERVER_EXPORT SaveOptions
2700{
2701public:
2702 std::optional<bool> includeText = {};
2703
2704 template<typename W>
2705 void walk(W &w)
2706 {
2707 field(w, "includeText", includeText);
2708 }
2709};
2710
2711class Q_LANGUAGESERVER_EXPORT TextDocumentSaveRegistrationOptions
2712 : public TextDocumentRegistrationOptions
2713{
2714public:
2715 std::optional<bool> includeText = {};
2716
2717 template<typename W>
2718 void walk(W &w)
2719 {
2720 TextDocumentRegistrationOptions::walk(w);
2721 field(w, "includeText", includeText);
2722 }
2723};
2724
2725class Q_LANGUAGESERVER_EXPORT DidSaveTextDocumentParams
2726{
2727public:
2728 TextDocumentIdentifier textDocument = {};
2729 std::optional<QByteArray> text = {};
2730
2731 template<typename W>
2732 void walk(W &w)
2733 {
2734 field(w, "textDocument", textDocument);
2735 field(w, "text", text);
2736 }
2737};
2738
2739class Q_LANGUAGESERVER_EXPORT DidCloseTextDocumentParams
2740{
2741public:
2742 TextDocumentIdentifier textDocument = {};
2743
2744 template<typename W>
2745 void walk(W &w)
2746 {
2747 field(w, "textDocument", textDocument);
2748 }
2749};
2750
2751class Q_LANGUAGESERVER_EXPORT PublishDiagnosticsParams
2752{
2753public:
2754 QByteArray uri = {};
2755 std::optional<int> version = {};
2756 QList<Diagnostic> diagnostics = {};
2757
2758 template<typename W>
2759 void walk(W &w)
2760 {
2761 field(w, "uri", uri);
2762 field(w, "version", version);
2763 field(w, "diagnostics", diagnostics);
2764 }
2765};
2766
2767class Q_LANGUAGESERVER_EXPORT CompletionRegistrationOptions
2768 : public TextDocumentRegistrationOptions,
2769 CompletionOptions
2770{
2771public:
2772 template<typename W>
2773 void walk(W &w)
2774 {
2775 TextDocumentRegistrationOptions::walk(w);
2776 CompletionOptions::walk(w);
2777 }
2778};
2779
2780class Q_LANGUAGESERVER_EXPORT CompletionContext
2781{
2782public:
2783 CompletionTriggerKind triggerKind = {};
2784 std::optional<QByteArray> triggerCharacter = {};
2785
2786 template<typename W>
2787 void walk(W &w)
2788 {
2789 field(w, "triggerKind", triggerKind);
2790 field(w, "triggerCharacter", triggerCharacter);
2791 }
2792};
2793
2794class Q_LANGUAGESERVER_EXPORT CompletionParams : public TextDocumentPositionParams,
2795 WorkDoneProgressParams,
2796 PartialResultParams
2797{
2798public:
2799 std::optional<CompletionContext> context = {};
2800
2801 template<typename W>
2802 void walk(W &w)
2803 {
2804 TextDocumentPositionParams::walk(w);
2805 WorkDoneProgressParams::walk(w);
2806 PartialResultParams::walk(w);
2807 field(w, "context", context);
2808 }
2809};
2810
2811class Q_LANGUAGESERVER_EXPORT InsertReplaceEdit
2812{
2813public:
2814 QByteArray newText = {};
2815 Range insert = {};
2816 Range replace = {};
2817
2818 template<typename W>
2819 void walk(W &w)
2820 {
2821 field(w, "newText", newText);
2822 field(w, "insert", insert);
2823 field(w, "replace", replace);
2824 }
2825};
2826
2827class Q_LANGUAGESERVER_EXPORT CompletionItem
2828{
2829public:
2830 QByteArray label = {};
2831 std::optional<QJsonValue> kind = {};
2832 std::optional<QList<int>> tags = {};
2833 std::optional<QByteArray> detail = {};
2834 std::optional<std::variant<QByteArray, MarkupContent>> documentation = {};
2835 std::optional<bool> deprecated = {};
2836 std::optional<bool> preselect = {};
2837 std::optional<QByteArray> sortText = {};
2838 std::optional<QByteArray> filterText = {};
2839 std::optional<QByteArray> insertText = {};
2840 std::optional<InsertTextFormat> insertTextFormat = {};
2841 std::optional<InsertTextMode> insertTextMode = {};
2842 std::optional<std::variant<TextEdit, InsertReplaceEdit>> textEdit = {};
2843 std::optional<QList<TextEdit>> additionalTextEdits = {};
2844 std::optional<QList<QByteArray>> commitCharacters = {};
2845 std::optional<Command> command = {};
2846 std::optional<QJsonValue> data = {};
2847
2848 template<typename W>
2849 void walk(W &w)
2850 {
2851 field(w, "label", label);
2852 field(w, "kind", kind);
2853 field(w, "tags", tags);
2854 field(w, "detail", detail);
2855 field(w, "documentation", documentation);
2856 field(w, "deprecated", deprecated);
2857 field(w, "preselect", preselect);
2858 field(w, "sortText", sortText);
2859 field(w, "filterText", filterText);
2860 field(w, "insertText", insertText);
2861 field(w, "insertTextFormat", insertTextFormat);
2862 field(w, "insertTextMode", insertTextMode);
2863 field(w, "textEdit", textEdit);
2864 field(w, "additionalTextEdits", additionalTextEdits);
2865 field(w, "commitCharacters", commitCharacters);
2866 field(w, "command", command);
2867 field(w, "data", data);
2868 }
2869};
2870
2871class Q_LANGUAGESERVER_EXPORT CompletionList
2872{
2873public:
2874 bool isIncomplete = {};
2875 QList<CompletionItem> items = {};
2876
2877 template<typename W>
2878 void walk(W &w)
2879 {
2880 field(w, "isIncomplete", isIncomplete);
2881 field(w, "items", items);
2882 }
2883};
2884
2885class Q_LANGUAGESERVER_EXPORT HoverRegistrationOptions : public TextDocumentRegistrationOptions,
2886 HoverOptions
2887{
2888public:
2889 template<typename W>
2890 void walk(W &w)
2891 {
2892 TextDocumentRegistrationOptions::walk(w);
2893 HoverOptions::walk(w);
2894 }
2895};
2896
2897class Q_LANGUAGESERVER_EXPORT HoverParams : public TextDocumentPositionParams,
2898 WorkDoneProgressParams
2899{
2900public:
2901 template<typename W>
2902 void walk(W &w)
2903 {
2904 TextDocumentPositionParams::walk(w);
2905 WorkDoneProgressParams::walk(w);
2906 }
2907};
2908
2909class Q_LANGUAGESERVER_EXPORT Hover
2910{
2911public:
2912 std::variant<MarkupContent, MarkedString, QList<MarkedString>> contents = {};
2913 std::optional<Range> range = {};
2914
2915 template<typename W>
2916 void walk(W &w)
2917 {
2918 field(w, "contents", contents);
2919 field(w, "range", range);
2920 }
2921};
2922
2923class Q_LANGUAGESERVER_EXPORT SignatureHelpRegistrationOptions
2924 : public TextDocumentRegistrationOptions,
2925 SignatureHelpOptions
2926{
2927public:
2928 template<typename W>
2929 void walk(W &w)
2930 {
2931 TextDocumentRegistrationOptions::walk(w);
2932 SignatureHelpOptions::walk(w);
2933 }
2934};
2935
2936class Q_LANGUAGESERVER_EXPORT ParameterInformation
2937{
2938public:
2939 std::variant<QByteArray, std::pair<int, int>> label = {};
2940 std::optional<std::variant<QByteArray, MarkupContent>> documentation = {};
2941
2942 template<typename W>
2943 void walk(W &w)
2944 {
2945 field(w, "label", label);
2946 field(w, "documentation", documentation);
2947 }
2948};
2949
2950class Q_LANGUAGESERVER_EXPORT SignatureInformation
2951{
2952public:
2953 QByteArray label = {};
2954 std::optional<std::variant<QByteArray, MarkupContent>> documentation = {};
2955 std::optional<QList<ParameterInformation>> parameters = {};
2956 std::optional<int> activeParameter = {};
2957
2958 template<typename W>
2959 void walk(W &w)
2960 {
2961 field(w, "label", label);
2962 field(w, "documentation", documentation);
2963 field(w, "parameters", parameters);
2964 field(w, "activeParameter", activeParameter);
2965 }
2966};
2967
2968class Q_LANGUAGESERVER_EXPORT SignatureHelp
2969{
2970public:
2971 QList<SignatureInformation> signatures = {};
2972 std::optional<int> activeSignature = {};
2973 std::optional<int> activeParameter = {};
2974
2975 template<typename W>
2976 void walk(W &w)
2977 {
2978 field(w, "signatures", signatures);
2979 field(w, "activeSignature", activeSignature);
2980 field(w, "activeParameter", activeParameter);
2981 }
2982};
2983
2984class Q_LANGUAGESERVER_EXPORT SignatureHelpContext
2985{
2986public:
2987 SignatureHelpTriggerKind triggerKind = {};
2988 std::optional<QByteArray> triggerCharacter = {};
2989 bool isRetrigger = {};
2990 std::optional<SignatureHelp> activeSignatureHelp = {};
2991
2992 template<typename W>
2993 void walk(W &w)
2994 {
2995 field(w, "triggerKind", triggerKind);
2996 field(w, "triggerCharacter", triggerCharacter);
2997 field(w, "isRetrigger", isRetrigger);
2998 field(w, "activeSignatureHelp", activeSignatureHelp);
2999 }
3000};
3001
3002class Q_LANGUAGESERVER_EXPORT SignatureHelpParams : public TextDocumentPositionParams,
3003 WorkDoneProgressParams
3004{
3005public:
3006 std::optional<SignatureHelpContext> context = {};
3007
3008 template<typename W>
3009 void walk(W &w)
3010 {
3011 TextDocumentPositionParams::walk(w);
3012 WorkDoneProgressParams::walk(w);
3013 field(w, "context", context);
3014 }
3015};
3016
3017class Q_LANGUAGESERVER_EXPORT DeclarationParams : public TextDocumentPositionParams,
3018 WorkDoneProgressParams,
3019 PartialResultParams
3020{
3021public:
3022 template<typename W>
3023 void walk(W &w)
3024 {
3025 TextDocumentPositionParams::walk(w);
3026 WorkDoneProgressParams::walk(w);
3027 PartialResultParams::walk(w);
3028 }
3029};
3030
3031class Q_LANGUAGESERVER_EXPORT DefinitionRegistrationOptions
3032 : public TextDocumentRegistrationOptions,
3033 DefinitionOptions
3034{
3035public:
3036 template<typename W>
3037 void walk(W &w)
3038 {
3039 TextDocumentRegistrationOptions::walk(w);
3040 DefinitionOptions::walk(w);
3041 }
3042};
3043
3044class Q_LANGUAGESERVER_EXPORT DefinitionParams : public TextDocumentPositionParams,
3045 WorkDoneProgressParams,
3046 PartialResultParams
3047{
3048public:
3049 template<typename W>
3050 void walk(W &w)
3051 {
3052 TextDocumentPositionParams::walk(w);
3053 WorkDoneProgressParams::walk(w);
3054 PartialResultParams::walk(w);
3055 }
3056};
3057
3058class Q_LANGUAGESERVER_EXPORT TypeDefinitionParams : public TextDocumentPositionParams,
3059 WorkDoneProgressParams,
3060 PartialResultParams
3061{
3062public:
3063 template<typename W>
3064 void walk(W &w)
3065 {
3066 TextDocumentPositionParams::walk(w);
3067 WorkDoneProgressParams::walk(w);
3068 PartialResultParams::walk(w);
3069 }
3070};
3071
3072class Q_LANGUAGESERVER_EXPORT ImplementationParams : public TextDocumentPositionParams,
3073 WorkDoneProgressParams,
3074 PartialResultParams
3075{
3076public:
3077 template<typename W>
3078 void walk(W &w)
3079 {
3080 TextDocumentPositionParams::walk(w);
3081 WorkDoneProgressParams::walk(w);
3082 PartialResultParams::walk(w);
3083 }
3084};
3085
3086class Q_LANGUAGESERVER_EXPORT ReferenceRegistrationOptions : public TextDocumentRegistrationOptions,
3087 ReferenceOptions
3088{
3089public:
3090 template<typename W>
3091 void walk(W &w)
3092 {
3093 TextDocumentRegistrationOptions::walk(w);
3094 ReferenceOptions::walk(w);
3095 }
3096};
3097
3098class Q_LANGUAGESERVER_EXPORT ReferenceContext
3099{
3100public:
3101 bool includeDeclaration = {};
3102
3103 template<typename W>
3104 void walk(W &w)
3105 {
3106 field(w, "includeDeclaration", includeDeclaration);
3107 }
3108};
3109
3110class Q_LANGUAGESERVER_EXPORT ReferenceParams : public TextDocumentPositionParams,
3111 WorkDoneProgressParams,
3112 PartialResultParams
3113{
3114public:
3115 ReferenceContext context = {};
3116
3117 template<typename W>
3118 void walk(W &w)
3119 {
3120 TextDocumentPositionParams::walk(w);
3121 WorkDoneProgressParams::walk(w);
3122 PartialResultParams::walk(w);
3123 field(w, "context", context);
3124 }
3125};
3126
3127class Q_LANGUAGESERVER_EXPORT DocumentHighlightRegistrationOptions
3128 : public TextDocumentRegistrationOptions,
3129 DocumentHighlightOptions
3130{
3131public:
3132 template<typename W>
3133 void walk(W &w)
3134 {
3135 TextDocumentRegistrationOptions::walk(w);
3136 DocumentHighlightOptions::walk(w);
3137 }
3138};
3139
3140class Q_LANGUAGESERVER_EXPORT DocumentHighlightParams : public TextDocumentPositionParams,
3141 WorkDoneProgressParams,
3142 PartialResultParams
3143{
3144public:
3145 template<typename W>
3146 void walk(W &w)
3147 {
3148 TextDocumentPositionParams::walk(w);
3149 WorkDoneProgressParams::walk(w);
3150 PartialResultParams::walk(w);
3151 }
3152};
3153
3154class Q_LANGUAGESERVER_EXPORT DocumentHighlight
3155{
3156public:
3157 Range range = {};
3158 std::optional<DocumentHighlightKind> kind = {};
3159
3160 template<typename W>
3161 void walk(W &w)
3162 {
3163 field(w, "range", range);
3164 field(w, "kind", kind);
3165 }
3166};
3167
3168class Q_LANGUAGESERVER_EXPORT DocumentSymbolRegistrationOptions
3169 : public TextDocumentRegistrationOptions,
3170 DocumentSymbolOptions
3171{
3172public:
3173 template<typename W>
3174 void walk(W &w)
3175 {
3176 TextDocumentRegistrationOptions::walk(w);
3177 DocumentSymbolOptions::walk(w);
3178 }
3179};
3180
3181class Q_LANGUAGESERVER_EXPORT DocumentSymbolParams : public WorkDoneProgressParams,
3182 PartialResultParams
3183{
3184public:
3185 TextDocumentIdentifier textDocument = {};
3186
3187 template<typename W>
3188 void walk(W &w)
3189 {
3190 WorkDoneProgressParams::walk(w);
3191 PartialResultParams::walk(w);
3192 field(w, "textDocument", textDocument);
3193 }
3194};
3195
3196class Q_LANGUAGESERVER_EXPORT DocumentSymbol
3197{
3198public:
3199 QByteArray name = {};
3200 std::optional<QByteArray> detail = {};
3201 SymbolKind kind = {};
3202 std::optional<QList<int>> tags = {};
3203 std::optional<bool> deprecated = {};
3204 Range range = {};
3205 Range selectionRange = {};
3206 std::optional<QList<DocumentSymbol>> children = {};
3207
3208 template<typename W>
3209 void walk(W &w)
3210 {
3211 field(w, "name", name);
3212 field(w, "detail", detail);
3213 field(w, "kind", kind);
3214 field(w, "tags", tags);
3215 field(w, "deprecated", deprecated);
3216 field(w, "range", range);
3217 field(w, "selectionRange", selectionRange);
3218 field(w, "children", children);
3219 }
3220};
3221
3222class Q_LANGUAGESERVER_EXPORT SymbolInformation
3223{
3224public:
3225 QByteArray name = {};
3226 SymbolKind kind = {};
3227 std::optional<QList<int>> tags = {};
3228 std::optional<bool> deprecated = {};
3229 Location location = {};
3230 std::optional<QByteArray> containerName = {};
3231
3232 template<typename W>
3233 void walk(W &w)
3234 {
3235 field(w, "name", name);
3236 field(w, "kind", kind);
3237 field(w, "tags", tags);
3238 field(w, "deprecated", deprecated);
3239 field(w, "location", location);
3240 field(w, "containerName", containerName);
3241 }
3242};
3243
3244class Q_LANGUAGESERVER_EXPORT CodeActionRegistrationOptions
3245 : public TextDocumentRegistrationOptions,
3246 CodeActionOptions
3247{
3248public:
3249 template<typename W>
3250 void walk(W &w)
3251 {
3252 TextDocumentRegistrationOptions::walk(w);
3253 CodeActionOptions::walk(w);
3254 }
3255};
3256
3257class Q_LANGUAGESERVER_EXPORT CodeActionContext
3258{
3259public:
3260 QList<Diagnostic> diagnostics = {};
3261 std::optional<QList<QByteArray>> only = {};
3262
3263 template<typename W>
3264 void walk(W &w)
3265 {
3266 field(w, "diagnostics", diagnostics);
3267 field(w, "only", only);
3268 }
3269};
3270
3271class Q_LANGUAGESERVER_EXPORT CodeActionParams : public WorkDoneProgressParams, PartialResultParams
3272{
3273public:
3274 TextDocumentIdentifier textDocument = {};
3275 Range range = {};
3276 CodeActionContext context = {};
3277
3278 template<typename W>
3279 void walk(W &w)
3280 {
3281 WorkDoneProgressParams::walk(w);
3282 PartialResultParams::walk(w);
3283 field(w, "textDocument", textDocument);
3284 field(w, "range", range);
3285 field(w, "context", context);
3286 }
3287};
3288
3289class Q_LANGUAGESERVER_EXPORT CodeAction
3290{
3291public:
3292 QByteArray title = {};
3293 std::optional<QByteArray> kind = {};
3294 std::optional<QList<Diagnostic>> diagnostics = {};
3295 std::optional<bool> isPreferred = {};
3296 std::optional<QJsonObject> disabled = {};
3297 std::optional<WorkspaceEdit> edit = {};
3298 std::optional<Command> command = {};
3299 std::optional<QJsonValue> data = {};
3300
3301 template<typename W>
3302 void walk(W &w)
3303 {
3304 field(w, "title", title);
3305 field(w, "kind", kind);
3306 field(w, "diagnostics", diagnostics);
3307 field(w, "isPreferred", isPreferred);
3308 field(w, "disabled", disabled);
3309 field(w, "edit", edit);
3310 field(w, "command", command);
3311 field(w, "data", data);
3312 }
3313};
3314
3315class Q_LANGUAGESERVER_EXPORT CodeLensRegistrationOptions : public TextDocumentRegistrationOptions,
3316 CodeLensOptions
3317{
3318public:
3319 template<typename W>
3320 void walk(W &w)
3321 {
3322 TextDocumentRegistrationOptions::walk(w);
3323 CodeLensOptions::walk(w);
3324 }
3325};
3326
3327class Q_LANGUAGESERVER_EXPORT CodeLensParams : public WorkDoneProgressParams, PartialResultParams
3328{
3329public:
3330 TextDocumentIdentifier textDocument = {};
3331
3332 template<typename W>
3333 void walk(W &w)
3334 {
3335 WorkDoneProgressParams::walk(w);
3336 PartialResultParams::walk(w);
3337 field(w, "textDocument", textDocument);
3338 }
3339};
3340
3341class Q_LANGUAGESERVER_EXPORT CodeLens
3342{
3343public:
3344 Range range = {};
3345 std::optional<Command> command = {};
3346 std::optional<QJsonValue> data = {};
3347
3348 template<typename W>
3349 void walk(W &w)
3350 {
3351 field(w, "range", range);
3352 field(w, "command", command);
3353 field(w, "data", data);
3354 }
3355};
3356
3357class Q_LANGUAGESERVER_EXPORT CodeLensWorkspaceClientCapabilities
3358{
3359public:
3360 std::optional<bool> refreshSupport = {};
3361
3362 template<typename W>
3363 void walk(W &w)
3364 {
3365 field(w, "refreshSupport", refreshSupport);
3366 }
3367};
3368
3369class Q_LANGUAGESERVER_EXPORT DocumentLinkRegistrationOptions
3370 : public TextDocumentRegistrationOptions,
3371 DocumentLinkOptions
3372{
3373public:
3374 template<typename W>
3375 void walk(W &w)
3376 {
3377 TextDocumentRegistrationOptions::walk(w);
3378 DocumentLinkOptions::walk(w);
3379 }
3380};
3381
3382class Q_LANGUAGESERVER_EXPORT DocumentLinkParams : public WorkDoneProgressParams,
3383 PartialResultParams
3384{
3385public:
3386 TextDocumentIdentifier textDocument = {};
3387
3388 template<typename W>
3389 void walk(W &w)
3390 {
3391 WorkDoneProgressParams::walk(w);
3392 PartialResultParams::walk(w);
3393 field(w, "textDocument", textDocument);
3394 }
3395};
3396
3397class Q_LANGUAGESERVER_EXPORT DocumentLink
3398{
3399public:
3400 Range range = {};
3401 std::optional<QByteArray> target = {};
3402 std::optional<QByteArray> tooltip = {};
3403 std::optional<QJsonValue> data = {};
3404
3405 template<typename W>
3406 void walk(W &w)
3407 {
3408 field(w, "range", range);
3409 field(w, "target", target);
3410 field(w, "tooltip", tooltip);
3411 field(w, "data", data);
3412 }
3413};
3414
3415class Q_LANGUAGESERVER_EXPORT DocumentColorParams : public WorkDoneProgressParams,
3416 PartialResultParams
3417{
3418public:
3419 TextDocumentIdentifier textDocument = {};
3420
3421 template<typename W>
3422 void walk(W &w)
3423 {
3424 WorkDoneProgressParams::walk(w);
3425 PartialResultParams::walk(w);
3426 field(w, "textDocument", textDocument);
3427 }
3428};
3429
3430class Q_LANGUAGESERVER_EXPORT Color
3431{
3432public:
3433 int red = {};
3434 int green = {};
3435 int blue = {};
3436 int alpha = {};
3437
3438 template<typename W>
3439 void walk(W &w)
3440 {
3441 field(w, "red", red);
3442 field(w, "green", green);
3443 field(w, "blue", blue);
3444 field(w, "alpha", alpha);
3445 }
3446};
3447
3448class Q_LANGUAGESERVER_EXPORT ColorInformation
3449{
3450public:
3451 Range range = {};
3452 Color color = {};
3453
3454 template<typename W>
3455 void walk(W &w)
3456 {
3457 field(w, "range", range);
3458 field(w, "color", color);
3459 }
3460};
3461
3462class Q_LANGUAGESERVER_EXPORT ColorPresentationParams : public WorkDoneProgressParams,
3463 PartialResultParams
3464{
3465public:
3466 TextDocumentIdentifier textDocument = {};
3467 Color color = {};
3468 Range range = {};
3469
3470 template<typename W>
3471 void walk(W &w)
3472 {
3473 WorkDoneProgressParams::walk(w);
3474 PartialResultParams::walk(w);
3475 field(w, "textDocument", textDocument);
3476 field(w, "color", color);
3477 field(w, "range", range);
3478 }
3479};
3480
3481class Q_LANGUAGESERVER_EXPORT ColorPresentation
3482{
3483public:
3484 QByteArray label = {};
3485 std::optional<TextEdit> textEdit = {};
3486 std::optional<QList<TextEdit>> additionalTextEdits = {};
3487
3488 template<typename W>
3489 void walk(W &w)
3490 {
3491 field(w, "label", label);
3492 field(w, "textEdit", textEdit);
3493 field(w, "additionalTextEdits", additionalTextEdits);
3494 }
3495};
3496
3497class Q_LANGUAGESERVER_EXPORT DocumentFormattingRegistrationOptions
3498 : public TextDocumentRegistrationOptions,
3499 DocumentFormattingOptions
3500{
3501public:
3502 template<typename W>
3503 void walk(W &w)
3504 {
3505 TextDocumentRegistrationOptions::walk(w);
3506 DocumentFormattingOptions::walk(w);
3507 }
3508};
3509
3510class Q_LANGUAGESERVER_EXPORT FormattingOptions
3511{
3512public:
3513 int tabSize = {};
3514 bool insertSpaces = {};
3515 std::optional<bool> trimTrailingWhitespace = {};
3516 std::optional<bool> insertFinalNewline = {};
3517 std::optional<bool> trimFinalNewlines = {};
3518 QJsonObject extraFields;
3519
3520 template<typename W>
3521 void walk(W &w)
3522 {
3523 field(w, "tabSize", tabSize);
3524 field(w, "insertSpaces", insertSpaces);
3525 field(w, "trimTrailingWhitespace", trimTrailingWhitespace);
3526 field(w, "insertFinalNewline", insertFinalNewline);
3527 field(w, "trimFinalNewlines", trimFinalNewlines);
3528 }
3529 template<typename W>
3530 void walkExtra(W &w)
3531 {
3532 w.handleExtras(extraFields);
3533 }
3534};
3535
3536class Q_LANGUAGESERVER_EXPORT DocumentFormattingParams : public WorkDoneProgressParams
3537{
3538public:
3539 TextDocumentIdentifier textDocument = {};
3540 FormattingOptions options = {};
3541
3542 template<typename W>
3543 void walk(W &w)
3544 {
3545 WorkDoneProgressParams::walk(w);
3546 field(w, "textDocument", textDocument);
3547 field(w, "options", options);
3548 }
3549};
3550
3551class Q_LANGUAGESERVER_EXPORT DocumentRangeFormattingRegistrationOptions
3552 : public TextDocumentRegistrationOptions,
3553 DocumentRangeFormattingOptions
3554{
3555public:
3556 template<typename W>
3557 void walk(W &w)
3558 {
3559 TextDocumentRegistrationOptions::walk(w);
3560 DocumentRangeFormattingOptions::walk(w);
3561 }
3562};
3563
3564class Q_LANGUAGESERVER_EXPORT DocumentRangeFormattingParams : public WorkDoneProgressParams
3565{
3566public:
3567 TextDocumentIdentifier textDocument = {};
3568 Range range = {};
3569 FormattingOptions options = {};
3570
3571 template<typename W>
3572 void walk(W &w)
3573 {
3574 WorkDoneProgressParams::walk(w);
3575 field(w, "textDocument", textDocument);
3576 field(w, "range", range);
3577 field(w, "options", options);
3578 }
3579};
3580
3581class Q_LANGUAGESERVER_EXPORT DocumentOnTypeFormattingRegistrationOptions
3582 : public TextDocumentRegistrationOptions,
3583 DocumentOnTypeFormattingOptions
3584{
3585public:
3586 template<typename W>
3587 void walk(W &w)
3588 {
3589 TextDocumentRegistrationOptions::walk(w);
3590 DocumentOnTypeFormattingOptions::walk(w);
3591 }
3592};
3593
3594class Q_LANGUAGESERVER_EXPORT DocumentOnTypeFormattingParams : public TextDocumentPositionParams
3595{
3596public:
3597 QByteArray ch = {};
3598 FormattingOptions options = {};
3599
3600 template<typename W>
3601 void walk(W &w)
3602 {
3603 TextDocumentPositionParams::walk(w);
3604 field(w, "ch", ch);
3605 field(w, "options", options);
3606 }
3607};
3608
3609class Q_LANGUAGESERVER_EXPORT RenameRegistrationOptions : public TextDocumentRegistrationOptions,
3610 RenameOptions
3611{
3612public:
3613 template<typename W>
3614 void walk(W &w)
3615 {
3616 TextDocumentRegistrationOptions::walk(w);
3617 RenameOptions::walk(w);
3618 }
3619};
3620
3621class Q_LANGUAGESERVER_EXPORT RenameParams : public TextDocumentPositionParams,
3622 WorkDoneProgressParams
3623{
3624public:
3625 QByteArray newName = {};
3626
3627 template<typename W>
3628 void walk(W &w)
3629 {
3630 TextDocumentPositionParams::walk(w);
3631 WorkDoneProgressParams::walk(w);
3632 field(w, "newName", newName);
3633 }
3634};
3635
3636class Q_LANGUAGESERVER_EXPORT PrepareRenameParams : public TextDocumentPositionParams
3637{
3638public:
3639 template<typename W>
3640 void walk(W &w)
3641 {
3642 TextDocumentPositionParams::walk(w);
3643 }
3644};
3645
3646class Q_LANGUAGESERVER_EXPORT FoldingRangeParams : public WorkDoneProgressParams,
3647 PartialResultParams
3648{
3649public:
3650 TextDocumentIdentifier textDocument = {};
3651
3652 template<typename W>
3653 void walk(W &w)
3654 {
3655 WorkDoneProgressParams::walk(w);
3656 PartialResultParams::walk(w);
3657 field(w, "textDocument", textDocument);
3658 }
3659};
3660
3661class Q_LANGUAGESERVER_EXPORT FoldingRange
3662{
3663public:
3664 int startLine = {};
3665 std::optional<int> startCharacter = {};
3666 int endLine = {};
3667 std::optional<int> endCharacter = {};
3668 std::optional<QByteArray> kind = {};
3669
3670 template<typename W>
3671 void walk(W &w)
3672 {
3673 field(w, "startLine", startLine);
3674 field(w, "startCharacter", startCharacter);
3675 field(w, "endLine", endLine);
3676 field(w, "endCharacter", endCharacter);
3677 field(w, "kind", kind);
3678 }
3679};
3680
3681class Q_LANGUAGESERVER_EXPORT SelectionRangeParams : public WorkDoneProgressParams,
3682 PartialResultParams
3683{
3684public:
3685 TextDocumentIdentifier textDocument = {};
3686 QList<Position> positions = {};
3687
3688 template<typename W>
3689 void walk(W &w)
3690 {
3691 WorkDoneProgressParams::walk(w);
3692 PartialResultParams::walk(w);
3693 field(w, "textDocument", textDocument);
3694 field(w, "positions", positions);
3695 }
3696};
3697
3698class Q_LANGUAGESERVER_EXPORT CallHierarchyPrepareParams : public TextDocumentPositionParams,
3699 WorkDoneProgressParams
3700{
3701public:
3702 template<typename W>
3703 void walk(W &w)
3704 {
3705 TextDocumentPositionParams::walk(w);
3706 WorkDoneProgressParams::walk(w);
3707 }
3708};
3709
3710class Q_LANGUAGESERVER_EXPORT CallHierarchyItem
3711{
3712public:
3713 QByteArray name = {};
3714 SymbolKind kind = {};
3715 std::optional<QList<int>> tags = {};
3716 std::optional<QByteArray> detail = {};
3717 QByteArray uri = {};
3718 Range range = {};
3719 Range selectionRange = {};
3720 std::optional<QJsonValue> data = {};
3721
3722 template<typename W>
3723 void walk(W &w)
3724 {
3725 field(w, "name", name);
3726 field(w, "kind", kind);
3727 field(w, "tags", tags);
3728 field(w, "detail", detail);
3729 field(w, "uri", uri);
3730 field(w, "range", range);
3731 field(w, "selectionRange", selectionRange);
3732 field(w, "data", data);
3733 }
3734};
3735
3736class Q_LANGUAGESERVER_EXPORT CallHierarchyIncomingCallsParams : public WorkDoneProgressParams,
3737 PartialResultParams
3738{
3739public:
3740 CallHierarchyItem item = {};
3741
3742 template<typename W>
3743 void walk(W &w)
3744 {
3745 WorkDoneProgressParams::walk(w);
3746 PartialResultParams::walk(w);
3747 field(w, "item", item);
3748 }
3749};
3750
3751class Q_LANGUAGESERVER_EXPORT CallHierarchyIncomingCall
3752{
3753public:
3754 CallHierarchyItem from = {};
3755 QList<Range> fromRanges = {};
3756
3757 template<typename W>
3758 void walk(W &w)
3759 {
3760 field(w, "from", from);
3761 field(w, "fromRanges", fromRanges);
3762 }
3763};
3764
3765class Q_LANGUAGESERVER_EXPORT CallHierarchyOutgoingCallsParams : public WorkDoneProgressParams,
3766 PartialResultParams
3767{
3768public:
3769 CallHierarchyItem item = {};
3770
3771 template<typename W>
3772 void walk(W &w)
3773 {
3774 WorkDoneProgressParams::walk(w);
3775 PartialResultParams::walk(w);
3776 field(w, "item", item);
3777 }
3778};
3779
3780class Q_LANGUAGESERVER_EXPORT CallHierarchyOutgoingCall
3781{
3782public:
3783 CallHierarchyItem to = {};
3784 QList<Range> fromRanges = {};
3785
3786 template<typename W>
3787 void walk(W &w)
3788 {
3789 field(w, "to", to);
3790 field(w, "fromRanges", fromRanges);
3791 }
3792};
3793
3794class Q_LANGUAGESERVER_EXPORT SemanticTokensParams : public WorkDoneProgressParams,
3795 PartialResultParams
3796{
3797public:
3798 TextDocumentIdentifier textDocument = {};
3799
3800 template<typename W>
3801 void walk(W &w)
3802 {
3803 WorkDoneProgressParams::walk(w);
3804 PartialResultParams::walk(w);
3805 field(w, "textDocument", textDocument);
3806 }
3807};
3808
3809class Q_LANGUAGESERVER_EXPORT SemanticTokens
3810{
3811public:
3812 std::optional<QByteArray> resultId = {};
3813 QList<int> data = {};
3814
3815 template<typename W>
3816 void walk(W &w)
3817 {
3818 field(w, "resultId", resultId);
3819 field(w, "data", data);
3820 }
3821};
3822
3823class Q_LANGUAGESERVER_EXPORT SemanticTokensPartialResult
3824{
3825public:
3826 QList<int> data = {};
3827
3828 template<typename W>
3829 void walk(W &w)
3830 {
3831 field(w, "data", data);
3832 }
3833};
3834
3835class Q_LANGUAGESERVER_EXPORT SemanticTokensDeltaParams : public WorkDoneProgressParams,
3836 PartialResultParams
3837{
3838public:
3839 TextDocumentIdentifier textDocument = {};
3840 QByteArray previousResultId = {};
3841
3842 template<typename W>
3843 void walk(W &w)
3844 {
3845 WorkDoneProgressParams::walk(w);
3846 PartialResultParams::walk(w);
3847 field(w, "textDocument", textDocument);
3848 field(w, "previousResultId", previousResultId);
3849 }
3850};
3851
3852class Q_LANGUAGESERVER_EXPORT SemanticTokensEdit
3853{
3854public:
3855 int start = {};
3856 int deleteCount = {};
3857 std::optional<QList<int>> data = {};
3858
3859 template<typename W>
3860 void walk(W &w)
3861 {
3862 field(w, "start", start);
3863 field(w, "deleteCount", deleteCount);
3864 field(w, "data", data);
3865 }
3866};
3867
3868class Q_LANGUAGESERVER_EXPORT SemanticTokensDelta
3869{
3870public:
3871 std::optional<QByteArray> resultId = {};
3872 QList<SemanticTokensEdit> edits = {};
3873
3874 template<typename W>
3875 void walk(W &w)
3876 {
3877 field(w, "resultId", resultId);
3878 field(w, "edits", edits);
3879 }
3880};
3881
3882class Q_LANGUAGESERVER_EXPORT SemanticTokensDeltaPartialResult
3883{
3884public:
3885 QList<SemanticTokensEdit> edits = {};
3886
3887 template<typename W>
3888 void walk(W &w)
3889 {
3890 field(w, "edits", edits);
3891 }
3892};
3893
3894class Q_LANGUAGESERVER_EXPORT SemanticTokensRangeParams : public WorkDoneProgressParams,
3895 PartialResultParams
3896{
3897public:
3898 TextDocumentIdentifier textDocument = {};
3899 Range range = {};
3900
3901 template<typename W>
3902 void walk(W &w)
3903 {
3904 WorkDoneProgressParams::walk(w);
3905 PartialResultParams::walk(w);
3906 field(w, "textDocument", textDocument);
3907 field(w, "range", range);
3908 }
3909};
3910
3911class Q_LANGUAGESERVER_EXPORT SemanticTokensWorkspaceClientCapabilities
3912{
3913public:
3914 std::optional<bool> refreshSupport = {};
3915
3916 template<typename W>
3917 void walk(W &w)
3918 {
3919 field(w, "refreshSupport", refreshSupport);
3920 }
3921};
3922
3923class Q_LANGUAGESERVER_EXPORT LinkedEditingRangeParams : public TextDocumentPositionParams,
3924 WorkDoneProgressParams
3925{
3926public:
3927 template<typename W>
3928 void walk(W &w)
3929 {
3930 TextDocumentPositionParams::walk(w);
3931 WorkDoneProgressParams::walk(w);
3932 }
3933};
3934
3935class Q_LANGUAGESERVER_EXPORT LinkedEditingRanges
3936{
3937public:
3938 QList<Range> ranges = {};
3939 std::optional<QByteArray> wordPattern = {};
3940
3941 template<typename W>
3942 void walk(W &w)
3943 {
3944 field(w, "ranges", ranges);
3945 field(w, "wordPattern", wordPattern);
3946 }
3947};
3948
3949class Q_LANGUAGESERVER_EXPORT MonikerParams : public TextDocumentPositionParams,
3950 WorkDoneProgressParams,
3951 PartialResultParams
3952{
3953public:
3954 template<typename W>
3955 void walk(W &w)
3956 {
3957 TextDocumentPositionParams::walk(w);
3958 WorkDoneProgressParams::walk(w);
3959 PartialResultParams::walk(w);
3960 }
3961};
3962
3963class Q_LANGUAGESERVER_EXPORT Moniker
3964{
3965public:
3966 QByteArray scheme = {};
3967 QByteArray identifier = {};
3968 UniquenessLevel unique = {};
3969 std::optional<MonikerKind> kind = {};
3970
3971 template<typename W>
3972 void walk(W &w)
3973 {
3974 field(w, "scheme", scheme);
3975 field(w, "identifier", identifier);
3976 field(w, "unique", unique);
3977 field(w, "kind", kind);
3978 }
3979};
3980
3981} // namespace QLspSpecification
3982
3983namespace QTypedJson {
3984
3985template<>
3986inline QString enumToString<QLspSpecification::TraceValue>(QLspSpecification::TraceValue value)
3987{
3988 switch (value) {
3989 case QLspSpecification::TraceValue::Off:
3990 return QLatin1String("off");
3991 case QLspSpecification::TraceValue::Messages:
3992 return QLatin1String("messages");
3993 case QLspSpecification::TraceValue::Verbose:
3994 return QLatin1String("verbose");
3995 }
3996 return QString();
3997}
3998
3999template<>
4000inline QString enumToString<QLspSpecification::ErrorCodes>(QLspSpecification::ErrorCodes value)
4001{
4002 return enumToIntString<QLspSpecification::ErrorCodes>(value);
4003}
4004
4005template<>
4006inline QString
4007enumToString<QLspSpecification::DiagnosticSeverity>(QLspSpecification::DiagnosticSeverity value)
4008{
4009 return enumToIntString<QLspSpecification::DiagnosticSeverity>(value);
4010}
4011
4012template<>
4013inline QString
4014enumToString<QLspSpecification::DiagnosticTag>(QLspSpecification::DiagnosticTag value)
4015{
4016 return enumToIntString<QLspSpecification::DiagnosticTag>(value);
4017}
4018
4019template<>
4020inline QString enumToString<QLspSpecification::ResourceOperationKind>(
4021 QLspSpecification::ResourceOperationKind value)
4022{
4023 switch (value) {
4024 case QLspSpecification::ResourceOperationKind::Create:
4025 return QLatin1String("create");
4026 case QLspSpecification::ResourceOperationKind::Rename:
4027 return QLatin1String("rename");
4028 case QLspSpecification::ResourceOperationKind::Delete:
4029 return QLatin1String("delete");
4030 default:
4031 return QString::number(int(value));
4032 }
4033}
4034
4035template<>
4036inline QString
4037enumToString<QLspSpecification::FailureHandlingKind>(QLspSpecification::FailureHandlingKind value)
4038{
4039 switch (value) {
4040 case QLspSpecification::FailureHandlingKind::Abort:
4041 return QLatin1String("abort");
4042 case QLspSpecification::FailureHandlingKind::Transactional:
4043 return QLatin1String("transactional");
4044 case QLspSpecification::FailureHandlingKind::TextOnlyTransactional:
4045 return QLatin1String("textOnlyTransactional");
4046 case QLspSpecification::FailureHandlingKind::Undo:
4047 return QLatin1String("undo");
4048 default:
4049 return QString::number(int(value));
4050 }
4051}
4052
4053template<>
4054inline QString enumToString<QLspSpecification::MarkupKind>(QLspSpecification::MarkupKind value)
4055{
4056 switch (value) {
4057 case QLspSpecification::MarkupKind::PlainText:
4058 return QLatin1String("plaintext");
4059 case QLspSpecification::MarkupKind::Markdown:
4060 return QLatin1String("markdown");
4061 default:
4062 return QString::number(int(value));
4063 }
4064}
4065
4066template<>
4067inline QString
4068enumToString<QLspSpecification::InitializeErrorCode>(QLspSpecification::InitializeErrorCode value)
4069{
4070 return enumToIntString<QLspSpecification::InitializeErrorCode>(value);
4071}
4072
4073template<>
4074inline QString enumToString<QLspSpecification::MessageType>(QLspSpecification::MessageType value)
4075{
4076 return enumToIntString<QLspSpecification::MessageType>(value);
4077}
4078
4079template<>
4080inline QString enumToString<QLspSpecification::WatchKind>(QLspSpecification::WatchKind value)
4081{
4082 return enumToIntString<QLspSpecification::WatchKind>(value);
4083}
4084
4085template<>
4086inline QString
4087enumToString<QLspSpecification::FileChangeType>(QLspSpecification::FileChangeType value)
4088{
4089 return enumToIntString<QLspSpecification::FileChangeType>(value);
4090}
4091
4092template<>
4093inline QString enumToString<QLspSpecification::FileOperationPatternKind>(
4094 QLspSpecification::FileOperationPatternKind value)
4095{
4096 switch (value) {
4097 case QLspSpecification::FileOperationPatternKind::File:
4098 return QLatin1String("file");
4099 case QLspSpecification::FileOperationPatternKind::Folder:
4100 return QLatin1String("folder");
4101 default:
4102 return QString::number(int(value));
4103 }
4104}
4105
4106template<>
4107inline QString
4108enumToString<QLspSpecification::TextDocumentSyncKind>(QLspSpecification::TextDocumentSyncKind value)
4109{
4110 return enumToIntString<QLspSpecification::TextDocumentSyncKind>(value);
4111}
4112
4113template<>
4114inline QString enumToString<QLspSpecification::TextDocumentSaveReason>(
4115 QLspSpecification::TextDocumentSaveReason value)
4116{
4117 return enumToIntString<QLspSpecification::TextDocumentSaveReason>(value);
4118}
4119
4120template<>
4121inline QString enumToString<QLspSpecification::CompletionTriggerKind>(
4122 QLspSpecification::CompletionTriggerKind value)
4123{
4124 return enumToIntString<QLspSpecification::CompletionTriggerKind>(value);
4125}
4126
4127template<>
4128inline QString
4129enumToString<QLspSpecification::InsertTextFormat>(QLspSpecification::InsertTextFormat value)
4130{
4131 return enumToIntString<QLspSpecification::InsertTextFormat>(value);
4132}
4133
4134template<>
4135inline QString
4136enumToString<QLspSpecification::CompletionItemTag>(QLspSpecification::CompletionItemTag value)
4137{
4138 return enumToIntString<QLspSpecification::CompletionItemTag>(value);
4139}
4140
4141template<>
4142inline QString
4143enumToString<QLspSpecification::InsertTextMode>(QLspSpecification::InsertTextMode value)
4144{
4145 return enumToIntString<QLspSpecification::InsertTextMode>(value);
4146}
4147
4148template<>
4149inline QString
4150enumToString<QLspSpecification::CompletionItemKind>(QLspSpecification::CompletionItemKind value)
4151{
4152 return enumToIntString<QLspSpecification::CompletionItemKind>(value);
4153}
4154
4155template<>
4156inline QString enumToString<QLspSpecification::SignatureHelpTriggerKind>(
4157 QLspSpecification::SignatureHelpTriggerKind value)
4158{
4159 return enumToIntString<QLspSpecification::SignatureHelpTriggerKind>(value);
4160}
4161
4162template<>
4163inline QString enumToString<QLspSpecification::DocumentHighlightKind>(
4164 QLspSpecification::DocumentHighlightKind value)
4165{
4166 return enumToIntString<QLspSpecification::DocumentHighlightKind>(value);
4167}
4168
4169template<>
4170inline QString enumToString<QLspSpecification::SymbolKind>(QLspSpecification::SymbolKind value)
4171{
4172 return enumToIntString<QLspSpecification::SymbolKind>(value);
4173}
4174
4175template<>
4176inline QString enumToString<QLspSpecification::SymbolTag>(QLspSpecification::SymbolTag value)
4177{
4178 return enumToIntString<QLspSpecification::SymbolTag>(value);
4179}
4180
4181template<>
4182inline QString
4183enumToString<QLspSpecification::CodeActionKind>(QLspSpecification::CodeActionKind value)
4184{
4185 switch (value) {
4186 case QLspSpecification::CodeActionKind::Empty:
4187 return QLatin1String("");
4188 case QLspSpecification::CodeActionKind::QuickFix:
4189 return QLatin1String("quickfix");
4190 case QLspSpecification::CodeActionKind::Refactor:
4191 return QLatin1String("refactor");
4192 case QLspSpecification::CodeActionKind::RefactorExtract:
4193 return QLatin1String("refactor.extract");
4194 case QLspSpecification::CodeActionKind::RefactorInline:
4195 return QLatin1String("refactor.inline");
4196 case QLspSpecification::CodeActionKind::RefactorRewrite:
4197 return QLatin1String("refactor.rewrite");
4198 case QLspSpecification::CodeActionKind::Source:
4199 return QLatin1String("source");
4200 case QLspSpecification::CodeActionKind::SourceOrganizeImports:
4201 return QLatin1String("source.organizeImports");
4202 default:
4203 return QString::number(int(value));
4204 }
4205}
4206
4207template<>
4208inline QLspSpecification::CodeActionKind
4209enumFromString<QLspSpecification::CodeActionKind>(const QString &string)
4210{
4211 if (string.compare(other: QLatin1String(""), cs: Qt::CaseInsensitive) == 0)
4212 return QLspSpecification::CodeActionKind::Empty;
4213 else if (string.compare(other: QLatin1String("quickfix"), cs: Qt::CaseInsensitive) == 0)
4214 return QLspSpecification::CodeActionKind::QuickFix;
4215 else if (string.compare(other: QLatin1String("refactor"), cs: Qt::CaseInsensitive) == 0)
4216 return QLspSpecification::CodeActionKind::Refactor;
4217 else if (string.compare(other: QLatin1String("refactor.extract"), cs: Qt::CaseInsensitive) == 0)
4218 return QLspSpecification::CodeActionKind::RefactorExtract;
4219 else if (string.compare(other: QLatin1String("refactor.inline"), cs: Qt::CaseInsensitive) == 0)
4220 return QLspSpecification::CodeActionKind::RefactorInline;
4221 else if (string.compare(other: QLatin1String("refactor.rewrite"), cs: Qt::CaseInsensitive) == 0)
4222 return QLspSpecification::CodeActionKind::RefactorRewrite;
4223 else if (string.compare(other: QLatin1String("source"), cs: Qt::CaseInsensitive) == 0)
4224 return QLspSpecification::CodeActionKind::Source;
4225 else if (string.compare(other: QLatin1String("source.organizeImports"), cs: Qt::CaseInsensitive) == 0)
4226 return QLspSpecification::CodeActionKind::SourceOrganizeImports;
4227 return QLspSpecification::CodeActionKind{};
4228}
4229
4230template<>
4231inline QString enumToString<QLspSpecification::PrepareSupportDefaultBehavior>(
4232 QLspSpecification::PrepareSupportDefaultBehavior value)
4233{
4234 return enumToIntString<QLspSpecification::PrepareSupportDefaultBehavior>(value);
4235}
4236
4237template<>
4238inline QString
4239enumToString<QLspSpecification::FoldingRangeKind>(QLspSpecification::FoldingRangeKind value)
4240{
4241 switch (value) {
4242 case QLspSpecification::FoldingRangeKind::Comment:
4243 return QLatin1String("comment");
4244 case QLspSpecification::FoldingRangeKind::Imports:
4245 return QLatin1String("imports");
4246 case QLspSpecification::FoldingRangeKind::Region:
4247 return QLatin1String("region");
4248 default:
4249 return QString::number(int(value));
4250 }
4251}
4252
4253template<>
4254inline QString
4255enumToString<QLspSpecification::SemanticTokenTypes>(QLspSpecification::SemanticTokenTypes value)
4256{
4257 switch (value) {
4258 case QLspSpecification::SemanticTokenTypes::Namespace:
4259 return QLatin1String("namespace");
4260 case QLspSpecification::SemanticTokenTypes::Type:
4261 return QLatin1String("type");
4262 case QLspSpecification::SemanticTokenTypes::Class:
4263 return QLatin1String("class");
4264 case QLspSpecification::SemanticTokenTypes::Enum:
4265 return QLatin1String("enum");
4266 case QLspSpecification::SemanticTokenTypes::Interface:
4267 return QLatin1String("interface");
4268 case QLspSpecification::SemanticTokenTypes::Struct:
4269 return QLatin1String("struct");
4270 case QLspSpecification::SemanticTokenTypes::TypeParameter:
4271 return QLatin1String("typeParameter");
4272 case QLspSpecification::SemanticTokenTypes::Parameter:
4273 return QLatin1String("parameter");
4274 case QLspSpecification::SemanticTokenTypes::Variable:
4275 return QLatin1String("variable");
4276 case QLspSpecification::SemanticTokenTypes::Property:
4277 return QLatin1String("property");
4278 case QLspSpecification::SemanticTokenTypes::EnumMember:
4279 return QLatin1String("enumMember");
4280 case QLspSpecification::SemanticTokenTypes::Event:
4281 return QLatin1String("event");
4282 case QLspSpecification::SemanticTokenTypes::Function:
4283 return QLatin1String("function");
4284 case QLspSpecification::SemanticTokenTypes::Method:
4285 return QLatin1String("method");
4286 case QLspSpecification::SemanticTokenTypes::Macro:
4287 return QLatin1String("macro");
4288 case QLspSpecification::SemanticTokenTypes::Keyword:
4289 return QLatin1String("keyword");
4290 case QLspSpecification::SemanticTokenTypes::Modifier:
4291 return QLatin1String("modifier");
4292 case QLspSpecification::SemanticTokenTypes::Comment:
4293 return QLatin1String("comment");
4294 case QLspSpecification::SemanticTokenTypes::String:
4295 return QLatin1String("string");
4296 case QLspSpecification::SemanticTokenTypes::Number:
4297 return QLatin1String("number");
4298 case QLspSpecification::SemanticTokenTypes::Regexp:
4299 return QLatin1String("regexp");
4300 case QLspSpecification::SemanticTokenTypes::Operator:
4301 return QLatin1String("operator");
4302 default:
4303 return QString::number(int(value));
4304 }
4305}
4306
4307template<>
4308inline QString enumToString<QLspSpecification::SemanticTokenModifiers>(
4309 QLspSpecification::SemanticTokenModifiers value)
4310{
4311 switch (value) {
4312 case QLspSpecification::SemanticTokenModifiers::Declaration:
4313 return QLatin1String("declaration");
4314 case QLspSpecification::SemanticTokenModifiers::Definition:
4315 return QLatin1String("definition");
4316 case QLspSpecification::SemanticTokenModifiers::Readonly:
4317 return QLatin1String("readonly");
4318 case QLspSpecification::SemanticTokenModifiers::Static:
4319 return QLatin1String("static");
4320 case QLspSpecification::SemanticTokenModifiers::Deprecated:
4321 return QLatin1String("deprecated");
4322 case QLspSpecification::SemanticTokenModifiers::Abstract:
4323 return QLatin1String("abstract");
4324 case QLspSpecification::SemanticTokenModifiers::Async:
4325 return QLatin1String("async");
4326 case QLspSpecification::SemanticTokenModifiers::Modification:
4327 return QLatin1String("modification");
4328 case QLspSpecification::SemanticTokenModifiers::Documentation:
4329 return QLatin1String("documentation");
4330 case QLspSpecification::SemanticTokenModifiers::DefaultLibrary:
4331 return QLatin1String("defaultLibrary");
4332 default:
4333 return QString::number(int(value));
4334 }
4335}
4336
4337template<>
4338inline QString enumToString<QLspSpecification::TokenFormat>(QLspSpecification::TokenFormat value)
4339{
4340 switch (value) {
4341 case QLspSpecification::TokenFormat::Relative:
4342 return QLatin1String("relative");
4343 default:
4344 return QString::number(int(value));
4345 }
4346}
4347
4348template<>
4349inline QString
4350enumToString<QLspSpecification::UniquenessLevel>(QLspSpecification::UniquenessLevel value)
4351{
4352 switch (value) {
4353 case QLspSpecification::UniquenessLevel::Document:
4354 return QLatin1String("document");
4355 case QLspSpecification::UniquenessLevel::Project:
4356 return QLatin1String("project");
4357 case QLspSpecification::UniquenessLevel::Group:
4358 return QLatin1String("group");
4359 case QLspSpecification::UniquenessLevel::Scheme:
4360 return QLatin1String("scheme");
4361 case QLspSpecification::UniquenessLevel::Global:
4362 return QLatin1String("global");
4363 default:
4364 return QString::number(int(value));
4365 }
4366}
4367
4368template<>
4369inline QString enumToString<QLspSpecification::MonikerKind>(QLspSpecification::MonikerKind value)
4370{
4371 switch (value) {
4372 case QLspSpecification::MonikerKind::Import:
4373 return QLatin1String("import");
4374 case QLspSpecification::MonikerKind::Export:
4375 return QLatin1String("export");
4376 case QLspSpecification::MonikerKind::Local:
4377 return QLatin1String("local");
4378 default:
4379 return QString::number(int(value));
4380 }
4381}
4382
4383} // namespace QTypedJson
4384QT_END_NAMESPACE
4385#endif // QLANGUAGESERVERSPECTYPES_P_H
4386

source code of qtlanguageserver/src/languageserver/qlanguageserverspectypes_p.h