procedure TLSPClient.SendRequest(const lspKind: TLSPKind; const method: string = ''; 
    const params: TLSPBaseParams = nil; const paramJSON: string = '');

// The event catches the response from the server
FLSPClient1.OnOnDocumentDiagnostic := OnDocumentDiagnostic1;

procedure OnOnDocumentDiagnostic1(Sender: TObject; const kind: string; const resultId: string; 
    const items: TArray<TLSPDiagnostic>; const errorCode: Integer; const errorMessage: string;
    const retriggerRequest: Boolean);
begin
  if kind = 'unchanged' then Exit;
  
  if (ErrorCode = Integer(TLSPErrorCodes.ServerCancelled)) and retriggerRequest then
  begin
    // Re-trigger the document diagnostic request
    ...
  end;
  
  ...
end;

  LSPClient1.OnInitialize := OnInitialize1;
  LSPClient1.OnInitialized := OnInitialized1;

LSPClient1.SendRequest(lspInitialize);

procedure OnInitialize1(Sender: TObject; var value: TLSPInitializeParams);
begin
  // Set only the options your client can handle.
  
  // Set root path and uri
  value.AddRoot(FSourcePath);
  
  // Workspace folders
  value.AddWorkspaceFolders(FStringlist);

  // Client Capabilities
  
  // Capabilities/textDocument/synchronization
  value.capabilities.AddSynchronizationSupport(True,True,False,False);
  
  // Capabilities/textDocument/completion
  value.capabilities.AddCompletionSupport(False,True,False,True,True,False,False,False,False);

  // Capabilities/textDocument/hover
  value.capabilities.AddHoverSupport(False,True,True);

  // Capabilities/textDocument/signatureHelp
  value.capabilities.AddSignatureHelpSupport(False,True,True,False,False);
  
  // Capabilities/textDocument/publishDiagnostics
  value.capabilities.AddPublishDiagnosticsSupport(True,False,False,False);

  // Process id
  value.processId := GetCurrentProcessId;
  
  ...
  
end;

if not LClient.IsRequestSupported(lspWillSaveTextDocument) then Exit;

// Send request
...

FindDynamicCapability(const method: string): TLSPTextDocumentRegistrationOptions

var
  i: Integer;
  watcher: TLSPFileSystemWatcher;
  dynOptions: TLSPTextDocumentRegistrationOptions;
  changeOptions: TLSPDidChangeWatchedFilesRegistrationOptions;
begin
  // Find capability for 'workspace/didChangeWatchedFiles' 
  dynOptions := FLSPClient.FindDynamicCapability('workspace/didChangeWatchedFiles');
  
  // If dynOptions is of the correct type - proceed
  if dynOptions is TLSPDidChangeWatchedFilesRegistrationOptions then
  begin
    // Typecast dynOptions
    changeOptions := dynOptions as TLSPDidChangeWatchedFilesRegistrationOptions;
    
    // The server want the program to send a 'workspace/didChangeWatchedFiles' notification
    // when the client detects changes to files and folders watched by the language server.
    // 
    // Find out if we should send a notification to the server by checking the "watchers" array.
    for i := 0 to Length(changeOptions.watchers) - 1 do
    begin
      watcher := changeOptions.watchers[i];
      if watcher.kind and TLSPWatchKind.Delete then
      begin
        // Do our deleted file match the pattern
        if MatchesMask(szOurDeletedFile, watcher.globPattern.pattern) then
        begin
          // Send a lspDidChangeWatchedFiles notification to the server with the
          // uri to the file and type as "Deleted".
          ...
        end;
      end;
    end;    
  end;
end;

FLSPClient.OnRegisterCapability := OnRegisterCapability1;
FLSPClient.OnUnRegisterCapability := OnUnRegisterCapability1;

procedure OnRegisterCapability1(Sender: TObject; const values: TLSPRegistrations; var errorCode: Integer; 
    var errorMessage: string);
var
  s: string;
  id: string;
  kind: TLSPKind;
  registerOptions: TLSPTextDocumentRegistrationOptions;
begin
  // Handle capabilities the server want to register
  for i := 0 to Lenght(values[i]) - 1 do
  begin
    id := values[i].id;
    s := values[i].method;
    kind := (Sender as TLSPClient).LSPKindFromMethod(s);
    
    // Store the id so it's possible to unregister the capability using the same id.
    case kind of
      lspDidChangeTextDocument: begin
        // Register sync kind dynamically.
        registerOptions := values[i].registerOptions;
        ResisterSyncKind(id,
                         TLSPTextDocumentChangeRegistrationOptions(registerOptions).syncKind,
                         TLSPTextDocumentChangeRegistrationOptions(registerOptions).documentSelector);
      end;
      lspWillSaveWaitUntilTextDocument: begin
        // The server want the client to send lspWillSaveWaitUntilTextDocument requests
        // before the document is actually saved.
        ResisterWillSaveWaitUntilTextDocument(id,values[i].registerOptions.documentSelector);
      end;
    end;
  end;
end;

procedure OnRegisterCapability1(Sender: TObject; const values: TLSPUnRegistrations; var errorCode: Integer; 
    var errorMessage: string; var Handled: Boolean);
begin
  ...
end;

// Close the server gracefully
LSPClient.CloseServer;

// Exit the server quickly
LSPClient.ExitServer(True);

FLSPClient.SendRequest(lspShutdown); (or FLSPClient1.CloseServer;)

procedure OnShutdown(Sender: TObject; const errorCode: Integer; const errorMessage: string);
begin
  if errorMessage <> '' then
  begin
    StatusMemo.Lines.Add('ERROR: ' + errorMessage);
    StatusMemo.Lines.Add('Trying to force the server to close!');
    (Sender as TLSPClient).ExitServer(False);
    Exit;
  end;

  // Shutdown was successful. Send exit request to close the server.
  (Sender as TLSPClient).SendRequest(lspExit);
end;

FLSPClient.SendRequest(lspExit); (or LSPClient.ExitServer(True);)

procedure OnExit(Sender: TObject; exitCode: Integer; const bRestartServer: Boolean);
var
  s: string;
begin
  s := 'The server has closed with exit code: ' + IntToStr(exitCode);
  StatusMemo.Lines.Add(s);
  
  // If the server crashed we could restart it
  if ((exitCode <> 0) or bRestartServer) and (FLSPClient.GetRunTimeInSeconds > 20) then
    RestartLSPServer;
end;

var
  params: TLSPDidOpenTextDocumentParams;
begin
  params := TLSPDidOpenTextDocumentParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.php');
  params.textDocument.version := 1;
  params.textDocument.languageId := 'php';
  params.textDocument.text := Memo1.text;

  FLSPClient1.SendRequest(lspDidOpenTextDocument, '', params);

var
  ext: string;
  syncKind: Integer;
  params: TLSPDidChangeTextDocumentParams;
begin
  ext := '.cpp';  
  syncKind := FLSPClient1.GetSyncKind(ext);
  if synckind = TLSPTextDocumentSyncKindRec.None then Exit;
  
  params := TLSPDidChangeTextDocumentParams.Create;
  params.textDocument := TLSPVersionedTextDocumentIdentifier.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  params.textDocument.version := version + 1;
  Inc(version);
    
  // Set changes
  if syncKind = TLSPTextDocumentSyncKindRec.Incremental then
  begin
    // Go through our list of changes (MemoChanges: TList<TLSPTextDocumentContentChangeEvent>)
    for i := 0 to AMemo.MemoChanges.Count - 1 do
      params.contentChanges.Add(AMemo.MemoChanges[i]);
  end
  else if syncKind = TLSPTextDocumentSyncKindRec.Full then
  begin
    content := TLSPBaseTextDocumentContentChangeEvent.Create;
    content.text := AMemo.Lines.Text;
    params.contentChanges.Add(content);
  end;
  
  FLSPClient1.SendRequest(lspDidChangeTextDocument, '', params);
end;

var
  params: TLSPDidCloseTextDocumentParams;
begin
  params := TLSPDidCloseTextDocumentParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.c');
  
  LClient.SendRequest(lspDidCloseTextDocument, '', params); 
end;

var
  params: TLSPDidSaveTextDocumentParams;
begin
  if not LClient.IsRequestSupported(lspDidSaveTextDocument) then Exit;
  
  params := TLSPDidSaveTextDocumentParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.c');
  
  // Optionally include the content when saved. Depends on the includeText option value.
  if LClient.IncludeText(lspDidSaveTextDocument, sz, False) then
  begin
    params.text := Memo1.Lines.Text;
  end;
  
  LClient.SendRequest(lspDidSaveTextDocument, '', params); 
end;

var
  i: Integer;
  params: TLSPWillSaveTextDocumentParams;
begin
  if not LClient.IsRequestSupported(lspWillSaveTextDocument) then Exit;
  
  params := TLSPWillSaveTextDocumentParams.Create;

  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  params.reason := 1;
  
  LClient.SendRequest(lspWillSaveTextDocument, '', params);
end;

1 = Manually triggered, e.g. by the user pressing save, by starting debugging, or by an API call.
2 = Automatic after a delay.
3 = When the editor lost focus.

FLSPClient1.OnWillSaveWaitUntilTextDocument := OnWillSaveWaitUntilTextDocument1;

