add initial lsp support

1 files changed, 3072 insertions, 0 deletions

diff --git a/internal/lsp/protocol/tsjson.go b/internal/lsp/protocol/tsjson.go
new file mode 100644
index 000000000..24eb515c0
--- /dev/null
+++ b/internal/lsp/protocol/tsjson.go
@@ -0,0 +1,3072 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Code generated for LSP. DO NOT EDIT.
+
+package protocol
+
+// Code generated from protocol/metaModel.json at ref release/protocol/3.17.6-next.9 (hash c94395b5da53729e6dff931293b051009ccaaaa4).
+// https://github.com/microsoft/vscode-languageserver-node/blob/release/protocol/3.17.6-next.9/protocol/metaModel.json
+// LSP metaData.version = 3.17.0.
+
+import "bytes"
+import "encoding/json"
+
+import "fmt"
+
+// UnmarshalError indicates that a JSON value did not conform to
+// one of the expected cases of an LSP union type.
+type UnmarshalError struct {
+	msg string
+}
+
+func (e UnmarshalError) Error() string {
+	return e.msg
+}
+func (t Or_CancelParams_id) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case int32:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [int32 string]", t)
+}
+
+func (t *Or_CancelParams_id) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder41 := json.NewDecoder(bytes.NewReader(x))
+	decoder41.DisallowUnknownFields()
+	var int32Val int32
+	if err := decoder41.Decode(&int32Val); err == nil {
+		t.Value = int32Val
+		return nil
+	}
+	decoder42 := json.NewDecoder(bytes.NewReader(x))
+	decoder42.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder42.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [int32 string]"}
+}
+
+func (t Or_ClientSemanticTokensRequestOptions_full) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case ClientSemanticTokensRequestFullDelta:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [ClientSemanticTokensRequestFullDelta bool]", t)
+}
+
+func (t *Or_ClientSemanticTokensRequestOptions_full) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder220 := json.NewDecoder(bytes.NewReader(x))
+	decoder220.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder220.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder221 := json.NewDecoder(bytes.NewReader(x))
+	decoder221.DisallowUnknownFields()
+	var h221 ClientSemanticTokensRequestFullDelta
+	if err := decoder221.Decode(&h221); err == nil {
+		t.Value = h221
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [ClientSemanticTokensRequestFullDelta bool]"}
+}
+
+func (t Or_ClientSemanticTokensRequestOptions_range) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case Lit_ClientSemanticTokensRequestOptions_range_Item1:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [Lit_ClientSemanticTokensRequestOptions_range_Item1 bool]", t)
+}
+
+func (t *Or_ClientSemanticTokensRequestOptions_range) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder217 := json.NewDecoder(bytes.NewReader(x))
+	decoder217.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder217.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder218 := json.NewDecoder(bytes.NewReader(x))
+	decoder218.DisallowUnknownFields()
+	var h218 Lit_ClientSemanticTokensRequestOptions_range_Item1
+	if err := decoder218.Decode(&h218); err == nil {
+		t.Value = h218
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [Lit_ClientSemanticTokensRequestOptions_range_Item1 bool]"}
+}
+
+func (t Or_CompletionItemDefaults_editRange) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case EditRangeWithInsertReplace:
+		return json.Marshal(x)
+	case Range:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [EditRangeWithInsertReplace Range]", t)
+}
+
+func (t *Or_CompletionItemDefaults_editRange) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder183 := json.NewDecoder(bytes.NewReader(x))
+	decoder183.DisallowUnknownFields()
+	var h183 EditRangeWithInsertReplace
+	if err := decoder183.Decode(&h183); err == nil {
+		t.Value = h183
+		return nil
+	}
+	decoder184 := json.NewDecoder(bytes.NewReader(x))
+	decoder184.DisallowUnknownFields()
+	var h184 Range
+	if err := decoder184.Decode(&h184); err == nil {
+		t.Value = h184
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [EditRangeWithInsertReplace Range]"}
+}
+
+func (t Or_CompletionItem_documentation) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case MarkupContent:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [MarkupContent string]", t)
+}
+
+func (t *Or_CompletionItem_documentation) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder25 := json.NewDecoder(bytes.NewReader(x))
+	decoder25.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder25.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder26 := json.NewDecoder(bytes.NewReader(x))
+	decoder26.DisallowUnknownFields()
+	var h26 MarkupContent
+	if err := decoder26.Decode(&h26); err == nil {
+		t.Value = h26
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [MarkupContent string]"}
+}
+
+func (t Or_CompletionItem_textEdit) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case InsertReplaceEdit:
+		return json.Marshal(x)
+	case TextEdit:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [InsertReplaceEdit TextEdit]", t)
+}
+
+func (t *Or_CompletionItem_textEdit) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder29 := json.NewDecoder(bytes.NewReader(x))
+	decoder29.DisallowUnknownFields()
+	var h29 InsertReplaceEdit
+	if err := decoder29.Decode(&h29); err == nil {
+		t.Value = h29
+		return nil
+	}
+	decoder30 := json.NewDecoder(bytes.NewReader(x))
+	decoder30.DisallowUnknownFields()
+	var h30 TextEdit
+	if err := decoder30.Decode(&h30); err == nil {
+		t.Value = h30
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [InsertReplaceEdit TextEdit]"}
+}
+
+func (t Or_Declaration) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case Location:
+		return json.Marshal(x)
+	case []Location:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [Location []Location]", t)
+}
+
+func (t *Or_Declaration) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder237 := json.NewDecoder(bytes.NewReader(x))
+	decoder237.DisallowUnknownFields()
+	var h237 Location
+	if err := decoder237.Decode(&h237); err == nil {
+		t.Value = h237
+		return nil
+	}
+	decoder238 := json.NewDecoder(bytes.NewReader(x))
+	decoder238.DisallowUnknownFields()
+	var h238 []Location
+	if err := decoder238.Decode(&h238); err == nil {
+		t.Value = h238
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [Location []Location]"}
+}
+
+func (t Or_Definition) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case Location:
+		return json.Marshal(x)
+	case []Location:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [Location []Location]", t)
+}
+
+func (t *Or_Definition) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder224 := json.NewDecoder(bytes.NewReader(x))
+	decoder224.DisallowUnknownFields()
+	var h224 Location
+	if err := decoder224.Decode(&h224); err == nil {
+		t.Value = h224
+		return nil
+	}
+	decoder225 := json.NewDecoder(bytes.NewReader(x))
+	decoder225.DisallowUnknownFields()
+	var h225 []Location
+	if err := decoder225.Decode(&h225); err == nil {
+		t.Value = h225
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [Location []Location]"}
+}
+
+func (t Or_Diagnostic_code) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case int32:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [int32 string]", t)
+}
+
+func (t *Or_Diagnostic_code) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder179 := json.NewDecoder(bytes.NewReader(x))
+	decoder179.DisallowUnknownFields()
+	var int32Val int32
+	if err := decoder179.Decode(&int32Val); err == nil {
+		t.Value = int32Val
+		return nil
+	}
+	decoder180 := json.NewDecoder(bytes.NewReader(x))
+	decoder180.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder180.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [int32 string]"}
+}
+
+func (t Or_DidChangeConfigurationRegistrationOptions_section) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case []string:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [[]string string]", t)
+}
+
+func (t *Or_DidChangeConfigurationRegistrationOptions_section) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder22 := json.NewDecoder(bytes.NewReader(x))
+	decoder22.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder22.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder23 := json.NewDecoder(bytes.NewReader(x))
+	decoder23.DisallowUnknownFields()
+	var h23 []string
+	if err := decoder23.Decode(&h23); err == nil {
+		t.Value = h23
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [[]string string]"}
+}
+
+func (t Or_DocumentDiagnosticReport) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case RelatedFullDocumentDiagnosticReport:
+		return json.Marshal(x)
+	case RelatedUnchangedDocumentDiagnosticReport:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [RelatedFullDocumentDiagnosticReport RelatedUnchangedDocumentDiagnosticReport]", t)
+}
+
+func (t *Or_DocumentDiagnosticReport) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder247 := json.NewDecoder(bytes.NewReader(x))
+	decoder247.DisallowUnknownFields()
+	var h247 RelatedFullDocumentDiagnosticReport
+	if err := decoder247.Decode(&h247); err == nil {
+		t.Value = h247
+		return nil
+	}
+	decoder248 := json.NewDecoder(bytes.NewReader(x))
+	decoder248.DisallowUnknownFields()
+	var h248 RelatedUnchangedDocumentDiagnosticReport
+	if err := decoder248.Decode(&h248); err == nil {
+		t.Value = h248
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [RelatedFullDocumentDiagnosticReport RelatedUnchangedDocumentDiagnosticReport]"}
+}
+
+func (t Or_DocumentDiagnosticReportPartialResult_relatedDocuments_Value) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case FullDocumentDiagnosticReport:
+		return json.Marshal(x)
+	case UnchangedDocumentDiagnosticReport:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]", t)
+}
+
+func (t *Or_DocumentDiagnosticReportPartialResult_relatedDocuments_Value) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder16 := json.NewDecoder(bytes.NewReader(x))
+	decoder16.DisallowUnknownFields()
+	var h16 FullDocumentDiagnosticReport
+	if err := decoder16.Decode(&h16); err == nil {
+		t.Value = h16
+		return nil
+	}
+	decoder17 := json.NewDecoder(bytes.NewReader(x))
+	decoder17.DisallowUnknownFields()
+	var h17 UnchangedDocumentDiagnosticReport
+	if err := decoder17.Decode(&h17); err == nil {
+		t.Value = h17
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]"}
+}
+
+func (t Or_DocumentFilter) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case NotebookCellTextDocumentFilter:
+		return json.Marshal(x)
+	case TextDocumentFilter:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [NotebookCellTextDocumentFilter TextDocumentFilter]", t)
+}
+
+func (t *Or_DocumentFilter) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder270 := json.NewDecoder(bytes.NewReader(x))
+	decoder270.DisallowUnknownFields()
+	var h270 NotebookCellTextDocumentFilter
+	if err := decoder270.Decode(&h270); err == nil {
+		t.Value = h270
+		return nil
+	}
+	decoder271 := json.NewDecoder(bytes.NewReader(x))
+	decoder271.DisallowUnknownFields()
+	var h271 TextDocumentFilter
+	if err := decoder271.Decode(&h271); err == nil {
+		t.Value = h271
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [NotebookCellTextDocumentFilter TextDocumentFilter]"}
+}
+
+func (t Or_GlobPattern) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case Pattern:
+		return json.Marshal(x)
+	case RelativePattern:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [Pattern RelativePattern]", t)
+}
+
+func (t *Or_GlobPattern) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder274 := json.NewDecoder(bytes.NewReader(x))
+	decoder274.DisallowUnknownFields()
+	var h274 Pattern
+	if err := decoder274.Decode(&h274); err == nil {
+		t.Value = h274
+		return nil
+	}
+	decoder275 := json.NewDecoder(bytes.NewReader(x))
+	decoder275.DisallowUnknownFields()
+	var h275 RelativePattern
+	if err := decoder275.Decode(&h275); err == nil {
+		t.Value = h275
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [Pattern RelativePattern]"}
+}
+
+func (t Or_Hover_contents) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case MarkedString:
+		return json.Marshal(x)
+	case MarkupContent:
+		return json.Marshal(x)
+	case []MarkedString:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [MarkedString MarkupContent []MarkedString]", t)
+}
+
+func (t *Or_Hover_contents) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder34 := json.NewDecoder(bytes.NewReader(x))
+	decoder34.DisallowUnknownFields()
+	var h34 MarkedString
+	if err := decoder34.Decode(&h34); err == nil {
+		t.Value = h34
+		return nil
+	}
+	decoder35 := json.NewDecoder(bytes.NewReader(x))
+	decoder35.DisallowUnknownFields()
+	var h35 MarkupContent
+	if err := decoder35.Decode(&h35); err == nil {
+		t.Value = h35
+		return nil
+	}
+	decoder36 := json.NewDecoder(bytes.NewReader(x))
+	decoder36.DisallowUnknownFields()
+	var h36 []MarkedString
+	if err := decoder36.Decode(&h36); err == nil {
+		t.Value = h36
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [MarkedString MarkupContent []MarkedString]"}
+}
+
+func (t Or_InlayHintLabelPart_tooltip) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case MarkupContent:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [MarkupContent string]", t)
+}
+
+func (t *Or_InlayHintLabelPart_tooltip) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder56 := json.NewDecoder(bytes.NewReader(x))
+	decoder56.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder56.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder57 := json.NewDecoder(bytes.NewReader(x))
+	decoder57.DisallowUnknownFields()
+	var h57 MarkupContent
+	if err := decoder57.Decode(&h57); err == nil {
+		t.Value = h57
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [MarkupContent string]"}
+}
+
+func (t Or_InlayHint_label) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case []InlayHintLabelPart:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [[]InlayHintLabelPart string]", t)
+}
+
+func (t *Or_InlayHint_label) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder9 := json.NewDecoder(bytes.NewReader(x))
+	decoder9.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder9.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder10 := json.NewDecoder(bytes.NewReader(x))
+	decoder10.DisallowUnknownFields()
+	var h10 []InlayHintLabelPart
+	if err := decoder10.Decode(&h10); err == nil {
+		t.Value = h10
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [[]InlayHintLabelPart string]"}
+}
+
+func (t Or_InlayHint_tooltip) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case MarkupContent:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [MarkupContent string]", t)
+}
+
+func (t *Or_InlayHint_tooltip) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder12 := json.NewDecoder(bytes.NewReader(x))
+	decoder12.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder12.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder13 := json.NewDecoder(bytes.NewReader(x))
+	decoder13.DisallowUnknownFields()
+	var h13 MarkupContent
+	if err := decoder13.Decode(&h13); err == nil {
+		t.Value = h13
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [MarkupContent string]"}
+}
+
+func (t Or_InlineCompletionItem_insertText) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case StringValue:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [StringValue string]", t)
+}
+
+func (t *Or_InlineCompletionItem_insertText) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder19 := json.NewDecoder(bytes.NewReader(x))
+	decoder19.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder19.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder20 := json.NewDecoder(bytes.NewReader(x))
+	decoder20.DisallowUnknownFields()
+	var h20 StringValue
+	if err := decoder20.Decode(&h20); err == nil {
+		t.Value = h20
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [StringValue string]"}
+}
+
+func (t Or_InlineValue) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case InlineValueEvaluatableExpression:
+		return json.Marshal(x)
+	case InlineValueText:
+		return json.Marshal(x)
+	case InlineValueVariableLookup:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [InlineValueEvaluatableExpression InlineValueText InlineValueVariableLookup]", t)
+}
+
+func (t *Or_InlineValue) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder242 := json.NewDecoder(bytes.NewReader(x))
+	decoder242.DisallowUnknownFields()
+	var h242 InlineValueEvaluatableExpression
+	if err := decoder242.Decode(&h242); err == nil {
+		t.Value = h242
+		return nil
+	}
+	decoder243 := json.NewDecoder(bytes.NewReader(x))
+	decoder243.DisallowUnknownFields()
+	var h243 InlineValueText
+	if err := decoder243.Decode(&h243); err == nil {
+		t.Value = h243
+		return nil
+	}
+	decoder244 := json.NewDecoder(bytes.NewReader(x))
+	decoder244.DisallowUnknownFields()
+	var h244 InlineValueVariableLookup
+	if err := decoder244.Decode(&h244); err == nil {
+		t.Value = h244
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [InlineValueEvaluatableExpression InlineValueText InlineValueVariableLookup]"}
+}
+
+func (t Or_LSPAny) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case LSPArray:
+		return json.Marshal(x)
+	case LSPObject:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case float64:
+		return json.Marshal(x)
+	case int32:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case uint32:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [LSPArray LSPObject bool float64 int32 string uint32]", t)
+}
+
+func (t *Or_LSPAny) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder228 := json.NewDecoder(bytes.NewReader(x))
+	decoder228.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder228.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder229 := json.NewDecoder(bytes.NewReader(x))
+	decoder229.DisallowUnknownFields()
+	var float64Val float64
+	if err := decoder229.Decode(&float64Val); err == nil {
+		t.Value = float64Val
+		return nil
+	}
+	decoder230 := json.NewDecoder(bytes.NewReader(x))
+	decoder230.DisallowUnknownFields()
+	var int32Val int32
+	if err := decoder230.Decode(&int32Val); err == nil {
+		t.Value = int32Val
+		return nil
+	}
+	decoder231 := json.NewDecoder(bytes.NewReader(x))
+	decoder231.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder231.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder232 := json.NewDecoder(bytes.NewReader(x))
+	decoder232.DisallowUnknownFields()
+	var uint32Val uint32
+	if err := decoder232.Decode(&uint32Val); err == nil {
+		t.Value = uint32Val
+		return nil
+	}
+	decoder233 := json.NewDecoder(bytes.NewReader(x))
+	decoder233.DisallowUnknownFields()
+	var h233 LSPArray
+	if err := decoder233.Decode(&h233); err == nil {
+		t.Value = h233
+		return nil
+	}
+	decoder234 := json.NewDecoder(bytes.NewReader(x))
+	decoder234.DisallowUnknownFields()
+	var h234 LSPObject
+	if err := decoder234.Decode(&h234); err == nil {
+		t.Value = h234
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [LSPArray LSPObject bool float64 int32 string uint32]"}
+}
+
+func (t Or_MarkedString) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case MarkedStringWithLanguage:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [MarkedStringWithLanguage string]", t)
+}
+
+func (t *Or_MarkedString) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder266 := json.NewDecoder(bytes.NewReader(x))
+	decoder266.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder266.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder267 := json.NewDecoder(bytes.NewReader(x))
+	decoder267.DisallowUnknownFields()
+	var h267 MarkedStringWithLanguage
+	if err := decoder267.Decode(&h267); err == nil {
+		t.Value = h267
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [MarkedStringWithLanguage string]"}
+}
+
+func (t Or_NotebookCellTextDocumentFilter_notebook) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case NotebookDocumentFilter:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [NotebookDocumentFilter string]", t)
+}
+
+func (t *Or_NotebookCellTextDocumentFilter_notebook) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder208 := json.NewDecoder(bytes.NewReader(x))
+	decoder208.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder208.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder209 := json.NewDecoder(bytes.NewReader(x))
+	decoder209.DisallowUnknownFields()
+	var h209 NotebookDocumentFilter
+	if err := decoder209.Decode(&h209); err == nil {
+		t.Value = h209
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [NotebookDocumentFilter string]"}
+}
+
+func (t Or_NotebookDocumentFilter) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case NotebookDocumentFilterNotebookType:
+		return json.Marshal(x)
+	case NotebookDocumentFilterPattern:
+		return json.Marshal(x)
+	case NotebookDocumentFilterScheme:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [NotebookDocumentFilterNotebookType NotebookDocumentFilterPattern NotebookDocumentFilterScheme]", t)
+}
+
+func (t *Or_NotebookDocumentFilter) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder285 := json.NewDecoder(bytes.NewReader(x))
+	decoder285.DisallowUnknownFields()
+	var h285 NotebookDocumentFilterNotebookType
+	if err := decoder285.Decode(&h285); err == nil {
+		t.Value = h285
+		return nil
+	}
+	decoder286 := json.NewDecoder(bytes.NewReader(x))
+	decoder286.DisallowUnknownFields()
+	var h286 NotebookDocumentFilterPattern
+	if err := decoder286.Decode(&h286); err == nil {
+		t.Value = h286
+		return nil
+	}
+	decoder287 := json.NewDecoder(bytes.NewReader(x))
+	decoder287.DisallowUnknownFields()
+	var h287 NotebookDocumentFilterScheme
+	if err := decoder287.Decode(&h287); err == nil {
+		t.Value = h287
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [NotebookDocumentFilterNotebookType NotebookDocumentFilterPattern NotebookDocumentFilterScheme]"}
+}
+
+func (t Or_NotebookDocumentFilterWithCells_notebook) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case NotebookDocumentFilter:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [NotebookDocumentFilter string]", t)
+}
+
+func (t *Or_NotebookDocumentFilterWithCells_notebook) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder192 := json.NewDecoder(bytes.NewReader(x))
+	decoder192.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder192.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder193 := json.NewDecoder(bytes.NewReader(x))
+	decoder193.DisallowUnknownFields()
+	var h193 NotebookDocumentFilter
+	if err := decoder193.Decode(&h193); err == nil {
+		t.Value = h193
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [NotebookDocumentFilter string]"}
+}
+
+func (t Or_NotebookDocumentFilterWithNotebook_notebook) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case NotebookDocumentFilter:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [NotebookDocumentFilter string]", t)
+}
+
+func (t *Or_NotebookDocumentFilterWithNotebook_notebook) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder189 := json.NewDecoder(bytes.NewReader(x))
+	decoder189.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder189.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder190 := json.NewDecoder(bytes.NewReader(x))
+	decoder190.DisallowUnknownFields()
+	var h190 NotebookDocumentFilter
+	if err := decoder190.Decode(&h190); err == nil {
+		t.Value = h190
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [NotebookDocumentFilter string]"}
+}
+
+func (t Or_NotebookDocumentSyncOptions_notebookSelector_Elem) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case NotebookDocumentFilterWithCells:
+		return json.Marshal(x)
+	case NotebookDocumentFilterWithNotebook:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [NotebookDocumentFilterWithCells NotebookDocumentFilterWithNotebook]", t)
+}
+
+func (t *Or_NotebookDocumentSyncOptions_notebookSelector_Elem) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder68 := json.NewDecoder(bytes.NewReader(x))
+	decoder68.DisallowUnknownFields()
+	var h68 NotebookDocumentFilterWithCells
+	if err := decoder68.Decode(&h68); err == nil {
+		t.Value = h68
+		return nil
+	}
+	decoder69 := json.NewDecoder(bytes.NewReader(x))
+	decoder69.DisallowUnknownFields()
+	var h69 NotebookDocumentFilterWithNotebook
+	if err := decoder69.Decode(&h69); err == nil {
+		t.Value = h69
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [NotebookDocumentFilterWithCells NotebookDocumentFilterWithNotebook]"}
+}
+
+func (t Or_ParameterInformation_documentation) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case MarkupContent:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [MarkupContent string]", t)
+}
+
+func (t *Or_ParameterInformation_documentation) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder205 := json.NewDecoder(bytes.NewReader(x))
+	decoder205.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder205.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder206 := json.NewDecoder(bytes.NewReader(x))
+	decoder206.DisallowUnknownFields()
+	var h206 MarkupContent
+	if err := decoder206.Decode(&h206); err == nil {
+		t.Value = h206
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [MarkupContent string]"}
+}
+
+func (t Or_ParameterInformation_label) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case Tuple_ParameterInformation_label_Item1:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [Tuple_ParameterInformation_label_Item1 string]", t)
+}
+
+func (t *Or_ParameterInformation_label) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder202 := json.NewDecoder(bytes.NewReader(x))
+	decoder202.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder202.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder203 := json.NewDecoder(bytes.NewReader(x))
+	decoder203.DisallowUnknownFields()
+	var h203 Tuple_ParameterInformation_label_Item1
+	if err := decoder203.Decode(&h203); err == nil {
+		t.Value = h203
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [Tuple_ParameterInformation_label_Item1 string]"}
+}
+
+func (t Or_PrepareRenameResult) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case PrepareRenameDefaultBehavior:
+		return json.Marshal(x)
+	case PrepareRenamePlaceholder:
+		return json.Marshal(x)
+	case Range:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [PrepareRenameDefaultBehavior PrepareRenamePlaceholder Range]", t)
+}
+
+func (t *Or_PrepareRenameResult) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder252 := json.NewDecoder(bytes.NewReader(x))
+	decoder252.DisallowUnknownFields()
+	var h252 PrepareRenameDefaultBehavior
+	if err := decoder252.Decode(&h252); err == nil {
+		t.Value = h252
+		return nil
+	}
+	decoder253 := json.NewDecoder(bytes.NewReader(x))
+	decoder253.DisallowUnknownFields()
+	var h253 PrepareRenamePlaceholder
+	if err := decoder253.Decode(&h253); err == nil {
+		t.Value = h253
+		return nil
+	}
+	decoder254 := json.NewDecoder(bytes.NewReader(x))
+	decoder254.DisallowUnknownFields()
+	var h254 Range
+	if err := decoder254.Decode(&h254); err == nil {
+		t.Value = h254
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [PrepareRenameDefaultBehavior PrepareRenamePlaceholder Range]"}
+}
+
+func (t Or_ProgressToken) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case int32:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [int32 string]", t)
+}
+
+func (t *Or_ProgressToken) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder255 := json.NewDecoder(bytes.NewReader(x))
+	decoder255.DisallowUnknownFields()
+	var int32Val int32
+	if err := decoder255.Decode(&int32Val); err == nil {
+		t.Value = int32Val
+		return nil
+	}
+	decoder256 := json.NewDecoder(bytes.NewReader(x))
+	decoder256.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder256.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [int32 string]"}
+}
+
+func (t Or_RelatedFullDocumentDiagnosticReport_relatedDocuments_Value) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case FullDocumentDiagnosticReport:
+		return json.Marshal(x)
+	case UnchangedDocumentDiagnosticReport:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]", t)
+}
+
+func (t *Or_RelatedFullDocumentDiagnosticReport_relatedDocuments_Value) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder60 := json.NewDecoder(bytes.NewReader(x))
+	decoder60.DisallowUnknownFields()
+	var h60 FullDocumentDiagnosticReport
+	if err := decoder60.Decode(&h60); err == nil {
+		t.Value = h60
+		return nil
+	}
+	decoder61 := json.NewDecoder(bytes.NewReader(x))
+	decoder61.DisallowUnknownFields()
+	var h61 UnchangedDocumentDiagnosticReport
+	if err := decoder61.Decode(&h61); err == nil {
+		t.Value = h61
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]"}
+}
+
+func (t Or_RelatedUnchangedDocumentDiagnosticReport_relatedDocuments_Value) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case FullDocumentDiagnosticReport:
+		return json.Marshal(x)
+	case UnchangedDocumentDiagnosticReport:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]", t)
+}
+
+func (t *Or_RelatedUnchangedDocumentDiagnosticReport_relatedDocuments_Value) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder64 := json.NewDecoder(bytes.NewReader(x))
+	decoder64.DisallowUnknownFields()
+	var h64 FullDocumentDiagnosticReport
+	if err := decoder64.Decode(&h64); err == nil {
+		t.Value = h64
+		return nil
+	}
+	decoder65 := json.NewDecoder(bytes.NewReader(x))
+	decoder65.DisallowUnknownFields()
+	var h65 UnchangedDocumentDiagnosticReport
+	if err := decoder65.Decode(&h65); err == nil {
+		t.Value = h65
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [FullDocumentDiagnosticReport UnchangedDocumentDiagnosticReport]"}
+}
+
+func (t Or_RelativePattern_baseUri) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case URI:
+		return json.Marshal(x)
+	case WorkspaceFolder:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [URI WorkspaceFolder]", t)
+}
+
+func (t *Or_RelativePattern_baseUri) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder214 := json.NewDecoder(bytes.NewReader(x))
+	decoder214.DisallowUnknownFields()
+	var h214 URI
+	if err := decoder214.Decode(&h214); err == nil {
+		t.Value = h214
+		return nil
+	}
+	decoder215 := json.NewDecoder(bytes.NewReader(x))
+	decoder215.DisallowUnknownFields()
+	var h215 WorkspaceFolder
+	if err := decoder215.Decode(&h215); err == nil {
+		t.Value = h215
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [URI WorkspaceFolder]"}
+}
+
+func (t Or_Result_textDocument_codeAction_Item0_Elem) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case CodeAction:
+		return json.Marshal(x)
+	case Command:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [CodeAction Command]", t)
+}
+
+func (t *Or_Result_textDocument_codeAction_Item0_Elem) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder322 := json.NewDecoder(bytes.NewReader(x))
+	decoder322.DisallowUnknownFields()
+	var h322 CodeAction
+	if err := decoder322.Decode(&h322); err == nil {
+		t.Value = h322
+		return nil
+	}
+	decoder323 := json.NewDecoder(bytes.NewReader(x))
+	decoder323.DisallowUnknownFields()
+	var h323 Command
+	if err := decoder323.Decode(&h323); err == nil {
+		t.Value = h323
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [CodeAction Command]"}
+}
+
+func (t Or_Result_textDocument_completion) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case CompletionList:
+		return json.Marshal(x)
+	case []CompletionItem:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [CompletionList []CompletionItem]", t)
+}
+
+func (t *Or_Result_textDocument_completion) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder310 := json.NewDecoder(bytes.NewReader(x))
+	decoder310.DisallowUnknownFields()
+	var h310 CompletionList
+	if err := decoder310.Decode(&h310); err == nil {
+		t.Value = h310
+		return nil
+	}
+	decoder311 := json.NewDecoder(bytes.NewReader(x))
+	decoder311.DisallowUnknownFields()
+	var h311 []CompletionItem
+	if err := decoder311.Decode(&h311); err == nil {
+		t.Value = h311
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [CompletionList []CompletionItem]"}
+}
+
+func (t Or_Result_textDocument_declaration) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case Declaration:
+		return json.Marshal(x)
+	case []DeclarationLink:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [Declaration []DeclarationLink]", t)
+}
+
+func (t *Or_Result_textDocument_declaration) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder298 := json.NewDecoder(bytes.NewReader(x))
+	decoder298.DisallowUnknownFields()
+	var h298 Declaration
+	if err := decoder298.Decode(&h298); err == nil {
+		t.Value = h298
+		return nil
+	}
+	decoder299 := json.NewDecoder(bytes.NewReader(x))
+	decoder299.DisallowUnknownFields()
+	var h299 []DeclarationLink
+	if err := decoder299.Decode(&h299); err == nil {
+		t.Value = h299
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [Declaration []DeclarationLink]"}
+}
+
+func (t Or_Result_textDocument_definition) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case Definition:
+		return json.Marshal(x)
+	case []DefinitionLink:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [Definition []DefinitionLink]", t)
+}
+
+func (t *Or_Result_textDocument_definition) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder314 := json.NewDecoder(bytes.NewReader(x))
+	decoder314.DisallowUnknownFields()
+	var h314 Definition
+	if err := decoder314.Decode(&h314); err == nil {
+		t.Value = h314
+		return nil
+	}
+	decoder315 := json.NewDecoder(bytes.NewReader(x))
+	decoder315.DisallowUnknownFields()
+	var h315 []DefinitionLink
+	if err := decoder315.Decode(&h315); err == nil {
+		t.Value = h315
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [Definition []DefinitionLink]"}
+}
+
+func (t Or_Result_textDocument_documentSymbol) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case []DocumentSymbol:
+		return json.Marshal(x)
+	case []SymbolInformation:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [[]DocumentSymbol []SymbolInformation]", t)
+}
+
+func (t *Or_Result_textDocument_documentSymbol) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder318 := json.NewDecoder(bytes.NewReader(x))
+	decoder318.DisallowUnknownFields()
+	var h318 []DocumentSymbol
+	if err := decoder318.Decode(&h318); err == nil {
+		t.Value = h318
+		return nil
+	}
+	decoder319 := json.NewDecoder(bytes.NewReader(x))
+	decoder319.DisallowUnknownFields()
+	var h319 []SymbolInformation
+	if err := decoder319.Decode(&h319); err == nil {
+		t.Value = h319
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [[]DocumentSymbol []SymbolInformation]"}
+}
+
+func (t Or_Result_textDocument_implementation) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case Definition:
+		return json.Marshal(x)
+	case []DefinitionLink:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [Definition []DefinitionLink]", t)
+}
+
+func (t *Or_Result_textDocument_implementation) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder290 := json.NewDecoder(bytes.NewReader(x))
+	decoder290.DisallowUnknownFields()
+	var h290 Definition
+	if err := decoder290.Decode(&h290); err == nil {
+		t.Value = h290
+		return nil
+	}
+	decoder291 := json.NewDecoder(bytes.NewReader(x))
+	decoder291.DisallowUnknownFields()
+	var h291 []DefinitionLink
+	if err := decoder291.Decode(&h291); err == nil {
+		t.Value = h291
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [Definition []DefinitionLink]"}
+}
+
+func (t Or_Result_textDocument_inlineCompletion) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case InlineCompletionList:
+		return json.Marshal(x)
+	case []InlineCompletionItem:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [InlineCompletionList []InlineCompletionItem]", t)
+}
+
+func (t *Or_Result_textDocument_inlineCompletion) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder306 := json.NewDecoder(bytes.NewReader(x))
+	decoder306.DisallowUnknownFields()
+	var h306 InlineCompletionList
+	if err := decoder306.Decode(&h306); err == nil {
+		t.Value = h306
+		return nil
+	}
+	decoder307 := json.NewDecoder(bytes.NewReader(x))
+	decoder307.DisallowUnknownFields()
+	var h307 []InlineCompletionItem
+	if err := decoder307.Decode(&h307); err == nil {
+		t.Value = h307
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [InlineCompletionList []InlineCompletionItem]"}
+}
+
+func (t Or_Result_textDocument_semanticTokens_full_delta) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case SemanticTokens:
+		return json.Marshal(x)
+	case SemanticTokensDelta:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [SemanticTokens SemanticTokensDelta]", t)
+}
+
+func (t *Or_Result_textDocument_semanticTokens_full_delta) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder302 := json.NewDecoder(bytes.NewReader(x))
+	decoder302.DisallowUnknownFields()
+	var h302 SemanticTokens
+	if err := decoder302.Decode(&h302); err == nil {
+		t.Value = h302
+		return nil
+	}
+	decoder303 := json.NewDecoder(bytes.NewReader(x))
+	decoder303.DisallowUnknownFields()
+	var h303 SemanticTokensDelta
+	if err := decoder303.Decode(&h303); err == nil {
+		t.Value = h303
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [SemanticTokens SemanticTokensDelta]"}
+}
+
+func (t Or_Result_textDocument_typeDefinition) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case Definition:
+		return json.Marshal(x)
+	case []DefinitionLink:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [Definition []DefinitionLink]", t)
+}
+
+func (t *Or_Result_textDocument_typeDefinition) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder294 := json.NewDecoder(bytes.NewReader(x))
+	decoder294.DisallowUnknownFields()
+	var h294 Definition
+	if err := decoder294.Decode(&h294); err == nil {
+		t.Value = h294
+		return nil
+	}
+	decoder295 := json.NewDecoder(bytes.NewReader(x))
+	decoder295.DisallowUnknownFields()
+	var h295 []DefinitionLink
+	if err := decoder295.Decode(&h295); err == nil {
+		t.Value = h295
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [Definition []DefinitionLink]"}
+}
+
+func (t Or_Result_workspace_symbol) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case []SymbolInformation:
+		return json.Marshal(x)
+	case []WorkspaceSymbol:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [[]SymbolInformation []WorkspaceSymbol]", t)
+}
+
+func (t *Or_Result_workspace_symbol) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder326 := json.NewDecoder(bytes.NewReader(x))
+	decoder326.DisallowUnknownFields()
+	var h326 []SymbolInformation
+	if err := decoder326.Decode(&h326); err == nil {
+		t.Value = h326
+		return nil
+	}
+	decoder327 := json.NewDecoder(bytes.NewReader(x))
+	decoder327.DisallowUnknownFields()
+	var h327 []WorkspaceSymbol
+	if err := decoder327.Decode(&h327); err == nil {
+		t.Value = h327
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [[]SymbolInformation []WorkspaceSymbol]"}
+}
+
+func (t Or_SemanticTokensOptions_full) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case SemanticTokensFullDelta:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [SemanticTokensFullDelta bool]", t)
+}
+
+func (t *Or_SemanticTokensOptions_full) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder47 := json.NewDecoder(bytes.NewReader(x))
+	decoder47.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder47.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder48 := json.NewDecoder(bytes.NewReader(x))
+	decoder48.DisallowUnknownFields()
+	var h48 SemanticTokensFullDelta
+	if err := decoder48.Decode(&h48); err == nil {
+		t.Value = h48
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [SemanticTokensFullDelta bool]"}
+}
+
+func (t Or_SemanticTokensOptions_range) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case Lit_SemanticTokensOptions_range_Item1:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [Lit_SemanticTokensOptions_range_Item1 bool]", t)
+}
+
+func (t *Or_SemanticTokensOptions_range) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder44 := json.NewDecoder(bytes.NewReader(x))
+	decoder44.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder44.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder45 := json.NewDecoder(bytes.NewReader(x))
+	decoder45.DisallowUnknownFields()
+	var h45 Lit_SemanticTokensOptions_range_Item1
+	if err := decoder45.Decode(&h45); err == nil {
+		t.Value = h45
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [Lit_SemanticTokensOptions_range_Item1 bool]"}
+}
+
+func (t Or_ServerCapabilities_callHierarchyProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case CallHierarchyOptions:
+		return json.Marshal(x)
+	case CallHierarchyRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [CallHierarchyOptions CallHierarchyRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_callHierarchyProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder140 := json.NewDecoder(bytes.NewReader(x))
+	decoder140.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder140.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder141 := json.NewDecoder(bytes.NewReader(x))
+	decoder141.DisallowUnknownFields()
+	var h141 CallHierarchyOptions
+	if err := decoder141.Decode(&h141); err == nil {
+		t.Value = h141
+		return nil
+	}
+	decoder142 := json.NewDecoder(bytes.NewReader(x))
+	decoder142.DisallowUnknownFields()
+	var h142 CallHierarchyRegistrationOptions
+	if err := decoder142.Decode(&h142); err == nil {
+		t.Value = h142
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [CallHierarchyOptions CallHierarchyRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_codeActionProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case CodeActionOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [CodeActionOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_codeActionProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder109 := json.NewDecoder(bytes.NewReader(x))
+	decoder109.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder109.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder110 := json.NewDecoder(bytes.NewReader(x))
+	decoder110.DisallowUnknownFields()
+	var h110 CodeActionOptions
+	if err := decoder110.Decode(&h110); err == nil {
+		t.Value = h110
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [CodeActionOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_colorProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case DocumentColorOptions:
+		return json.Marshal(x)
+	case DocumentColorRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [DocumentColorOptions DocumentColorRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_colorProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder113 := json.NewDecoder(bytes.NewReader(x))
+	decoder113.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder113.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder114 := json.NewDecoder(bytes.NewReader(x))
+	decoder114.DisallowUnknownFields()
+	var h114 DocumentColorOptions
+	if err := decoder114.Decode(&h114); err == nil {
+		t.Value = h114
+		return nil
+	}
+	decoder115 := json.NewDecoder(bytes.NewReader(x))
+	decoder115.DisallowUnknownFields()
+	var h115 DocumentColorRegistrationOptions
+	if err := decoder115.Decode(&h115); err == nil {
+		t.Value = h115
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [DocumentColorOptions DocumentColorRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_declarationProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case DeclarationOptions:
+		return json.Marshal(x)
+	case DeclarationRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [DeclarationOptions DeclarationRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_declarationProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder83 := json.NewDecoder(bytes.NewReader(x))
+	decoder83.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder83.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder84 := json.NewDecoder(bytes.NewReader(x))
+	decoder84.DisallowUnknownFields()
+	var h84 DeclarationOptions
+	if err := decoder84.Decode(&h84); err == nil {
+		t.Value = h84
+		return nil
+	}
+	decoder85 := json.NewDecoder(bytes.NewReader(x))
+	decoder85.DisallowUnknownFields()
+	var h85 DeclarationRegistrationOptions
+	if err := decoder85.Decode(&h85); err == nil {
+		t.Value = h85
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [DeclarationOptions DeclarationRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_definitionProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case DefinitionOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [DefinitionOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_definitionProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder87 := json.NewDecoder(bytes.NewReader(x))
+	decoder87.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder87.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder88 := json.NewDecoder(bytes.NewReader(x))
+	decoder88.DisallowUnknownFields()
+	var h88 DefinitionOptions
+	if err := decoder88.Decode(&h88); err == nil {
+		t.Value = h88
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [DefinitionOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_diagnosticProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case DiagnosticOptions:
+		return json.Marshal(x)
+	case DiagnosticRegistrationOptions:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [DiagnosticOptions DiagnosticRegistrationOptions]", t)
+}
+
+func (t *Or_ServerCapabilities_diagnosticProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder174 := json.NewDecoder(bytes.NewReader(x))
+	decoder174.DisallowUnknownFields()
+	var h174 DiagnosticOptions
+	if err := decoder174.Decode(&h174); err == nil {
+		t.Value = h174
+		return nil
+	}
+	decoder175 := json.NewDecoder(bytes.NewReader(x))
+	decoder175.DisallowUnknownFields()
+	var h175 DiagnosticRegistrationOptions
+	if err := decoder175.Decode(&h175); err == nil {
+		t.Value = h175
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [DiagnosticOptions DiagnosticRegistrationOptions]"}
+}
+
+func (t Or_ServerCapabilities_documentFormattingProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case DocumentFormattingOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [DocumentFormattingOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_documentFormattingProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder120 := json.NewDecoder(bytes.NewReader(x))
+	decoder120.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder120.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder121 := json.NewDecoder(bytes.NewReader(x))
+	decoder121.DisallowUnknownFields()
+	var h121 DocumentFormattingOptions
+	if err := decoder121.Decode(&h121); err == nil {
+		t.Value = h121
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [DocumentFormattingOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_documentHighlightProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case DocumentHighlightOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [DocumentHighlightOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_documentHighlightProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder103 := json.NewDecoder(bytes.NewReader(x))
+	decoder103.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder103.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder104 := json.NewDecoder(bytes.NewReader(x))
+	decoder104.DisallowUnknownFields()
+	var h104 DocumentHighlightOptions
+	if err := decoder104.Decode(&h104); err == nil {
+		t.Value = h104
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [DocumentHighlightOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_documentRangeFormattingProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case DocumentRangeFormattingOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [DocumentRangeFormattingOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_documentRangeFormattingProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder123 := json.NewDecoder(bytes.NewReader(x))
+	decoder123.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder123.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder124 := json.NewDecoder(bytes.NewReader(x))
+	decoder124.DisallowUnknownFields()
+	var h124 DocumentRangeFormattingOptions
+	if err := decoder124.Decode(&h124); err == nil {
+		t.Value = h124
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [DocumentRangeFormattingOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_documentSymbolProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case DocumentSymbolOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [DocumentSymbolOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_documentSymbolProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder106 := json.NewDecoder(bytes.NewReader(x))
+	decoder106.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder106.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder107 := json.NewDecoder(bytes.NewReader(x))
+	decoder107.DisallowUnknownFields()
+	var h107 DocumentSymbolOptions
+	if err := decoder107.Decode(&h107); err == nil {
+		t.Value = h107
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [DocumentSymbolOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_foldingRangeProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case FoldingRangeOptions:
+		return json.Marshal(x)
+	case FoldingRangeRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [FoldingRangeOptions FoldingRangeRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_foldingRangeProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder130 := json.NewDecoder(bytes.NewReader(x))
+	decoder130.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder130.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder131 := json.NewDecoder(bytes.NewReader(x))
+	decoder131.DisallowUnknownFields()
+	var h131 FoldingRangeOptions
+	if err := decoder131.Decode(&h131); err == nil {
+		t.Value = h131
+		return nil
+	}
+	decoder132 := json.NewDecoder(bytes.NewReader(x))
+	decoder132.DisallowUnknownFields()
+	var h132 FoldingRangeRegistrationOptions
+	if err := decoder132.Decode(&h132); err == nil {
+		t.Value = h132
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [FoldingRangeOptions FoldingRangeRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_hoverProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case HoverOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [HoverOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_hoverProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder79 := json.NewDecoder(bytes.NewReader(x))
+	decoder79.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder79.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder80 := json.NewDecoder(bytes.NewReader(x))
+	decoder80.DisallowUnknownFields()
+	var h80 HoverOptions
+	if err := decoder80.Decode(&h80); err == nil {
+		t.Value = h80
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [HoverOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_implementationProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case ImplementationOptions:
+		return json.Marshal(x)
+	case ImplementationRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [ImplementationOptions ImplementationRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_implementationProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder96 := json.NewDecoder(bytes.NewReader(x))
+	decoder96.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder96.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder97 := json.NewDecoder(bytes.NewReader(x))
+	decoder97.DisallowUnknownFields()
+	var h97 ImplementationOptions
+	if err := decoder97.Decode(&h97); err == nil {
+		t.Value = h97
+		return nil
+	}
+	decoder98 := json.NewDecoder(bytes.NewReader(x))
+	decoder98.DisallowUnknownFields()
+	var h98 ImplementationRegistrationOptions
+	if err := decoder98.Decode(&h98); err == nil {
+		t.Value = h98
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [ImplementationOptions ImplementationRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_inlayHintProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case InlayHintOptions:
+		return json.Marshal(x)
+	case InlayHintRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [InlayHintOptions InlayHintRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_inlayHintProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder169 := json.NewDecoder(bytes.NewReader(x))
+	decoder169.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder169.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder170 := json.NewDecoder(bytes.NewReader(x))
+	decoder170.DisallowUnknownFields()
+	var h170 InlayHintOptions
+	if err := decoder170.Decode(&h170); err == nil {
+		t.Value = h170
+		return nil
+	}
+	decoder171 := json.NewDecoder(bytes.NewReader(x))
+	decoder171.DisallowUnknownFields()
+	var h171 InlayHintRegistrationOptions
+	if err := decoder171.Decode(&h171); err == nil {
+		t.Value = h171
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [InlayHintOptions InlayHintRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_inlineCompletionProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case InlineCompletionOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [InlineCompletionOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_inlineCompletionProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder177 := json.NewDecoder(bytes.NewReader(x))
+	decoder177.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder177.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder178 := json.NewDecoder(bytes.NewReader(x))
+	decoder178.DisallowUnknownFields()
+	var h178 InlineCompletionOptions
+	if err := decoder178.Decode(&h178); err == nil {
+		t.Value = h178
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [InlineCompletionOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_inlineValueProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case InlineValueOptions:
+		return json.Marshal(x)
+	case InlineValueRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [InlineValueOptions InlineValueRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_inlineValueProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder164 := json.NewDecoder(bytes.NewReader(x))
+	decoder164.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder164.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder165 := json.NewDecoder(bytes.NewReader(x))
+	decoder165.DisallowUnknownFields()
+	var h165 InlineValueOptions
+	if err := decoder165.Decode(&h165); err == nil {
+		t.Value = h165
+		return nil
+	}
+	decoder166 := json.NewDecoder(bytes.NewReader(x))
+	decoder166.DisallowUnknownFields()
+	var h166 InlineValueRegistrationOptions
+	if err := decoder166.Decode(&h166); err == nil {
+		t.Value = h166
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [InlineValueOptions InlineValueRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_linkedEditingRangeProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case LinkedEditingRangeOptions:
+		return json.Marshal(x)
+	case LinkedEditingRangeRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [LinkedEditingRangeOptions LinkedEditingRangeRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_linkedEditingRangeProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder145 := json.NewDecoder(bytes.NewReader(x))
+	decoder145.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder145.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder146 := json.NewDecoder(bytes.NewReader(x))
+	decoder146.DisallowUnknownFields()
+	var h146 LinkedEditingRangeOptions
+	if err := decoder146.Decode(&h146); err == nil {
+		t.Value = h146
+		return nil
+	}
+	decoder147 := json.NewDecoder(bytes.NewReader(x))
+	decoder147.DisallowUnknownFields()
+	var h147 LinkedEditingRangeRegistrationOptions
+	if err := decoder147.Decode(&h147); err == nil {
+		t.Value = h147
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [LinkedEditingRangeOptions LinkedEditingRangeRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_monikerProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case MonikerOptions:
+		return json.Marshal(x)
+	case MonikerRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [MonikerOptions MonikerRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_monikerProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder154 := json.NewDecoder(bytes.NewReader(x))
+	decoder154.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder154.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder155 := json.NewDecoder(bytes.NewReader(x))
+	decoder155.DisallowUnknownFields()
+	var h155 MonikerOptions
+	if err := decoder155.Decode(&h155); err == nil {
+		t.Value = h155
+		return nil
+	}
+	decoder156 := json.NewDecoder(bytes.NewReader(x))
+	decoder156.DisallowUnknownFields()
+	var h156 MonikerRegistrationOptions
+	if err := decoder156.Decode(&h156); err == nil {
+		t.Value = h156
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [MonikerOptions MonikerRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_notebookDocumentSync) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case NotebookDocumentSyncOptions:
+		return json.Marshal(x)
+	case NotebookDocumentSyncRegistrationOptions:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [NotebookDocumentSyncOptions NotebookDocumentSyncRegistrationOptions]", t)
+}
+
+func (t *Or_ServerCapabilities_notebookDocumentSync) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder76 := json.NewDecoder(bytes.NewReader(x))
+	decoder76.DisallowUnknownFields()
+	var h76 NotebookDocumentSyncOptions
+	if err := decoder76.Decode(&h76); err == nil {
+		t.Value = h76
+		return nil
+	}
+	decoder77 := json.NewDecoder(bytes.NewReader(x))
+	decoder77.DisallowUnknownFields()
+	var h77 NotebookDocumentSyncRegistrationOptions
+	if err := decoder77.Decode(&h77); err == nil {
+		t.Value = h77
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [NotebookDocumentSyncOptions NotebookDocumentSyncRegistrationOptions]"}
+}
+
+func (t Or_ServerCapabilities_referencesProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case ReferenceOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [ReferenceOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_referencesProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder100 := json.NewDecoder(bytes.NewReader(x))
+	decoder100.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder100.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder101 := json.NewDecoder(bytes.NewReader(x))
+	decoder101.DisallowUnknownFields()
+	var h101 ReferenceOptions
+	if err := decoder101.Decode(&h101); err == nil {
+		t.Value = h101
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [ReferenceOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_renameProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case RenameOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [RenameOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_renameProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder126 := json.NewDecoder(bytes.NewReader(x))
+	decoder126.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder126.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder127 := json.NewDecoder(bytes.NewReader(x))
+	decoder127.DisallowUnknownFields()
+	var h127 RenameOptions
+	if err := decoder127.Decode(&h127); err == nil {
+		t.Value = h127
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [RenameOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_selectionRangeProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case SelectionRangeOptions:
+		return json.Marshal(x)
+	case SelectionRangeRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [SelectionRangeOptions SelectionRangeRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_selectionRangeProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder135 := json.NewDecoder(bytes.NewReader(x))
+	decoder135.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder135.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder136 := json.NewDecoder(bytes.NewReader(x))
+	decoder136.DisallowUnknownFields()
+	var h136 SelectionRangeOptions
+	if err := decoder136.Decode(&h136); err == nil {
+		t.Value = h136
+		return nil
+	}
+	decoder137 := json.NewDecoder(bytes.NewReader(x))
+	decoder137.DisallowUnknownFields()
+	var h137 SelectionRangeRegistrationOptions
+	if err := decoder137.Decode(&h137); err == nil {
+		t.Value = h137
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [SelectionRangeOptions SelectionRangeRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_semanticTokensProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case SemanticTokensOptions:
+		return json.Marshal(x)
+	case SemanticTokensRegistrationOptions:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [SemanticTokensOptions SemanticTokensRegistrationOptions]", t)
+}
+
+func (t *Or_ServerCapabilities_semanticTokensProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder150 := json.NewDecoder(bytes.NewReader(x))
+	decoder150.DisallowUnknownFields()
+	var h150 SemanticTokensOptions
+	if err := decoder150.Decode(&h150); err == nil {
+		t.Value = h150
+		return nil
+	}
+	decoder151 := json.NewDecoder(bytes.NewReader(x))
+	decoder151.DisallowUnknownFields()
+	var h151 SemanticTokensRegistrationOptions
+	if err := decoder151.Decode(&h151); err == nil {
+		t.Value = h151
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [SemanticTokensOptions SemanticTokensRegistrationOptions]"}
+}
+
+func (t Or_ServerCapabilities_textDocumentSync) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case TextDocumentSyncKind:
+		return json.Marshal(x)
+	case TextDocumentSyncOptions:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [TextDocumentSyncKind TextDocumentSyncOptions]", t)
+}
+
+func (t *Or_ServerCapabilities_textDocumentSync) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder72 := json.NewDecoder(bytes.NewReader(x))
+	decoder72.DisallowUnknownFields()
+	var h72 TextDocumentSyncKind
+	if err := decoder72.Decode(&h72); err == nil {
+		t.Value = h72
+		return nil
+	}
+	decoder73 := json.NewDecoder(bytes.NewReader(x))
+	decoder73.DisallowUnknownFields()
+	var h73 TextDocumentSyncOptions
+	if err := decoder73.Decode(&h73); err == nil {
+		t.Value = h73
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [TextDocumentSyncKind TextDocumentSyncOptions]"}
+}
+
+func (t Or_ServerCapabilities_typeDefinitionProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case TypeDefinitionOptions:
+		return json.Marshal(x)
+	case TypeDefinitionRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [TypeDefinitionOptions TypeDefinitionRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_typeDefinitionProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder91 := json.NewDecoder(bytes.NewReader(x))
+	decoder91.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder91.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder92 := json.NewDecoder(bytes.NewReader(x))
+	decoder92.DisallowUnknownFields()
+	var h92 TypeDefinitionOptions
+	if err := decoder92.Decode(&h92); err == nil {
+		t.Value = h92
+		return nil
+	}
+	decoder93 := json.NewDecoder(bytes.NewReader(x))
+	decoder93.DisallowUnknownFields()
+	var h93 TypeDefinitionRegistrationOptions
+	if err := decoder93.Decode(&h93); err == nil {
+		t.Value = h93
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [TypeDefinitionOptions TypeDefinitionRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_typeHierarchyProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case TypeHierarchyOptions:
+		return json.Marshal(x)
+	case TypeHierarchyRegistrationOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [TypeHierarchyOptions TypeHierarchyRegistrationOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_typeHierarchyProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder159 := json.NewDecoder(bytes.NewReader(x))
+	decoder159.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder159.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder160 := json.NewDecoder(bytes.NewReader(x))
+	decoder160.DisallowUnknownFields()
+	var h160 TypeHierarchyOptions
+	if err := decoder160.Decode(&h160); err == nil {
+		t.Value = h160
+		return nil
+	}
+	decoder161 := json.NewDecoder(bytes.NewReader(x))
+	decoder161.DisallowUnknownFields()
+	var h161 TypeHierarchyRegistrationOptions
+	if err := decoder161.Decode(&h161); err == nil {
+		t.Value = h161
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [TypeHierarchyOptions TypeHierarchyRegistrationOptions bool]"}
+}
+
+func (t Or_ServerCapabilities_workspaceSymbolProvider) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case WorkspaceSymbolOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [WorkspaceSymbolOptions bool]", t)
+}
+
+func (t *Or_ServerCapabilities_workspaceSymbolProvider) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder117 := json.NewDecoder(bytes.NewReader(x))
+	decoder117.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder117.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder118 := json.NewDecoder(bytes.NewReader(x))
+	decoder118.DisallowUnknownFields()
+	var h118 WorkspaceSymbolOptions
+	if err := decoder118.Decode(&h118); err == nil {
+		t.Value = h118
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [WorkspaceSymbolOptions bool]"}
+}
+
+func (t Or_SignatureInformation_documentation) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case MarkupContent:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [MarkupContent string]", t)
+}
+
+func (t *Or_SignatureInformation_documentation) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder186 := json.NewDecoder(bytes.NewReader(x))
+	decoder186.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder186.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	decoder187 := json.NewDecoder(bytes.NewReader(x))
+	decoder187.DisallowUnknownFields()
+	var h187 MarkupContent
+	if err := decoder187.Decode(&h187); err == nil {
+		t.Value = h187
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [MarkupContent string]"}
+}
+
+func (t Or_TextDocumentContentChangeEvent) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case TextDocumentContentChangePartial:
+		return json.Marshal(x)
+	case TextDocumentContentChangeWholeDocument:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [TextDocumentContentChangePartial TextDocumentContentChangeWholeDocument]", t)
+}
+
+func (t *Or_TextDocumentContentChangeEvent) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder263 := json.NewDecoder(bytes.NewReader(x))
+	decoder263.DisallowUnknownFields()
+	var h263 TextDocumentContentChangePartial
+	if err := decoder263.Decode(&h263); err == nil {
+		t.Value = h263
+		return nil
+	}
+	decoder264 := json.NewDecoder(bytes.NewReader(x))
+	decoder264.DisallowUnknownFields()
+	var h264 TextDocumentContentChangeWholeDocument
+	if err := decoder264.Decode(&h264); err == nil {
+		t.Value = h264
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [TextDocumentContentChangePartial TextDocumentContentChangeWholeDocument]"}
+}
+
+func (t Or_TextDocumentEdit_edits_Elem) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case AnnotatedTextEdit:
+		return json.Marshal(x)
+	case SnippetTextEdit:
+		return json.Marshal(x)
+	case TextEdit:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [AnnotatedTextEdit SnippetTextEdit TextEdit]", t)
+}
+
+func (t *Or_TextDocumentEdit_edits_Elem) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder52 := json.NewDecoder(bytes.NewReader(x))
+	decoder52.DisallowUnknownFields()
+	var h52 AnnotatedTextEdit
+	if err := decoder52.Decode(&h52); err == nil {
+		t.Value = h52
+		return nil
+	}
+	decoder53 := json.NewDecoder(bytes.NewReader(x))
+	decoder53.DisallowUnknownFields()
+	var h53 SnippetTextEdit
+	if err := decoder53.Decode(&h53); err == nil {
+		t.Value = h53
+		return nil
+	}
+	decoder54 := json.NewDecoder(bytes.NewReader(x))
+	decoder54.DisallowUnknownFields()
+	var h54 TextEdit
+	if err := decoder54.Decode(&h54); err == nil {
+		t.Value = h54
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [AnnotatedTextEdit SnippetTextEdit TextEdit]"}
+}
+
+func (t Or_TextDocumentFilter) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case TextDocumentFilterLanguage:
+		return json.Marshal(x)
+	case TextDocumentFilterPattern:
+		return json.Marshal(x)
+	case TextDocumentFilterScheme:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [TextDocumentFilterLanguage TextDocumentFilterPattern TextDocumentFilterScheme]", t)
+}
+
+func (t *Or_TextDocumentFilter) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder279 := json.NewDecoder(bytes.NewReader(x))
+	decoder279.DisallowUnknownFields()
+	var h279 TextDocumentFilterLanguage
+	if err := decoder279.Decode(&h279); err == nil {
+		t.Value = h279
+		return nil
+	}
+	decoder280 := json.NewDecoder(bytes.NewReader(x))
+	decoder280.DisallowUnknownFields()
+	var h280 TextDocumentFilterPattern
+	if err := decoder280.Decode(&h280); err == nil {
+		t.Value = h280
+		return nil
+	}
+	decoder281 := json.NewDecoder(bytes.NewReader(x))
+	decoder281.DisallowUnknownFields()
+	var h281 TextDocumentFilterScheme
+	if err := decoder281.Decode(&h281); err == nil {
+		t.Value = h281
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [TextDocumentFilterLanguage TextDocumentFilterPattern TextDocumentFilterScheme]"}
+}
+
+func (t Or_TextDocumentSyncOptions_save) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case SaveOptions:
+		return json.Marshal(x)
+	case bool:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [SaveOptions bool]", t)
+}
+
+func (t *Or_TextDocumentSyncOptions_save) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder195 := json.NewDecoder(bytes.NewReader(x))
+	decoder195.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder195.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder196 := json.NewDecoder(bytes.NewReader(x))
+	decoder196.DisallowUnknownFields()
+	var h196 SaveOptions
+	if err := decoder196.Decode(&h196); err == nil {
+		t.Value = h196
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [SaveOptions bool]"}
+}
+
+func (t Or_WorkspaceDocumentDiagnosticReport) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case WorkspaceFullDocumentDiagnosticReport:
+		return json.Marshal(x)
+	case WorkspaceUnchangedDocumentDiagnosticReport:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [WorkspaceFullDocumentDiagnosticReport WorkspaceUnchangedDocumentDiagnosticReport]", t)
+}
+
+func (t *Or_WorkspaceDocumentDiagnosticReport) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder259 := json.NewDecoder(bytes.NewReader(x))
+	decoder259.DisallowUnknownFields()
+	var h259 WorkspaceFullDocumentDiagnosticReport
+	if err := decoder259.Decode(&h259); err == nil {
+		t.Value = h259
+		return nil
+	}
+	decoder260 := json.NewDecoder(bytes.NewReader(x))
+	decoder260.DisallowUnknownFields()
+	var h260 WorkspaceUnchangedDocumentDiagnosticReport
+	if err := decoder260.Decode(&h260); err == nil {
+		t.Value = h260
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [WorkspaceFullDocumentDiagnosticReport WorkspaceUnchangedDocumentDiagnosticReport]"}
+}
+
+func (t Or_WorkspaceEdit_documentChanges_Elem) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case CreateFile:
+		return json.Marshal(x)
+	case DeleteFile:
+		return json.Marshal(x)
+	case RenameFile:
+		return json.Marshal(x)
+	case TextDocumentEdit:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [CreateFile DeleteFile RenameFile TextDocumentEdit]", t)
+}
+
+func (t *Or_WorkspaceEdit_documentChanges_Elem) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder4 := json.NewDecoder(bytes.NewReader(x))
+	decoder4.DisallowUnknownFields()
+	var h4 CreateFile
+	if err := decoder4.Decode(&h4); err == nil {
+		t.Value = h4
+		return nil
+	}
+	decoder5 := json.NewDecoder(bytes.NewReader(x))
+	decoder5.DisallowUnknownFields()
+	var h5 DeleteFile
+	if err := decoder5.Decode(&h5); err == nil {
+		t.Value = h5
+		return nil
+	}
+	decoder6 := json.NewDecoder(bytes.NewReader(x))
+	decoder6.DisallowUnknownFields()
+	var h6 RenameFile
+	if err := decoder6.Decode(&h6); err == nil {
+		t.Value = h6
+		return nil
+	}
+	decoder7 := json.NewDecoder(bytes.NewReader(x))
+	decoder7.DisallowUnknownFields()
+	var h7 TextDocumentEdit
+	if err := decoder7.Decode(&h7); err == nil {
+		t.Value = h7
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [CreateFile DeleteFile RenameFile TextDocumentEdit]"}
+}
+
+func (t Or_WorkspaceFoldersServerCapabilities_changeNotifications) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case bool:
+		return json.Marshal(x)
+	case string:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [bool string]", t)
+}
+
+func (t *Or_WorkspaceFoldersServerCapabilities_changeNotifications) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder210 := json.NewDecoder(bytes.NewReader(x))
+	decoder210.DisallowUnknownFields()
+	var boolVal bool
+	if err := decoder210.Decode(&boolVal); err == nil {
+		t.Value = boolVal
+		return nil
+	}
+	decoder211 := json.NewDecoder(bytes.NewReader(x))
+	decoder211.DisallowUnknownFields()
+	var stringVal string
+	if err := decoder211.Decode(&stringVal); err == nil {
+		t.Value = stringVal
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [bool string]"}
+}
+
+func (t Or_WorkspaceOptions_textDocumentContent) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case TextDocumentContentOptions:
+		return json.Marshal(x)
+	case TextDocumentContentRegistrationOptions:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [TextDocumentContentOptions TextDocumentContentRegistrationOptions]", t)
+}
+
+func (t *Or_WorkspaceOptions_textDocumentContent) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder199 := json.NewDecoder(bytes.NewReader(x))
+	decoder199.DisallowUnknownFields()
+	var h199 TextDocumentContentOptions
+	if err := decoder199.Decode(&h199); err == nil {
+		t.Value = h199
+		return nil
+	}
+	decoder200 := json.NewDecoder(bytes.NewReader(x))
+	decoder200.DisallowUnknownFields()
+	var h200 TextDocumentContentRegistrationOptions
+	if err := decoder200.Decode(&h200); err == nil {
+		t.Value = h200
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [TextDocumentContentOptions TextDocumentContentRegistrationOptions]"}
+}
+
+func (t Or_WorkspaceSymbol_location) MarshalJSON() ([]byte, error) {
+	switch x := t.Value.(type) {
+	case Location:
+		return json.Marshal(x)
+	case LocationUriOnly:
+		return json.Marshal(x)
+	case nil:
+		return []byte("null"), nil
+	}
+	return nil, fmt.Errorf("type %T not one of [Location LocationUriOnly]", t)
+}
+
+func (t *Or_WorkspaceSymbol_location) UnmarshalJSON(x []byte) error {
+	if string(x) == "null" {
+		t.Value = nil
+		return nil
+	}
+	decoder39 := json.NewDecoder(bytes.NewReader(x))
+	decoder39.DisallowUnknownFields()
+	var h39 Location
+	if err := decoder39.Decode(&h39); err == nil {
+		t.Value = h39
+		return nil
+	}
+	decoder40 := json.NewDecoder(bytes.NewReader(x))
+	decoder40.DisallowUnknownFields()
+	var h40 LocationUriOnly
+	if err := decoder40.Decode(&h40); err == nil {
+		t.Value = h40
+		return nil
+	}
+	return &UnmarshalError{"unmarshal failed to match one of [Location LocationUriOnly]"}
+}