1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8    clippy::approx_constant,
9    clippy::type_complexity,
10    clippy::unreadable_literal,
11    clippy::upper_case_acronyms
12)]
13#![cfg_attr(feature = "dox", feature(doc_cfg))]
14
15#[allow(unused_imports)]
16use libc::{
17    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
18    intptr_t, size_t, ssize_t, uintptr_t, FILE,
19};
20
21#[allow(unused_imports)]
22use glib::{gboolean, gconstpointer, gpointer, GType};
23
24pub type FlatpakError = c_int;
26pub const FLATPAK_ERROR_ALREADY_INSTALLED: FlatpakError = 0;
27pub const FLATPAK_ERROR_NOT_INSTALLED: FlatpakError = 1;
28pub const FLATPAK_ERROR_ONLY_PULLED: FlatpakError = 2;
29pub const FLATPAK_ERROR_DIFFERENT_REMOTE: FlatpakError = 3;
30pub const FLATPAK_ERROR_ABORTED: FlatpakError = 4;
31pub const FLATPAK_ERROR_SKIPPED: FlatpakError = 5;
32pub const FLATPAK_ERROR_NEED_NEW_FLATPAK: FlatpakError = 6;
33pub const FLATPAK_ERROR_REMOTE_NOT_FOUND: FlatpakError = 7;
34pub const FLATPAK_ERROR_RUNTIME_NOT_FOUND: FlatpakError = 8;
35pub const FLATPAK_ERROR_DOWNGRADE: FlatpakError = 9;
36pub const FLATPAK_ERROR_INVALID_REF: FlatpakError = 10;
37pub const FLATPAK_ERROR_INVALID_DATA: FlatpakError = 11;
38pub const FLATPAK_ERROR_UNTRUSTED: FlatpakError = 12;
39pub const FLATPAK_ERROR_SETUP_FAILED: FlatpakError = 13;
40pub const FLATPAK_ERROR_EXPORT_FAILED: FlatpakError = 14;
41pub const FLATPAK_ERROR_REMOTE_USED: FlatpakError = 15;
42pub const FLATPAK_ERROR_RUNTIME_USED: FlatpakError = 16;
43pub const FLATPAK_ERROR_INVALID_NAME: FlatpakError = 17;
44pub const FLATPAK_ERROR_OUT_OF_SPACE: FlatpakError = 18;
45pub const FLATPAK_ERROR_WRONG_USER: FlatpakError = 19;
46pub const FLATPAK_ERROR_NOT_CACHED: FlatpakError = 20;
47pub const FLATPAK_ERROR_REF_NOT_FOUND: FlatpakError = 21;
48pub const FLATPAK_ERROR_PERMISSION_DENIED: FlatpakError = 22;
49pub const FLATPAK_ERROR_AUTHENTICATION_FAILED: FlatpakError = 23;
50pub const FLATPAK_ERROR_NOT_AUTHORIZED: FlatpakError = 24;
51
52pub type FlatpakPortalError = c_int;
53pub const FLATPAK_PORTAL_ERROR_FAILED: FlatpakPortalError = 0;
54pub const FLATPAK_PORTAL_ERROR_INVALID_ARGUMENT: FlatpakPortalError = 1;
55pub const FLATPAK_PORTAL_ERROR_NOT_FOUND: FlatpakPortalError = 2;
56pub const FLATPAK_PORTAL_ERROR_EXISTS: FlatpakPortalError = 3;
57pub const FLATPAK_PORTAL_ERROR_NOT_ALLOWED: FlatpakPortalError = 4;
58pub const FLATPAK_PORTAL_ERROR_CANCELLED: FlatpakPortalError = 5;
59pub const FLATPAK_PORTAL_ERROR_WINDOW_DESTROYED: FlatpakPortalError = 6;
60
61pub type FlatpakRefKind = c_int;
62pub const FLATPAK_REF_KIND_APP: FlatpakRefKind = 0;
63pub const FLATPAK_REF_KIND_RUNTIME: FlatpakRefKind = 1;
64
65pub type FlatpakRemoteType = c_int;
66pub const FLATPAK_REMOTE_TYPE_STATIC: FlatpakRemoteType = 0;
67pub const FLATPAK_REMOTE_TYPE_USB: FlatpakRemoteType = 1;
68pub const FLATPAK_REMOTE_TYPE_LAN: FlatpakRemoteType = 2;
69
70pub type FlatpakStorageType = c_int;
71pub const FLATPAK_STORAGE_TYPE_DEFAULT: FlatpakStorageType = 0;
72pub const FLATPAK_STORAGE_TYPE_HARD_DISK: FlatpakStorageType = 1;
73pub const FLATPAK_STORAGE_TYPE_SDCARD: FlatpakStorageType = 2;
74pub const FLATPAK_STORAGE_TYPE_MMC: FlatpakStorageType = 3;
75pub const FLATPAK_STORAGE_TYPE_NETWORK: FlatpakStorageType = 4;
76
77pub type FlatpakTransactionOperationType = c_int;
78pub const FLATPAK_TRANSACTION_OPERATION_INSTALL: FlatpakTransactionOperationType = 0;
79pub const FLATPAK_TRANSACTION_OPERATION_UPDATE: FlatpakTransactionOperationType = 1;
80pub const FLATPAK_TRANSACTION_OPERATION_INSTALL_BUNDLE: FlatpakTransactionOperationType = 2;
81pub const FLATPAK_TRANSACTION_OPERATION_UNINSTALL: FlatpakTransactionOperationType = 3;
82pub const FLATPAK_TRANSACTION_OPERATION_LAST_TYPE: FlatpakTransactionOperationType = 4;
83
84pub type FlatpakTransactionRemoteReason = c_int;
85pub const FLATPAK_TRANSACTION_REMOTE_GENERIC_REPO: FlatpakTransactionRemoteReason = 0;
86pub const FLATPAK_TRANSACTION_REMOTE_RUNTIME_DEPS: FlatpakTransactionRemoteReason = 1;
87
88pub type FlatpakInstallFlags = c_uint;
92pub const FLATPAK_INSTALL_FLAGS_NONE: FlatpakInstallFlags = 0;
93pub const FLATPAK_INSTALL_FLAGS_NO_STATIC_DELTAS: FlatpakInstallFlags = 1;
94pub const FLATPAK_INSTALL_FLAGS_NO_DEPLOY: FlatpakInstallFlags = 4;
95pub const FLATPAK_INSTALL_FLAGS_NO_PULL: FlatpakInstallFlags = 8;
96pub const FLATPAK_INSTALL_FLAGS_NO_TRIGGERS: FlatpakInstallFlags = 16;
97
98pub type FlatpakLaunchFlags = c_uint;
99pub const FLATPAK_LAUNCH_FLAGS_NONE: FlatpakLaunchFlags = 0;
100pub const FLATPAK_LAUNCH_FLAGS_DO_NOT_REAP: FlatpakLaunchFlags = 1;
101
102pub type FlatpakQueryFlags = c_uint;
103pub const FLATPAK_QUERY_FLAGS_NONE: FlatpakQueryFlags = 0;
104pub const FLATPAK_QUERY_FLAGS_ONLY_CACHED: FlatpakQueryFlags = 1;
105pub const FLATPAK_QUERY_FLAGS_ONLY_SIDELOADED: FlatpakQueryFlags = 2;
106
107pub type FlatpakTransactionErrorDetails = c_uint;
108pub const FLATPAK_TRANSACTION_ERROR_DETAILS_NON_FATAL: FlatpakTransactionErrorDetails = 1;
109
110pub type FlatpakTransactionResult = c_uint;
111pub const FLATPAK_TRANSACTION_RESULT_NO_CHANGE: FlatpakTransactionResult = 1;
112
113pub type FlatpakUninstallFlags = c_uint;
114pub const FLATPAK_UNINSTALL_FLAGS_NONE: FlatpakUninstallFlags = 0;
115pub const FLATPAK_UNINSTALL_FLAGS_NO_PRUNE: FlatpakUninstallFlags = 1;
116pub const FLATPAK_UNINSTALL_FLAGS_NO_TRIGGERS: FlatpakUninstallFlags = 2;
117
118pub type FlatpakUpdateFlags = c_uint;
119pub const FLATPAK_UPDATE_FLAGS_NONE: FlatpakUpdateFlags = 0;
120pub const FLATPAK_UPDATE_FLAGS_NO_DEPLOY: FlatpakUpdateFlags = 1;
121pub const FLATPAK_UPDATE_FLAGS_NO_PULL: FlatpakUpdateFlags = 2;
122pub const FLATPAK_UPDATE_FLAGS_NO_STATIC_DELTAS: FlatpakUpdateFlags = 4;
123pub const FLATPAK_UPDATE_FLAGS_NO_PRUNE: FlatpakUpdateFlags = 8;
124pub const FLATPAK_UPDATE_FLAGS_NO_TRIGGERS: FlatpakUpdateFlags = 16;
125
126pub type FlatpakProgressCallback =
128    Option<unsafe extern "C" fn(*const c_char, c_uint, gboolean, gpointer)>;
129
130#[derive(Copy, Clone)]
132#[repr(C)]
133pub struct FlatpakBundleRefClass {
134    pub parent_class: FlatpakRefClass,
135}
136
137impl ::std::fmt::Debug for FlatpakBundleRefClass {
138    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
139        f.debug_struct(&format!("FlatpakBundleRefClass @ {:p}", self))
140            .field("parent_class", &self.parent_class)
141            .finish()
142    }
143}
144
145#[derive(Copy, Clone)]
146#[repr(C)]
147pub struct FlatpakInstallationClass {
148    pub parent_class: gobject::GObjectClass,
149}
150
151impl ::std::fmt::Debug for FlatpakInstallationClass {
152    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
153        f.debug_struct(&format!("FlatpakInstallationClass @ {:p}", self))
154            .field("parent_class", &self.parent_class)
155            .finish()
156    }
157}
158
159#[derive(Copy, Clone)]
160#[repr(C)]
161pub struct FlatpakInstalledRefClass {
162    pub parent_class: FlatpakRefClass,
163}
164
165impl ::std::fmt::Debug for FlatpakInstalledRefClass {
166    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
167        f.debug_struct(&format!("FlatpakInstalledRefClass @ {:p}", self))
168            .field("parent_class", &self.parent_class)
169            .finish()
170    }
171}
172
173#[derive(Copy, Clone)]
174#[repr(C)]
175pub struct FlatpakInstanceClass {
176    pub parent_class: gobject::GObjectClass,
177}
178
179impl ::std::fmt::Debug for FlatpakInstanceClass {
180    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
181        f.debug_struct(&format!("FlatpakInstanceClass @ {:p}", self))
182            .field("parent_class", &self.parent_class)
183            .finish()
184    }
185}
186
187#[derive(Copy, Clone)]
188#[repr(C)]
189pub struct FlatpakRefClass {
190    pub parent_class: gobject::GObjectClass,
191}
192
193impl ::std::fmt::Debug for FlatpakRefClass {
194    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
195        f.debug_struct(&format!("FlatpakRefClass @ {:p}", self))
196            .field("parent_class", &self.parent_class)
197            .finish()
198    }
199}
200
201#[derive(Copy, Clone)]
202#[repr(C)]
203pub struct FlatpakRelatedRefClass {
204    pub parent_class: FlatpakRefClass,
205}
206
207impl ::std::fmt::Debug for FlatpakRelatedRefClass {
208    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
209        f.debug_struct(&format!("FlatpakRelatedRefClass @ {:p}", self))
210            .field("parent_class", &self.parent_class)
211            .finish()
212    }
213}
214
215#[derive(Copy, Clone)]
216#[repr(C)]
217pub struct FlatpakRemoteClass {
218    pub parent_class: gobject::GObjectClass,
219}
220
221impl ::std::fmt::Debug for FlatpakRemoteClass {
222    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
223        f.debug_struct(&format!("FlatpakRemoteClass @ {:p}", self))
224            .field("parent_class", &self.parent_class)
225            .finish()
226    }
227}
228
229#[derive(Copy, Clone)]
230#[repr(C)]
231pub struct FlatpakRemoteRefClass {
232    pub parent_class: FlatpakRefClass,
233}
234
235impl ::std::fmt::Debug for FlatpakRemoteRefClass {
236    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
237        f.debug_struct(&format!("FlatpakRemoteRefClass @ {:p}", self))
238            .field("parent_class", &self.parent_class)
239            .finish()
240    }
241}
242
243#[derive(Copy, Clone)]
244#[repr(C)]
245pub struct FlatpakTransactionClass {
246    pub parent_class: gobject::GObjectClass,
247    pub new_operation: Option<
248        unsafe extern "C" fn(
249            *mut FlatpakTransaction,
250            *mut FlatpakTransactionOperation,
251            *mut FlatpakTransactionProgress,
252        ),
253    >,
254    pub operation_done: Option<
255        unsafe extern "C" fn(
256            *mut FlatpakTransaction,
257            *mut FlatpakTransactionOperation,
258            *const c_char,
259            FlatpakTransactionResult,
260        ),
261    >,
262    pub operation_error: Option<
263        unsafe extern "C" fn(
264            *mut FlatpakTransaction,
265            *mut FlatpakTransactionOperation,
266            *const glib::GError,
267            FlatpakTransactionErrorDetails,
268        ) -> gboolean,
269    >,
270    pub choose_remote_for_ref: Option<
271        unsafe extern "C" fn(
272            *mut FlatpakTransaction,
273            *const c_char,
274            *const c_char,
275            *const *const c_char,
276        ) -> c_int,
277    >,
278    pub end_of_lifed: Option<
279        unsafe extern "C" fn(*mut FlatpakTransaction, *const c_char, *const c_char, *const c_char),
280    >,
281    pub ready: Option<unsafe extern "C" fn(*mut FlatpakTransaction) -> gboolean>,
282    pub add_new_remote: Option<
283        unsafe extern "C" fn(
284            *mut FlatpakTransaction,
285            FlatpakTransactionRemoteReason,
286            *const c_char,
287            *const c_char,
288            *const c_char,
289        ) -> gboolean,
290    >,
291    pub run: Option<
292        unsafe extern "C" fn(
293            *mut FlatpakTransaction,
294            *mut gio::GCancellable,
295            *mut *mut glib::GError,
296        ) -> gboolean,
297    >,
298    pub end_of_lifed_with_rebase: Option<
299        unsafe extern "C" fn(
300            *mut FlatpakTransaction,
301            *const c_char,
302            *const c_char,
303            *const c_char,
304            *const c_char,
305            *mut *const c_char,
306        ) -> gboolean,
307    >,
308    pub webflow_start: Option<
309        unsafe extern "C" fn(
310            *mut FlatpakTransaction,
311            *const c_char,
312            *const c_char,
313            *mut glib::GVariant,
314            c_uint,
315        ) -> gboolean,
316    >,
317    pub webflow_done:
318        Option<unsafe extern "C" fn(*mut FlatpakTransaction, *mut glib::GVariant, c_uint)>,
319    pub basic_auth_start: Option<
320        unsafe extern "C" fn(
321            *mut FlatpakTransaction,
322            *const c_char,
323            *const c_char,
324            *mut glib::GVariant,
325            c_uint,
326        ) -> gboolean,
327    >,
328    pub install_authenticator:
329        Option<unsafe extern "C" fn(*mut FlatpakTransaction, *const c_char, *const c_char)>,
330    pub padding: [gpointer; 4],
331}
332
333impl ::std::fmt::Debug for FlatpakTransactionClass {
334    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
335        f.debug_struct(&format!("FlatpakTransactionClass @ {:p}", self))
336            .field("parent_class", &self.parent_class)
337            .field("new_operation", &self.new_operation)
338            .field("operation_done", &self.operation_done)
339            .field("operation_error", &self.operation_error)
340            .field("choose_remote_for_ref", &self.choose_remote_for_ref)
341            .field("end_of_lifed", &self.end_of_lifed)
342            .field("ready", &self.ready)
343            .field("add_new_remote", &self.add_new_remote)
344            .field("run", &self.run)
345            .field("end_of_lifed_with_rebase", &self.end_of_lifed_with_rebase)
346            .field("webflow_start", &self.webflow_start)
347            .field("webflow_done", &self.webflow_done)
348            .field("basic_auth_start", &self.basic_auth_start)
349            .field("install_authenticator", &self.install_authenticator)
350            .field("padding", &self.padding)
351            .finish()
352    }
353}
354
355#[derive(Copy, Clone)]
356#[repr(C)]
357pub struct FlatpakTransactionOperationClass {
358    pub parent_class: gobject::GObjectClass,
359}
360
361impl ::std::fmt::Debug for FlatpakTransactionOperationClass {
362    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
363        f.debug_struct(&format!("FlatpakTransactionOperationClass @ {:p}", self))
364            .field("parent_class", &self.parent_class)
365            .finish()
366    }
367}
368
369#[derive(Copy, Clone)]
370#[repr(C)]
371pub struct FlatpakTransactionProgressClass {
372    pub parent_class: gobject::GObjectClass,
373}
374
375impl ::std::fmt::Debug for FlatpakTransactionProgressClass {
376    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
377        f.debug_struct(&format!("FlatpakTransactionProgressClass @ {:p}", self))
378            .field("parent_class", &self.parent_class)
379            .finish()
380    }
381}
382
383#[derive(Copy, Clone)]
385#[repr(C)]
386pub struct FlatpakBundleRef {
387    pub parent: FlatpakRef,
388}
389
390impl ::std::fmt::Debug for FlatpakBundleRef {
391    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
392        f.debug_struct(&format!("FlatpakBundleRef @ {:p}", self))
393            .field("parent", &self.parent)
394            .finish()
395    }
396}
397
398#[derive(Copy, Clone)]
399#[repr(C)]
400pub struct FlatpakInstallation {
401    pub parent: gobject::GObject,
402}
403
404impl ::std::fmt::Debug for FlatpakInstallation {
405    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
406        f.debug_struct(&format!("FlatpakInstallation @ {:p}", self))
407            .field("parent", &self.parent)
408            .finish()
409    }
410}
411
412#[derive(Copy, Clone)]
413#[repr(C)]
414pub struct FlatpakInstalledRef {
415    pub parent: FlatpakRef,
416}
417
418impl ::std::fmt::Debug for FlatpakInstalledRef {
419    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
420        f.debug_struct(&format!("FlatpakInstalledRef @ {:p}", self))
421            .field("parent", &self.parent)
422            .finish()
423    }
424}
425
426#[derive(Copy, Clone)]
427#[repr(C)]
428pub struct FlatpakInstance {
429    pub parent: gobject::GObject,
430}
431
432impl ::std::fmt::Debug for FlatpakInstance {
433    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
434        f.debug_struct(&format!("FlatpakInstance @ {:p}", self))
435            .field("parent", &self.parent)
436            .finish()
437    }
438}
439
440#[derive(Copy, Clone)]
441#[repr(C)]
442pub struct FlatpakRef {
443    pub parent: gobject::GObject,
444}
445
446impl ::std::fmt::Debug for FlatpakRef {
447    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
448        f.debug_struct(&format!("FlatpakRef @ {:p}", self))
449            .field("parent", &self.parent)
450            .finish()
451    }
452}
453
454#[derive(Copy, Clone)]
455#[repr(C)]
456pub struct FlatpakRelatedRef {
457    pub parent: FlatpakRef,
458}
459
460impl ::std::fmt::Debug for FlatpakRelatedRef {
461    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
462        f.debug_struct(&format!("FlatpakRelatedRef @ {:p}", self))
463            .field("parent", &self.parent)
464            .finish()
465    }
466}
467
468#[derive(Copy, Clone)]
469#[repr(C)]
470pub struct FlatpakRemote {
471    pub parent: gobject::GObject,
472}
473
474impl ::std::fmt::Debug for FlatpakRemote {
475    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
476        f.debug_struct(&format!("FlatpakRemote @ {:p}", self))
477            .field("parent", &self.parent)
478            .finish()
479    }
480}
481
482#[derive(Copy, Clone)]
483#[repr(C)]
484pub struct FlatpakRemoteRef {
485    pub parent: FlatpakRef,
486}
487
488impl ::std::fmt::Debug for FlatpakRemoteRef {
489    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
490        f.debug_struct(&format!("FlatpakRemoteRef @ {:p}", self))
491            .field("parent", &self.parent)
492            .finish()
493    }
494}
495
496#[derive(Copy, Clone)]
497#[repr(C)]
498pub struct FlatpakTransaction {
499    pub parent_instance: gobject::GObject,
500}
501
502impl ::std::fmt::Debug for FlatpakTransaction {
503    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
504        f.debug_struct(&format!("FlatpakTransaction @ {:p}", self))
505            .field("parent_instance", &self.parent_instance)
506            .finish()
507    }
508}
509
510#[repr(C)]
511pub struct FlatpakTransactionOperation {
512    _data: [u8; 0],
513    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
514}
515
516impl ::std::fmt::Debug for FlatpakTransactionOperation {
517    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
518        f.debug_struct(&format!("FlatpakTransactionOperation @ {:p}", self))
519            .finish()
520    }
521}
522
523#[repr(C)]
524pub struct FlatpakTransactionProgress {
525    _data: [u8; 0],
526    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
527}
528
529impl ::std::fmt::Debug for FlatpakTransactionProgress {
530    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
531        f.debug_struct(&format!("FlatpakTransactionProgress @ {:p}", self))
532            .finish()
533    }
534}
535
536#[link(name = "flatpak")]
537extern "C" {
538
539    pub fn flatpak_error_get_type() -> GType;
543    pub fn flatpak_error_quark() -> glib::GQuark;
544
545    pub fn flatpak_portal_error_get_type() -> GType;
549    pub fn flatpak_portal_error_quark() -> glib::GQuark;
550
551    pub fn flatpak_ref_kind_get_type() -> GType;
555
556    pub fn flatpak_remote_type_get_type() -> GType;
560
561    #[cfg(any(feature = "v0_6_15", feature = "dox"))]
565    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_6_15")))]
566    pub fn flatpak_storage_type_get_type() -> GType;
567
568    pub fn flatpak_transaction_operation_type_get_type() -> GType;
572    pub fn flatpak_transaction_operation_type_to_string(
573        kind: FlatpakTransactionOperationType,
574    ) -> *const c_char;
575
576    pub fn flatpak_transaction_remote_reason_get_type() -> GType;
580
581    pub fn flatpak_install_flags_get_type() -> GType;
585
586    pub fn flatpak_launch_flags_get_type() -> GType;
590
591    #[cfg(any(feature = "v1_3_3", feature = "dox"))]
595    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
596    pub fn flatpak_query_flags_get_type() -> GType;
597
598    pub fn flatpak_transaction_error_details_get_type() -> GType;
602
603    pub fn flatpak_transaction_result_get_type() -> GType;
607
608    #[cfg(any(feature = "v0_11_8", feature = "dox"))]
612    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_11_8")))]
613    pub fn flatpak_uninstall_flags_get_type() -> GType;
614
615    pub fn flatpak_update_flags_get_type() -> GType;
619
620    pub fn flatpak_bundle_ref_get_type() -> GType;
624    pub fn flatpak_bundle_ref_new(
625        file: *mut gio::GFile,
626        error: *mut *mut glib::GError,
627    ) -> *mut FlatpakBundleRef;
628    pub fn flatpak_bundle_ref_get_appstream(self_: *mut FlatpakBundleRef) -> *mut glib::GBytes;
629    pub fn flatpak_bundle_ref_get_file(self_: *mut FlatpakBundleRef) -> *mut gio::GFile;
630    pub fn flatpak_bundle_ref_get_icon(
631        self_: *mut FlatpakBundleRef,
632        size: c_int,
633    ) -> *mut glib::GBytes;
634    pub fn flatpak_bundle_ref_get_installed_size(self_: *mut FlatpakBundleRef) -> u64;
635    pub fn flatpak_bundle_ref_get_metadata(self_: *mut FlatpakBundleRef) -> *mut glib::GBytes;
636    pub fn flatpak_bundle_ref_get_origin(self_: *mut FlatpakBundleRef) -> *mut c_char;
637    #[cfg(any(feature = "v0_8", feature = "dox"))]
638    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8")))]
639    pub fn flatpak_bundle_ref_get_runtime_repo_url(self_: *mut FlatpakBundleRef) -> *mut c_char;
640
641    pub fn flatpak_installation_get_type() -> GType;
645    pub fn flatpak_installation_new_for_path(
646        path: *mut gio::GFile,
647        user: gboolean,
648        cancellable: *mut gio::GCancellable,
649        error: *mut *mut glib::GError,
650    ) -> *mut FlatpakInstallation;
651    pub fn flatpak_installation_new_system(
652        cancellable: *mut gio::GCancellable,
653        error: *mut *mut glib::GError,
654    ) -> *mut FlatpakInstallation;
655    #[cfg(any(feature = "v0_8", feature = "dox"))]
656    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8")))]
657    pub fn flatpak_installation_new_system_with_id(
658        id: *const c_char,
659        cancellable: *mut gio::GCancellable,
660        error: *mut *mut glib::GError,
661    ) -> *mut FlatpakInstallation;
662    pub fn flatpak_installation_new_user(
663        cancellable: *mut gio::GCancellable,
664        error: *mut *mut glib::GError,
665    ) -> *mut FlatpakInstallation;
666    #[cfg(any(feature = "v1_3_4", feature = "dox"))]
667    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_4")))]
668    pub fn flatpak_installation_add_remote(
669        self_: *mut FlatpakInstallation,
670        remote: *mut FlatpakRemote,
671        if_needed: gboolean,
672        cancellable: *mut gio::GCancellable,
673        error: *mut *mut glib::GError,
674    ) -> gboolean;
675    #[cfg(any(feature = "v0_10", feature = "dox"))]
676    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_10")))]
677    pub fn flatpak_installation_cleanup_local_refs_sync(
678        self_: *mut FlatpakInstallation,
679        cancellable: *mut gio::GCancellable,
680        error: *mut *mut glib::GError,
681    ) -> gboolean;
682    pub fn flatpak_installation_create_monitor(
683        self_: *mut FlatpakInstallation,
684        cancellable: *mut gio::GCancellable,
685        error: *mut *mut glib::GError,
686    ) -> *mut gio::GFileMonitor;
687    pub fn flatpak_installation_drop_caches(
688        self_: *mut FlatpakInstallation,
689        cancellable: *mut gio::GCancellable,
690        error: *mut *mut glib::GError,
691    ) -> gboolean;
692    pub fn flatpak_installation_fetch_remote_metadata_sync(
693        self_: *mut FlatpakInstallation,
694        remote_name: *const c_char,
695        ref_: *mut FlatpakRef,
696        cancellable: *mut gio::GCancellable,
697        error: *mut *mut glib::GError,
698    ) -> *mut glib::GBytes;
699    pub fn flatpak_installation_fetch_remote_ref_sync(
700        self_: *mut FlatpakInstallation,
701        remote_name: *const c_char,
702        kind: FlatpakRefKind,
703        name: *const c_char,
704        arch: *const c_char,
705        branch: *const c_char,
706        cancellable: *mut gio::GCancellable,
707        error: *mut *mut glib::GError,
708    ) -> *mut FlatpakRemoteRef;
709    #[cfg(any(feature = "v1_3_3", feature = "dox"))]
710    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
711    pub fn flatpak_installation_fetch_remote_ref_sync_full(
712        self_: *mut FlatpakInstallation,
713        remote_name: *const c_char,
714        kind: FlatpakRefKind,
715        name: *const c_char,
716        arch: *const c_char,
717        branch: *const c_char,
718        flags: FlatpakQueryFlags,
719        cancellable: *mut gio::GCancellable,
720        error: *mut *mut glib::GError,
721    ) -> *mut FlatpakRemoteRef;
722    pub fn flatpak_installation_fetch_remote_size_sync(
723        self_: *mut FlatpakInstallation,
724        remote_name: *const c_char,
725        ref_: *mut FlatpakRef,
726        download_size: *mut u64,
727        installed_size: *mut u64,
728        cancellable: *mut gio::GCancellable,
729        error: *mut *mut glib::GError,
730    ) -> gboolean;
731    pub fn flatpak_installation_get_config(
732        self_: *mut FlatpakInstallation,
733        key: *const c_char,
734        cancellable: *mut gio::GCancellable,
735        error: *mut *mut glib::GError,
736    ) -> *mut c_char;
737    pub fn flatpak_installation_get_current_installed_app(
738        self_: *mut FlatpakInstallation,
739        name: *const c_char,
740        cancellable: *mut gio::GCancellable,
741        error: *mut *mut glib::GError,
742    ) -> *mut FlatpakInstalledRef;
743    #[cfg(any(feature = "v1_5", feature = "dox"))]
744    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_5")))]
745    pub fn flatpak_installation_get_default_languages(
746        self_: *mut FlatpakInstallation,
747        error: *mut *mut glib::GError,
748    ) -> *mut *mut c_char;
749    #[cfg(any(feature = "v1_5_1", feature = "dox"))]
750    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_5_1")))]
751    pub fn flatpak_installation_get_default_locales(
752        self_: *mut FlatpakInstallation,
753        error: *mut *mut glib::GError,
754    ) -> *mut *mut c_char;
755    #[cfg(any(feature = "v0_8", feature = "dox"))]
756    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8")))]
757    pub fn flatpak_installation_get_display_name(self_: *mut FlatpakInstallation) -> *const c_char;
758    #[cfg(any(feature = "v0_8", feature = "dox"))]
759    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8")))]
760    pub fn flatpak_installation_get_id(self_: *mut FlatpakInstallation) -> *const c_char;
761    pub fn flatpak_installation_get_installed_ref(
762        self_: *mut FlatpakInstallation,
763        kind: FlatpakRefKind,
764        name: *const c_char,
765        arch: *const c_char,
766        branch: *const c_char,
767        cancellable: *mut gio::GCancellable,
768        error: *mut *mut glib::GError,
769    ) -> *mut FlatpakInstalledRef;
770    pub fn flatpak_installation_get_is_user(self_: *mut FlatpakInstallation) -> gboolean;
771    #[cfg(any(feature = "v1_1", feature = "dox"))]
772    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
773    pub fn flatpak_installation_get_min_free_space_bytes(
774        self_: *mut FlatpakInstallation,
775        out_bytes: *mut u64,
776        error: *mut *mut glib::GError,
777    ) -> gboolean;
778    #[cfg(any(feature = "v1_1_1", feature = "dox"))]
779    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_1")))]
780    pub fn flatpak_installation_get_no_interaction(self_: *mut FlatpakInstallation) -> gboolean;
781    pub fn flatpak_installation_get_path(self_: *mut FlatpakInstallation) -> *mut gio::GFile;
782    #[cfg(any(feature = "v0_8", feature = "dox"))]
783    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8")))]
784    pub fn flatpak_installation_get_priority(self_: *mut FlatpakInstallation) -> c_int;
785    pub fn flatpak_installation_get_remote_by_name(
786        self_: *mut FlatpakInstallation,
787        name: *const c_char,
788        cancellable: *mut gio::GCancellable,
789        error: *mut *mut glib::GError,
790    ) -> *mut FlatpakRemote;
791    #[cfg(any(feature = "v0_8", feature = "dox"))]
792    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8")))]
793    pub fn flatpak_installation_get_storage_type(
794        self_: *mut FlatpakInstallation,
795    ) -> FlatpakStorageType;
796    pub fn flatpak_installation_install(
797        self_: *mut FlatpakInstallation,
798        remote_name: *const c_char,
799        kind: FlatpakRefKind,
800        name: *const c_char,
801        arch: *const c_char,
802        branch: *const c_char,
803        progress: FlatpakProgressCallback,
804        progress_data: gpointer,
805        cancellable: *mut gio::GCancellable,
806        error: *mut *mut glib::GError,
807    ) -> *mut FlatpakInstalledRef;
808    pub fn flatpak_installation_install_bundle(
809        self_: *mut FlatpakInstallation,
810        file: *mut gio::GFile,
811        progress: FlatpakProgressCallback,
812        progress_data: gpointer,
813        cancellable: *mut gio::GCancellable,
814        error: *mut *mut glib::GError,
815    ) -> *mut FlatpakInstalledRef;
816    pub fn flatpak_installation_install_full(
817        self_: *mut FlatpakInstallation,
818        flags: FlatpakInstallFlags,
819        remote_name: *const c_char,
820        kind: FlatpakRefKind,
821        name: *const c_char,
822        arch: *const c_char,
823        branch: *const c_char,
824        subpaths: *const *const c_char,
825        progress: FlatpakProgressCallback,
826        progress_data: gpointer,
827        cancellable: *mut gio::GCancellable,
828        error: *mut *mut glib::GError,
829    ) -> *mut FlatpakInstalledRef;
830    #[cfg(any(feature = "v0_6_10", feature = "dox"))]
831    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_6_10")))]
832    pub fn flatpak_installation_install_ref_file(
833        self_: *mut FlatpakInstallation,
834        ref_file_data: *mut glib::GBytes,
835        cancellable: *mut gio::GCancellable,
836        error: *mut *mut glib::GError,
837    ) -> *mut FlatpakRemoteRef;
838    pub fn flatpak_installation_launch(
839        self_: *mut FlatpakInstallation,
840        name: *const c_char,
841        arch: *const c_char,
842        branch: *const c_char,
843        commit: *const c_char,
844        cancellable: *mut gio::GCancellable,
845        error: *mut *mut glib::GError,
846    ) -> gboolean;
847    #[cfg(any(feature = "v1_1", feature = "dox"))]
848    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
849    pub fn flatpak_installation_launch_full(
850        self_: *mut FlatpakInstallation,
851        flags: FlatpakLaunchFlags,
852        name: *const c_char,
853        arch: *const c_char,
854        branch: *const c_char,
855        commit: *const c_char,
856        instance_out: *mut *mut FlatpakInstance,
857        cancellable: *mut gio::GCancellable,
858        error: *mut *mut glib::GError,
859    ) -> gboolean;
860    pub fn flatpak_installation_list_installed_refs(
861        self_: *mut FlatpakInstallation,
862        cancellable: *mut gio::GCancellable,
863        error: *mut *mut glib::GError,
864    ) -> *mut glib::GPtrArray;
865    pub fn flatpak_installation_list_installed_refs_by_kind(
866        self_: *mut FlatpakInstallation,
867        kind: FlatpakRefKind,
868        cancellable: *mut gio::GCancellable,
869        error: *mut *mut glib::GError,
870    ) -> *mut glib::GPtrArray;
871    pub fn flatpak_installation_list_installed_refs_for_update(
872        self_: *mut FlatpakInstallation,
873        cancellable: *mut gio::GCancellable,
874        error: *mut *mut glib::GError,
875    ) -> *mut glib::GPtrArray;
876    #[cfg(any(feature = "v0_6_7", feature = "dox"))]
877    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_6_7")))]
878    pub fn flatpak_installation_list_installed_related_refs_sync(
879        self_: *mut FlatpakInstallation,
880        remote_name: *const c_char,
881        ref_: *const c_char,
882        cancellable: *mut gio::GCancellable,
883        error: *mut *mut glib::GError,
884    ) -> *mut glib::GPtrArray;
885    pub fn flatpak_installation_list_remote_refs_sync(
886        self_: *mut FlatpakInstallation,
887        remote_or_uri: *const c_char,
888        cancellable: *mut gio::GCancellable,
889        error: *mut *mut glib::GError,
890    ) -> *mut glib::GPtrArray;
891    #[cfg(any(feature = "v1_3_3", feature = "dox"))]
892    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
893    pub fn flatpak_installation_list_remote_refs_sync_full(
894        self_: *mut FlatpakInstallation,
895        remote_or_uri: *const c_char,
896        flags: FlatpakQueryFlags,
897        cancellable: *mut gio::GCancellable,
898        error: *mut *mut glib::GError,
899    ) -> *mut glib::GPtrArray;
900    #[cfg(any(feature = "v0_6_7", feature = "dox"))]
901    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_6_7")))]
902    pub fn flatpak_installation_list_remote_related_refs_sync(
903        self_: *mut FlatpakInstallation,
904        remote_name: *const c_char,
905        ref_: *const c_char,
906        cancellable: *mut gio::GCancellable,
907        error: *mut *mut glib::GError,
908    ) -> *mut glib::GPtrArray;
909    pub fn flatpak_installation_list_remotes(
910        self_: *mut FlatpakInstallation,
911        cancellable: *mut gio::GCancellable,
912        error: *mut *mut glib::GError,
913    ) -> *mut glib::GPtrArray;
914    pub fn flatpak_installation_list_remotes_by_type(
915        self_: *mut FlatpakInstallation,
916        types: *const FlatpakRemoteType,
917        num_types: size_t,
918        cancellable: *mut gio::GCancellable,
919        error: *mut *mut glib::GError,
920    ) -> *mut glib::GPtrArray;
921    #[cfg(any(feature = "v1_1_2", feature = "dox"))]
922    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_2")))]
923    pub fn flatpak_installation_list_unused_refs(
924        self_: *mut FlatpakInstallation,
925        arch: *const c_char,
926        cancellable: *mut gio::GCancellable,
927        error: *mut *mut glib::GError,
928    ) -> *mut glib::GPtrArray;
929    pub fn flatpak_installation_load_app_overrides(
930        self_: *mut FlatpakInstallation,
931        app_id: *const c_char,
932        cancellable: *mut gio::GCancellable,
933        error: *mut *mut glib::GError,
934    ) -> *mut c_char;
935    pub fn flatpak_installation_modify_remote(
936        self_: *mut FlatpakInstallation,
937        remote: *mut FlatpakRemote,
938        cancellable: *mut gio::GCancellable,
939        error: *mut *mut glib::GError,
940    ) -> gboolean;
941    #[cfg(any(feature = "v0_10", feature = "dox"))]
942    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_10")))]
943    pub fn flatpak_installation_prune_local_repo(
944        self_: *mut FlatpakInstallation,
945        cancellable: *mut gio::GCancellable,
946        error: *mut *mut glib::GError,
947    ) -> gboolean;
948    #[cfg(any(feature = "v0_10", feature = "dox"))]
949    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_10")))]
950    pub fn flatpak_installation_remove_local_ref_sync(
951        self_: *mut FlatpakInstallation,
952        remote_name: *const c_char,
953        ref_: *const c_char,
954        cancellable: *mut gio::GCancellable,
955        error: *mut *mut glib::GError,
956    ) -> gboolean;
957    pub fn flatpak_installation_remove_remote(
958        self_: *mut FlatpakInstallation,
959        name: *const c_char,
960        cancellable: *mut gio::GCancellable,
961        error: *mut *mut glib::GError,
962    ) -> gboolean;
963    #[cfg(any(feature = "v1_0_3", feature = "dox"))]
964    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_0_3")))]
965    pub fn flatpak_installation_run_triggers(
966        self_: *mut FlatpakInstallation,
967        cancellable: *mut gio::GCancellable,
968        error: *mut *mut glib::GError,
969    ) -> gboolean;
970    pub fn flatpak_installation_set_config_sync(
971        self_: *mut FlatpakInstallation,
972        key: *const c_char,
973        value: *const c_char,
974        cancellable: *mut gio::GCancellable,
975        error: *mut *mut glib::GError,
976    ) -> gboolean;
977    #[cfg(any(feature = "v1_1_1", feature = "dox"))]
978    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_1")))]
979    pub fn flatpak_installation_set_no_interaction(
980        self_: *mut FlatpakInstallation,
981        no_interaction: gboolean,
982    );
983    pub fn flatpak_installation_uninstall(
984        self_: *mut FlatpakInstallation,
985        kind: FlatpakRefKind,
986        name: *const c_char,
987        arch: *const c_char,
988        branch: *const c_char,
989        progress: FlatpakProgressCallback,
990        progress_data: gpointer,
991        cancellable: *mut gio::GCancellable,
992        error: *mut *mut glib::GError,
993    ) -> gboolean;
994    #[cfg(any(feature = "v0_11_8", feature = "dox"))]
995    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_11_8")))]
996    pub fn flatpak_installation_uninstall_full(
997        self_: *mut FlatpakInstallation,
998        flags: FlatpakUninstallFlags,
999        kind: FlatpakRefKind,
1000        name: *const c_char,
1001        arch: *const c_char,
1002        branch: *const c_char,
1003        progress: FlatpakProgressCallback,
1004        progress_data: gpointer,
1005        cancellable: *mut gio::GCancellable,
1006        error: *mut *mut glib::GError,
1007    ) -> gboolean;
1008    pub fn flatpak_installation_update(
1009        self_: *mut FlatpakInstallation,
1010        flags: FlatpakUpdateFlags,
1011        kind: FlatpakRefKind,
1012        name: *const c_char,
1013        arch: *const c_char,
1014        branch: *const c_char,
1015        progress: FlatpakProgressCallback,
1016        progress_data: gpointer,
1017        cancellable: *mut gio::GCancellable,
1018        error: *mut *mut glib::GError,
1019    ) -> *mut FlatpakInstalledRef;
1020    pub fn flatpak_installation_update_appstream_full_sync(
1021        self_: *mut FlatpakInstallation,
1022        remote_name: *const c_char,
1023        arch: *const c_char,
1024        progress: FlatpakProgressCallback,
1025        progress_data: gpointer,
1026        out_changed: *mut gboolean,
1027        cancellable: *mut gio::GCancellable,
1028        error: *mut *mut glib::GError,
1029    ) -> gboolean;
1030    pub fn flatpak_installation_update_appstream_sync(
1031        self_: *mut FlatpakInstallation,
1032        remote_name: *const c_char,
1033        arch: *const c_char,
1034        out_changed: *mut gboolean,
1035        cancellable: *mut gio::GCancellable,
1036        error: *mut *mut glib::GError,
1037    ) -> gboolean;
1038    pub fn flatpak_installation_update_full(
1039        self_: *mut FlatpakInstallation,
1040        flags: FlatpakUpdateFlags,
1041        kind: FlatpakRefKind,
1042        name: *const c_char,
1043        arch: *const c_char,
1044        branch: *const c_char,
1045        subpaths: *const *const c_char,
1046        progress: FlatpakProgressCallback,
1047        progress_data: gpointer,
1048        cancellable: *mut gio::GCancellable,
1049        error: *mut *mut glib::GError,
1050    ) -> *mut FlatpakInstalledRef;
1051    #[cfg(any(feature = "v0_6_13", feature = "dox"))]
1052    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_6_13")))]
1053    pub fn flatpak_installation_update_remote_sync(
1054        self_: *mut FlatpakInstallation,
1055        name: *const c_char,
1056        cancellable: *mut gio::GCancellable,
1057        error: *mut *mut glib::GError,
1058    ) -> gboolean;
1059
1060    pub fn flatpak_installed_ref_get_type() -> GType;
1064    #[cfg(any(feature = "v1_4_2", feature = "dox"))]
1065    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4_2")))]
1066    pub fn flatpak_installed_ref_get_appdata_content_rating(
1067        self_: *mut FlatpakInstalledRef,
1068    ) -> *mut glib::GHashTable;
1069    #[cfg(any(feature = "v1_4_2", feature = "dox"))]
1070    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4_2")))]
1071    pub fn flatpak_installed_ref_get_appdata_content_rating_type(
1072        self_: *mut FlatpakInstalledRef,
1073    ) -> *const c_char;
1074    #[cfg(any(feature = "v1_1_2", feature = "dox"))]
1075    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_2")))]
1076    pub fn flatpak_installed_ref_get_appdata_license(
1077        self_: *mut FlatpakInstalledRef,
1078    ) -> *const c_char;
1079    #[cfg(any(feature = "v1_1_2", feature = "dox"))]
1080    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_2")))]
1081    pub fn flatpak_installed_ref_get_appdata_name(self_: *mut FlatpakInstalledRef)
1082        -> *const c_char;
1083    #[cfg(any(feature = "v1_1_2", feature = "dox"))]
1084    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_2")))]
1085    pub fn flatpak_installed_ref_get_appdata_summary(
1086        self_: *mut FlatpakInstalledRef,
1087    ) -> *const c_char;
1088    #[cfg(any(feature = "v1_1_2", feature = "dox"))]
1089    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_2")))]
1090    pub fn flatpak_installed_ref_get_appdata_version(
1091        self_: *mut FlatpakInstalledRef,
1092    ) -> *const c_char;
1093    pub fn flatpak_installed_ref_get_deploy_dir(self_: *mut FlatpakInstalledRef) -> *const c_char;
1094    pub fn flatpak_installed_ref_get_eol(self_: *mut FlatpakInstalledRef) -> *const c_char;
1095    pub fn flatpak_installed_ref_get_eol_rebase(self_: *mut FlatpakInstalledRef) -> *const c_char;
1096    pub fn flatpak_installed_ref_get_installed_size(self_: *mut FlatpakInstalledRef) -> u64;
1097    pub fn flatpak_installed_ref_get_is_current(self_: *mut FlatpakInstalledRef) -> gboolean;
1098    pub fn flatpak_installed_ref_get_latest_commit(
1099        self_: *mut FlatpakInstalledRef,
1100    ) -> *const c_char;
1101    pub fn flatpak_installed_ref_get_origin(self_: *mut FlatpakInstalledRef) -> *const c_char;
1102    pub fn flatpak_installed_ref_get_subpaths(
1103        self_: *mut FlatpakInstalledRef,
1104    ) -> *const *const c_char;
1105    #[cfg(any(feature = "v1_1_2", feature = "dox"))]
1106    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_2")))]
1107    pub fn flatpak_installed_ref_load_appdata(
1108        self_: *mut FlatpakInstalledRef,
1109        cancellable: *mut gio::GCancellable,
1110        error: *mut *mut glib::GError,
1111    ) -> *mut glib::GBytes;
1112    pub fn flatpak_installed_ref_load_metadata(
1113        self_: *mut FlatpakInstalledRef,
1114        cancellable: *mut gio::GCancellable,
1115        error: *mut *mut glib::GError,
1116    ) -> *mut glib::GBytes;
1117
1118    pub fn flatpak_instance_get_type() -> GType;
1122    #[cfg(any(feature = "v1_1", feature = "dox"))]
1123    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
1124    pub fn flatpak_instance_get_all() -> *mut glib::GPtrArray;
1125    #[cfg(any(feature = "v1_1", feature = "dox"))]
1126    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
1127    pub fn flatpak_instance_get_app(self_: *mut FlatpakInstance) -> *const c_char;
1128    #[cfg(any(feature = "v1_1", feature = "dox"))]
1129    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
1130    pub fn flatpak_instance_get_arch(self_: *mut FlatpakInstance) -> *const c_char;
1131    #[cfg(any(feature = "v1_1", feature = "dox"))]
1132    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
1133    pub fn flatpak_instance_get_branch(self_: *mut FlatpakInstance) -> *const c_char;
1134    #[cfg(any(feature = "v1_1", feature = "dox"))]
1135    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
1136    pub fn flatpak_instance_get_child_pid(self_: *mut FlatpakInstance) -> c_int;
1137    #[cfg(any(feature = "v1_1", feature = "dox"))]
1138    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
1139    pub fn flatpak_instance_get_commit(self_: *mut FlatpakInstance) -> *const c_char;
1140    #[cfg(any(feature = "v1_1", feature = "dox"))]
1141    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
1142    pub fn flatpak_instance_get_id(self_: *mut FlatpakInstance) -> *const c_char;
1143    #[cfg(any(feature = "v1_1", feature = "dox"))]
1144    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
1145    pub fn flatpak_instance_get_info(self_: *mut FlatpakInstance) -> *mut glib::GKeyFile;
1146    #[cfg(any(feature = "v1_1", feature = "dox"))]
1147    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
1148    pub fn flatpak_instance_get_pid(self_: *mut FlatpakInstance) -> c_int;
1149    #[cfg(any(feature = "v1_1", feature = "dox"))]
1150    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
1151    pub fn flatpak_instance_get_runtime(self_: *mut FlatpakInstance) -> *const c_char;
1152    #[cfg(any(feature = "v1_1", feature = "dox"))]
1153    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1")))]
1154    pub fn flatpak_instance_get_runtime_commit(self_: *mut FlatpakInstance) -> *const c_char;
1155    pub fn flatpak_instance_is_running(self_: *mut FlatpakInstance) -> gboolean;
1156
1157    pub fn flatpak_ref_get_type() -> GType;
1161    pub fn flatpak_ref_parse(ref_: *const c_char, error: *mut *mut glib::GError)
1162        -> *mut FlatpakRef;
1163    pub fn flatpak_ref_format_ref(self_: *mut FlatpakRef) -> *mut c_char;
1164    pub fn flatpak_ref_get_arch(self_: *mut FlatpakRef) -> *const c_char;
1165    pub fn flatpak_ref_get_branch(self_: *mut FlatpakRef) -> *const c_char;
1166    pub fn flatpak_ref_get_collection_id(self_: *mut FlatpakRef) -> *const c_char;
1167    pub fn flatpak_ref_get_commit(self_: *mut FlatpakRef) -> *const c_char;
1168    pub fn flatpak_ref_get_kind(self_: *mut FlatpakRef) -> FlatpakRefKind;
1169    pub fn flatpak_ref_get_name(self_: *mut FlatpakRef) -> *const c_char;
1170
1171    pub fn flatpak_related_ref_get_type() -> GType;
1175    #[cfg(any(feature = "v0_6_7", feature = "dox"))]
1176    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_6_7")))]
1177    pub fn flatpak_related_ref_get_subpaths(self_: *mut FlatpakRelatedRef) -> *const *const c_char;
1178    #[cfg(any(feature = "v0_11_8", feature = "dox"))]
1179    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_11_8")))]
1180    pub fn flatpak_related_ref_should_autoprune(self_: *mut FlatpakRelatedRef) -> gboolean;
1181    #[cfg(any(feature = "v0_6_7", feature = "dox"))]
1182    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_6_7")))]
1183    pub fn flatpak_related_ref_should_delete(self_: *mut FlatpakRelatedRef) -> gboolean;
1184    #[cfg(any(feature = "v0_6_7", feature = "dox"))]
1185    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_6_7")))]
1186    pub fn flatpak_related_ref_should_download(self_: *mut FlatpakRelatedRef) -> gboolean;
1187
1188    pub fn flatpak_remote_get_type() -> GType;
1192    pub fn flatpak_remote_new(name: *const c_char) -> *mut FlatpakRemote;
1193    #[cfg(any(feature = "v1_3_4", feature = "dox"))]
1194    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_4")))]
1195    pub fn flatpak_remote_new_from_file(
1196        name: *const c_char,
1197        data: *mut glib::GBytes,
1198        error: *mut *mut glib::GError,
1199    ) -> *mut FlatpakRemote;
1200    pub fn flatpak_remote_get_appstream_dir(
1201        self_: *mut FlatpakRemote,
1202        arch: *const c_char,
1203    ) -> *mut gio::GFile;
1204    pub fn flatpak_remote_get_appstream_timestamp(
1205        self_: *mut FlatpakRemote,
1206        arch: *const c_char,
1207    ) -> *mut gio::GFile;
1208    pub fn flatpak_remote_get_collection_id(self_: *mut FlatpakRemote) -> *mut c_char;
1209    #[cfg(any(feature = "v1_4", feature = "dox"))]
1210    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4")))]
1211    pub fn flatpak_remote_get_comment(self_: *mut FlatpakRemote) -> *mut c_char;
1212    #[cfg(any(feature = "v0_6_12", feature = "dox"))]
1213    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_6_12")))]
1214    pub fn flatpak_remote_get_default_branch(self_: *mut FlatpakRemote) -> *mut c_char;
1215    #[cfg(any(feature = "v1_4", feature = "dox"))]
1216    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4")))]
1217    pub fn flatpak_remote_get_description(self_: *mut FlatpakRemote) -> *mut c_char;
1218    pub fn flatpak_remote_get_disabled(self_: *mut FlatpakRemote) -> gboolean;
1219    #[cfg(any(feature = "v1_4", feature = "dox"))]
1220    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4")))]
1221    pub fn flatpak_remote_get_filter(self_: *mut FlatpakRemote) -> *mut c_char;
1222    pub fn flatpak_remote_get_gpg_verify(self_: *mut FlatpakRemote) -> gboolean;
1223    #[cfg(any(feature = "v1_4", feature = "dox"))]
1224    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4")))]
1225    pub fn flatpak_remote_get_homepage(self_: *mut FlatpakRemote) -> *mut c_char;
1226    #[cfg(any(feature = "v1_4", feature = "dox"))]
1227    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4")))]
1228    pub fn flatpak_remote_get_icon(self_: *mut FlatpakRemote) -> *mut c_char;
1229    #[cfg(any(feature = "v1_1_1", feature = "dox"))]
1230    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_1")))]
1231    pub fn flatpak_remote_get_main_ref(self_: *mut FlatpakRemote) -> *mut c_char;
1232    pub fn flatpak_remote_get_name(self_: *mut FlatpakRemote) -> *const c_char;
1233    pub fn flatpak_remote_get_nodeps(self_: *mut FlatpakRemote) -> gboolean;
1234    pub fn flatpak_remote_get_noenumerate(self_: *mut FlatpakRemote) -> gboolean;
1235    pub fn flatpak_remote_get_prio(self_: *mut FlatpakRemote) -> c_int;
1236    #[cfg(any(feature = "v0_9_8", feature = "dox"))]
1237    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_9_8")))]
1238    pub fn flatpak_remote_get_remote_type(self_: *mut FlatpakRemote) -> FlatpakRemoteType;
1239    pub fn flatpak_remote_get_title(self_: *mut FlatpakRemote) -> *mut c_char;
1240    pub fn flatpak_remote_get_url(self_: *mut FlatpakRemote) -> *mut c_char;
1241    pub fn flatpak_remote_set_collection_id(
1242        self_: *mut FlatpakRemote,
1243        collection_id: *const c_char,
1244    );
1245    #[cfg(any(feature = "v1_4", feature = "dox"))]
1246    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4")))]
1247    pub fn flatpak_remote_set_comment(self_: *mut FlatpakRemote, comment: *const c_char);
1248    #[cfg(any(feature = "v0_6_12", feature = "dox"))]
1249    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_6_12")))]
1250    pub fn flatpak_remote_set_default_branch(
1251        self_: *mut FlatpakRemote,
1252        default_branch: *const c_char,
1253    );
1254    #[cfg(any(feature = "v1_4", feature = "dox"))]
1255    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4")))]
1256    pub fn flatpak_remote_set_description(self_: *mut FlatpakRemote, description: *const c_char);
1257    pub fn flatpak_remote_set_disabled(self_: *mut FlatpakRemote, disabled: gboolean);
1258    #[cfg(any(feature = "v1_4", feature = "dox"))]
1259    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4")))]
1260    pub fn flatpak_remote_set_filter(self_: *mut FlatpakRemote, filter_path: *const c_char);
1261    pub fn flatpak_remote_set_gpg_key(self_: *mut FlatpakRemote, gpg_key: *mut glib::GBytes);
1262    pub fn flatpak_remote_set_gpg_verify(self_: *mut FlatpakRemote, gpg_verify: gboolean);
1263    #[cfg(any(feature = "v1_4", feature = "dox"))]
1264    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4")))]
1265    pub fn flatpak_remote_set_homepage(self_: *mut FlatpakRemote, homepage: *const c_char);
1266    #[cfg(any(feature = "v1_4", feature = "dox"))]
1267    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_4")))]
1268    pub fn flatpak_remote_set_icon(self_: *mut FlatpakRemote, icon: *const c_char);
1269    #[cfg(any(feature = "v1_1_1", feature = "dox"))]
1270    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_1")))]
1271    pub fn flatpak_remote_set_main_ref(self_: *mut FlatpakRemote, main_ref: *const c_char);
1272    pub fn flatpak_remote_set_nodeps(self_: *mut FlatpakRemote, nodeps: gboolean);
1273    pub fn flatpak_remote_set_noenumerate(self_: *mut FlatpakRemote, noenumerate: gboolean);
1274    pub fn flatpak_remote_set_prio(self_: *mut FlatpakRemote, prio: c_int);
1275    pub fn flatpak_remote_set_title(self_: *mut FlatpakRemote, title: *const c_char);
1276    pub fn flatpak_remote_set_url(self_: *mut FlatpakRemote, url: *const c_char);
1277
1278    pub fn flatpak_remote_ref_get_type() -> GType;
1282    pub fn flatpak_remote_ref_get_download_size(self_: *mut FlatpakRemoteRef) -> u64;
1283    pub fn flatpak_remote_ref_get_eol(self_: *mut FlatpakRemoteRef) -> *const c_char;
1284    pub fn flatpak_remote_ref_get_eol_rebase(self_: *mut FlatpakRemoteRef) -> *const c_char;
1285    pub fn flatpak_remote_ref_get_installed_size(self_: *mut FlatpakRemoteRef) -> u64;
1286    pub fn flatpak_remote_ref_get_metadata(self_: *mut FlatpakRemoteRef) -> *mut glib::GBytes;
1287    pub fn flatpak_remote_ref_get_remote_name(self_: *mut FlatpakRemoteRef) -> *const c_char;
1288
1289    pub fn flatpak_transaction_get_type() -> GType;
1293    pub fn flatpak_transaction_new_for_installation(
1294        installation: *mut FlatpakInstallation,
1295        cancellable: *mut gio::GCancellable,
1296        error: *mut *mut glib::GError,
1297    ) -> *mut FlatpakTransaction;
1298    #[cfg(any(feature = "v1_5_1", feature = "dox"))]
1299    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_5_1")))]
1300    pub fn flatpak_transaction_abort_webflow(self_: *mut FlatpakTransaction, id: c_uint);
1301    pub fn flatpak_transaction_add_default_dependency_sources(self_: *mut FlatpakTransaction);
1302    pub fn flatpak_transaction_add_dependency_source(
1303        self_: *mut FlatpakTransaction,
1304        installation: *mut FlatpakInstallation,
1305    );
1306    pub fn flatpak_transaction_add_install(
1307        self_: *mut FlatpakTransaction,
1308        remote: *const c_char,
1309        ref_: *const c_char,
1310        subpaths: *mut *const c_char,
1311        error: *mut *mut glib::GError,
1312    ) -> gboolean;
1313    pub fn flatpak_transaction_add_install_bundle(
1314        self_: *mut FlatpakTransaction,
1315        file: *mut gio::GFile,
1316        gpg_data: *mut glib::GBytes,
1317        error: *mut *mut glib::GError,
1318    ) -> gboolean;
1319    pub fn flatpak_transaction_add_install_flatpakref(
1320        self_: *mut FlatpakTransaction,
1321        flatpakref_data: *mut glib::GBytes,
1322        error: *mut *mut glib::GError,
1323    ) -> gboolean;
1324    #[cfg(any(feature = "v1_3_3", feature = "dox"))]
1325    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_3_3")))]
1326    pub fn flatpak_transaction_add_rebase(
1327        self_: *mut FlatpakTransaction,
1328        remote: *const c_char,
1329        ref_: *const c_char,
1330        subpaths: *mut *const c_char,
1331        previous_ids: *mut *const c_char,
1332        error: *mut *mut glib::GError,
1333    ) -> gboolean;
1334    #[cfg(any(feature = "v1_7_1", feature = "dox"))]
1335    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_7_1")))]
1336    pub fn flatpak_transaction_add_sideload_repo(
1337        self_: *mut FlatpakTransaction,
1338        path: *const c_char,
1339    );
1340    pub fn flatpak_transaction_add_uninstall(
1341        self_: *mut FlatpakTransaction,
1342        ref_: *const c_char,
1343        error: *mut *mut glib::GError,
1344    ) -> gboolean;
1345    pub fn flatpak_transaction_add_update(
1346        self_: *mut FlatpakTransaction,
1347        ref_: *const c_char,
1348        subpaths: *mut *const c_char,
1349        commit: *const c_char,
1350        error: *mut *mut glib::GError,
1351    ) -> gboolean;
1352    #[cfg(any(feature = "v1_5_2", feature = "dox"))]
1353    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_5_2")))]
1354    pub fn flatpak_transaction_complete_basic_auth(
1355        self_: *mut FlatpakTransaction,
1356        id: c_uint,
1357        user: *const c_char,
1358        password: *const c_char,
1359        options: *mut glib::GVariant,
1360    );
1361    pub fn flatpak_transaction_get_current_operation(
1362        self_: *mut FlatpakTransaction,
1363    ) -> *mut FlatpakTransactionOperation;
1364    pub fn flatpak_transaction_get_installation(
1365        self_: *mut FlatpakTransaction,
1366    ) -> *mut FlatpakInstallation;
1367    #[cfg(any(feature = "v1_5_1", feature = "dox"))]
1368    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_5_1")))]
1369    pub fn flatpak_transaction_get_no_deploy(self_: *mut FlatpakTransaction) -> gboolean;
1370    #[cfg(any(feature = "v1_5_1", feature = "dox"))]
1371    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_5_1")))]
1372    pub fn flatpak_transaction_get_no_pull(self_: *mut FlatpakTransaction) -> gboolean;
1373    pub fn flatpak_transaction_get_operations(self_: *mut FlatpakTransaction) -> *mut glib::GList;
1374    #[cfg(any(feature = "v1_5_1", feature = "dox"))]
1375    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_5_1")))]
1376    pub fn flatpak_transaction_get_parent_window(self_: *mut FlatpakTransaction) -> *const c_char;
1377    pub fn flatpak_transaction_is_empty(self_: *mut FlatpakTransaction) -> gboolean;
1378    pub fn flatpak_transaction_run(
1379        transaction: *mut FlatpakTransaction,
1380        cancellable: *mut gio::GCancellable,
1381        error: *mut *mut glib::GError,
1382    ) -> gboolean;
1383    pub fn flatpak_transaction_set_default_arch(
1384        self_: *mut FlatpakTransaction,
1385        arch: *const c_char,
1386    );
1387    pub fn flatpak_transaction_set_disable_dependencies(
1388        self_: *mut FlatpakTransaction,
1389        disable_dependencies: gboolean,
1390    );
1391    pub fn flatpak_transaction_set_disable_prune(
1392        self_: *mut FlatpakTransaction,
1393        disable_prune: gboolean,
1394    );
1395    pub fn flatpak_transaction_set_disable_related(
1396        self_: *mut FlatpakTransaction,
1397        disable_related: gboolean,
1398    );
1399    pub fn flatpak_transaction_set_disable_static_deltas(
1400        self_: *mut FlatpakTransaction,
1401        disable_static_deltas: gboolean,
1402    );
1403    pub fn flatpak_transaction_set_force_uninstall(
1404        self_: *mut FlatpakTransaction,
1405        force_uninstall: gboolean,
1406    );
1407    pub fn flatpak_transaction_set_no_deploy(self_: *mut FlatpakTransaction, no_deploy: gboolean);
1408    #[cfg(any(feature = "v1_7_3", feature = "dox"))]
1409    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_7_3")))]
1410    pub fn flatpak_transaction_set_no_interaction(
1411        self_: *mut FlatpakTransaction,
1412        no_interaction: gboolean,
1413    );
1414    pub fn flatpak_transaction_set_no_pull(self_: *mut FlatpakTransaction, no_pull: gboolean);
1415    #[cfg(any(feature = "v1_5_1", feature = "dox"))]
1416    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_5_1")))]
1417    pub fn flatpak_transaction_set_parent_window(
1418        self_: *mut FlatpakTransaction,
1419        parent_window: *const c_char,
1420    );
1421    pub fn flatpak_transaction_set_reinstall(self_: *mut FlatpakTransaction, reinstall: gboolean);
1422
1423    pub fn flatpak_transaction_operation_get_type() -> GType;
1427    pub fn flatpak_transaction_operation_get_bundle_path(
1428        self_: *mut FlatpakTransactionOperation,
1429    ) -> *mut gio::GFile;
1430    pub fn flatpak_transaction_operation_get_commit(
1431        self_: *mut FlatpakTransactionOperation,
1432    ) -> *const c_char;
1433    #[cfg(any(feature = "v1_1_2", feature = "dox"))]
1434    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_2")))]
1435    pub fn flatpak_transaction_operation_get_download_size(
1436        self_: *mut FlatpakTransactionOperation,
1437    ) -> u64;
1438    #[cfg(any(feature = "v1_1_2", feature = "dox"))]
1439    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_2")))]
1440    pub fn flatpak_transaction_operation_get_installed_size(
1441        self_: *mut FlatpakTransactionOperation,
1442    ) -> u64;
1443    #[cfg(any(feature = "v1_7_3", feature = "dox"))]
1444    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_7_3")))]
1445    pub fn flatpak_transaction_operation_get_is_skipped(
1446        self_: *mut FlatpakTransactionOperation,
1447    ) -> gboolean;
1448    pub fn flatpak_transaction_operation_get_metadata(
1449        self_: *mut FlatpakTransactionOperation,
1450    ) -> *mut glib::GKeyFile;
1451    pub fn flatpak_transaction_operation_get_old_metadata(
1452        self_: *mut FlatpakTransactionOperation,
1453    ) -> *mut glib::GKeyFile;
1454    pub fn flatpak_transaction_operation_get_operation_type(
1455        self_: *mut FlatpakTransactionOperation,
1456    ) -> FlatpakTransactionOperationType;
1457    pub fn flatpak_transaction_operation_get_ref(
1458        self_: *mut FlatpakTransactionOperation,
1459    ) -> *const c_char;
1460    #[cfg(any(feature = "v1_7_3", feature = "dox"))]
1461    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_7_3")))]
1462    pub fn flatpak_transaction_operation_get_related_to_ops(
1463        self_: *mut FlatpakTransactionOperation,
1464    ) -> *mut glib::GPtrArray;
1465    pub fn flatpak_transaction_operation_get_remote(
1466        self_: *mut FlatpakTransactionOperation,
1467    ) -> *const c_char;
1468
1469    pub fn flatpak_transaction_progress_get_type() -> GType;
1473    #[cfg(any(feature = "v1_1_2", feature = "dox"))]
1474    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_2")))]
1475    pub fn flatpak_transaction_progress_get_bytes_transferred(
1476        self_: *mut FlatpakTransactionProgress,
1477    ) -> u64;
1478    pub fn flatpak_transaction_progress_get_is_estimating(
1479        self_: *mut FlatpakTransactionProgress,
1480    ) -> gboolean;
1481    pub fn flatpak_transaction_progress_get_progress(
1482        self_: *mut FlatpakTransactionProgress,
1483    ) -> c_int;
1484    #[cfg(any(feature = "v1_1_2", feature = "dox"))]
1485    #[cfg_attr(feature = "dox", doc(cfg(feature = "v1_1_2")))]
1486    pub fn flatpak_transaction_progress_get_start_time(
1487        self_: *mut FlatpakTransactionProgress,
1488    ) -> u64;
1489    pub fn flatpak_transaction_progress_get_status(
1490        self_: *mut FlatpakTransactionProgress,
1491    ) -> *mut c_char;
1492    pub fn flatpak_transaction_progress_set_update_frequency(
1493        self_: *mut FlatpakTransactionProgress,
1494        update_interval: c_uint,
1495    );
1496
1497    pub fn flatpak_get_default_arch() -> *const c_char;
1501    pub fn flatpak_get_supported_arches() -> *const *const c_char;
1502    #[cfg(any(feature = "v0_8", feature = "dox"))]
1503    #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_8")))]
1504    pub fn flatpak_get_system_installations(
1505        cancellable: *mut gio::GCancellable,
1506        error: *mut *mut glib::GError,
1507    ) -> *mut glib::GPtrArray;
1508
1509}