1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(clippy::approx_constant, clippy::type_complexity, clippy::unreadable_literal, clippy::upper_case_acronyms)]
8#![cfg_attr(docsrs, feature(doc_cfg))]
9
10use glib_sys as glib;
11use gobject_sys as gobject;
12use gio_sys as gio;
13
14#[allow(unused_imports)]
15use std::ffi::{c_int, c_char, c_uchar, c_float, c_uint, c_double,
16 c_short, c_ushort, c_long, c_ulong, c_void};
17#[allow(unused_imports)]
18use libc::{size_t, ssize_t, time_t, off_t, intptr_t, uintptr_t, FILE};
19#[cfg(unix)]
20#[allow(unused_imports)]
21use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
22
23#[allow(unused_imports)]
24use glib::{gboolean, gconstpointer, gpointer, GType};
25
26pub type AstalGreetAuthMessageType = c_int;
28pub const ASTAL_GREET_AUTH_MESSAGE_TYPE_VISIBLE: AstalGreetAuthMessageType = 0;
29pub const ASTAL_GREET_AUTH_MESSAGE_TYPE_SECRET: AstalGreetAuthMessageType = 1;
30pub const ASTAL_GREET_AUTH_MESSAGE_TYPE_INFO: AstalGreetAuthMessageType = 2;
31pub const ASTAL_GREET_AUTH_MESSAGE_TYPE_ERROR: AstalGreetAuthMessageType = 3;
32
33pub type AstalGreetErrorType = c_int;
34pub const ASTAL_GREET_ERROR_TYPE_AUTH_ERROR: AstalGreetErrorType = 0;
35pub const ASTAL_GREET_ERROR_TYPE_ERROR: AstalGreetErrorType = 1;
36
37pub const ASTAL_GREET_MAJOR_VERSION: c_int = 0;
39pub const ASTAL_GREET_MINOR_VERSION: c_int = 1;
40pub const ASTAL_GREET_MICRO_VERSION: c_int = 0;
41pub const ASTAL_GREET_VERSION: &[u8] = b"0.1.0\0";
42
43#[derive(Copy, Clone)]
45#[repr(C)]
46pub struct AstalGreetAuthMessageClass {
47 pub parent_class: AstalGreetResponseClass,
48}
49
50impl ::std::fmt::Debug for AstalGreetAuthMessageClass {
51 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
52 f.debug_struct(&format!("AstalGreetAuthMessageClass @ {self:p}"))
53 .finish()
54 }
55}
56
57#[repr(C)]
58#[allow(dead_code)]
59pub struct _AstalGreetAuthMessagePrivate {
60 _data: [u8; 0],
61 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
62}
63
64pub type AstalGreetAuthMessagePrivate = _AstalGreetAuthMessagePrivate;
65
66#[derive(Copy, Clone)]
67#[repr(C)]
68pub struct AstalGreetCancelSessionClass {
69 pub parent_class: AstalGreetRequestClass,
70}
71
72impl ::std::fmt::Debug for AstalGreetCancelSessionClass {
73 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
74 f.debug_struct(&format!("AstalGreetCancelSessionClass @ {self:p}"))
75 .finish()
76 }
77}
78
79#[repr(C)]
80#[allow(dead_code)]
81pub struct _AstalGreetCancelSessionPrivate {
82 _data: [u8; 0],
83 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
84}
85
86pub type AstalGreetCancelSessionPrivate = _AstalGreetCancelSessionPrivate;
87
88#[derive(Copy, Clone)]
89#[repr(C)]
90pub struct AstalGreetCreateSessionClass {
91 pub parent_class: AstalGreetRequestClass,
92}
93
94impl ::std::fmt::Debug for AstalGreetCreateSessionClass {
95 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
96 f.debug_struct(&format!("AstalGreetCreateSessionClass @ {self:p}"))
97 .finish()
98 }
99}
100
101#[repr(C)]
102#[allow(dead_code)]
103pub struct _AstalGreetCreateSessionPrivate {
104 _data: [u8; 0],
105 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
106}
107
108pub type AstalGreetCreateSessionPrivate = _AstalGreetCreateSessionPrivate;
109
110#[derive(Copy, Clone)]
111#[repr(C)]
112pub struct AstalGreetErrorClass {
113 pub parent_class: AstalGreetResponseClass,
114}
115
116impl ::std::fmt::Debug for AstalGreetErrorClass {
117 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
118 f.debug_struct(&format!("AstalGreetErrorClass @ {self:p}"))
119 .finish()
120 }
121}
122
123#[repr(C)]
124#[allow(dead_code)]
125pub struct _AstalGreetErrorPrivate {
126 _data: [u8; 0],
127 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
128}
129
130pub type AstalGreetErrorPrivate = _AstalGreetErrorPrivate;
131
132#[derive(Copy, Clone)]
133#[repr(C)]
134pub struct AstalGreetPostAuthMesssageClass {
135 pub parent_class: AstalGreetRequestClass,
136}
137
138impl ::std::fmt::Debug for AstalGreetPostAuthMesssageClass {
139 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
140 f.debug_struct(&format!("AstalGreetPostAuthMesssageClass @ {self:p}"))
141 .finish()
142 }
143}
144
145#[repr(C)]
146#[allow(dead_code)]
147pub struct _AstalGreetPostAuthMesssagePrivate {
148 _data: [u8; 0],
149 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
150}
151
152pub type AstalGreetPostAuthMesssagePrivate = _AstalGreetPostAuthMesssagePrivate;
153
154#[derive(Copy, Clone)]
155#[repr(C)]
156pub struct AstalGreetRequestClass {
157 pub parent_class: gobject::GObjectClass,
158}
159
160impl ::std::fmt::Debug for AstalGreetRequestClass {
161 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
162 f.debug_struct(&format!("AstalGreetRequestClass @ {self:p}"))
163 .finish()
164 }
165}
166
167#[repr(C)]
168#[allow(dead_code)]
169pub struct _AstalGreetRequestPrivate {
170 _data: [u8; 0],
171 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
172}
173
174pub type AstalGreetRequestPrivate = _AstalGreetRequestPrivate;
175
176#[derive(Copy, Clone)]
177#[repr(C)]
178pub struct AstalGreetResponseClass {
179 pub parent_class: gobject::GObjectClass,
180}
181
182impl ::std::fmt::Debug for AstalGreetResponseClass {
183 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
184 f.debug_struct(&format!("AstalGreetResponseClass @ {self:p}"))
185 .finish()
186 }
187}
188
189#[repr(C)]
190#[allow(dead_code)]
191pub struct _AstalGreetResponsePrivate {
192 _data: [u8; 0],
193 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
194}
195
196pub type AstalGreetResponsePrivate = _AstalGreetResponsePrivate;
197
198#[derive(Copy, Clone)]
199#[repr(C)]
200pub struct AstalGreetStartSessionClass {
201 pub parent_class: AstalGreetRequestClass,
202}
203
204impl ::std::fmt::Debug for AstalGreetStartSessionClass {
205 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
206 f.debug_struct(&format!("AstalGreetStartSessionClass @ {self:p}"))
207 .finish()
208 }
209}
210
211#[repr(C)]
212#[allow(dead_code)]
213pub struct _AstalGreetStartSessionPrivate {
214 _data: [u8; 0],
215 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
216}
217
218pub type AstalGreetStartSessionPrivate = _AstalGreetStartSessionPrivate;
219
220#[derive(Copy, Clone)]
221#[repr(C)]
222pub struct AstalGreetSuccessClass {
223 pub parent_class: AstalGreetResponseClass,
224}
225
226impl ::std::fmt::Debug for AstalGreetSuccessClass {
227 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
228 f.debug_struct(&format!("AstalGreetSuccessClass @ {self:p}"))
229 .finish()
230 }
231}
232
233#[repr(C)]
234#[allow(dead_code)]
235pub struct _AstalGreetSuccessPrivate {
236 _data: [u8; 0],
237 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
238}
239
240pub type AstalGreetSuccessPrivate = _AstalGreetSuccessPrivate;
241
242#[derive(Copy, Clone)]
244#[repr(C)]
245pub struct AstalGreetAuthMessage {
246 pub parent_instance: AstalGreetResponse,
247 pub priv_: *mut AstalGreetAuthMessagePrivate,
248}
249
250impl ::std::fmt::Debug for AstalGreetAuthMessage {
251 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
252 f.debug_struct(&format!("AstalGreetAuthMessage @ {self:p}"))
253 .finish()
254 }
255}
256
257#[derive(Copy, Clone)]
258#[repr(C)]
259pub struct AstalGreetCancelSession {
260 pub parent_instance: AstalGreetRequest,
261 pub priv_: *mut AstalGreetCancelSessionPrivate,
262}
263
264impl ::std::fmt::Debug for AstalGreetCancelSession {
265 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
266 f.debug_struct(&format!("AstalGreetCancelSession @ {self:p}"))
267 .finish()
268 }
269}
270
271#[derive(Copy, Clone)]
272#[repr(C)]
273pub struct AstalGreetCreateSession {
274 pub parent_instance: AstalGreetRequest,
275 pub priv_: *mut AstalGreetCreateSessionPrivate,
276}
277
278impl ::std::fmt::Debug for AstalGreetCreateSession {
279 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
280 f.debug_struct(&format!("AstalGreetCreateSession @ {self:p}"))
281 .finish()
282 }
283}
284
285#[derive(Copy, Clone)]
286#[repr(C)]
287pub struct AstalGreetError {
288 pub parent_instance: AstalGreetResponse,
289 pub priv_: *mut AstalGreetErrorPrivate,
290}
291
292impl ::std::fmt::Debug for AstalGreetError {
293 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
294 f.debug_struct(&format!("AstalGreetError @ {self:p}"))
295 .finish()
296 }
297}
298
299#[derive(Copy, Clone)]
300#[repr(C)]
301pub struct AstalGreetPostAuthMesssage {
302 pub parent_instance: AstalGreetRequest,
303 pub priv_: *mut AstalGreetPostAuthMesssagePrivate,
304}
305
306impl ::std::fmt::Debug for AstalGreetPostAuthMesssage {
307 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
308 f.debug_struct(&format!("AstalGreetPostAuthMesssage @ {self:p}"))
309 .finish()
310 }
311}
312
313#[derive(Copy, Clone)]
314#[repr(C)]
315pub struct AstalGreetRequest {
316 pub parent_instance: gobject::GObject,
317 pub priv_: *mut AstalGreetRequestPrivate,
318}
319
320impl ::std::fmt::Debug for AstalGreetRequest {
321 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
322 f.debug_struct(&format!("AstalGreetRequest @ {self:p}"))
323 .finish()
324 }
325}
326
327#[derive(Copy, Clone)]
328#[repr(C)]
329pub struct AstalGreetResponse {
330 pub parent_instance: gobject::GObject,
331 pub priv_: *mut AstalGreetResponsePrivate,
332}
333
334impl ::std::fmt::Debug for AstalGreetResponse {
335 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
336 f.debug_struct(&format!("AstalGreetResponse @ {self:p}"))
337 .finish()
338 }
339}
340
341#[derive(Copy, Clone)]
342#[repr(C)]
343pub struct AstalGreetStartSession {
344 pub parent_instance: AstalGreetRequest,
345 pub priv_: *mut AstalGreetStartSessionPrivate,
346}
347
348impl ::std::fmt::Debug for AstalGreetStartSession {
349 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
350 f.debug_struct(&format!("AstalGreetStartSession @ {self:p}"))
351 .finish()
352 }
353}
354
355#[derive(Copy, Clone)]
356#[repr(C)]
357pub struct AstalGreetSuccess {
358 pub parent_instance: AstalGreetResponse,
359 pub priv_: *mut AstalGreetSuccessPrivate,
360}
361
362impl ::std::fmt::Debug for AstalGreetSuccess {
363 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
364 f.debug_struct(&format!("AstalGreetSuccess @ {self:p}"))
365 .finish()
366 }
367}
368
369extern "C" {
370
371 pub fn astal_greet_auth_message_type_get_type() -> GType;
375
376 pub fn astal_greet_error_type_get_type() -> GType;
380
381 pub fn astal_greet_auth_message_get_type() -> GType;
385 pub fn astal_greet_auth_message_get_message_type(self_: *mut AstalGreetAuthMessage) -> AstalGreetAuthMessageType;
386 pub fn astal_greet_auth_message_get_message(self_: *mut AstalGreetAuthMessage) -> *const c_char;
387
388 pub fn astal_greet_cancel_session_get_type() -> GType;
392 pub fn astal_greet_cancel_session_new() -> *mut AstalGreetCancelSession;
393
394 pub fn astal_greet_create_session_get_type() -> GType;
398 pub fn astal_greet_create_session_new(username: *const c_char) -> *mut AstalGreetCreateSession;
399 pub fn astal_greet_create_session_get_username(self_: *mut AstalGreetCreateSession) -> *const c_char;
400 pub fn astal_greet_create_session_set_username(self_: *mut AstalGreetCreateSession, value: *const c_char);
401
402 pub fn astal_greet_error_get_type() -> GType;
406 pub fn astal_greet_error_get_error_type(self_: *mut AstalGreetError) -> AstalGreetErrorType;
407 pub fn astal_greet_error_get_description(self_: *mut AstalGreetError) -> *const c_char;
408
409 pub fn astal_greet_post_auth_messsage_get_type() -> GType;
413 pub fn astal_greet_post_auth_messsage_new(response: *const c_char) -> *mut AstalGreetPostAuthMesssage;
414 pub fn astal_greet_post_auth_messsage_get_response(self_: *mut AstalGreetPostAuthMesssage) -> *const c_char;
415 pub fn astal_greet_post_auth_messsage_set_response(self_: *mut AstalGreetPostAuthMesssage, value: *const c_char);
416
417 pub fn astal_greet_request_get_type() -> GType;
421 pub fn astal_greet_request_send(self_: *mut AstalGreetRequest, _callback_: gio::GAsyncReadyCallback, _callback__target: *mut c_void);
422 pub fn astal_greet_request_send_finish(self_: *mut AstalGreetRequest, _res_: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut AstalGreetResponse;
423 pub fn astal_greet_request_get_type_name(self_: *mut AstalGreetRequest) -> *const c_char;
424
425 pub fn astal_greet_response_get_type() -> GType;
429
430 pub fn astal_greet_start_session_get_type() -> GType;
434 pub fn astal_greet_start_session_new(cmd: *mut *mut c_char, cmd_length1: c_int, env: *mut *mut c_char, env_length1: c_int) -> *mut AstalGreetStartSession;
435 pub fn astal_greet_start_session_get_cmd(self_: *mut AstalGreetStartSession, result_length1: *mut c_int) -> *mut *mut c_char;
436 pub fn astal_greet_start_session_set_cmd(self_: *mut AstalGreetStartSession, value: *mut *mut c_char, value_length1: c_int);
437 pub fn astal_greet_start_session_get_env(self_: *mut AstalGreetStartSession, result_length1: *mut c_int) -> *mut *mut c_char;
438 pub fn astal_greet_start_session_set_env(self_: *mut AstalGreetStartSession, value: *mut *mut c_char, value_length1: c_int);
439
440 pub fn astal_greet_success_get_type() -> GType;
444
445 pub fn astal_greet_login(username: *const c_char, password: *const c_char, cmd: *const c_char, _callback_: gio::GAsyncReadyCallback, _callback__target: *mut c_void);
449 pub fn astal_greet_login_finish(_res_: *mut gio::GAsyncResult, error: *mut *mut glib::GError);
450 pub fn astal_greet_login_with_env(username: *const c_char, password: *const c_char, cmd: *const c_char, env: *mut *mut c_char, env_length1: c_int, _callback_: gio::GAsyncReadyCallback, _callback__target: *mut c_void);
451 pub fn astal_greet_login_with_env_finish(_res_: *mut gio::GAsyncResult, error: *mut *mut glib::GError);
452
453}