/* libguestfs generated file
 * WARNING: THIS FILE IS GENERATED FROM:
 *   generator/generator_*.ml
 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
 *
 * Copyright (C) 2009-2012 Red Hat Inc.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */


#ifndef GUESTFS_GOBJECT_H__
#define GUESTFS_GOBJECT_H__

#include <glib-object.h>

G_BEGIN_DECLS

/* Guestfs::Session object definition */
#define GUESTFS_TYPE_SESSION             (guestfs_session_get_type())
#define GUESTFS_SESSION(obj)             (G_TYPE_CHECK_INSTANCE_CAST ( (obj), GUESTFS_TYPE_SESSION, GuestfsSession))
#define GUESTFS_SESSION_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ( (klass), GUESTFS_TYPE_SESSION, GuestfsSessionClass))
#define GUESTFS_IS_SESSION(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ( (obj), GUESTFS_TYPE_SESSION))
#define GUESTFS_IS_SESSION_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ( (klass), GUESTFS_TYPE_SESSION))
#define GUESTFS_SESSION_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS ( (obj), GUESTFS_TYPE_SESSION, GuestfsSessionClass))

typedef struct _GuestfsSession GuestfsSession;
typedef struct _GuestfsSessionClass GuestfsSessionClass;
typedef struct _GuestfsSessionPrivate GuestfsSessionPrivate;

struct _GuestfsSession
{
  GObject parent;
  GuestfsSessionPrivate *priv;
};

struct _GuestfsSessionClass
{
  GObjectClass parent_class;
};

GType guestfs_session_get_type(void);
GuestfsSession *guestfs_session_new(void);

/* Guestfs::Tristate */
typedef enum
{
  GUESTFS_TRISTATE_FALSE,
  GUESTFS_TRISTATE_TRUE,
  GUESTFS_TRISTATE_NONE
} GuestfsTristate;

GType guestfs_tristate_get_type(void);
#define GUESTFS_TYPE_TRISTATE (guestfs_tristate_get_type())

/* Structs */
typedef struct _GuestfsIntBool GuestfsIntBool;
struct _GuestfsIntBool {
  gint32 i;
  gint32 b;
};
GType guestfs_int_bool_get_type(void);

typedef struct _GuestfsPV GuestfsPV;
struct _GuestfsPV {
  gchar *pv_name;
  /* The next field is NOT nul-terminated, be careful when printing it: */
  gchar pv_uuid[32];
  gchar *pv_fmt;
  guint64 pv_size;
  guint64 dev_size;
  guint64 pv_free;
  guint64 pv_used;
  gchar *pv_attr;
  gint64 pv_pe_count;
  gint64 pv_pe_alloc_count;
  gchar *pv_tags;
  guint64 pe_start;
  gint64 pv_mda_count;
  guint64 pv_mda_free;
};
GType guestfs_lvm_pv_get_type(void);

typedef struct _GuestfsVG GuestfsVG;
struct _GuestfsVG {
  gchar *vg_name;
  /* The next field is NOT nul-terminated, be careful when printing it: */
  gchar vg_uuid[32];
  gchar *vg_fmt;
  gchar *vg_attr;
  guint64 vg_size;
  guint64 vg_free;
  gchar *vg_sysid;
  guint64 vg_extent_size;
  gint64 vg_extent_count;
  gint64 vg_free_count;
  gint64 max_lv;
  gint64 max_pv;
  gint64 pv_count;
  gint64 lv_count;
  gint64 snap_count;
  gint64 vg_seqno;
  gchar *vg_tags;
  gint64 vg_mda_count;
  guint64 vg_mda_free;
};
GType guestfs_lvm_vg_get_type(void);

typedef struct _GuestfsLV GuestfsLV;
struct _GuestfsLV {
  gchar *lv_name;
  /* The next field is NOT nul-terminated, be careful when printing it: */
  gchar lv_uuid[32];
  gchar *lv_attr;
  gint64 lv_major;
  gint64 lv_minor;
  gint64 lv_kernel_major;
  gint64 lv_kernel_minor;
  guint64 lv_size;
  gint64 seg_count;
  gchar *origin;
  /* The next field is [0..100] or -1 meaning 'not present': */
  gfloat snap_percent;
  /* The next field is [0..100] or -1 meaning 'not present': */
  gfloat copy_percent;
  gchar *move_pv;
  gchar *lv_tags;
  gchar *mirror_log;
  gchar *modules;
};
GType guestfs_lvm_lv_get_type(void);

typedef struct _GuestfsStat GuestfsStat;
struct _GuestfsStat {
  gint64 dev;
  gint64 ino;
  gint64 mode;
  gint64 nlink;
  gint64 uid;
  gint64 gid;
  gint64 rdev;
  gint64 size;
  gint64 blksize;
  gint64 blocks;
  gint64 atime;
  gint64 mtime;
  gint64 ctime;
};
GType guestfs_stat_get_type(void);

typedef struct _GuestfsStatVFS GuestfsStatVFS;
struct _GuestfsStatVFS {
  gint64 bsize;
  gint64 frsize;
  gint64 blocks;
  gint64 bfree;
  gint64 bavail;
  gint64 files;
  gint64 ffree;
  gint64 favail;
  gint64 fsid;
  gint64 flag;
  gint64 namemax;
};
GType guestfs_statvfs_get_type(void);

typedef struct _GuestfsDirent GuestfsDirent;
struct _GuestfsDirent {
  gint64 ino;
  gchar ftyp;
  gchar *name;
};
GType guestfs_dirent_get_type(void);

typedef struct _GuestfsVersion GuestfsVersion;
struct _GuestfsVersion {
  gint64 major;
  gint64 minor;
  gint64 release;
  gchar *extra;
};
GType guestfs_version_get_type(void);

typedef struct _GuestfsXAttr GuestfsXAttr;
struct _GuestfsXAttr {
  gchar *attrname;
  GByteArray *attrval;
};
GType guestfs_xattr_get_type(void);

typedef struct _GuestfsINotifyEvent GuestfsINotifyEvent;
struct _GuestfsINotifyEvent {
  gint64 in_wd;
  guint32 in_mask;
  guint32 in_cookie;
  gchar *in_name;
};
GType guestfs_inotify_event_get_type(void);

typedef struct _GuestfsPartition GuestfsPartition;
struct _GuestfsPartition {
  gint32 part_num;
  guint64 part_start;
  guint64 part_end;
  guint64 part_size;
};
GType guestfs_partition_get_type(void);

typedef struct _GuestfsApplication GuestfsApplication;
struct _GuestfsApplication {
  gchar *app_name;
  gchar *app_display_name;
  gint32 app_epoch;
  gchar *app_version;
  gchar *app_release;
  gchar *app_install_path;
  gchar *app_trans_path;
  gchar *app_publisher;
  gchar *app_url;
  gchar *app_source_package;
  gchar *app_summary;
  gchar *app_description;
};
GType guestfs_application_get_type(void);

/* Optional arguments */

/* GuestfsAddDriveOpts */
#define GUESTFS_TYPE_ADD_DRIVE_OPTS (guestfs_add_drive_opts_get_type())
#define GUESTFS_ADD_DRIVE_OPTS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_ADD_DRIVE_OPTS, GuestfsAddDriveOpts))
#define GUESTFS_ADD_DRIVE_OPTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_ADD_DRIVE_OPTS, GuestfsAddDriveOptsClass))
#define GUESTFS_IS_ADD_DRIVE_OPTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_ADD_DRIVE_OPTS))
#define GUESTFS_IS_ADD_DRIVE_OPTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_ADD_DRIVE_OPTS))
#define GUESTFS_ADD_DRIVE_OPTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_ADD_DRIVE_OPTS, GuestfsAddDriveOptsClass))

typedef struct _GuestfsAddDriveOpts GuestfsAddDriveOpts;
typedef struct _GuestfsAddDriveOptsPrivate GuestfsAddDriveOptsPrivate;
typedef struct _GuestfsAddDriveOptsClass GuestfsAddDriveOptsClass;

struct _GuestfsAddDriveOpts {
  GObject parent;
  GuestfsAddDriveOptsPrivate *priv;
};