var
  i: Integer;
  params: TLSPWillSaveTextDocumentParams;
begin
  if not LClient.IsRequestSupported(lspWillSaveWaitUntilTextDocument) then Exit;
  
  params := TLSPWillSaveTextDocumentParams.Create;

  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  params.reason := 1;
  
  LClient.SendRequest(lspWillSaveWaitUntilTextDocument, '', params);
end;

procedure OnWillSaveWaitUntilTextDocument1(Sender: TObject; const value: TLSPWorkspaceEdit);
begin
  if Assigned(value) then
  begin
    // Process value object. See OnWorkspaceApplyEdit on how to process 
    // the TLSPTextEdit object.
    ...
  end;
end;

1 = Manually triggered, e.g. by the user pressing save, by starting debugging, or by an API call.
2 = Automatic after a delay.
3 = When the editor lost focus.

var
  params: TLSPDidOpenNotebookDocumentParams;
  cell: TLSPNotebookCell;
begin
  if not LClient.IsRequestSupported(lspDidOpenNotebookDocument) then Exit;
  params := TLSPDidOpenNotebookDocumentParams.Create;
  params.notebookDocument := TLSPNotebookDocument.Create;
  params.notebookDocument.uri := FilePathToUri('c:\source\foo.notebook');
  params.notebookDocument.version := 1;
  
  SetLength(params.notebookDocument.cells,2);
  cell.kind := 2;
  cell.document := FilePathToUri('c:\source\hello.py');
  params.notebookDocument.cells[0] := cell;
  
  cell.kind := 2;
  cell.document := FilePathToUri('c:\source\hi.py');
  params.notebookDocument.cells[1] := cell;

  FLSPClient1.SendRequest(lspDidOpenNotebookDocument, '', params);

var
  ext: string;
  syncKind: Integer;
  params: TLSPDidChangeNotebookDocumentParams;
begin
  if not LClient.IsRequestSupported(lspDidChangeNotebookDocument) then Exit;
  ext := '.notebook';  
  syncKind := FLSPClient1.GetSyncKind(ext);
  if synckind = TLSPTextDocumentSyncKindRec.None then Exit;
  
  params := TLSPDidChangeNotebookDocumentParams.Create;
  params.notebookDocument.uri := FilePathToUri('c:\source\foo.notebook');
  params.notebookDocument.version := version + 1;
  Inc(version);
    
  // Set changes
  if syncKind = TLSPTextDocumentSyncKindRec.Incremental then
  begin
    // Go through our list of changes (MemoChanges: TList<TLSPTextDocumentContentChangeEvent>)
    for i := 0 to AMemo.MemoChanges.Count - 1 do
      params.change.cells.textContent.changes.Add(AMemo.MemoChanges[i]);
  end
  else if syncKind = TLSPTextDocumentSyncKindRec.Full then
  begin
    content := TLSPBaseTextDocumentContentChangeEvent.Create;
    content.text := AMemo.Lines.Text;
    params.change.cells.textContent.changes.Add(content);
  end;
  
  FLSPClient1.SendRequest(lspDidChangeNotebookDocument, '', params);
end;

var
  params: TLSPDidSaveNotebookDocumentParams;
begin
  params := TLSPDidSaveNotebookDocumentParams.Create;
  params.notebookDocument.uri := FilePathToUri('c:\source\foo.notebook');
  
  LClient.SendRequest(lspDidSaveNotebookDocument, '', params); 
end;

var
  params: TLSPDidCloseNotebookDocumentParams;
begin
  params := TLSPDidCloseNotebookDocumentParams.Create;
  params.notebookDocument.uri := FilePathToUri('c:\source\foo.notebook');
  
  // The text documents that represent the content
  // of a notebook cell that got closed.
  SetLength(params.cellTextDocuments,1);
  params.cellTextDocuments[0].uri := FilePathToUri('c:\source\foo.py');  
  
  LClient.SendRequest(lspDidCloseNotebookDocument, '', params); 
end;

// The event catches the response from the server
FLSPClient1.OnCompletion := OnCompletion1;

var
  params: TLSPCompletionParams;
begin
  if not FLSPClient1.IsRequestSupported(lspCompletion) then Exit;
  
  // You can also make sure the server has been initialized before you send
  // a completion request.
  if not FLSPClient1.Initialized then Exit;
  
  params := TLSPCompletionParams.Create;
  
  // Text document and position
  params.textDocument.uri := FilePathToUri('c:\source.foo.c');
  params.position.line := 12;
  params.position.character := 6;
  
  FLSPClient1.SendRequest(lspCompletion, '', params);
end;

