1use lsp::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 SignInInitiate {}
 19
 20#[derive(Debug, Serialize, Deserialize)]
 21pub struct SignInInitiateParams {}
 22
 23#[derive(Debug, Serialize, Deserialize)]
 24#[serde(tag = "status")]
 25pub enum SignInInitiateResult {
 26    AlreadySignedIn { user: String },
 27    PromptUserDeviceFlow(PromptUserDeviceFlow),
 28}
 29
 30#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
 31#[serde(rename_all = "camelCase")]
 32pub struct PromptUserDeviceFlow {
 33    pub user_code: String,
 34    pub verification_uri: String,
 35}
 36
 37impl lsp::request::Request for SignInInitiate {
 38    type Params = SignInInitiateParams;
 39    type Result = SignInInitiateResult;
 40    const METHOD: &'static str = "signInInitiate";
 41}
 42
 43pub enum SignInConfirm {}
 44
 45#[derive(Debug, Serialize, Deserialize)]
 46#[serde(rename_all = "camelCase")]
 47pub struct SignInConfirmParams {
 48    pub user_code: String,
 49}
 50
 51#[derive(Debug, Serialize, Deserialize)]
 52#[serde(tag = "status")]
 53pub enum SignInStatus {
 54    #[serde(rename = "OK")]
 55    Ok {
 56        user: Option<String>,
 57    },
 58    MaybeOk {
 59        user: String,
 60    },
 61    AlreadySignedIn {
 62        user: String,
 63    },
 64    NotAuthorized {
 65        user: String,
 66    },
 67    NotSignedIn,
 68}
 69
 70impl lsp::request::Request for SignInConfirm {
 71    type Params = SignInConfirmParams;
 72    type Result = SignInStatus;
 73    const METHOD: &'static str = "signInConfirm";
 74}
 75
 76pub enum SignOut {}
 77
 78#[derive(Debug, Serialize, Deserialize)]
 79#[serde(rename_all = "camelCase")]
 80pub struct SignOutParams {}
 81
 82#[derive(Debug, Serialize, Deserialize)]
 83#[serde(rename_all = "camelCase")]
 84pub struct SignOutResult {}
 85
 86impl lsp::request::Request for SignOut {
 87    type Params = SignOutParams;
 88    type Result = SignOutResult;
 89    const METHOD: &'static str = "signOut";
 90}
 91
 92pub enum StatusNotification {}
 93
 94#[derive(Debug, Serialize, Deserialize)]
 95pub struct StatusNotificationParams {
 96    pub message: String,
 97    pub status: String, // One of Normal/InProgress
 98}
 99
100impl lsp::notification::Notification for StatusNotification {
101    type Params = StatusNotificationParams;
102    const METHOD: &'static str = "statusNotification";
103}
104
105pub enum SetEditorInfo {}
106
107#[derive(Debug, Serialize, Deserialize)]
108#[serde(rename_all = "camelCase")]
109pub struct SetEditorInfoParams {
110    pub editor_info: EditorInfo,
111    pub editor_plugin_info: EditorPluginInfo,
112}
113
114impl lsp::request::Request for SetEditorInfo {
115    type Params = SetEditorInfoParams;
116    type Result = String;
117    const METHOD: &'static str = "setEditorInfo";
118}
119
120#[derive(Debug, Serialize, Deserialize)]
121#[serde(rename_all = "camelCase")]
122pub struct EditorInfo {
123    pub name: String,
124    pub version: String,
125}
126
127#[derive(Debug, Serialize, Deserialize)]
128#[serde(rename_all = "camelCase")]
129pub struct EditorPluginInfo {
130    pub name: String,
131    pub version: String,
132}
133
134pub enum NotifyAccepted {}
135
136#[derive(Debug, Serialize, Deserialize)]
137#[serde(rename_all = "camelCase")]
138pub struct NotifyAcceptedParams {
139    pub uuid: String,
140}
141
142impl lsp::request::Request for NotifyAccepted {
143    type Params = NotifyAcceptedParams;
144    type Result = String;
145    const METHOD: &'static str = "notifyAccepted";
146}
147
148pub enum NotifyRejected {}
149
150#[derive(Debug, Serialize, Deserialize)]
151#[serde(rename_all = "camelCase")]
152pub struct NotifyRejectedParams {
153    pub uuids: Vec<String>,
154}
155
156impl lsp::request::Request for NotifyRejected {
157    type Params = NotifyRejectedParams;
158    type Result = String;
159    const METHOD: &'static str = "notifyRejected";
160}
161
162#[derive(Debug, Serialize, Deserialize)]
163#[serde(rename_all = "camelCase")]
164pub struct NextEditSuggestions;
165
166#[derive(Debug, Serialize, Deserialize)]
167#[serde(rename_all = "camelCase")]
168pub struct NextEditSuggestionsParams {
169    pub(crate) text_document: VersionedTextDocumentIdentifier,
170    pub(crate) position: lsp::Position,
171}
172
173#[derive(Clone, Debug, Serialize, Deserialize)]
174#[serde(rename_all = "camelCase")]
175pub struct NextEditSuggestion {
176    pub text: String,
177    pub text_document: VersionedTextDocumentIdentifier,
178    pub range: lsp::Range,
179    pub command: Option<lsp::Command>,
180}
181
182#[derive(Debug, Serialize, Deserialize)]
183#[serde(rename_all = "camelCase")]
184pub struct NextEditSuggestionsResult {
185    pub edits: Vec<NextEditSuggestion>,
186}
187
188impl lsp::request::Request for NextEditSuggestions {
189    type Params = NextEditSuggestionsParams;
190    type Result = NextEditSuggestionsResult;
191
192    const METHOD: &'static str = "textDocument/copilotInlineEdit";
193}