struct _GuestfsAddDriveOptsClass {
  GObjectClass parent_class;
};

GType guestfs_add_drive_opts_get_type(void);
GuestfsAddDriveOpts *guestfs_add_drive_opts_new(void);

/* GuestfsAddDomain */
#define GUESTFS_TYPE_ADD_DOMAIN (guestfs_add_domain_get_type())
#define GUESTFS_ADD_DOMAIN(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_ADD_DOMAIN, GuestfsAddDomain))
#define GUESTFS_ADD_DOMAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_ADD_DOMAIN, GuestfsAddDomainClass))
#define GUESTFS_IS_ADD_DOMAIN(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_ADD_DOMAIN))
#define GUESTFS_IS_ADD_DOMAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_ADD_DOMAIN))
#define GUESTFS_ADD_DOMAIN_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_ADD_DOMAIN, GuestfsAddDomainClass))

typedef struct _GuestfsAddDomain GuestfsAddDomain;
typedef struct _GuestfsAddDomainPrivate GuestfsAddDomainPrivate;
typedef struct _GuestfsAddDomainClass GuestfsAddDomainClass;

struct _GuestfsAddDomain {
  GObject parent;
  GuestfsAddDomainPrivate *priv;
};

struct _GuestfsAddDomainClass {
  GObjectClass parent_class;
};

GType guestfs_add_domain_get_type(void);
GuestfsAddDomain *guestfs_add_domain_new(void);

/* GuestfsInspectGetIcon */
#define GUESTFS_TYPE_INSPECT_GET_ICON (guestfs_inspect_get_icon_get_type())
#define GUESTFS_INSPECT_GET_ICON(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_INSPECT_GET_ICON, GuestfsInspectGetIcon))
#define GUESTFS_INSPECT_GET_ICON_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_INSPECT_GET_ICON, GuestfsInspectGetIconClass))
#define GUESTFS_IS_INSPECT_GET_ICON(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_INSPECT_GET_ICON))
#define GUESTFS_IS_INSPECT_GET_ICON_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_INSPECT_GET_ICON))
#define GUESTFS_INSPECT_GET_ICON_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_INSPECT_GET_ICON, GuestfsInspectGetIconClass))

typedef struct _GuestfsInspectGetIcon GuestfsInspectGetIcon;
typedef struct _GuestfsInspectGetIconPrivate GuestfsInspectGetIconPrivate;
typedef struct _GuestfsInspectGetIconClass GuestfsInspectGetIconClass;

struct _GuestfsInspectGetIcon {
  GObject parent;
  GuestfsInspectGetIconPrivate *priv;
};

struct _GuestfsInspectGetIconClass {
  GObjectClass parent_class;
};

GType guestfs_inspect_get_icon_get_type(void);
GuestfsInspectGetIcon *guestfs_inspect_get_icon_new(void);

/* GuestfsMkfsOpts */
#define GUESTFS_TYPE_MKFS_OPTS (guestfs_mkfs_opts_get_type())
#define GUESTFS_MKFS_OPTS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_MKFS_OPTS, GuestfsMkfsOpts))
#define GUESTFS_MKFS_OPTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_MKFS_OPTS, GuestfsMkfsOptsClass))
#define GUESTFS_IS_MKFS_OPTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_MKFS_OPTS))
#define GUESTFS_IS_MKFS_OPTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_MKFS_OPTS))
#define GUESTFS_MKFS_OPTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_MKFS_OPTS, GuestfsMkfsOptsClass))

typedef struct _GuestfsMkfsOpts GuestfsMkfsOpts;
typedef struct _GuestfsMkfsOptsPrivate GuestfsMkfsOptsPrivate;
typedef struct _GuestfsMkfsOptsClass GuestfsMkfsOptsClass;

struct _GuestfsMkfsOpts {
  GObject parent;
  GuestfsMkfsOptsPrivate *priv;
};

struct _GuestfsMkfsOptsClass {
  GObjectClass parent_class;
};

GType guestfs_mkfs_opts_get_type(void);
GuestfsMkfsOpts *guestfs_mkfs_opts_new(void);

/* GuestfsMount9P */
#define GUESTFS_TYPE_MOUNT_9P (guestfs_mount_9p_get_type())
#define GUESTFS_MOUNT_9P(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_MOUNT_9P, GuestfsMount9P))
#define GUESTFS_MOUNT_9P_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_MOUNT_9P, GuestfsMount9PClass))
#define GUESTFS_IS_MOUNT_9P(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_MOUNT_9P))
#define GUESTFS_IS_MOUNT_9P_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_MOUNT_9P))
#define GUESTFS_MOUNT_9P_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_MOUNT_9P, GuestfsMount9PClass))

typedef struct _GuestfsMount9P GuestfsMount9P;
typedef struct _GuestfsMount9PPrivate GuestfsMount9PPrivate;
typedef struct _GuestfsMount9PClass GuestfsMount9PClass;

struct _GuestfsMount9P {
  GObject parent;
  GuestfsMount9PPrivate *priv;
};

struct _GuestfsMount9PClass {
  GObjectClass parent_class;
};

GType guestfs_mount_9p_get_type(void);
GuestfsMount9P *guestfs_mount_9p_new(void);

/* GuestfsNTFSResizeOpts */
#define GUESTFS_TYPE_NTFSRESIZE_OPTS (guestfs_ntfsresize_opts_get_type())
#define GUESTFS_NTFSRESIZE_OPTS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_NTFSRESIZE_OPTS, GuestfsNTFSResizeOpts))
#define GUESTFS_NTFSRESIZE_OPTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_NTFSRESIZE_OPTS, GuestfsNTFSResizeOptsClass))
#define GUESTFS_IS_NTFSRESIZE_OPTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_NTFSRESIZE_OPTS))
#define GUESTFS_IS_NTFSRESIZE_OPTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_NTFSRESIZE_OPTS))
#define GUESTFS_NTFSRESIZE_OPTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_NTFSRESIZE_OPTS, GuestfsNTFSResizeOptsClass))

typedef struct _GuestfsNTFSResizeOpts GuestfsNTFSResizeOpts;
typedef struct _GuestfsNTFSResizeOptsPrivate GuestfsNTFSResizeOptsPrivate;
typedef struct _GuestfsNTFSResizeOptsClass GuestfsNTFSResizeOptsClass;

struct _GuestfsNTFSResizeOpts {
  GObject parent;
  GuestfsNTFSResizeOptsPrivate *priv;
};

struct _GuestfsNTFSResizeOptsClass {
  GObjectClass parent_class;
};

GType guestfs_ntfsresize_opts_get_type(void);
GuestfsNTFSResizeOpts *guestfs_ntfsresize_opts_new(void);

/* GuestfsBTRFSFilesystemResize */
#define GUESTFS_TYPE_BTRFS_FILESYSTEM_RESIZE (guestfs_btrfs_filesystem_resize_get_type())
#define GUESTFS_BTRFS_FILESYSTEM_RESIZE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_BTRFS_FILESYSTEM_RESIZE, GuestfsBTRFSFilesystemResize))
#define GUESTFS_BTRFS_FILESYSTEM_RESIZE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_BTRFS_FILESYSTEM_RESIZE, GuestfsBTRFSFilesystemResizeClass))
#define GUESTFS_IS_BTRFS_FILESYSTEM_RESIZE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_BTRFS_FILESYSTEM_RESIZE))
#define GUESTFS_IS_BTRFS_FILESYSTEM_RESIZE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_BTRFS_FILESYSTEM_RESIZE))
#define GUESTFS_BTRFS_FILESYSTEM_RESIZE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_BTRFS_FILESYSTEM_RESIZE, GuestfsBTRFSFilesystemResizeClass))

typedef struct _GuestfsBTRFSFilesystemResize GuestfsBTRFSFilesystemResize;
typedef struct _GuestfsBTRFSFilesystemResizePrivate GuestfsBTRFSFilesystemResizePrivate;
typedef struct _GuestfsBTRFSFilesystemResizeClass GuestfsBTRFSFilesystemResizeClass;

struct _GuestfsBTRFSFilesystemResize {
  GObject parent;
  GuestfsBTRFSFilesystemResizePrivate *priv;
};

