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 tab_size: u32,
103    pub indent_size: u32,
104    pub insert_spaces: bool,
105    pub uri: lsp::Url,
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 message: String,
147    pub level: u8,
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}