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: 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 source: String,
103    pub tab_size: u32,
104    pub indent_size: u32,
105    pub insert_spaces: bool,
106    pub uri: lsp::Url,
107    pub path: String,
108    pub relative_path: String,
109    pub language_id: String,
110    pub position: lsp::Position,
111    pub version: usize,
112}
113
114#[derive(Debug, Serialize, Deserialize)]
115#[serde(rename_all = "camelCase")]
116pub struct GetCompletionsResult {
117    pub completions: Vec<Completion>,
118}
119
120#[derive(Clone, Debug, Default, Serialize, Deserialize)]
121#[serde(rename_all = "camelCase")]
122pub struct Completion {
123    pub text: String,
124    pub position: lsp::Position,
125    pub uuid: String,
126    pub range: lsp::Range,
127    pub display_text: String,
128}
129
130impl lsp::request::Request for GetCompletions {
131    type Params = GetCompletionsParams;
132    type Result = GetCompletionsResult;
133    const METHOD: &'static str = "getCompletions";
134}
135
136pub enum GetCompletionsCycling {}
137
138impl lsp::request::Request for GetCompletionsCycling {
139    type Params = GetCompletionsParams;
140    type Result = GetCompletionsResult;
141    const METHOD: &'static str = "getCompletionsCycling";
142}
143
144pub enum LogMessage {}
145
146#[derive(Debug, Serialize, Deserialize)]
147#[serde(rename_all = "camelCase")]
148pub struct LogMessageParams {
149    pub level: u8,
150    pub message: String,
151    pub metadata_str: String,
152    pub extra: Vec<String>,
153}
154
155impl lsp::notification::Notification for LogMessage {
156    type Params = LogMessageParams;
157    const METHOD: &'static str = "LogMessage";
158}
159
160pub enum StatusNotification {}
161
162#[derive(Debug, Serialize, Deserialize)]
163pub struct StatusNotificationParams {
164    pub message: String,
165    pub status: String, // One of Normal/InProgress
166}
167
168impl lsp::notification::Notification for StatusNotification {
169    type Params = StatusNotificationParams;
170    const METHOD: &'static str = "statusNotification";
171}