struct _GuestfsBTRFSFilesystemResizeClass {
  GObjectClass parent_class;
};

GType guestfs_btrfs_filesystem_resize_get_type(void);
GuestfsBTRFSFilesystemResize *guestfs_btrfs_filesystem_resize_new(void);

/* GuestfsCompressOut */
#define GUESTFS_TYPE_COMPRESS_OUT (guestfs_compress_out_get_type())
#define GUESTFS_COMPRESS_OUT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_COMPRESS_OUT, GuestfsCompressOut))
#define GUESTFS_COMPRESS_OUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_COMPRESS_OUT, GuestfsCompressOutClass))
#define GUESTFS_IS_COMPRESS_OUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_COMPRESS_OUT))
#define GUESTFS_IS_COMPRESS_OUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_COMPRESS_OUT))
#define GUESTFS_COMPRESS_OUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_COMPRESS_OUT, GuestfsCompressOutClass))

typedef struct _GuestfsCompressOut GuestfsCompressOut;
typedef struct _GuestfsCompressOutPrivate GuestfsCompressOutPrivate;
typedef struct _GuestfsCompressOutClass GuestfsCompressOutClass;

struct _GuestfsCompressOut {
  GObject parent;
  GuestfsCompressOutPrivate *priv;
};

struct _GuestfsCompressOutClass {
  GObjectClass parent_class;
};

GType guestfs_compress_out_get_type(void);
GuestfsCompressOut *guestfs_compress_out_new(void);

/* GuestfsCompressDeviceOut */
#define GUESTFS_TYPE_COMPRESS_DEVICE_OUT (guestfs_compress_device_out_get_type())
#define GUESTFS_COMPRESS_DEVICE_OUT(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_COMPRESS_DEVICE_OUT, GuestfsCompressDeviceOut))
#define GUESTFS_COMPRESS_DEVICE_OUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_COMPRESS_DEVICE_OUT, GuestfsCompressDeviceOutClass))
#define GUESTFS_IS_COMPRESS_DEVICE_OUT(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_COMPRESS_DEVICE_OUT))
#define GUESTFS_IS_COMPRESS_DEVICE_OUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_COMPRESS_DEVICE_OUT))
#define GUESTFS_COMPRESS_DEVICE_OUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_COMPRESS_DEVICE_OUT, GuestfsCompressDeviceOutClass))

typedef struct _GuestfsCompressDeviceOut GuestfsCompressDeviceOut;
typedef struct _GuestfsCompressDeviceOutPrivate GuestfsCompressDeviceOutPrivate;
typedef struct _GuestfsCompressDeviceOutClass GuestfsCompressDeviceOutClass;

struct _GuestfsCompressDeviceOut {
  GObject parent;
  GuestfsCompressDeviceOutPrivate *priv;
};

struct _GuestfsCompressDeviceOutClass {
  GObjectClass parent_class;
};

GType guestfs_compress_device_out_get_type(void);
GuestfsCompressDeviceOut *guestfs_compress_device_out_new(void);

/* GuestfsCopyDeviceToDevice */
#define GUESTFS_TYPE_COPY_DEVICE_TO_DEVICE (guestfs_copy_device_to_device_get_type())
#define GUESTFS_COPY_DEVICE_TO_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_COPY_DEVICE_TO_DEVICE, GuestfsCopyDeviceToDevice))
#define GUESTFS_COPY_DEVICE_TO_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_COPY_DEVICE_TO_DEVICE, GuestfsCopyDeviceToDeviceClass))
#define GUESTFS_IS_COPY_DEVICE_TO_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_COPY_DEVICE_TO_DEVICE))
#define GUESTFS_IS_COPY_DEVICE_TO_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_COPY_DEVICE_TO_DEVICE))
#define GUESTFS_COPY_DEVICE_TO_DEVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_COPY_DEVICE_TO_DEVICE, GuestfsCopyDeviceToDeviceClass))

typedef struct _GuestfsCopyDeviceToDevice GuestfsCopyDeviceToDevice;
typedef struct _GuestfsCopyDeviceToDevicePrivate GuestfsCopyDeviceToDevicePrivate;
typedef struct _GuestfsCopyDeviceToDeviceClass GuestfsCopyDeviceToDeviceClass;

struct _GuestfsCopyDeviceToDevice {
  GObject parent;
  GuestfsCopyDeviceToDevicePrivate *priv;
};

struct _GuestfsCopyDeviceToDeviceClass {
  GObjectClass parent_class;
};

GType guestfs_copy_device_to_device_get_type(void);
GuestfsCopyDeviceToDevice *guestfs_copy_device_to_device_new(void);

/* GuestfsCopyDeviceToFile */
#define GUESTFS_TYPE_COPY_DEVICE_TO_FILE (guestfs_copy_device_to_file_get_type())
#define GUESTFS_COPY_DEVICE_TO_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_COPY_DEVICE_TO_FILE, GuestfsCopyDeviceToFile))
#define GUESTFS_COPY_DEVICE_TO_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_COPY_DEVICE_TO_FILE, GuestfsCopyDeviceToFileClass))
#define GUESTFS_IS_COPY_DEVICE_TO_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_COPY_DEVICE_TO_FILE))
#define GUESTFS_IS_COPY_DEVICE_TO_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_COPY_DEVICE_TO_FILE))
#define GUESTFS_COPY_DEVICE_TO_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_COPY_DEVICE_TO_FILE, GuestfsCopyDeviceToFileClass))

typedef struct _GuestfsCopyDeviceToFile GuestfsCopyDeviceToFile;
typedef struct _GuestfsCopyDeviceToFilePrivate GuestfsCopyDeviceToFilePrivate;
typedef struct _GuestfsCopyDeviceToFileClass GuestfsCopyDeviceToFileClass;

struct _GuestfsCopyDeviceToFile {
  GObject parent;
  GuestfsCopyDeviceToFilePrivate *priv;
};

struct _GuestfsCopyDeviceToFileClass {
  GObjectClass parent_class;
};

GType guestfs_copy_device_to_file_get_type(void);
GuestfsCopyDeviceToFile *guestfs_copy_device_to_file_new(void);

/* GuestfsCopyFileToDevice */
#define GUESTFS_TYPE_COPY_FILE_TO_DEVICE (guestfs_copy_file_to_device_get_type())
#define GUESTFS_COPY_FILE_TO_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_COPY_FILE_TO_DEVICE, GuestfsCopyFileToDevice))
#define GUESTFS_COPY_FILE_TO_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_COPY_FILE_TO_DEVICE, GuestfsCopyFileToDeviceClass))
#define GUESTFS_IS_COPY_FILE_TO_DEVICE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_COPY_FILE_TO_DEVICE))
#define GUESTFS_IS_COPY_FILE_TO_DEVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_COPY_FILE_TO_DEVICE))
#define GUESTFS_COPY_FILE_TO_DEVICE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_COPY_FILE_TO_DEVICE, GuestfsCopyFileToDeviceClass))

typedef struct _GuestfsCopyFileToDevice GuestfsCopyFileToDevice;
typedef struct _GuestfsCopyFileToDevicePrivate GuestfsCopyFileToDevicePrivate;
typedef struct _GuestfsCopyFileToDeviceClass GuestfsCopyFileToDeviceClass;

struct _GuestfsCopyFileToDevice {
  GObject parent;
  GuestfsCopyFileToDevicePrivate *priv;
};

struct _GuestfsCopyFileToDeviceClass {
  GObjectClass parent_class;
};

GType guestfs_copy_file_to_device_get_type(void);
GuestfsCopyFileToDevice *guestfs_copy_file_to_device_new(void);

/* GuestfsCopyFileToFile */
#define GUESTFS_TYPE_COPY_FILE_TO_FILE (guestfs_copy_file_to_file_get_type())
#define GUESTFS_COPY_FILE_TO_FILE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_COPY_FILE_TO_FILE, GuestfsCopyFileToFile))
#define GUESTFS_COPY_FILE_TO_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_COPY_FILE_TO_FILE, GuestfsCopyFileToFileClass))
#define GUESTFS_IS_COPY_FILE_TO_FILE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_COPY_FILE_TO_FILE))
#define GUESTFS_IS_COPY_FILE_TO_FILE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_COPY_FILE_TO_FILE))
#define GUESTFS_COPY_FILE_TO_FILE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_COPY_FILE_TO_FILE, GuestfsCopyFileToFileClass))

