1use lsp::{Uri, VersionedTextDocumentIdentifier};
2use serde::{Deserialize, Serialize};
3
4pub enum CheckStatus {}
5
6#[derive(Debug, Serialize, Deserialize)]
7#[serde(rename_all = "camelCase")]
8pub struct CheckStatusParams {
9 pub local_checks_only: bool,
10}
11
12impl lsp::request::Request for CheckStatus {
13 type Params = CheckStatusParams;
14 type Result = SignInStatus;
15 const METHOD: &'static str = "checkStatus";
16}
17
18pub enum SignIn {}
19
20#[derive(Debug, Serialize, Deserialize)]
21pub struct SignInParams {}
22
23#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
24#[serde(rename_all = "camelCase")]
25pub struct PromptUserDeviceFlow {
26 pub user_code: String,
27 pub command: lsp::Command,
28}
29
30impl lsp::request::Request for SignIn {
31 type Params = SignInParams;
32 type Result = PromptUserDeviceFlow;
33 const METHOD: &'static str = "signIn";
34}
35
36#[derive(Debug, Serialize, Deserialize)]
37#[serde(tag = "status")]
38pub enum SignInStatus {
39 #[serde(rename = "OK")]
40 Ok {
41 user: Option<String>,
42 },
43 MaybeOk {
44 user: String,
45 },
46 AlreadySignedIn {
47 user: String,
48 },
49 NotAuthorized {
50 user: String,
51 },
52 NotSignedIn,
53}
54
55pub enum SignOut {}
56
57#[derive(Debug, Serialize, Deserialize)]
58#[serde(rename_all = "camelCase")]
59pub struct SignOutParams {}
60
61#[derive(Debug, Serialize, Deserialize)]
62#[serde(rename_all = "camelCase")]
63pub struct SignOutResult {}
64
65impl lsp::request::Request for SignOut {
66 type Params = SignOutParams;
67 type Result = SignOutResult;
68 const METHOD: &'static str = "signOut";
69}
70
71pub enum DidChangeStatus {}
72
73#[derive(Debug, Serialize, Deserialize)]
74pub struct DidChangeStatusParams {
75 #[serde(default)]
76 pub message: Option<String>,
77 pub kind: StatusKind,
78}
79
80#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
81pub enum StatusKind {
82 Normal,
83 Error,
84 Warning,
85 Inactive,
86}
87
88impl lsp::notification::Notification for DidChangeStatus {
89 type Params = DidChangeStatusParams;
90 const METHOD: &'static str = "didChangeStatus";
91}
92
93pub enum SetEditorInfo {}
94
95#[derive(Debug, Serialize, Deserialize)]
96#[serde(rename_all = "camelCase")]
97pub struct SetEditorInfoParams {
98 pub editor_info: EditorInfo,
99 pub editor_plugin_info: EditorPluginInfo,
100}
101
102impl lsp::request::Request for SetEditorInfo {
103 type Params = SetEditorInfoParams;
104 type Result = String;
105 const METHOD: &'static str = "setEditorInfo";
106}
107
108#[derive(Debug, Serialize, Deserialize)]
109#[serde(rename_all = "camelCase")]
110pub struct EditorInfo {
111 pub name: String,
112 pub version: String,
113}
114
115#[derive(Debug, Serialize, Deserialize)]
116#[serde(rename_all = "camelCase")]
117pub struct EditorPluginInfo {
118 pub name: String,
119 pub version: String,
120}
121
122pub enum NotifyAccepted {}
123
124#[derive(Debug, Serialize, Deserialize)]
125#[serde(rename_all = "camelCase")]
126pub struct NotifyAcceptedParams {
127 pub uuid: String,
128}
129
130impl lsp::request::Request for NotifyAccepted {
131 type Params = NotifyAcceptedParams;
132 type Result = String;
133 const METHOD: &'static str = "notifyAccepted";
134}
135
136pub enum NotifyRejected {}
137
138#[derive(Debug, Serialize, Deserialize)]
139#[serde(rename_all = "camelCase")]
140pub struct NotifyRejectedParams {
141 pub uuids: Vec<String>,
142}
143
144impl lsp::request::Request for NotifyRejected {
145 type Params = NotifyRejectedParams;
146 type Result = String;
147 const METHOD: &'static str = "notifyRejected";
148}
149
150#[derive(Debug, Serialize, Deserialize)]
151#[serde(rename_all = "camelCase")]
152pub struct NextEditSuggestions;
153
154#[derive(Debug, Serialize, Deserialize)]
155#[serde(rename_all = "camelCase")]
156pub struct NextEditSuggestionsParams {
157 pub(crate) text_document: VersionedTextDocumentIdentifier,
158 pub(crate) position: lsp::Position,
159}
160
161#[derive(Clone, Debug, Serialize, Deserialize)]
162#[serde(rename_all = "camelCase")]
163pub struct NextEditSuggestion {
164 pub text: String,
165 pub text_document: VersionedTextDocumentIdentifier,
166 pub range: lsp::Range,
167 pub command: Option<lsp::Command>,
168}
169
170#[derive(Debug, Serialize, Deserialize)]
171#[serde(rename_all = "camelCase")]
172pub struct NextEditSuggestionsResult {
173 pub edits: Vec<NextEditSuggestion>,
174}
175
176impl lsp::request::Request for NextEditSuggestions {
177 type Params = NextEditSuggestionsParams;
178 type Result = NextEditSuggestionsResult;
179
180 const METHOD: &'static str = "textDocument/copilotInlineEdit";
181}
182
183pub(crate) struct DidFocus;
184
185#[derive(Serialize, Deserialize)]
186pub(crate) struct DidFocusParams {
187 #[serde(skip_serializing_if = "Option::is_none")]
188 pub(crate) uri: Option<Uri>,
189}
190
191impl lsp::notification::Notification for DidFocus {
192 type Params = DidFocusParams;
193 const METHOD: &'static str = "textDocument/didFocus";
194}
195
196pub(crate) struct DidShowInlineEdit;
197
198#[derive(Serialize, Deserialize)]
199pub(crate) struct DidShowInlineEditParams {
200 pub(crate) item: serde_json::Value,
201}
202
203impl lsp::notification::Notification for DidShowInlineEdit {
204 type Params = DidShowInlineEditParams;
205 const METHOD: &'static str = "textDocument/didShowInlineEdit";
206}
207
208// Inline Completions (non-NES) - textDocument/inlineCompletion
209
210pub enum InlineCompletions {}
211
212#[derive(Debug, Serialize, Deserialize)]
213#[serde(rename_all = "camelCase")]
214pub struct InlineCompletionsParams {
215 pub text_document: VersionedTextDocumentIdentifier,
216 pub position: lsp::Position,
217 pub context: InlineCompletionContext,
218 #[serde(skip_serializing_if = "Option::is_none")]
219 pub formatting_options: Option<FormattingOptions>,
220}
221
222#[derive(Debug, Serialize, Deserialize)]
223#[serde(rename_all = "camelCase")]
224pub struct InlineCompletionContext {
225 pub trigger_kind: InlineCompletionTriggerKind,
226}
227
228#[derive(Debug, Clone, Copy)]
229pub enum InlineCompletionTriggerKind {
230 Invoked = 1,
231 Automatic = 2,
232}
233
234impl Serialize for InlineCompletionTriggerKind {
235 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
236 where
237 S: serde::Serializer,
238 {
239 serializer.serialize_u8(*self as u8)
240 }
241}
242
243impl<'de> Deserialize<'de> for InlineCompletionTriggerKind {
244 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
245 where
246 D: serde::Deserializer<'de>,
247 {
248 let value = u8::deserialize(deserializer)?;
249 match value {
250 1 => Ok(InlineCompletionTriggerKind::Invoked),
251 2 => Ok(InlineCompletionTriggerKind::Automatic),
252 _ => Err(serde::de::Error::custom("invalid trigger kind")),
253 }
254 }
255}
256
257#[derive(Debug, Serialize, Deserialize)]
258#[serde(rename_all = "camelCase")]
259pub struct FormattingOptions {
260 pub tab_size: u32,
261 pub insert_spaces: bool,
262}
263
264#[derive(Debug, Serialize, Deserialize)]
265#[serde(rename_all = "camelCase")]
266pub struct InlineCompletionsResult {
267 pub items: Vec<InlineCompletionItem>,
268}
269
270#[derive(Clone, Debug, Serialize, Deserialize)]
271#[serde(rename_all = "camelCase")]
272pub struct InlineCompletionItem {
273 pub insert_text: String,
274 pub range: lsp::Range,
275 #[serde(skip_serializing_if = "Option::is_none")]
276 pub command: Option<lsp::Command>,
277}
278
279impl lsp::request::Request for InlineCompletions {
280 type Params = InlineCompletionsParams;
281 type Result = InlineCompletionsResult;
282
283 const METHOD: &'static str = "textDocument/inlineCompletion";
284}
285
286// Telemetry notifications for inline completions
287
288pub(crate) struct DidShowCompletion;
289
290#[derive(Debug, Serialize, Deserialize)]
291#[serde(rename_all = "camelCase")]
292pub(crate) struct DidShowCompletionParams {
293 pub(crate) item: InlineCompletionItem,
294}
295
296impl lsp::notification::Notification for DidShowCompletion {
297 type Params = DidShowCompletionParams;
298 const METHOD: &'static str = "textDocument/didShowCompletion";
299}