1use serde::{Deserialize, Serialize};
2
3pub enum CheckStatus {}
4
5#[derive(Debug, Serialize, Deserialize)]
6#[serde(rename_all = "camelCase")]
7pub struct CheckStatusParams {
8 pub local_checks_only: bool,
9}
10
11impl lsp::request::Request for CheckStatus {
12 type Params = CheckStatusParams;
13 type Result = SignInStatus;
14 const METHOD: &'static str = "checkStatus";
15}
16
17pub enum SignInInitiate {}
18
19#[derive(Debug, Serialize, Deserialize)]
20pub struct SignInInitiateParams {}
21
22#[derive(Debug, Serialize, Deserialize)]
23#[serde(tag = "status")]
24pub enum SignInInitiateResult {
25 AlreadySignedIn { user: String },
26 PromptUserDeviceFlow(PromptUserDeviceFlow),
27}
28
29#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
30#[serde(rename_all = "camelCase")]
31pub struct PromptUserDeviceFlow {
32 pub user_code: String,
33 pub verification_uri: String,
34}
35
36impl lsp::request::Request for SignInInitiate {
37 type Params = SignInInitiateParams;
38 type Result = SignInInitiateResult;
39 const METHOD: &'static str = "signInInitiate";
40}
41
42pub enum SignInConfirm {}
43
44#[derive(Debug, Serialize, Deserialize)]
45#[serde(rename_all = "camelCase")]
46pub struct SignInConfirmParams {
47 pub user_code: String,
48}
49
50#[derive(Debug, Serialize, Deserialize)]
51#[serde(tag = "status")]
52pub enum SignInStatus {
53 #[serde(rename = "OK")]
54 Ok {
55 user: Option<String>,
56 },
57 MaybeOk {
58 user: String,
59 },
60 AlreadySignedIn {
61 user: String,
62 },
63 NotAuthorized {
64 user: String,
65 },
66 NotSignedIn,
67}
68
69impl lsp::request::Request for SignInConfirm {
70 type Params = SignInConfirmParams;
71 type Result = SignInStatus;
72 const METHOD: &'static str = "signInConfirm";
73}
74
75pub enum SignOut {}
76
77#[derive(Debug, Serialize, Deserialize)]
78#[serde(rename_all = "camelCase")]
79pub struct SignOutParams {}
80
81#[derive(Debug, Serialize, Deserialize)]
82#[serde(rename_all = "camelCase")]
83pub struct SignOutResult {}
84
85impl lsp::request::Request for SignOut {
86 type Params = SignOutParams;
87 type Result = SignOutResult;
88 const METHOD: &'static str = "signOut";
89}
90
91pub enum GetCompletions {}
92
93#[derive(Debug, Serialize, Deserialize)]
94#[serde(rename_all = "camelCase")]
95pub struct GetCompletionsParams {
96 pub doc: GetCompletionsDocument,
97}
98
99#[derive(Debug, Serialize, Deserialize)]
100#[serde(rename_all = "camelCase")]
101pub struct GetCompletionsDocument {
102 pub tab_size: u32,
103 pub indent_size: u32,
104 pub insert_spaces: bool,
105 pub uri: lsp::Uri,
106 pub relative_path: String,
107 pub position: lsp::Position,
108 pub version: usize,
109}
110
111#[derive(Debug, Serialize, Deserialize)]
112#[serde(rename_all = "camelCase")]
113pub struct GetCompletionsResult {
114 pub completions: Vec<Completion>,
115}
116
117#[derive(Clone, Debug, Default, Serialize, Deserialize)]
118#[serde(rename_all = "camelCase")]
119pub struct Completion {
120 pub text: String,
121 pub position: lsp::Position,
122 pub uuid: String,
123 pub range: lsp::Range,
124 pub display_text: String,
125}
126
127impl lsp::request::Request for GetCompletions {
128 type Params = GetCompletionsParams;
129 type Result = GetCompletionsResult;
130 const METHOD: &'static str = "getCompletions";
131}
132
133pub enum GetCompletionsCycling {}
134
135impl lsp::request::Request for GetCompletionsCycling {
136 type Params = GetCompletionsParams;
137 type Result = GetCompletionsResult;
138 const METHOD: &'static str = "getCompletionsCycling";
139}
140
141pub enum LogMessage {}
142
143#[derive(Debug, Serialize, Deserialize)]
144#[serde(rename_all = "camelCase")]
145pub struct LogMessageParams {
146 pub level: u8,
147 pub message: String,
148 pub metadata_str: String,
149 pub extra: Vec<String>,
150}
151
152impl lsp::notification::Notification for LogMessage {
153 type Params = LogMessageParams;
154 const METHOD: &'static str = "LogMessage";
155}
156
157pub enum StatusNotification {}
158
159#[derive(Debug, Serialize, Deserialize)]
160pub struct StatusNotificationParams {
161 pub message: String,
162 pub status: String, // One of Normal/InProgress
163}
164
165impl lsp::notification::Notification for StatusNotification {
166 type Params = StatusNotificationParams;
167 const METHOD: &'static str = "statusNotification";
168}
169
170pub enum SetEditorInfo {}
171
172#[derive(Debug, Serialize, Deserialize)]
173#[serde(rename_all = "camelCase")]
174pub struct SetEditorInfoParams {
175 pub editor_info: EditorInfo,
176 pub editor_plugin_info: EditorPluginInfo,
177}
178
179impl lsp::request::Request for SetEditorInfo {
180 type Params = SetEditorInfoParams;
181 type Result = String;
182 const METHOD: &'static str = "setEditorInfo";
183}
184
185#[derive(Debug, Serialize, Deserialize)]
186#[serde(rename_all = "camelCase")]
187pub struct EditorInfo {
188 pub name: String,
189 pub version: String,
190}
191
192#[derive(Debug, Serialize, Deserialize)]
193#[serde(rename_all = "camelCase")]
194pub struct EditorPluginInfo {
195 pub name: String,
196 pub version: String,
197}
198
199pub enum NotifyAccepted {}
200
201#[derive(Debug, Serialize, Deserialize)]
202#[serde(rename_all = "camelCase")]
203pub struct NotifyAcceptedParams {
204 pub uuid: String,
205}
206
207impl lsp::request::Request for NotifyAccepted {
208 type Params = NotifyAcceptedParams;
209 type Result = String;
210 const METHOD: &'static str = "notifyAccepted";
211}
212
213pub enum NotifyRejected {}
214
215#[derive(Debug, Serialize, Deserialize)]
216#[serde(rename_all = "camelCase")]
217pub struct NotifyRejectedParams {
218 pub uuids: Vec<String>,
219}
220
221impl lsp::request::Request for NotifyRejected {
222 type Params = NotifyRejectedParams;
223 type Result = String;
224 const METHOD: &'static str = "notifyRejected";
225}