typedef struct _GuestfsCopyFileToFile GuestfsCopyFileToFile;
typedef struct _GuestfsCopyFileToFilePrivate GuestfsCopyFileToFilePrivate;
typedef struct _GuestfsCopyFileToFileClass GuestfsCopyFileToFileClass;

struct _GuestfsCopyFileToFile {
  GObject parent;
  GuestfsCopyFileToFilePrivate *priv;
};

struct _GuestfsCopyFileToFileClass {
  GObjectClass parent_class;
};

GType guestfs_copy_file_to_file_get_type(void);
GuestfsCopyFileToFile *guestfs_copy_file_to_file_new(void);

/* GuestfsTune2FS */
#define GUESTFS_TYPE_TUNE2FS (guestfs_tune2fs_get_type())
#define GUESTFS_TUNE2FS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_TUNE2FS, GuestfsTune2FS))
#define GUESTFS_TUNE2FS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_TUNE2FS, GuestfsTune2FSClass))
#define GUESTFS_IS_TUNE2FS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_TUNE2FS))
#define GUESTFS_IS_TUNE2FS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_TUNE2FS))
#define GUESTFS_TUNE2FS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_TUNE2FS, GuestfsTune2FSClass))

typedef struct _GuestfsTune2FS GuestfsTune2FS;
typedef struct _GuestfsTune2FSPrivate GuestfsTune2FSPrivate;
typedef struct _GuestfsTune2FSClass GuestfsTune2FSClass;

struct _GuestfsTune2FS {
  GObject parent;
  GuestfsTune2FSPrivate *priv;
};

struct _GuestfsTune2FSClass {
  GObjectClass parent_class;
};

GType guestfs_tune2fs_get_type(void);
GuestfsTune2FS *guestfs_tune2fs_new(void);

/* GuestfsMDCreate */
#define GUESTFS_TYPE_MD_CREATE (guestfs_md_create_get_type())
#define GUESTFS_MD_CREATE(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GUESTFS_TYPE_MD_CREATE, GuestfsMDCreate))
#define GUESTFS_MD_CREATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GUESTFS_TYPE_MD_CREATE, GuestfsMDCreateClass))
#define GUESTFS_IS_MD_CREATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE((klass), GUESTFS_TYPE_MD_CREATE))
#define GUESTFS_IS_MD_CREATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GUESTFS_TYPE_MD_CREATE))
#define GUESTFS_MD_CREATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GUESTFS_TYPE_MD_CREATE, GuestfsMDCreateClass))

typedef struct _GuestfsMDCreate GuestfsMDCreate;
typedef struct _GuestfsMDCreatePrivate GuestfsMDCreatePrivate;
typedef struct _GuestfsMDCreateClass GuestfsMDCreateClass;

struct _GuestfsMDCreate {
  GObject parent;
  GuestfsMDCreatePrivate *priv;
};

struct _GuestfsMDCreateClass {
  GObjectClass parent_class;
};

GType guestfs_md_create_get_type(void);
GuestfsMDCreate *guestfs_md_create_new(void);