procedure OnCompletion1(Sender: TObject; const list: TLSPCompletionList; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  s: string;
  item,obj: TLSPCompletionItem;
begin
  // ---------------------------------------------------------------------------
  // Item defaults ?
  // Since 3.17.0 the server can return default item values that can be used if
  // none is provided in the item.
  //
  // commitCharacters: TArray<string>
  FCompletion.CommitCharacters := Copy(list.itemDefaults.commitCharacters);
  if list.itemDefaults.editRange is TLSPInsertReplaceEdit then
  begin
    FCompletion.InsertRange := TLSPInsertReplaceEdit(list.itemDefaults.editRange).insert;
    FCompletion.ReplaceRange := TLSPInsertReplaceEdit(list.itemDefaults.editRange).replace;
  end
  else list.itemDefaults.editRange is TLSPTextEdit then
  begin
    FCompletion.Range := list.itemDefaults.editRange.range;
  end;
  // ---------------------------------------------------------------------------
    
  // Read completion items to a list
  for i := 0 to list.items.Count - 1 do
  begin
    // Copy objects to ensure the object is still available if we need to send
    // a resolve request to the server.
    item := list.items[i];
    s := item.slabel;

    obj := TLSPCompletionItem.Create;
    obj.slabel := item.slabel;
    obj.kind := item.kind;
    obj.detail := item.detail;
    obj.documentation := item.documentation;
    obj.data := item.data; // Always include this otherwise CompletionResolve will not work.
    FCompletionList.AddObject(s,obj);
  end;
  UpdateCompletionList;
end;

// The event catches the response from the server
FLSPClient1.OnCompletionItemResolve := OnCompletionItemResolve1;

var
  item: TLSPCompletionItem;
begin
  // Make sure the request is supported
  if not FLSPClient1.IsRequestSupported(lspCompletionItemResolve) then Exit;
  
  // Get the item to resolve from our completion list
  item := TLSPCompletionItem(FCompletionList.Objects[index]);  
  
  FLSPClient1.SendRequest(lspCompletionItemResolve, '', item);
end;

procedure OnCompletionItemResolve1(Sender: TObject; const item: TLSPCompletionItem; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
begin
  // Get the information you want to display
  detail := item.detail;
  documentation := item.documentation;
  ...
end;

// The event catches the response from the server
FLSPClient1.OnHover := OnHover1;

var
  params: TLSPHoverParams;
begin
  if not FLSPClient1.IsRequestSupported(lspHover) then Exit;
  
  params := TLSPHoverParams.Create;
  params.textDocument.uri := FilePathToUri(FFileName);
  params.position.line := 6;
  params.position.character := 8;
  
  FLSPClient1.SendRequest(lspHover, '', params);
end;

procedure OnHover1(Sender: TObject; const value: TLSPHover; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
begin
  // Check to see what type of data the server returned
  if Length(value.contentsMarkedArray) > 0 then
  begin
    // Array of TLSPMarkedString items (or strings)
    for i := 0 to Length(value.contentsMarkedArray) - 1 do
    begin
      lang := value.contentsMarkedArray[i].language;
      val := value.contentsMarkedArray[i].value;
      
      // Store lang and val pairs
      ...
    end;
  end
  else if value.contents.value <> '' then
  begin
    // The server returned a TLSPMarkupContent object. kind = 'plaintext' | 'markdown';
    kind := value.contents.kind;
    val := value.contents.value;
  end
  else
  begin
    // The server returned a single TLSPMarkedString object or a string
    lang := value.contentMarked.language;
    val := value.contentMarked.value;
  end;
  
  ShowHintWindow(...);
end;

// The event catches the response from the server
FLSPClient1.OnSignatureHelp := OnSignatureHelp1;

var
  params: TLSPSignatureHelpParams;
begin
  if not FLSPClient1.IsRequestSupported(lspSignatureHelp) then Exit;
  
  params := TLSPSignatureHelpParams.Create;
  params.position.line := 6;
  params.position.character := 8;
  
  FLSPClient1.SendRequest(lspSignatureHelp, '', params);
end;

procedure OnSignatureHelp1(Sender: TObject; const value: TLSPSignatureHelp; const errorCode: Integer; 
    const errorMessage: string);
var
  i,j: Integer;
  ...
begin
  // Process one or more signatures (there may be overloaded functions with different parameters).
  for i := 0 to Length(value.signatures) - 1 do
  begin
    sLabel := value.signatures[i].slabel;
    documentationKind := value.signatures[i].documentation.kind;
    documentationValue := value.signatures[i].documentation.value;
    
    for j := 0 to Length(value.signatures[i].parameters) - 1 do
    begin
      arr[j].sLabel := value.signatures[i].parameters[j].slabel;
      arr[j].documentationKind := value.signatures[i].documentation.kind;
      arr[j].documentationValue := value.signatures[i].documentation.value;
      ...
    end;
    
    // Store the data
    ...
  end;
  
  // Active signature
  activeSignature := value.activeSignature;
  
  // Active parameter of the active signature
  activeParameter := value.activeParameter;
end;

procedure OnPublishDiagnostics1(Sender: TObject; const uri: string; const version: Cardinal; 
    const diagnostics: TArray<TLSPDiagnostic>);
var
  i: Integer;
  s,ws: string;
  item: TDiagnosticItem;
begin
  for i := 0 to Length(diagnostics) - 1 do
  begin
    // Process information in the array
    item := TDiagnosticItem.Create;
    item.Range := diagnostics[i].range;
    item.Severity := diagnostics[i].severity;
    item.MessageStr := diagnostics[i].messageString;
    
    case item.Severity of
      1: ws := '[Error]';
      2: ws := '[Warning]';
      3: ws := '[Information]';
      4: ws := '[Hint]';
      else
        ws := '';
    end;
    s := ws + ' ' + item.MessageStr;

    ListBoxDiagnostics.Items.AddObject(s, item);
    ...
  end;
end;

// The event catches the response from the server
FLSPClient1.OnOnDocumentDiagnostic := OnDocumentDiagnostic1;

var
  item: TLSPDocumentDiagnosticParams;
begin
  // Make sure the request is supported
  if not FLSPClient1.IsRequestSupported(lspDocumentDiagnostic) then Exit;
  
  item := TLSPDocumentDiagnosticParams.Create;
  item.textDocument.uri := FilePathToUri(FFileName);  
  
  FLSPClient1.SendRequest(lspDocumentDiagnostic, '', item);
end;

procedure OnDocumentDiagnostic1(Sender: TObject; const kind: string; const resultId: string; 
    const items: TArray<TLSPDiagnostic>; const errorCode: Integer; const errorMessage: string;
    const retriggerRequest: Boolean);
var
  i: Integer;
  s,ws: string;
  item: TDiagnosticItem;
begin
  if kind = 'unchanged' then Exit;
  
  if (ErrorCode = Integer(TLSPErrorCodes.ServerCancelled)) and retriggerRequest then
  begin
    // Re-trigger the document diagnostic request
    ...
  end;
  
  for i := 0 to Length(items) - 1 do
  begin
    // Process information in the array
    item := TDiagnosticItem.Create;
    item.Range := items[i].range;
    item.Severity := items[i].severity;
    item.MessageStr := items[i].messageString;
    
    case item.Severity of
      1: ws := '[Error]';
      2: ws := '[Warning]';
      3: ws := '[Information]';
      4: ws := '[Hint]';
      else
        ws := '';
    end;
    s := ws + ' ' + item.MessageStr;

    ListBoxDiagnostics.Items.AddObject(s, item);
    ...
  end;
end;

// The event catches the response from the server
FLSPClient1.OnOnWorkspaceDiagnostic := OnWorkspaceDiagnostic1;

var
  item: TLSPWorkspaceDiagnosticParams;
begin
  // Make sure the request is supported
  if not FLSPClient1.IsRequestSupported(lspWorkspaceDiagnostic) then Exit;
  
  item := TLSPWorkspaceDiagnosticParams.Create; 
  
  FLSPClient1.SendRequest(lspWorkspaceDiagnostic, '', item);
end;

procedure OnWorkspaceDiagnostic1(Sender: TObject; reports: TArray<TLSPWorkspaceDocumentDiagnosticReport>;
    const errorCode: Integer; const errorMessage: string; const retriggerRequest: Boolean);
var
  i,j,ver: Integer;
  s,sz,ws: string;
  item: TDiagnosticItem;
begin
  if kind = 'unchanged' then Exit;
  
  if (ErrorCode = Integer(TLSPErrorCodes.ServerCancelled)) and retriggerRequest then
  begin
    // Re-trigger the document diagnostic request
    ...
  end;
  
  for i := 0 to Length(reports) - 1 do
  begin
    sz := reports[i].uri;
    ver := reports[i].version;
    
    // Process diagnostics in the array
    for j := 0 to Length(reports[i].items) - 1 do
    begin
      item := TDiagnosticItem.Create;
      item.Range := reports[i].items[j].range;
      item.Severity := reports[i].items[j].severity;
      item.MessageStr := reports[i].items[j].messageString;
        
      case item.Severity of
        1: ws := '[Error]';
        2: ws := '[Warning]';
        3: ws := '[Information]';
        4: ws := '[Hint]';
        else
          ws := '';
      end;
      s := ws + ' ' + item.MessageStr;

      ListBoxDiagnostics.reports.AddObject(s, sz, ver, item);
      ...
    end;
  end;
end;

// Set event handler to be able to recieve refresh requests
LSPClient1.OnWorkspaceDiagnosticRefresh := OnWorkspaceDiagnosticRefresh1;

procedure OnCodeLensRefresh1(Sender: TObject; var errorCode: Integer; var errorMessage: string);
var
  item: TLSPWorkspaceDiagnosticParams;
begin
  // Pull for new diagnostics.
  item := TLSPWorkspaceDiagnosticParams.Create;  
  FLSPClient1.SendRequest(lspWorkspaceDiagnostic, '', item);
end;

// The event catches the response from the server
FLSPClient1.OnGotoDeclaration := OnGotoDeclaration1;

var
  params: TLSPDeclarationParams;
begin
  if not FLSPClient1.IsRequestSupported(lspGotoDeclaration) then Exit;
  
  params := TLSPDeclarationParams.Create;
  params.position.line := 126;
  params.position.character := 10;
  
  FLSPClient1.SendRequest(lspGotoDeclaration, '', params);
end;

procedure OnGotoDeclaration1(Sender: TObject; const value: TLSPGotoResponse; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  uri: string;
  range: TLSPRange;
  location: TLSPLocation;
  locationLink: TLSPLocationLink;
begin
  // The response can be null, TLSPLocation, TArray<TLSPLocation> or TArray<TLSPLocationLink>
  if Length(value.locationLinks) > 0 then
  begin
    for i := 0 to Length(value.locationLinks) - 1 do
    begin
      uri := value.locationLinks[i].targetUri;
      locationLink := value.locationLinks[i];
      
      // Add data to a list ...
      AddToDeclList(uri, locationLink);
    end;
  end
  else if Length(value.locations) > 0 then
  begin
    for i := 0 to Length(value.locations) - 1 do
    begin
      uri := value.locations[i].uri;
      location := value.locations[i];
      
      // Add data to a list ...
      AddToDeclList(uri, location);
    end;
  end
  else
  begin
    uri := value.location.uri;
    range := value.location.range;
    
    if uri <> '' then  
    begin
      // Add data to a list ...
      AddToDeclList(uri, range);
    end;
  end;
  
  // Display the locations and let the user select, or just open the first
  // file and highlight the location.
  ...
end;

// The event catches the response from the server
FLSPClient1.OnGotoDefinition := OnGotoDefinition1;

var
  params: TLSPDefinitionParams;
begin
  if not FLSPClient1.IsRequestSupported(lspGotoDefinition) then Exit;
  
  params := TLSPDefinitionParams.Create;
  params.position.line := 102;
  params.position.character := 20;
  
  FLSPClient1.SendRequest(lspGotoDefinition, '', params);
end;

procedure OnGotoDefinition1(Sender: TObject; const value: TLSPGotoResponse; const errorCode: Integer; 
    const errorMessage: string);
begin    
  // See Goto Declaration Request for example
end;

// The event catches the response from the server
FLSPClient1.OnGotoImplementation := OnGotoImplementation1;

var
  params: TLSPImplementationParams;
begin
  if not FLSPClient1.IsRequestSupported(lspGotoImplementation) then Exit;
  
  params := TLSPImplementationParams.Create;
  params.position.line := 11;
  params.position.character := 3;
  
  FLSPClient1.SendRequest(lspGotoImplementation, '', params);
end;

procedure OnGotoImplementation1(Sender: TObject; const value: TLSPGotoResponse; const errorCode: Integer; 
    const errorMessage: string);
begin    
  // See Goto Declaration Request for example
end;

// The event catches the response from the server
FLSPClient1.OnGotoTypeDefinition := OnGotoTypeDefinition1;

var
  params: TLSPTypeDefinitionParams;
begin
  if not FLSPClient1.IsRequestSupported(lspGotoTypeDefinition) then Exit;
  
  params := TLSPTypeDefinitionParams.Create;
  params.position.line := 12;
  params.position.character := 11;
  
  FLSPClient1.SendRequest(lspGotoTypeDefinition, '', params);
end;

procedure OnGotoTypeDefinition1(Sender: TObject; const value: TLSPGotoResponse; const errorCode: Integer; 
    const errorMessage: string);
begin    
  // See Goto Declaration Request for example
end;

// The event catches the response from the server
FLSPClient1.OnFindReferences := OnFindReferences1;

var
  params: TLSPReferencesParams;
begin
  if not FLSPClient1.IsRequestSupported(lspReferences) then Exit;
  
  params := TLSPReferencesParams.Create;
  params.position.line := 11;
  params.position.character := 3;
  params.context.includeDeclaration := True;
  
  FLSPClient1.SendRequest(lspReferences, '', params);
end;

procedure OnFindReferences1(Sender: TObject; const value: TLSPFindReferencesResponse;
  const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
  LRange: TLSPRange;
begin    
  // Display all references found in the project
  for i := 0 to Length(value.locations) - 1 do
  begin
    sz := UriToFilePath(value.locations[i].uri);
    LRange := value.locations[i].range;
    ProcessItem(sz, LRange);
  end;
end;

procedure ProcessItem(const sz: string; const range: TLSPRange);
begin
  // You could display found references in a tree
  //
  // [-] C:\MyFolder\Source\Foo.cpp
  //       Line: 12: <The actual text line ...>
  //       Line: 28: ...
  
end;

// The event catches the response from the server
FLSPClient1.OnDocumentHighlight := OnDocumentHighlight1;

var
  params: TLSPDocumentHighlightParams;
begin
  if not FLSPClient1.IsRequestSupported(lspDocumentHighlight) then Exit;
  
  params := TLSPDocumentHighlightParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  params.position.line := 12;
  params.position.character := 11;
  
  FLSPClient1.SendRequest(lspDocumentHighlight, '', params);
end;

procedure OnDocumentHighlight1(Sender: TObject; const value: TLSPDocumentHighlightResponse; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  kind: Cardinal;
  range: TLSPRange;
begin    
  for i := 0 to Length(value.list) - 1 do
  begin
    kind := value.list[i].kind;
    range := value.list[i].range;
    
    // Add values
    AddSelections(kind, range);
  end;
  ...
end;

// The event catches the response from the server
FLSPClient1.OnDocumentSymbols := OnDocumentSymbols1;

var
  params: TLSPDocumentSymbolParams;
begin
  if not FLSPClient1.IsRequestSupported(lspDocumentSymbol) then Exit;
  
  params := TLSPDocumentSymbolParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.java');
  
  FLSPClient1.SendRequest(lspDocumentSymbol, '', params);
end;

procedure OnDocumentSymbols1(Sender: TObject; const value: TLSPDocumentSymbolsResponse; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  sym: TLSPDocumentSymbol;
begin    
  for i := 0 to Length(value.symbols) - 1 do
  begin
    sym := value.symbols[i];
    
    // Add symbols
    AddSymbols(sym.name, sym);
  end;
  ...
end;

// The event catches the response from the server
FLSPClient1.OnCodeAction := OnCodeAction1;

var
  params: TLSPCodeActionParams;
begin
  if not FLSPClient1.IsRequestSupported(lspCodeAction) then Exit;
  
  params := TLSPCodeActionParams.Create;
  
  // Document
  params.textDocument.uri := FilePathToUri('c:\source\foo.js');
  
  // Code action kind
  params.context.only := ['quickfix','refactor','refactor.extract','refactor.inline','refactor.rewrite',
                          'source','source.organizeImports'];
  
  // Range
  params.range.startPos.line := 2;
  params.range.startPos.character := 0;
  params.range.endPos.line := 16;
  params.range.endPos.character := 0;
  
  // Include diagnostics errors inside the passed range
  ...  
  
  FLSPClient1.SendRequest(lspCodeAction, '', params);
end;

procedure OnCodeAction1(Sender: TObject; const value: TLSPCodeActionResponse; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  item: TLSPCodeAction;
  f: TSelectForm;
begin
  f := TSelectForm.Create(Self);
  try
    for i := 0 to value.codeActions.Count - 1 do
    begin
      item := TLSPCodeAction.Create;
      if value.codeActions[i].title <> '' then
      begin
        // Code action 
        item.title := value.codeActions[i].title;
        item.kind := value.codeActions[i].kind;
        if Assigned(value.codeActions[i].edit) then
        begin
          item.edit := TLSPWorkspaceEdit.Create;
          if Assigned(value.codeActions[i].edit.changes) then
            item.edit.changes.Create(value.codeActions[i].edit.changes);
          if Length(value.codeActions[i].edit.documentChanges) > 0 then
            item.edit.documentChanges := Copy(value.codeActions[i].edit.documentChanges);
        end;
      end
      else
      begin
        // Command
        item.title := value.codeActions[i].command.title;
      end;
      item.command := value.codeActions[i].command;
      item.data := value.codeActions[i].data;

      f.List.Items.AddObject(item.title, item);
    end;
    
    if f.List.Items.Count = 0 then Exit;

    if f.ShowModal = mrOK then
    begin
      if f.List.ItemIndex >= 0 then
      begin
        obj := TLSPCodeAction(f.List.Items.Objects[f.List.ItemIndex]);

        // Check for edit or command. If none found - send a codeActionResolve
        if Assigned(obj.edit) then
          LSPApplyChanges(obj.edit)
        else if obj.command.command <> '' then
          LSPSendExecuteCommand(obj.command)
        else
          LSPSendCodeActionResolve(obj);
        end;
      end;
    end;
  finally
    f.Release;
  end;
end;

// The event catches the response from the server
FLSPClient1.OnCodeActionResolve := OnCodeActionResolve1;

var
  params: TLSPCodeAction;
begin
  if not FLSPClient1.IsRequestSupported(lspCodeActionResolve) then Exit;
  
  // Resolve code action
  params := FCodeActionList[FIndex];
  
  FLSPClient1.SendRequest(lspCodeActionResolve, '', params);
end;

procedure OnCodeActionResolve1(Sender: TObject; const value: TLSPCodeAction; const errorCode: Integer; 
    const errorMessage: string);
begin
  if Assigned(value.edit) then
    LSPApplyChanges(value.edit)
end;

// Event to catch the code lens response from the server
FLSPClient1.OnCodeLens := OnCodeLens1;

var
  params: TLSPCodeLensParams;
begin
  if not FLSPClient1.IsRequestSupported(lspCodeLens) then Exit;
  
  params := TLSPCodeLensParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.pas');
  
  FLSPClient1.SendRequest(lspCodeLens, '', params);
end;

procedure OnCodeLens1(Sender: TObject; const value: TLSPCodeLensResponse; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  lens: TLSPCodeLens;
begin
  for i := 0 to value.codeLensList.Count - 1 do
  begin
    lens := value.codeLensList[i];
    AddCodeLensToList(lens);
  end;
  ...
end;

// The event catches the response from the server
FLSPClient1.OnCodeLensResolve := OnCodeLensResolve1;

var
  params: TLSPCodeLens;
begin
  if not FLSPClient1.IsRequestSupported(lspCodelensResolve) then Exit;
  
  params := GetCodeLensFromList(FIndex);
  
  FLSPClient1.SendRequest(lspCodeLensResolve, '', params);
end;

procedure OnCodeLensResolve1(Sender: TObject; const value: TLSPCodeLens; const errorCode: Integer; 
    const errorMessage: string);
begin
  ResolveLens(value);
  ...
end;

// Set event handler to be able to recieve refresh requests
LSPClient1.OnCodeLensRefresh := OnCodeLensRefresh1;

procedure OnCodeLensRefresh1(Sender: TObject; var errorCode: Integer; var errorMessage: string);
begin
  // Refresh code lenses.
  ...
  
  FLSPClient1.SendResponse(lspCodeLensRefresh);
end;

// Event to catch response from the server
FLSPClient1.OnDocumentLink := OnDocumentLink1;

var
  params: TLSPDocumentLinkParams;
begin
  if not FLSPClient1.IsRequestSupported(lspDocumentLink) then Exit;
  
  params := TLSPDocumentLinkParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  
  FLSPClient1.SendRequest(lspDocumentLink, '', params);
end;

procedure OnDocumentLink1(Sender: TObject; const value: TLSPDocumentLinkResponse; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  link: TLSPDocumentLink;
begin
  for i := 0 to value.documentLinks.Count - 1 do
  begin
    link := value.documentLinks[i];
    AddDocumentLinkToList(link);
  end;
  ...
end;

// Catch the response from the server
FLSPClient1.OnDocumentLinkResolve := OnDocumentLinkResolve1;

var
  params: TLSPDocumentLink;
begin
  if not FLSPClient1.IsRequestSupported(lspDocumentLinkResolve) then Exit;
  
  // Resolve document link
  params := FDocumentLinkList[FIndex];
  
  FLSPClient1.SendRequest(lspDocumentLinkResolve, '', params);
end;

procedure OnDocumentLinkResolve1(Sender: TObject; const value: TLSPDocumentLink; const errorCode: Integer; 
    const errorMessage: string);
begin
  // Get information from value
  ...
end;

// Event to catch response from the server
FLSPClient1.OnDocumentColor := OnDocumentColor1;

var
  params: TLSPDocumentColorParams;
begin
  if not FLSPClient1.IsRequestSupported(lspDocumentColor) then Exit;
  
  params := TLSPDocumentColorParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  
  FLSPClient1.SendRequest(lspDocumentColor, '', params);
end;

procedure OnDocumentColor1(Sender: TObject; const values: TLSPColorInformationValues; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  colorInfo: TLSPColorInformation;
  alpha: Cardinal;
  red, green, blue: Cardinal;
  range: TLSPRange;
begin
  for i := 0 to Length(values.colors) - 1 do
  begin
    colorInfo := values.colors[i];
    
    // Convert colors
    red := Round(255 * colorInfo.color.red);
    green := Round(255 * colorInfo.color.green);
    blue := Round(255 * colorInfo.color.blue);
    alpha := Round(255 * colorInfo.color.alpha);
    
    // Where the color was found
    range := colorInfo.range;
    
    AddColorInfo(RGB(red, green, blue), alpha, range);
  end;
  ...
end;

// Event to catch response from the server
FLSPClient1.OnColorPresentation := OnColorPresentation1;

var
  params: TLSPColorPresentationParams;
begin
  if not FLSPClient1.IsRequestSupported(lspColorPresentation) then Exit;
  
  params := TLSPColorPresentationParams.Create;
  
  // Text document
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  
  // Color information
  params.color := AColor;
  
  // Range where the color is inserted
  params.range := ARange;  
  
  FLSPClient1.SendRequest(lspColorPresentation, '', params);
end;

procedure OnColorPresentation1(Sender: TObject; const values: TLSPColorPresentationValues; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  colorPresentation: TLSPColorPresentation;
  s: string;
  range: TLSPRange;
begin
  for i := 0 to Length(values.colorPresentations) - 1 do
  begin
    colorPresentation := values.colorPresentations[i];
    
    // Label or text
    s := colorPresentation.slabel;
    if colorPresentation.textEdit.newText <> '' then
      s := colorPresentation.textEdit.newText;
    
    // Range
    range := colorPresentation.textEdit.range;
    
    AddColorPresentation(s, range);
  end;
  ...
end;

// Event to catch response from the server
FLSPClient1.OnDocumentFormatting := OnDocumentFormatting1;

var
  params: TLSPDocumentFormattingParams;
begin
  if not FLSPClient1.IsRequestSupported(lspDocumentFormatting) then Exit;
  
  params := TLSPDocumentFormattingParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  params.options.tabSize := 2;
  params.options.insertSpaces := True;
  params.options.trimTrailingWhitespace := true;

  FLSPClient.SendRequest(lspDocumentFormatting, '', params);
end;

procedure OnDocumentFormatting1(Sender: TObject; const value: TLSPTextEditValues; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  edit: TLSPTextEdit;
begin
  // The returned array may be reversed by the server so we need to check it.
  // You should apply changes from the end of document to the beginning.
  if IsReversed(value.edits) then
  begin 
    for i := 0 to Length(value.edits) - 1 do
    begin
      edit := value.edits[i];
      ModifyDocument(edit.newText, edit.range);
    end;
  end
  else
  begin
    for i := Length(value.edits) - 1 downto 0 do
    begin
      edit := value.edits[i];
      ModifyDocument(edit.newText, edit.range);
    end;
  end;
end;

// Event to catch response from the server
FLSPClient1.OnDocumentRangeFormatting := OnDocumentRangeFormatting1;

var
  params: TLSPDocumentRangeFormattingParams;
begin
  if not FLSPClient1.IsRequestSupported(lspDocumentRangeFormatting) then Exit;
  
  params := TLSPDocumentRangeFormattingParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  params.options.tabSize := 2;
  params.options.insertSpaces := True;
  params.options.trimTrailingWhitespace := true;
  
  params.range.startPos.line := 10;
  params.range.startPos.character := 0;
  params.range.endPos.line := 200;
  params.range.endPos.character := 0;

  FLSPClient.SendRequest(lspDocumentRangeFormatting, '', params);
end;

procedure OnDocumentRangeFormatting1(Sender: TObject; const value: TLSPTextEditValues; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  edit: TLSPTextEdit;
begin
  // The returned array may be reversed by the server so we need to check it.
  // You should apply changes from the end of document to the beginning.
  if IsReversed(value.edits) then
  begin 
    for i := 0 to Length(value.edits) - 1 do
    begin
      edit := value.edits[i];
      ModifyDocument(edit.newText, edit.range);
    end;
  end
  else
  begin
    for i := Length(value.edits) - 1 downto 0 do
    begin
      edit := value.edits[i];
      ModifyDocument(edit.newText, edit.range);
    end;
  end;
end;

// Event to catch response from the server
FLSPClient1.OnDocumentOnTypeFormatting := OnDocumentOnTypeFormatting1;

var
  params: TLSPDocumentOnTypeFormattingParams;
begin
  if not FLSPClient1.IsRequestSupported(lspDocumentOnTypeFormatting) then Exit;
  
  params := TLSPDocumentOnTypeFormattingParams.Create;
  
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  params.ch := ';';
  
  params.options.tabSize := 2;
  params.options.insertSpaces := True;
  params.options.trimTrailingWhitespace := true;
  
  params.position.line := 10;
  params.position.character := 8;

  FLSPClient.SendRequest(lspDocumentOnTypeFormatting, '', params);
end;

procedure OnDocumentOnTypeFormatting1(Sender: TObject; const values: TLSPTextEditValues; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  edit: TLSPTextEdit;
begin
  // The returned array may be reversed by the server so we need to check it.
  // You should apply changes from the end of document to the beginning.
  if IsReversed(value.edits) then
  begin 
    for i := 0 to Length(value.edits) - 1 do
    begin
      edit := value.edits[i];
      ModifyDocument(edit.newText, edit.range);
    end;
  end
  else
  begin
    for i := Length(value.edits) - 1 downto 0 do
    begin
      edit := value.edits[i];
      ModifyDocument(edit.newText, edit.range);
    end;
  end;
end;

FLSPClient1.OnFoldingRange := OnFoldingRange1;

var
  i: Integer;
  params: TLSPFoldingRangeParams;
begin
  if not FLSPClient1.IsRequestSupported(lspFoldingRange) then Exit;
  
  params := TLSPFoldingRangeParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  
  FLSPClient1.SendRequest(lspFoldingRange, '', params);
end;

procedure OnFoldingRange1(Sender: TObject; const values: TLSPFoldingRangeResponse; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  foldRange: TLSPFoldingRange;
begin
  if Assigned(values) then
  begin
    for i := 0 to Length(values.foldingRanges) - 1 do
    begin
      foldRange := values.foldingRanges[i];
      AddFoldingRange(foldRange.kind, foldRange.startLine, foldRange.endLine);
    end;
  end;
end;

FLSPClient1.OnSelectionRange := OnSelectionRange1;

var
  i: Integer;
  params: TLSPSelectionRangeParams;
begin
  if not FLSPClient1.IsRequestSupported(lspSelectionRange) then Exit;
  
  params := TLSPSelectionRangeParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  
  // Set position(s)
  SetLength(params.positions, 1);
  params.positions[0].line := 10;
  params.positions[0].character := 34;
  
  FLSPClient1.SendRequest(lspSelectionRange, '', params);
end;

procedure OnSelectionRange1(Sender: TObject; const values: TLSPSelectionRangeResponse; const errorCode: Integer; 
    const errorMessage: string);
var
  i: Integer;
  selRange: TLSPSelectionRange;
begin
  for i := 0 to values.selRanges.Count - 1 do
  begin
    selRange := values.selRanges[i];
    AddSelectionRange(selRange.range, selRange.parent);
  end;
end;

FLSPClient1.OnPrepareCallHierarchy := OnPrepareCallHierarchy1;

var
  i: Integer;
  params: TLSPCallHierarchyPrepareParams;
begin
  if not FLSPClient1.IsRequestSupported(lspPrepareCallHierarchy) then Exit;
  
  params := TLSPCallHierarchyPrepareParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  params.position.line := 4;
  params.position.character := 8;
  
  FLSPClient1.SendRequest(lspPrepareCallHierarchy, '', params);
end;

procedure OnPrepareCallHierarchy1(Sender: TObject; const values: TLSPPrepareCallHierarchyResponse; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
  item: TLSPCallHierarchyItem;
begin
  for i := 0 to Length(values) - 1 do
  begin
    // item may include:
    // name           = 'foo'
    // kind           = symMethod
    // uri            = 'c:\source\foo.java'
    // range          = range of the method
    // selectionRange = range of the method name

    item := values[i];    
    AddCallHierarchy(item.name, item);
  end;
end;

FLSPClient1.OnCallHierarchyIncomming := OnCallHierarchyIncomming1;

var
  i: Integer;
  params: TLSPCallHierarchyIncomingCallsParams;
begin
  if not FLSPClient1.IsRequestSupported(lspCallHierarchyIncommingCalls) then Exit;
  
  // Get the item for our method, e.g. "Foo()"
  params := GetCallHierarchyItem(FIndex);
    
  FLSPClient1.SendRequest(lspCallHierarchyIncommingCalls, '', params);
end;

procedure OnCallHierarchyIncomming1(Sender: TObject; const values: TLSPCallHierarchyIncomingCallResponse; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
  item: TLSPCallHierarchyIncomingCall;
begin
  for i := 0 to Length(values) - 1 do
  begin
    // Collect all methods, functions etc. from where the method "Foo()" is called.
    item := values[i];    
    AddIncommingHierarchyCalls(item.name, item);
  end;
end;

FLSPClient1.OnCallHierarchyOutgoing := OnCallHierarchyOutgoing1;

var
  i: Integer;
  params: TLSPCallHierarchyOutgoingCallsParams;
begin
  if not FLSPClient1.IsRequestSupported(lspCallHierarchyOutgoingCalls) then Exit;
  
  // Get the item for our method, e.g. "Foo()"
  params := GetCallHierarchyItem(FIndex);
    
  FLSPClient1.SendRequest(lspCallHierarchyOutgoingCalls, '', params);
end;

procedure OnCallHierarchyOutgoing1(Sender: TObject; const values: TLSPCallHierarchyOutgoingCallResponse; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
  item: TLSPCallHierarchyOutgoingCall;
begin
  for i := 0 to Length(values) - 1 do
  begin
    // Collect a list of all calls made from Foo().
    item := values[i];    
    AddOutgoingHierarchyCalls(item.name, item);
  end;
end;

FLSPClient1.OnPrepareTypeHierarchy := OnPrepareTypeHierarchy1;

var
  i: Integer;
  params: TLSPTypeHierarchyPrepareParams;
begin
  if not FLSPClient1.IsRequestSupported(lspPrepareTypeHierarchy) then Exit;
  
  params := TLSPTypeHierarchyPrepareParams.Create;
  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  params.position.line := 4;
  params.position.character := 8;
  
  FLSPClient1.SendRequest(lspPrepareTypeHierarchy, '', params);
end;

procedure OnPrepareTypeHierarchy1(Sender: TObject; const values: TLSPPrepareTypeHierarchyResponse; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
  item: TLSPTypeHierarchyItem;
begin
  for i := 0 to Length(values) - 1 do
  begin
    // item may include:
    // name           = 'foo'
    // kind           = symMethod
    // uri            = 'c:\source\foo.java'
    // range          = range of the method
    // selectionRange = range of the method name

    item := values[i];    
    AddTypeHierarchy(item.name, item);
  end;
end;

FLSPClient1.OnTypeHierarchySupertypes := OnTypeHierarchySupertypes1;

var
  i: Integer;
  params: TLSPTypeHierarchySupertypesParams;
begin
  if not FLSPClient1.IsRequestSupported(lspTypeHierarchySupertypes) then Exit;
  
  // Get the item for our method, e.g. "Foo()"
  params := GetTypeHierarchyItem(FIndex);
    
  FLSPClient1.SendRequest(lspTypeHierarchySupertypes, '', params);
end;

procedure OnTypeHierarchySupertypes1(Sender: TObject; const values: TLSPPrepareTypeHierarchyResponse; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
  item: TLSPTypeHierarchyItem;
begin
  for i := 0 to Length(values) - 1 do
  begin
    item := values[i];    
    AddTypeHierarchySupertypes(item.name, item);
  end;
end;

FLSPClient1.OnTypeHierarchySubtypes := OnTypeHierarchySubtypes1;

var
  i: Integer;
  params: TLSPTypeHierarchySubtypesParams;
begin
  if not FLSPClient1.IsRequestSupported(lspTypeHierarchySubtypes) then Exit;
  
  // Get the item for our method, e.g. "Foo()"
  params := GetTypeHierarchyItem(FIndex);
    
  FLSPClient1.SendRequest(lspTypeHierarchySubtypes, '', params);
end;

procedure OnTypeHierarchySubtypes1(Sender: TObject; const values: TLSPPrepareTypeHierarchyResponse; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
  item: TLSPTypeHierarchyItem;
begin
  for i := 0 to Length(values) - 1 do
  begin
    item := values[i];    
    AddTypeHierarchySubtypes(item.name, item);
  end;
end;

FLSPClient1.OnSemanticTokensFull := OnSemanticTokensFull1;

var
  i: Integer;
  params: TLSPSemanticTokensParams;
begin
  if not FLSPClient1.IsRequestSupported(lspSemanticTokensFull) then Exit;
  
  params := TLSPSemanticTokensParams.Create;
  
  // Find all tokens in the given file
  params.textDocument.uri := FilePathToUri('c:\source\foo.h');
    
  FLSPClient1.SendRequest(lspSemanticTokensFull, '', params);
end;

procedure OnSemanticTokensFull1(Sender: TObject; const values: TLSPSemanticTokens; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
begin
  if not Assigned(values) then Exit;
  
  // Optional result id if delta updating is used.
  FTokenResultId := Values.resultId;
  
  // Collect a list of tokens.
  for i := 0 to Length(values.data) - 1 do
    FTokens.Add(values.data[i]);    
end;

FLSPClient1.OnSemanticTokensFullDelta := OnSemanticTokensFullDelta1;

var
  i: Integer;
  params: TLSPSemanticTokensDeltaParams;
begin
  if not FLSPClient1.IsRequestSupported(lspSemanticTokensDelta) then Exit;
  
  params : TLSPSemanticTokensDeltaParams.Create;
  
  // Find all tokens in the given file
  params.textDocument.uri := FilePathToUri('c:\source\foo.h');
  
  // Result id from a previous request
  params.previousResultId := FTokenResultId;
    
  FLSPClient1.SendRequest(lspSemanticTokensFullDelta, '', params);
end;

procedure OnSemanticTokensFullDelta1(Sender: TObject; const values: TLSPSemanticTokensDelta; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
  edit: TLSPSemanticTokensEdit;
begin
  if not Assigned(values) then Exit;
  
  // Result id
  FTokenResultId := Values.resultId;
  
  // Edit the list of tokens
  for i := 0 to Length(values.data) - 1 do
    EditTokensList(values.edits[i]);    
end;

FLSPClient1.OnSemanticTokensRange := OnSemanticTokensRange1;

var
  i: Integer;
  params: TLSPSemanticTokensRangeParams;
begin
  if not FLSPClient1.IsRequestSupported(lspSemanticTokensRange) then Exit;
  
  params := TLSPSemanticTokensRangeParams.Create;
  
  // Find all tokens in the given file
  params.textDocument.uri := FilePathToUri('c:\source\foo.h');
  
  // Range
  params.range.startPos.line := 0;
  params.range.startPos.character := 0;
  params.range.endPos.line := 200;
  params.range.endPos.character := 0;
    
  FLSPClient1.SendRequest(lspSemanticTokensRange, '', params);
end;

procedure OnSemanticTokensRange1(Sender: TObject; const values: TLSPSemanticTokens; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
begin
  if not Assigned(values) then Exit;
  
  // Optional result id if delta updating is used.
  FTokenResultId := Values.resultId;
  
  // Collect a list of tokens.
  for i := 0 to Length(values.data) - 1 do
    FTokens.Add(values.data[i]);    
end;

FLSPClient1.OnSemanticTokensRefresh := OnSemanticTokensRefresh1;

procedure OnSemanticTokensRange1(Sender: TObject; const errorCode: Integer; const errorMessage: string);
begin
  // Send a new semantic tokens request a file?
  ...  
end;

FLSPClient1.OnLinkedEditingRange := OnLinkedEditingRange1;

var
  i: Integer;
  params: TLSPLinkedEditingRangeParams;
begin
  if not FLSPClient1.IsRequestSupported(lspLinkedEditingRange) then Exit;
  
  params := TLSPLinkedEditingRangeParams.Create;
  
  // Find all instances of the text (e.g. variable) in the document
  params.textDocument.uri := FilePathToUri('c:\source\foo.h');
  
  // Position
  params.position.line := 10;
  params.position.character := 0;
    
  FLSPClient1.SendRequest(lspLinkedEditingRange, '', params);
end;

procedure OnLinkedEditingRange1(Sender: TObject; const values: TLSPLinkedEditingRanges; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
begin
  if not Assigned(values) then Exit;
  
  // A list of ranges that can be renamed together.
  for i := 0 to Length(values.ranges) - 1 do
    AddEditingRange(values.ranges[i]);    
end;

FLSPClient1.OnMoniker := OnMoniker1;

var
  i: Integer;
  params: TLSPMonikerParams;
begin
  if not FLSPClient1.IsRequestSupported(lspMoniker) then Exit;
  
  params := TLSPMonikerParams.Create;
  
  // Get symbol monikers from document
  params.textDocument.uri := FilePathToUri('c:\source\foo.h');
  
  // Position in the text
  params.position.line := 10;
  params.position.character := 0;
    
  FLSPClient1.SendRequest(lspMoniker, '', params);
end;

procedure OnMoniker1(Sender: TObject; const values: TLSPMonikerResult; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
begin
  if not Assigned(values) then Exit;
  
  // A list of moniker types
  for i := 0 to Length(values.monikers) - 1 do
    AddMonikerToList(values.monikers[i]);    
end;

FLSPClient1.OnInlayHint := OnInlayHint1;

var
  i: Integer;
  params: TLSPInlayHintParams;
begin
  if not FLSPClient1.IsRequestSupported(lspInlayHint) then Exit;
  
  params := TLSPInlayHintParams.Create;
  
  // Get text document
  params.textDocument.uri := FilePathToUri('c:\source\foo.php');
  
  // Position in the text
  params.position.line := 10;
  params.position.character := 0;
    
  FLSPClient1.SendRequest(lspInlayHint, '', params);
end;

procedure OnInlayHint1(Sender: TObject; const values: TLSPInlayHintResult; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
begin
  if not Assigned(values) then Exit;
  
  // Fill a list of InlayHint types
  for i := 0 to Length(values.inlayHints) - 1 do
    AddInlayHintsToList(values.inlayHints[i]);    
end;

// The event catches the response from the server
FLSPClient1.OnInlayHintResolve := OnInlayHintResolve1;

var
  item: TLSPInlayHint;
begin
  // Make sure the request is supported
  if not FLSPClient1.IsRequestSupported(lspInlayHintResolve) then Exit;
  
  // Get the item to resolve from our hints list
  item := TLSPInlayHint(FHintsList.Objects[index]);  
  
  FLSPClient1.SendRequest(lspInlayHintResolve, '', item);
end;

procedure OnInlayHintResolve1(Sender: TObject; const item: TLSPInlayHint; const errorCode: Integer; 
    const errorMessage: string);
var
  s: string;
begin
  // Get the information you want to use
  s := item.tooltip.value;
  ...
end;

// Set event handler to be able to recieve refresh requests
LSPClient1.OnInlayHintRefresh := OnInlayHintRefresh1;

procedure OnInlayHintRefresh1(Sender: TObject; var errorCode: Integer; var errorMessage: string);
begin
  // Refresh inlay hints.
  ...
  
  FLSPClient1.SendResponse(lspInlayHintRefresh);
end;

FLSPClient1.OnInlineValue := OnInlineValue1;

var
  i: Integer;
  params: TLSPInlineValueParams;
begin
  if not FLSPClient1.IsRequestSupported(lspInlineValue) then Exit;
  
  params := TLSPInlineValueParams.Create;
  
  // Get text document
  params.textDocument.uri := FilePathToUri('c:\source\foo.php');
  
  // The document range for which inline values should be computed.
  params.range.startPos.line := 10;
  params.range.startPos.character := 4;
  params.range.endPos.line := 20;
  params.range.endPos.character := 14;
    
  FLSPClient1.SendRequest(lspInlineValue, '', params);
end;

procedure OnInlineValue1(Sender: TObject; const values: TLSPInlineValueResult; 
    const errorCode: Integer; const errorMessage: string);
var
  i: Integer;
begin
  if not Assigned(values) then Exit;
  
  // Handle inline values
  for i := 0 to values.inlineValues.Count - 1 do
  begin
    if values.inlineValues[i] is TLSPInlineValueText then
    begin
      s := TLSPInlineValueText(values.inlineValues[i]).text;
      ...
    end
    else if values.inlineValues[i] is TLSPInlineValueVariableLookup then
    begin
      s := TLSPInlineValueVariableLookup(values.inlineValues[i]).variableName;
      ...
    end
    else if values.inlineValues[i] is TLSPInlineValueEvaluatableExpression then
    begin
      s := TLSPInlineValueEvaluatableExpression(values.inlineValues[i]).expression;
      ...
    end;
  end;    
end;

// Set event handler to be able to recieve refresh requests
LSPClient1.OnInlineValueRefresh := OnInlineValueRefresh1;

procedure OnInlineValueRefresh1(Sender: TObject; var errorCode: Integer; var errorMessage: string);
begin
  // Refresh inline values.
  ...
  
  FLSPClient1.SendResponse(lspInlineValueRefresh);
end;

// Set event handlers
LSPClient1.OnExecuteCommand := OnExecuteCommand1;
LSPClient1.OnWorkspaceApplyEdit := OnWorkspaceApplyEdit1;

procedure LSPSendExecuteCommand(const item: TLSPCommand);
var
  params: TLSPExecuteCommandParams;
begin
  if not LClient.IsRequestSupported(lspWorkspaceExecuteCommand) then Exit;

  // Send execute command request to server
  params := TLSPExecuteCommandParams.Create;
  params.command := item.command;
  params.arguments := item.arguments;

  LClient.SendRequest(lspWorkspaceExecuteCommand, '', params);
end;

procedure OnWorkspaceApplyEdit1(Sender: TObject; const value: TLSPApplyWorkspaceEditParams;
  var responseValue: TLSPApplyWorkspaceEditResponse; var errorCode: Integer; var errorMessage: string);
begin
  LSPApplyChanges(value.edit);
end;

procedure OnExecuteCommand1(Sender: TObject; Json: string; const errorCode: Integer;
  const errorMsg: string);
begin
  if errorMsg <> '' then
    OnError(Sender, errorCode, errorMsg);
end;

var
  params: TLSPDidChangeWorkspaceFoldersParams;
begin
  if not FLSPClient1.IsRequestSupported(lspDidChangeWorkspaceFolders) then Exit;
  
  params := TLSPDidChangeWorkspaceFoldersParams.Create;

  SetLength(params.event.added, 1);
  params.event.added[i].name := 'NewFolder';
  params.event.added[i].uri := FilePathToUri('c:\source\NewFolder');

  SetLength(params.event.Removed, 1);
  params.event.removed[i].name := 'oldFolder';
  params.event.removed[i].uri := FilePathToUri('c:\source\OldFolder');

  FLSPClient1.SendRequest(lspDidChangeWorkspaceFolders, '', params);
end;

  s := '{"settings": {
          "css": {
              "lint": {
                  "argumentsInColorFunction": "error",
                  "boxModel": "ignore",
                  "compatibleVendorPrefixes": "ignore",
                  ...
              },
              "trace": {
                  "server": "verbose"
              },
              "validate": true
          },
          "scss": {
              ...
          }
          }
        }';

   LSPClient.SendRequest(lspDidChangeConfiguration, '', nil, s);

// We have created a new file (new.cpp) and deleted (old.cpp). Let the server know.
// The change type. 1=created, 2=changed, 3=deleted

var
  params: TLSPDidChangeWatchedFilesParams;
begin
  if not FLSPClient1.IsRequestSupported(lspDidChangeWatchedFiles) then Exit;
  
  params := TLSPDidChangeWatchedFilesParams.Create;

  SetLength(params.changes, 2);
  params.changes[0].typ := 1;
  params.changes[0].uri := FilePathToUri('c:\source\new.cpp');
  params.changes[1].typ := 3;
  params.changes[1].uri := FilePathToUri('c:\source\old.cpp');
  
  FLSPClient1.SendRequest(lspDidChangeWatchedFiles, '', params);
end;

procedure DidCreateFiles(const files: TStringlist);
var
  i: Integer;
  params: TLSPCreateFilesParams;
begin
  if not FLSPClient1.IsRequestSupported(lspWorkspaceDidCreateFiles) then Exit;
  
  params := TLSPCreateFilesParams.Create;

  SetLength(params.files, files.Count);
  for i := 0 to files.Count - 1 do
    params.files[i].uri := files[i];

  FLSPClient1.SendRequest(lspWorkspaceDidCreateFiles, '', params);
end;

procedure DidDeleteFiles(const files: TStringlist);
var
  i: Integer;
  params: TLSPDeleteFilesParams;
begin
  if not FLSPClient1.IsRequestSupported(lspWorkspaceDidDeleteFiles) then Exit;
  
  params := TLSPDeleteFilesParams.Create;

  SetLength(params.files, files.Count);
  for i := 0 to files.Count - 1 do
    params.files[i].uri := files[i];

  FLSPClient1.SendRequest(lspWorkspaceDidDeleteFiles, '', params);
end;

procedure DidRenameFiles(const files: TStringlist);
var
  i: Integer;
  params: TLSPRenameFilesParams;
begin
  if not FLSPClient1.IsRequestSupported(lspWorkspaceDidRenameFiles) then Exit;
  
  params := TLSPRenameFilesParams.Create;

  SetLength(params.files, files.Count);
  for i := 0 to files.Count - 1 do
  begin
    params.files[i].oldUri := files.Names[i];
    params.files[i].newUri := files.ValueFromIndex[i];
  end;

  FLSPClient1.SendRequest(lspWorkspaceDidRenameFiles, '', params);
end;

FLSPClient1.OnWorkspaceWillCreateFiles := OnWorkspaceWillCreateFiles1;

// Add files and folder paths to the stringlist and make the request
files.Add('c:\dummy\foo.c');
WillCreateFiles(files);

procedure WillCreateFiles(const files: TStringList);
var
  i: Integer;
  params: TLSPCreateFilesParams;
begin
  if not FLSPClient1.IsRequestSupported(lspWorkspaceWillCreateFiles) then Exit;
  
  params := TLSPCreateFilesParams.Create;

  SetLength(params.files, files.Count);
  for i := 0 to files.Count - 1 do
    params.files[i].uri := files[i];

  FLSPClient1.SendRequest(lspWorkspaceWillCreateFiles, '', params);
end;

procedure OnWorkspaceWillCreateFiles1(Sender: TObject; const value: TLSPWorkspaceEdit);
begin
  // The request can return a WorkspaceEdit which will be applied to workspace before 
  // the files are created.
  if Assigned(value) then
  begin
    // Process value object
    ...
  end;
end;

FLSPClient1.OnWorkspaceWillDeleteFiles := OnWorkspaceWillDeleteFiles1;

// Add files and folder paths to the stringlist and send the request
files.Add('c:\dummy\foo.c');
WillDeleteFiles(files);

procedure WillDeleteFiles(const files: TStringList);
var
  i: Integer;
  params: TLSPDeleteFilesParams;
begin
  if not FLSPClient1.IsRequestSupported(lspWorkspaceWillDeleteFiles) then Exit;
  
  params := TLSPDeleteFilesParams.Create;

  SetLength(params.files, files.Count);
  for i := 0 to files.Count - 1 do
    params.files[i].uri := files[i];
  
  FLSPClient1.SendRequest(lspWorkspaceWillDeleteFiles, '', params);
end;

procedure OnWorkspaceWillDeleteFiles1(Sender: TObject; const value: TLSPWorkspaceEdit);
begin
  // The request can return a WorkspaceEdit which will be applied to workspace before 
  // the files are deleted.
  if Assigned(value) then
  begin
    // Process value object
    ...
  end;
end;

FLSPClient1.OnWorkspaceWillRenameFiles := OnWorkspaceWillRenameFiles1;

// Add old and new files and folder paths to the stringlist and send the request
old := 'c:\source\old_foo.c';
new := 'c:\source\new_foo.c';
files.Add(old + '=' + new);
WillRenameFiles(files);

procedure WillRenameFiles(const files: TStringList);
var
  i: Integer;
  params: TLSPRenameFilesParams;
begin
  if not FLSPClient1.IsRequestSupported(lspWorkspaceWillRenameFiles) then Exit;
  
  params := TLSPRenameFilesParams.Create;

  SetLength(params.files, files.Count);
  for i := 0 to files.Count - 1 do
  begin
    params.files[i].oldUri := files.Names[i];
    params.files[i].newUri := files.ValueFromIndex[i];
  end;

  FLSPClient1.SendRequest(lspWorkspaceWillRenameFiles, '', params);
end;

procedure OnWorkspaceWillRenameFiles1(Sender: TObject; const value: TLSPWorkspaceEdit);
begin
  // The request can return a WorkspaceEdit which will be applied to workspace before 
  // the files are renamed.
  if Assigned(value) then
  begin
    // Process value object
    ...
  end;
end;

  LSPClient1.OnWorkspaceSymbols := OnWorkspaceSymbols1;
  LSPClient1.OnWorkDoneProgress := OnWorkDoneProgress1;
  LSPClient1.OnProgress := OnProgress1;
  
  if not FLSPClient1.IsRequestSupported(lspWorkspaceSymbol) then Exit;
  params := TLSPWorkspaceSymbolParams.Create;
  params.query := 'single';
  params.workDoneToken := '28c6150c-bd7b-11e7-abc4-cec278b6b50a';
  params.partialResultToken := '';
  LSPClient1.SendRequest(lspWorkspaceSymbol, '', params);
  
  // Handle the response in the event handler
  procedure OnWorkspaceSymbolsRequest1(Sender: TObject; const symbols: TLSPSymbolInformations);
  var
    i: Integer;
    name: string;
    kind: TLSPSymbolKind;
    location: TLSPLocation;
  begin
    for i := 0 to Length(symbols) - 1 do
    begin
      name := symbols[i].name;
      kind := symbols[i].kind;
      location := symbols[i].location;
      
      // Process symbol (add to stringlist ...)
      ...
    end;
  end;

FLSPClient1.OnRename := OnRename1;

var
  i: Integer;
  params: TLSPRenameParams;
begin
  if not FLSPClient1.IsRequestSupported(lspRename) then Exit;
  
  params := TLSPRenameParams.Create;

  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  params.position.line := 1;
  params.position.character := 8;
  params.newName := 'foo';
  
  FLSPClient1.SendRequest(lspRename, '', params);
end;

procedure OnRename1(Sender: TObject; const value: TLSPWorkspaceEdit; const errorCode: Integer; 
    const errorMessage: string);
begin
  if Assigned(value) then
  begin
    // Process the changes to the document
    ApplyChanges(value);
  end;
end;

FLSPClient1.OnPrepareRename := OnPrepareRename1;

var
  i: Integer;
  params: TLSPPrepareRenameParams;
begin
  if not FLSPClient1.IsRequestSupported(lspPrepareRename) then Exit;
  
  params := TLSPPrepareRenameParams.Create;

  params.textDocument.uri := FilePathToUri('c:\source\foo.cpp');
  params.position.line := 1;
  params.position.character := 8;
  
  FLSPClient1.SendRequest(lspPrepareRename, '', params);
end;

procedure OnPrepareRename1(Sender: TObject; const value: TLSPPrepareRenameResponse; const errorCode: Integer; 
    const errorMessage: string);
begin
  if Assigned(value) then
  begin
    // If value.defaultBehavior is true the rename position is valid and the client should
    // use its default behavior to compute the rename range.
    ...
      
    // Otherwise a range of the string to be renamed is provided and optionally a placeholder 
    // text of the string content to be renamed.
    ...
  end
  else
  begin
    // Rename is not valid at the given position
    ...
  end;
end;

procedure OnConfiguration1(Sender: TObject; const values: TLSPConfigurationParams; 
    var AJsonResult: string; var errorCode: Integer; var errorMessage: string);
var
  i: Integer;
  item: TLSPConfigurationItem;
  s: string;
begin
  for i := 0 to Length(values) do
  begin
    item := values[i];
    id s <> '' then s := s + ',';
    
    // Find configuration and return a Json string. Return null if the setting isn't found.
    s := s + GetConfigAsJson(item.scopeUri, item.section);
  end;
  AJsonResult := '[' + s + ']';
end;

  LSPClient1.OnProgress := OnProgress1;
  
  params := TLSPWorkspaceSymbolParams.Create;
  params.query := 'single';
  params.workDoneToken := '';
  params.partialResultToken := '28c6150c-bd7b-11e7-abc4-cec278b6b50a';
  LSPClient1.SendRequest(lspWorkspaceSymbol, '', params);
  
  // Handle the responses in the OnProgress event handler
  procedure OnProgress1(Sender: TObject; const id: TLSPId; const value: TLSPBaseParams);
  var
    i: Integer;
    name: string;
    uri: string;
    range: TLSPRange;
    kind: TLSPSymbolKind;
    location: TLSPLocation;
    symbols: TLSPSymbolInformations;
    gotoInfo: TLSPGotoResponse;
  begin
    case id of
      lspWorkspaceSymbol:
      begin
        symbols := TLSPWorkspaceSymbolInformationParam(value).values;
        for i := 0 to Length(symbols) - 1 do
        begin
          name := symbols[i].name;
          kind := symbols[i].kind;
          location := symbols[i].location;
      
          // Process symbol (e.g. add to stringlist ...)
          ...
        end;
      end;
      lspGotoDeclaration:
      begin
        gotoInfo := TLSPGotoResponse(value);
        for i := 0 to Length(gotoInfo.locationLinks) - 1 do
        begin
          uri := gotoInfo.locationLinks[i].targetUri;
          range := gotoInfo.locationLinks[i].targetRange;
          ...
          // Maybe add to a list
          ...
        end;
      end;
    end;
  end;

FLSPClient1.OnWorkspaceApplyEdit := OnWorkspaceApplyEdit1;

procedure OnWorkspaceApplyEdit1(Sender: TObject; const value: TLSPApplyWorkspaceEditParams; 
    var responseValue: TLSPApplyWorkspaceEditResponse; var errorCode: Integer; var errorMessage: string);
var
  i,j: Integer;
  lbl,sz: string;
  change: TLSPBaseParams;
  edit: TLSPTextEdit;
begin
  lbl := value.slabel;
  
  if Length(value.edit.documentChanges) > 0 then
  begin
    // Process changes
    for i := 0 to Length(value.edit.documentChanges) - 1 do
    begin
      change := value.edit.documentChanges[i];
      if change is TLSPTextDocumentEdit then
      begin
        // Retrieve document path
        sz := FLSPClient.UriToFilePath(TLSPTextDocumentEdit(change).textDocument.uri);
        
        // Get all changes to the document
        for j := 0 to Length(TLSPTextDocumentEdit(change).edits) - 1 do
        begin
          edit := TLSPTextDocumentEdit(change).edits[j];
                    
          // Apply changes
          ModifyDocument(sz, edit.newText, edit.range);
        end;
      end;
    end;
    responseValue.applied := True;
  end;
end;

Language           Identifier
-------------------------------
ABAP               abap
Windows Bat        bat
BibTeX             bibtex
Clojure            clojure
Coffeescript       coffeescript
C                  c
C++                cpp
C#                 csharp
CSS                css
Diff               diff
Dart               dart
Dockerfile         dockerfile
Elixir             elixir
Erlang             erlang
F#                 fsharp
Git                git-commit and git-rebase
Go                 go
Groovy             groovy
Handlebars         handlebars
HTML               html
Ini                ini
Java               java
JavaScript         javascript
JavaScript React   javascriptreact
JSON               json
LaTeX              latex
Less               less
Lua                lua
Makefile           makefile
Markdown           markdown
Objective-C        objective-c
Objective-C++      objective-cpp
Perl               perl
Perl 6             perl6
PHP                php
Powershell         powershell
Pug                jade
Python             python
R                  r
Razor (cshtml)     razor
Ruby               ruby
Rust               rust
SCSS               scss (syntax using curly brackets), sass (indented syntax)
Scala              scala
ShaderLab          shaderlab
Shell Script       shellscript
SQL                sql
Swift              swift
TypeScript         typescript
TypeScript React   typescriptreact
TeX                tex
Visual Basic       vb
XML                xml
XSL                xsl
YAML               yaml