/* Generated methods */
gboolean test0(GuestfsSession *session, const gchar *str, const gchar *optstr, GSList *strlist, gboolean b, gint32 integer, gint64 integer64, const gchar *filein, const gchar *fileout, GByteArray *bufferin, GError **err);
gint32 test0rint(GuestfsSession *session, const gchar *val, GError **err);
gint32 test0rinterr(GuestfsSession *session, , GError **err);
gint64 test0rint64(GuestfsSession *session, const gchar *val, GError **err);
gint64 test0rint64err(GuestfsSession *session, , GError **err);
gboolean test0rbool(GuestfsSession *session, const gchar *val, GError **err);
gboolean test0rboolerr(GuestfsSession *session, , GError **err);
gchar *test0rconststring(GuestfsSession *session, const gchar *val, GError **err);
gchar *test0rconststringerr(GuestfsSession *session, , GError **err);
gchar *test0rconstoptstring(GuestfsSession *session, const gchar *val);
gchar *test0rconstoptstringerr(GuestfsSession *session, );
gchar *test0rstring(GuestfsSession *session, const gchar *val, GError **err);
gchar *test0rstringerr(GuestfsSession *session, , GError **err);
GSList *test0rstringlist(GuestfsSession *session, const gchar *val, GError **err);
GSList *test0rstringlisterr(GuestfsSession *session, , GError **err);
GuestfsPV *test0rstruct(GuestfsSession *session, const gchar *val, GError **err);
GuestfsPV *test0rstructerr(GuestfsSession *session, , GError **err);
GSList *test0rstructlist(GuestfsSession *session, const gchar *val, GError **err);
GSList *test0rstructlisterr(GuestfsSession *session, , GError **err);
GHashTable *test0rhashtable(GuestfsSession *session, const gchar *val, GError **err);
GHashTable *test0rhashtableerr(GuestfsSession *session, , GError **err);
gboolean launch(GuestfsSession *session, , GError **err);
gboolean wait_ready(GuestfsSession *session, , GError **err);
gboolean kill_subprocess(GuestfsSession *session, , GError **err);
gboolean add_drive(GuestfsSession *session, const gchar *filename, GError **err);
gboolean add_cdrom(GuestfsSession *session, const gchar *filename, GError **err);
gboolean add_drive_ro(GuestfsSession *session, const gchar *filename, GError **err);
gboolean config(GuestfsSession *session, const gchar *qemuparam, const gchar *qemuvalue, GError **err);
gboolean set_qemu(GuestfsSession *session, const gchar *qemu, GError **err);
gchar *get_qemu(GuestfsSession *session, , GError **err);
gboolean set_path(GuestfsSession *session, const gchar *searchpath, GError **err);
gchar *get_path(GuestfsSession *session, , GError **err);
gboolean set_append(GuestfsSession *session, const gchar *append, GError **err);
gchar *get_append(GuestfsSession *session, );
gboolean set_autosync(GuestfsSession *session, gboolean autosync, GError **err);
gboolean get_autosync(GuestfsSession *session, , GError **err);
gboolean set_verbose(GuestfsSession *session, gboolean verbose, GError **err);
gboolean get_verbose(GuestfsSession *session, , GError **err);
gboolean is_ready(GuestfsSession *session, , GError **err);
gboolean is_config(GuestfsSession *session, , GError **err);
gboolean is_launching(GuestfsSession *session, , GError **err);
gboolean is_busy(GuestfsSession *session, , GError **err);
gint32 get_state(GuestfsSession *session, , GError **err);
gboolean set_memsize(GuestfsSession *session, gint32 memsize, GError **err);
gint32 get_memsize(GuestfsSession *session, , GError **err);
gint32 get_pid(GuestfsSession *session, , GError **err);
GuestfsVersion *version(GuestfsSession *session, , GError **err);
gboolean set_selinux(GuestfsSession *session, gboolean selinux, GError **err);
gboolean get_selinux(GuestfsSession *session, , GError **err);
gboolean set_trace(GuestfsSession *session, gboolean trace, GError **err);
gboolean get_trace(GuestfsSession *session, , GError **err);
gboolean set_direct(GuestfsSession *session, gboolean direct, GError **err);
gboolean get_direct(GuestfsSession *session, , GError **err);
gboolean set_recovery_proc(GuestfsSession *session, gboolean recoveryproc, GError **err);
gboolean get_recovery_proc(GuestfsSession *session, , GError **err);
gboolean add_drive_with_if(GuestfsSession *session, const gchar *filename, const gchar *iface, GError **err);
gboolean add_drive_ro_with_if(GuestfsSession *session, const gchar *filename, const gchar *iface, GError **err);
gchar *file_architecture(GuestfsSession *session, const gchar *filename, GError **err);
GSList *inspect_os(GuestfsSession *session, , GError **err);
gchar *inspect_get_type(GuestfsSession *session, const gchar *root, GError **err);
gchar *inspect_get_arch(GuestfsSession *session, const gchar *root, GError **err);
gchar *inspect_get_distro(GuestfsSession *session, const gchar *root, GError **err);
gint32 inspect_get_major_version(GuestfsSession *session, const gchar *root, GError **err);
gint32 inspect_get_minor_version(GuestfsSession *session, const gchar *root, GError **err);
gchar *inspect_get_product_name(GuestfsSession *session, const gchar *root, GError **err);
GHashTable *inspect_get_mountpoints(GuestfsSession *session, const gchar *root, GError **err);
GSList *inspect_get_filesystems(GuestfsSession *session, const gchar *root, GError **err);
gboolean set_network(GuestfsSession *session, gboolean network, GError **err);
gboolean get_network(GuestfsSession *session, , GError **err);
GHashTable *list_filesystems(GuestfsSession *session, , GError **err);
gboolean add_drive_opts(GuestfsSession *session, const gchar *filename, GuestfsAddDriveOpts *optargs, GError **err);
gchar *inspect_get_windows_systemroot(GuestfsSession *session, const gchar *root, GError **err);
GSList *inspect_get_roots(GuestfsSession *session, , GError **err);
GSList *debug_cmdline(GuestfsSession *session, , GError **err);
GSList *debug_drives(GuestfsSession *session, , GError **err);
gint32 add_domain(GuestfsSession *session, const gchar *dom, GuestfsAddDomain *optargs, GError **err);
gchar *inspect_get_package_format(GuestfsSession *session, const gchar *root, GError **err);
gchar *inspect_get_package_management(GuestfsSession *session, const gchar *root, GError **err);
GSList *inspect_list_applications(GuestfsSession *session, const gchar *root, GError **err);
gchar *inspect_get_hostname(GuestfsSession *session, const gchar *root, GError **err);
gchar *inspect_get_format(GuestfsSession *session, const gchar *root, GError **err);
gboolean inspect_is_live(GuestfsSession *session, const gchar *root, GError **err);
gboolean inspect_is_netinst(GuestfsSession *session, const gchar *root, GError **err);
gboolean inspect_is_multipart(GuestfsSession *session, const gchar *root, GError **err);
gboolean set_attach_method(GuestfsSession *session, const gchar *attachmethod, GError **err);
gchar *get_attach_method(GuestfsSession *session, , GError **err);
gchar *inspect_get_product_variant(GuestfsSession *session, const gchar *root, GError **err);
gchar *inspect_get_windows_current_control_set(GuestfsSession *session, const gchar *root, GError **err);
GHashTable *inspect_get_drive_mappings(GuestfsSession *session, const gchar *root, GError **err);
GByteArray *inspect_get_icon(GuestfsSession *session, const gchar *root, GuestfsInspectGetIcon *optargs, GError **err);
gboolean set_pgroup(GuestfsSession *session, gboolean pgroup, GError **err);
gboolean get_pgroup(GuestfsSession *session, , GError **err);
gboolean set_smp(GuestfsSession *session, gint32 smp, GError **err);
gint32 get_smp(GuestfsSession *session, , GError **err);
gboolean mount(GuestfsSession *session, const gchar *device, const gchar *mountpoint, GError **err);
gboolean sync(GuestfsSession *session, , GError **err);
gboolean touch(GuestfsSession *session, const gchar *path, GError **err);
gchar *cat(GuestfsSession *session, const gchar *path, GError **err);
gchar *ll(GuestfsSession *session, const gchar *directory, GError **err);
GSList *ls(GuestfsSession *session, const gchar *directory, GError **err);
GSList *list_devices(GuestfsSession *session, , GError **err);
GSList *list_partitions(GuestfsSession *session, , GError **err);
GSList *pvs(GuestfsSession *session, , GError **err);
GSList *vgs(GuestfsSession *session, , GError **err);
GSList *lvs(GuestfsSession *session, , GError **err);
GSList *pvs_full(GuestfsSession *session, , GError **err);
GSList *vgs_full(GuestfsSession *session, , GError **err);
GSList *lvs_full(GuestfsSession *session, , GError **err);
GSList *read_lines(GuestfsSession *session, const gchar *path, GError **err);
gboolean aug_init(GuestfsSession *session, const gchar *root, gint32 flags, GError **err);
gboolean aug_close(GuestfsSession *session, , GError **err);
gint32 aug_defvar(GuestfsSession *session, const gchar *name, const gchar *expr, GError **err);
GuestfsIntBool *aug_defnode(GuestfsSession *session, const gchar *name, const gchar *expr, const gchar *val, GError **err);
gchar *aug_get(GuestfsSession *session, const gchar *augpath, GError **err);
gboolean aug_set(GuestfsSession *session, const gchar *augpath, const gchar *val, GError **err);
gboolean aug_insert(GuestfsSession *session, const gchar *augpath, const gchar *label, gboolean before, GError **err);
gint32 aug_rm(GuestfsSession *session, const gchar *augpath, GError **err);
gboolean aug_mv(GuestfsSession *session, const gchar *src, const gchar *dest, GError **err);
GSList *aug_match(GuestfsSession *session, const gchar *augpath, GError **err);
gboolean aug_save(GuestfsSession *session, , GError **err);
gboolean aug_load(GuestfsSession *session, , GError **err);
GSList *aug_ls(GuestfsSession *session, const gchar *augpath, GError **err);
gboolean rm(GuestfsSession *session, const gchar *path, GError **err);
gboolean rmdir(GuestfsSession *session, const gchar *path, GError **err);
gboolean rm_rf(GuestfsSession *session, const gchar *path, GError **err);
gboolean mkdir(GuestfsSession *session, const gchar *path, GError **err);
gboolean mkdir_p(GuestfsSession *session, const gchar *path, GError **err);
gboolean chmod(GuestfsSession *session, gint32 mode, const gchar *path, GError **err);
gboolean chown(GuestfsSession *session, gint32 owner, gint32 group, const gchar *path, GError **err);
gboolean exists(GuestfsSession *session, const gchar *path, GError **err);
gboolean is_file(GuestfsSession *session, const gchar *path, GError **err);
gboolean is_dir(GuestfsSession *session, const gchar *path, GError **err);
gboolean pvcreate(GuestfsSession *session, const gchar *device, GError **err);
gboolean vgcreate(GuestfsSession *session, const gchar *volgroup, GSList *physvols, GError **err);
gboolean lvcreate(GuestfsSession *session, const gchar *logvol, const gchar *volgroup, gint32 mbytes, GError **err);
gboolean mkfs(GuestfsSession *session, const gchar *fstype, const gchar *device, GError **err);
gboolean sfdisk(GuestfsSession *session, const gchar *device, gint32 cyls, gint32 heads, gint32 sectors, GSList *lines, GError **err);
gboolean write_file(GuestfsSession *session, const gchar *path, const gchar *content, gint32 size, GError **err);
gboolean umount(GuestfsSession *session, const gchar *pathordevice, GError **err);
GSList *mounts(GuestfsSession *session, , GError **err);
gboolean umount_all(GuestfsSession *session, , GError **err);
gboolean lvm_remove_all(GuestfsSession *session, , GError **err);
gchar *file(GuestfsSession *session, const gchar *path, GError **err);
gchar *command(GuestfsSession *session, GSList *arguments, GError **err);
GSList *command_lines(GuestfsSession *session, GSList *arguments, GError **err);
GuestfsStat *stat(GuestfsSession *session, const gchar *path, GError **err);
GuestfsStat *lstat(GuestfsSession *session, const gchar *path, GError **err);
GuestfsStatVFS *statvfs(GuestfsSession *session, const gchar *path, GError **err);
GHashTable *tune2fs_l(GuestfsSession *session, const gchar *device, GError **err);
gboolean blockdev_setro(GuestfsSession *session, const gchar *device, GError **err);
gboolean blockdev_setrw(GuestfsSession *session, const gchar *device, GError **err);
gboolean blockdev_getro(GuestfsSession *session, const gchar *device, GError **err);
gint32 blockdev_getss(GuestfsSession *session, const gchar *device, GError **err);
gint32 blockdev_getbsz(GuestfsSession *session, const gchar *device, GError **err);
gboolean blockdev_setbsz(GuestfsSession *session, const gchar *device, gint32 blocksize, GError **err);
gint64 blockdev_getsz(GuestfsSession *session, const gchar *device, GError **err);
gint64 blockdev_getsize64(GuestfsSession *session, const gchar *device, GError **err);
gboolean blockdev_flushbufs(GuestfsSession *session, const gchar *device, GError **err);
gboolean blockdev_rereadpt(GuestfsSession *session, const gchar *device, GError **err);
gboolean upload(GuestfsSession *session, const gchar *filename, const gchar *remotefilename, GError **err);
gboolean download(GuestfsSession *session, const gchar *remotefilename, const gchar *filename, GError **err);
gchar *checksum(GuestfsSession *session, const gchar *csumtype, const gchar *path, GError **err);
gboolean tar_in(GuestfsSession *session, const gchar *tarfile, const gchar *directory, GError **err);
gboolean tar_out(GuestfsSession *session, const gchar *directory, const gchar *tarfile, GError **err);
gboolean tgz_in(GuestfsSession *session, const gchar *tarball, const gchar *directory, GError **err);
gboolean tgz_out(GuestfsSession *session, const gchar *directory, const gchar *tarball, GError **err);
gboolean mount_ro(GuestfsSession *session, const gchar *device, const gchar *mountpoint, GError **err);
gboolean mount_options(GuestfsSession *session, const gchar *options, const gchar *device, const gchar *mountpoint, GError **err);
gboolean mount_vfs(GuestfsSession *session, const gchar *options, const gchar *vfstype, const gchar *device, const gchar *mountpoint, GError **err);
gchar *debug(GuestfsSession *session, const gchar *subcmd, GSList *extraargs, GError **err);
gboolean lvremove(GuestfsSession *session, const gchar *device, GError **err);
gboolean vgremove(GuestfsSession *session, const gchar *vgname, GError **err);
gboolean pvremove(GuestfsSession *session, const gchar *device, GError **err);
gboolean set_e2label(GuestfsSession *session, const gchar *device, const gchar *label, GError **err);
gchar *get_e2label(GuestfsSession *session, const gchar *device, GError **err);
gboolean set_e2uuid(GuestfsSession *session, const gchar *device, const gchar *uuid, GError **err);
gchar *get_e2uuid(GuestfsSession *session, const gchar *device, GError **err);
gint32 fsck(GuestfsSession *session, const gchar *fstype, const gchar *device, GError **err);
gboolean zero(GuestfsSession *session, const gchar *device, GError **err);
gboolean grub_install(GuestfsSession *session, const gchar *root, const gchar *device, GError **err);
gboolean cp(GuestfsSession *session, const gchar *src, const gchar *dest, GError **err);
gboolean cp_a(GuestfsSession *session, const gchar *src, const gchar *dest, GError **err);
gboolean mv(GuestfsSession *session, const gchar *src, const gchar *dest, GError **err);
gboolean drop_caches(GuestfsSession *session, gint32 whattodrop, GError **err);
gchar *dmesg(GuestfsSession *session, , GError **err);
gboolean ping_daemon(GuestfsSession *session, , GError **err);
gboolean equal(GuestfsSession *session, const gchar *file1, const gchar *file2, GError **err);
GSList *strings(GuestfsSession *session, const gchar *path, GError **err);
GSList *strings_e(GuestfsSession *session, const gchar *encoding, const gchar *path, GError **err);
gchar *hexdump(GuestfsSession *session, const gchar *path, GError **err);
gboolean zerofree(GuestfsSession *session, const gchar *device, GError **err);
gboolean pvresize(GuestfsSession *session, const gchar *device, GError **err);
gboolean sfdisk_N(GuestfsSession *session, const gchar *device, gint32 partnum, gint32 cyls, gint32 heads, gint32 sectors, const gchar *line, GError **err);
gchar *sfdisk_l(GuestfsSession *session, const gchar *device, GError **err);
gchar *sfdisk_kernel_geometry(GuestfsSession *session, const gchar *device, GError **err);
gchar *sfdisk_disk_geometry(GuestfsSession *session, const gchar *device, GError **err);
gboolean vg_activate_all(GuestfsSession *session, gboolean activate, GError **err);
gboolean vg_activate(GuestfsSession *session, gboolean activate, GSList *volgroups, GError **err);
gboolean lvresize(GuestfsSession *session, const gchar *device, gint32 mbytes, GError **err);
gboolean resize2fs(GuestfsSession *session, const gchar *device, GError **err);
GSList *find(GuestfsSession *session, const gchar *directory, GError **err);
gboolean e2fsck_f(GuestfsSession *session, const gchar *device, GError **err);
gboolean sleep(GuestfsSession *session, gint32 secs, GError **err);
gint32 ntfs_3g_probe(GuestfsSession *session, gboolean rw, const gchar *device, GError **err);
gchar *sh(GuestfsSession *session, const gchar *command, GError **err);
GSList *sh_lines(GuestfsSession *session, const gchar *command, GError **err);
GSList *glob_expand(GuestfsSession *session, const gchar *pattern, GError **err);
gboolean scrub_device(GuestfsSession *session, const gchar *device, GError **err);
gboolean scrub_file(GuestfsSession *session, const gchar *file, GError **err);
gboolean scrub_freespace(GuestfsSession *session, const gchar *dir, GError **err);
gchar *mkdtemp(GuestfsSession *session, const gchar *template, GError **err);
gint32 wc_l(GuestfsSession *session, const gchar *path, GError **err);
gint32 wc_w(GuestfsSession *session, const gchar *path, GError **err);
gint32 wc_c(GuestfsSession *session, const gchar *path, GError **err);
GSList *head(GuestfsSession *session, const gchar *path, GError **err);
GSList *head_n(GuestfsSession *session, gint32 nrlines, const gchar *path, GError **err);
GSList *tail(GuestfsSession *session, const gchar *path, GError **err);
GSList *tail_n(GuestfsSession *session, gint32 nrlines, const gchar *path, GError **err);
gchar *df(GuestfsSession *session, , GError **err);
gchar *df_h(GuestfsSession *session, , GError **err);
gint64 du(GuestfsSession *session, const gchar *path, GError **err);
GSList *initrd_list(GuestfsSession *session, const gchar *path, GError **err);
gboolean mount_loop(GuestfsSession *session, const gchar *file, const gchar *mountpoint, GError **err);
gboolean mkswap(GuestfsSession *session, const gchar *device, GError **err);
gboolean mkswap_L(GuestfsSession *session, const gchar *label, const gchar *device, GError **err);
gboolean mkswap_U(GuestfsSession *session, const gchar *uuid, const gchar *device, GError **err);
gboolean mknod(GuestfsSession *session, gint32 mode, gint32 devmajor, gint32 devminor, const gchar *path, GError **err);
gboolean mkfifo(GuestfsSession *session, gint32 mode, const gchar *path, GError **err);
gboolean mknod_b(GuestfsSession *session, gint32 mode, gint32 devmajor, gint32 devminor, const gchar *path, GError **err);
gboolean mknod_c(GuestfsSession *session, gint32 mode, gint32 devmajor, gint32 devminor, const gchar *path, GError **err);
gint32 umask(GuestfsSession *session, gint32 mask, GError **err);
GSList *readdir(GuestfsSession *session, const gchar *dir, GError **err);
gboolean sfdiskM(GuestfsSession *session, const gchar *device, GSList *lines, GError **err);
gchar *zfile(GuestfsSession *session, const gchar *meth, const gchar *path, GError **err);
GSList *getxattrs(GuestfsSession *session, const gchar *path, GError **err);
GSList *lgetxattrs(GuestfsSession *session, const gchar *path, GError **err);
gboolean setxattr(GuestfsSession *session, const gchar *xattr, const gchar *val, gint32 vallen, const gchar *path, GError **err);
gboolean lsetxattr(GuestfsSession *session, const gchar *xattr, const gchar *val, gint32 vallen, const gchar *path, GError **err);
gboolean removexattr(GuestfsSession *session, const gchar *xattr, const gchar *path, GError **err);
gboolean lremovexattr(GuestfsSession *session, const gchar *xattr, const gchar *path, GError **err);
GHashTable *mountpoints(GuestfsSession *session, , GError **err);
gboolean mkmountpoint(GuestfsSession *session, const gchar *exemptpath, GError **err);
gboolean rmmountpoint(GuestfsSession *session, const gchar *exemptpath, GError **err);
GByteArray *read_file(GuestfsSession *session, const gchar *path, GError **err);
GSList *grep(GuestfsSession *session, const gchar *regex, const gchar *path, GError **err);
GSList *egrep(GuestfsSession *session, const gchar *regex, const gchar *path, GError **err);
GSList *fgrep(GuestfsSession *session, const gchar *pattern, const gchar *path, GError **err);
GSList *grepi(GuestfsSession *session, const gchar *regex, const gchar *path, GError **err);
GSList *egrepi(GuestfsSession *session, const gchar *regex, const gchar *path, GError **err);
GSList *fgrepi(GuestfsSession *session, const gchar *pattern, const gchar *path, GError **err);
GSList *zgrep(GuestfsSession *session, const gchar *regex, const gchar *path, GError **err);
GSList *zegrep(GuestfsSession *session, const gchar *regex, const gchar *path, GError **err);
GSList *zfgrep(GuestfsSession *session, const gchar *pattern, const gchar *path, GError **err);
GSList *zgrepi(GuestfsSession *session, const gchar *regex, const gchar *path, GError **err);
GSList *zegrepi(GuestfsSession *session, const gchar *regex, const gchar *path, GError **err);
GSList *zfgrepi(GuestfsSession *session, const gchar *pattern, const gchar *path, GError **err);
gchar *realpath(GuestfsSession *session, const gchar *path, GError **err);
gboolean ln(GuestfsSession *session, const gchar *target, const gchar *linkname, GError **err);
gboolean ln_f(GuestfsSession *session, const gchar *target, const gchar *linkname, GError **err);
gboolean ln_s(GuestfsSession *session, const gchar *target, const gchar *linkname, GError **err);
gboolean ln_sf(GuestfsSession *session, const gchar *target, const gchar *linkname, GError **err);
gchar *readlink(GuestfsSession *session, const gchar *path, GError **err);
gboolean fallocate(GuestfsSession *session, const gchar *path, gint32 len, GError **err);
gboolean swapon_device(GuestfsSession *session, const gchar *device, GError **err);
gboolean swapoff_device(GuestfsSession *session, const gchar *device, GError **err);
gboolean swapon_file(GuestfsSession *session, const gchar *file, GError **err);
gboolean swapoff_file(GuestfsSession *session, const gchar *file, GError **err);
gboolean swapon_label(GuestfsSession *session, const gchar *label, GError **err);
gboolean swapoff_label(GuestfsSession *session, const gchar *label, GError **err);
gboolean swapon_uuid(GuestfsSession *session, const gchar *uuid, GError **err);
gboolean swapoff_uuid(GuestfsSession *session, const gchar *uuid, GError **err);
gboolean mkswap_file(GuestfsSession *session, const gchar *path, GError **err);
gboolean inotify_init(GuestfsSession *session, gint32 maxevents, GError **err);
gint64 inotify_add_watch(GuestfsSession *session, const gchar *path, gint32 mask, GError **err);
gboolean inotify_rm_watch(GuestfsSession *session, gint32 wd, GError **err);
GSList *inotify_read(GuestfsSession *session, , GError **err);
GSList *inotify_files(GuestfsSession *session, , GError **err);
gboolean inotify_close(GuestfsSession *session, , GError **err);
gboolean setcon(GuestfsSession *session, const gchar *context, GError **err);
gchar *getcon(GuestfsSession *session, , GError **err);
gboolean mkfs_b(GuestfsSession *session, const gchar *fstype, gint32 blocksize, const gchar *device, GError **err);
gboolean mke2journal(GuestfsSession *session, gint32 blocksize, const gchar *device, GError **err);
gboolean mke2journal_L(GuestfsSession *session, gint32 blocksize, const gchar *label, const gchar *device, GError **err);
gboolean mke2journal_U(GuestfsSession *session, gint32 blocksize, const gchar *uuid, const gchar *device, GError **err);
gboolean mke2fs_J(GuestfsSession *session, const gchar *fstype, gint32 blocksize, const gchar *device, const gchar *journal, GError **err);
gboolean mke2fs_JL(GuestfsSession *session, const gchar *fstype, gint32 blocksize, const gchar *device, const gchar *label, GError **err);
gboolean mke2fs_JU(GuestfsSession *session, const gchar *fstype, gint32 blocksize, const gchar *device, const gchar *uuid, GError **err);
gboolean modprobe(GuestfsSession *session, const gchar *modulename, GError **err);
gchar *echo_daemon(GuestfsSession *session, GSList *words, GError **err);
gboolean find0(GuestfsSession *session, const gchar *directory, const gchar *files, GError **err);
gchar *case_sensitive_path(GuestfsSession *session, const gchar *path, GError **err);
gchar *vfs_type(GuestfsSession *session, const gchar *device, GError **err);
gboolean truncate(GuestfsSession *session, const gchar *path, GError **err);
gboolean truncate_size(GuestfsSession *session, const gchar *path, gint64 size, GError **err);
gboolean utimens(GuestfsSession *session, const gchar *path, gint64 atsecs, gint64 atnsecs, gint64 mtsecs, gint64 mtnsecs, GError **err);
gboolean mkdir_mode(GuestfsSession *session, const gchar *path, gint32 mode, GError **err);
gboolean lchown(GuestfsSession *session, gint32 owner, gint32 group, const gchar *path, GError **err);
GSList *lstatlist(GuestfsSession *session, const gchar *path, GSList *names, GError **err);
GSList *lxattrlist(GuestfsSession *session, const gchar *path, GSList *names, GError **err);
GSList *readlinklist(GuestfsSession *session, const gchar *path, GSList *names, GError **err);
GByteArray *pread(GuestfsSession *session, const gchar *path, gint32 count, gint64 offset, GError **err);
gboolean part_init(GuestfsSession *session, const gchar *device, const gchar *parttype, GError **err);
gboolean part_add(GuestfsSession *session, const gchar *device, const gchar *prlogex, gint64 startsect, gint64 endsect, GError **err);
gboolean part_disk(GuestfsSession *session, const gchar *device, const gchar *parttype, GError **err);
gboolean part_set_bootable(GuestfsSession *session, const gchar *device, gint32 partnum, gboolean bootable, GError **err);
gboolean part_set_name(GuestfsSession *session, const gchar *device, gint32 partnum, const gchar *name, GError **err);
GSList *part_list(GuestfsSession *session, const gchar *device, GError **err);
gchar *part_get_parttype(GuestfsSession *session, const gchar *device, GError **err);
gboolean fill(GuestfsSession *session, gint32 c, gint32 len, const gchar *path, GError **err);
gboolean available(GuestfsSession *session, GSList *groups, GError **err);
gboolean dd(GuestfsSession *session, const gchar *src, const gchar *dest, GError **err);
gint64 filesize(GuestfsSession *session, const gchar *file, GError **err);
gboolean lvrename(GuestfsSession *session, const gchar *logvol, const gchar *newlogvol, GError **err);
gboolean vgrename(GuestfsSession *session, const gchar *volgroup, const gchar *newvolgroup, GError **err);
GByteArray *initrd_cat(GuestfsSession *session, const gchar *initrdpath, const gchar *filename, GError **err);
gchar *pvuuid(GuestfsSession *session, const gchar *device, GError **err);
gchar *vguuid(GuestfsSession *session, const gchar *vgname, GError **err);
gchar *lvuuid(GuestfsSession *session, const gchar *device, GError **err);
GSList *vgpvuuids(GuestfsSession *session, const gchar *vgname, GError **err);
GSList *vglvuuids(GuestfsSession *session, const gchar *vgname, GError **err);
gboolean copy_size(GuestfsSession *session, const gchar *src, const gchar *dest, gint64 size, GError **err);
gboolean zero_device(GuestfsSession *session, const gchar *device, GError **err);
gboolean txz_in(GuestfsSession *session, const gchar *tarball, const gchar *directory, GError **err);
gboolean txz_out(GuestfsSession *session, const gchar *directory, const gchar *tarball, GError **err);
gboolean ntfsresize(GuestfsSession *session, const gchar *device, GError **err);
gboolean vgscan(GuestfsSession *session, , GError **err);
gboolean part_del(GuestfsSession *session, const gchar *device, gint32 partnum, GError **err);
gboolean part_get_bootable(GuestfsSession *session, const gchar *device, gint32 partnum, GError **err);
gint32 part_get_mbr_id(GuestfsSession *session, const gchar *device, gint32 partnum, GError **err);
gboolean part_set_mbr_id(GuestfsSession *session, const gchar *device, gint32 partnum, gint32 idbyte, GError **err);
gchar *checksum_device(GuestfsSession *session, const gchar *csumtype, const gchar *device, GError **err);
gboolean lvresize_free(GuestfsSession *session, const gchar *lv, gint32 percent, GError **err);
gboolean aug_clear(GuestfsSession *session, const gchar *augpath, GError **err);
gint32 get_umask(GuestfsSession *session, , GError **err);
gboolean debug_upload(GuestfsSession *session, const gchar *filename, const gchar *tmpname, gint32 mode, GError **err);
gboolean base64_in(GuestfsSession *session, const gchar *base64file, const gchar *filename, GError **err);
gboolean base64_out(GuestfsSession *session, const gchar *filename, const gchar *base64file, GError **err);
gboolean checksums_out(GuestfsSession *session, const gchar *csumtype, const gchar *directory, const gchar *sumsfile, GError **err);
gboolean fill_pattern(GuestfsSession *session, const gchar *pattern, gint32 len, const gchar *path, GError **err);
gboolean write(GuestfsSession *session, const gchar *path, GByteArray *content, GError **err);
gint32 pwrite(GuestfsSession *session, const gchar *path, GByteArray *content, gint64 offset, GError **err);
gboolean resize2fs_size(GuestfsSession *session, const gchar *device, gint64 size, GError **err);
gboolean pvresize_size(GuestfsSession *session, const gchar *device, gint64 size, GError **err);
gboolean ntfsresize_size(GuestfsSession *session, const gchar *device, gint64 size, GError **err);
GSList *available_all_groups(GuestfsSession *session, , GError **err);
gboolean fallocate64(GuestfsSession *session, const gchar *path, gint64 len, GError **err);
gchar *vfs_label(GuestfsSession *session, const gchar *device, GError **err);
gchar *vfs_uuid(GuestfsSession *session, const gchar *device, GError **err);
gboolean lvm_set_filter(GuestfsSession *session, GSList *devices, GError **err);
gboolean lvm_clear_filter(GuestfsSession *session, , GError **err);
gboolean luks_open(GuestfsSession *session, const gchar *device, const gchar *key, const gchar *mapname, GError **err);
gboolean luks_open_ro(GuestfsSession *session, const gchar *device, const gchar *key, const gchar *mapname, GError **err);
gboolean luks_close(GuestfsSession *session, const gchar *device, GError **err);
gboolean luks_format(GuestfsSession *session, const gchar *device, const gchar *key, gint32 keyslot, GError **err);
gboolean luks_format_cipher(GuestfsSession *session, const gchar *device, const gchar *key, gint32 keyslot, const gchar *cipher, GError **err);
gboolean luks_add_key(GuestfsSession *session, const gchar *device, const gchar *key, const gchar *newkey, gint32 keyslot, GError **err);
gboolean luks_kill_slot(GuestfsSession *session, const gchar *device, const gchar *key, gint32 keyslot, GError **err);
gboolean is_lv(GuestfsSession *session, const gchar *device, GError **err);
gchar *findfs_uuid(GuestfsSession *session, const gchar *uuid, GError **err);
gchar *findfs_label(GuestfsSession *session, const gchar *label, GError **err);
gboolean is_chardev(GuestfsSession *session, const gchar *path, GError **err);
gboolean is_blockdev(GuestfsSession *session, const gchar *path, GError **err);
gboolean is_fifo(GuestfsSession *session, const gchar *path, GError **err);
gboolean is_symlink(GuestfsSession *session, const gchar *path, GError **err);
gboolean is_socket(GuestfsSession *session, const gchar *path, GError **err);
gchar *part_to_dev(GuestfsSession *session, const gchar *partition, GError **err);
gboolean upload_offset(GuestfsSession *session, const gchar *filename, const gchar *remotefilename, gint64 offset, GError **err);
gboolean download_offset(GuestfsSession *session, const gchar *remotefilename, const gchar *filename, gint64 offset, gint64 size, GError **err);
gint32 pwrite_device(GuestfsSession *session, const gchar *device, GByteArray *content, gint64 offset, GError **err);
GByteArray *pread_device(GuestfsSession *session, const gchar *device, gint32 count, gint64 offset, GError **err);
gchar *lvm_canonical_lv_name(GuestfsSession *session, const gchar *lvname, GError **err);
gboolean mkfs_opts(GuestfsSession *session, const gchar *fstype, const gchar *device, GuestfsMkfsOpts *optargs, GError **err);
GByteArray *getxattr(GuestfsSession *session, const gchar *path, const gchar *name, GError **err);
GByteArray *lgetxattr(GuestfsSession *session, const gchar *path, const gchar *name, GError **err);
gboolean resize2fs_M(GuestfsSession *session, const gchar *device, GError **err);
gboolean internal_autosync(GuestfsSession *session, , GError **err);
gboolean is_zero(GuestfsSession *session, const gchar *path, GError **err);
gboolean is_zero_device(GuestfsSession *session, const gchar *device, GError **err);
GSList *list_9p(GuestfsSession *session, , GError **err);
gboolean mount_9p(GuestfsSession *session, const gchar *mounttag, const gchar *mountpoint, GuestfsMount9P *optargs, GError **err);
GSList *list_dm_devices(GuestfsSession *session, , GError **err);
gboolean ntfsresize_opts(GuestfsSession *session, const gchar *device, GuestfsNTFSResizeOpts *optargs, GError **err);
gboolean btrfs_filesystem_resize(GuestfsSession *session, const gchar *mountpoint, GuestfsBTRFSFilesystemResize *optargs, GError **err);
gboolean write_append(GuestfsSession *session, const gchar *path, GByteArray *content, GError **err);
gboolean compress_out(GuestfsSession *session, const gchar *ctype, const gchar *file, const gchar *zfile, GuestfsCompressOut *optargs, GError **err);
gboolean compress_device_out(GuestfsSession *session, const gchar *ctype, const gchar *device, const gchar *zdevice, GuestfsCompressDeviceOut *optargs, GError **err);
gint32 part_to_partnum(GuestfsSession *session, const gchar *partition, GError **err);
gboolean copy_device_to_device(GuestfsSession *session, const gchar *src, const gchar *dest, GuestfsCopyDeviceToDevice *optargs, GError **err);
gboolean copy_device_to_file(GuestfsSession *session, const gchar *src, const gchar *dest, GuestfsCopyDeviceToFile *optargs, GError **err);
gboolean copy_file_to_device(GuestfsSession *session, const gchar *src, const gchar *dest, GuestfsCopyFileToDevice *optargs, GError **err);
gboolean copy_file_to_file(GuestfsSession *session, const gchar *src, const gchar *dest, GuestfsCopyFileToFile *optargs, GError **err);
gboolean tune2fs(GuestfsSession *session, const gchar *device, GuestfsTune2FS *optargs, GError **err);
gboolean md_create(GuestfsSession *session, const gchar *name, GSList *devices, GuestfsMDCreate *optargs, GError **err);
GSList *list_md_devices(GuestfsSession *session, , GError **err);
GHashTable *md_detail(GuestfsSession *session, const gchar *md, GError **err);
gboolean md_stop(GuestfsSession *session, const gchar *md, GError **err);
GHashTable *blkid(GuestfsSession *session, const gchar *device, GError **err);