/* repo.c generated by valac 0.56.7, the Vala compiler
 * generated from repo.vala, do not modify */

#include <glib-object.h>
#include <glib.h>
#include <string.h>

#if !defined(VALA_EXTERN)
#if defined(_MSC_VER)
#define VALA_EXTERN __declspec(dllexport) extern
#elif __GNUC__ >= 4
#define VALA_EXTERN __attribute__((visibility("default"))) extern
#else
#define VALA_EXTERN extern
#endif
#endif

#define SEAFILE_TYPE_REPO (seafile_repo_get_type ())
#define SEAFILE_REPO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SEAFILE_TYPE_REPO, SeafileRepo))
#define SEAFILE_REPO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SEAFILE_TYPE_REPO, SeafileRepoClass))
#define SEAFILE_IS_REPO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SEAFILE_TYPE_REPO))
#define SEAFILE_IS_REPO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SEAFILE_TYPE_REPO))
#define SEAFILE_REPO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SEAFILE_TYPE_REPO, SeafileRepoClass))

typedef struct _SeafileRepo SeafileRepo;
typedef struct _SeafileRepoClass SeafileRepoClass;
typedef struct _SeafileRepoPrivate SeafileRepoPrivate;
enum  {
	SEAFILE_REPO_0_PROPERTY,
	SEAFILE_REPO_ID_PROPERTY,
	SEAFILE_REPO_NAME_PROPERTY,
	SEAFILE_REPO_DESC_PROPERTY,
	SEAFILE_REPO_VERSION_PROPERTY,
	SEAFILE_REPO_LAST_MODIFY_PROPERTY,
	SEAFILE_REPO_SIZE_PROPERTY,
	SEAFILE_REPO_FILE_COUNT_PROPERTY,
	SEAFILE_REPO_HEAD_CMMT_ID_PROPERTY,
	SEAFILE_REPO_ROOT_PROPERTY,
	SEAFILE_REPO_REPO_ID_PROPERTY,
	SEAFILE_REPO_REPO_NAME_PROPERTY,
	SEAFILE_REPO_REPO_DESC_PROPERTY,
	SEAFILE_REPO_LAST_MODIFIED_PROPERTY,
	SEAFILE_REPO_ENCRYPTED_PROPERTY,
	SEAFILE_REPO_MAGIC_PROPERTY,
	SEAFILE_REPO_ENC_VERSION_PROPERTY,
	SEAFILE_REPO_RANDOM_KEY_PROPERTY,
	SEAFILE_REPO_SALT_PROPERTY,
	SEAFILE_REPO_WORKTREE_PROPERTY,
	SEAFILE_REPO_RELAY_ID_PROPERTY,
	SEAFILE_REPO_LAST_SYNC_TIME_PROPERTY,
	SEAFILE_REPO_AUTO_SYNC_PROPERTY,
	SEAFILE_REPO_WORKTREE_INVALID_PROPERTY,
	SEAFILE_REPO_IS_VIRTUAL_PROPERTY,
	SEAFILE_REPO_ORIGIN_REPO_ID_PROPERTY,
	SEAFILE_REPO_ORIGIN_REPO_NAME_PROPERTY,
	SEAFILE_REPO_ORIGIN_PATH_PROPERTY,
	SEAFILE_REPO_IS_ORIGINAL_OWNER_PROPERTY,
	SEAFILE_REPO_VIRTUAL_PERM_PROPERTY,
	SEAFILE_REPO_STORE_ID_PROPERTY,
	SEAFILE_REPO_IS_CORRUPTED_PROPERTY,
	SEAFILE_REPO_REPAIRED_PROPERTY,
	SEAFILE_REPO_SHARE_TYPE_PROPERTY,
	SEAFILE_REPO_PERMISSION_PROPERTY,
	SEAFILE_REPO_USER_PROPERTY,
	SEAFILE_REPO_GROUP_ID_PROPERTY,
	SEAFILE_REPO_IS_SHARED_PROPERTY,
	SEAFILE_REPO_NUM_PROPERTIES
};
static GParamSpec* seafile_repo_properties[SEAFILE_REPO_NUM_PROPERTIES];
#define _g_free0(var) (var = (g_free (var), NULL))

#define SEAFILE_TYPE_SYNC_TASK (seafile_sync_task_get_type ())
#define SEAFILE_SYNC_TASK(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SEAFILE_TYPE_SYNC_TASK, SeafileSyncTask))
#define SEAFILE_SYNC_TASK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SEAFILE_TYPE_SYNC_TASK, SeafileSyncTaskClass))
#define SEAFILE_IS_SYNC_TASK(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SEAFILE_TYPE_SYNC_TASK))
#define SEAFILE_IS_SYNC_TASK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SEAFILE_TYPE_SYNC_TASK))
#define SEAFILE_SYNC_TASK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SEAFILE_TYPE_SYNC_TASK, SeafileSyncTaskClass))

typedef struct _SeafileSyncTask SeafileSyncTask;
typedef struct _SeafileSyncTaskClass SeafileSyncTaskClass;
typedef struct _SeafileSyncTaskPrivate SeafileSyncTaskPrivate;
enum  {
	SEAFILE_SYNC_TASK_0_PROPERTY,
	SEAFILE_SYNC_TASK_FORCE_UPLOAD_PROPERTY,
	SEAFILE_SYNC_TASK_REPO_ID_PROPERTY,
	SEAFILE_SYNC_TASK_STATE_PROPERTY,
	SEAFILE_SYNC_TASK_ERROR_PROPERTY,
	SEAFILE_SYNC_TASK_NUM_PROPERTIES
};
static GParamSpec* seafile_sync_task_properties[SEAFILE_SYNC_TASK_NUM_PROPERTIES];

#define SEAFILE_TYPE_SESSION_INFO (seafile_session_info_get_type ())
#define SEAFILE_SESSION_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SEAFILE_TYPE_SESSION_INFO, SeafileSessionInfo))
#define SEAFILE_SESSION_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SEAFILE_TYPE_SESSION_INFO, SeafileSessionInfoClass))
#define SEAFILE_IS_SESSION_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SEAFILE_TYPE_SESSION_INFO))
#define SEAFILE_IS_SESSION_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SEAFILE_TYPE_SESSION_INFO))
#define SEAFILE_SESSION_INFO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SEAFILE_TYPE_SESSION_INFO, SeafileSessionInfoClass))

typedef struct _SeafileSessionInfo SeafileSessionInfo;
typedef struct _SeafileSessionInfoClass SeafileSessionInfoClass;
typedef struct _SeafileSessionInfoPrivate SeafileSessionInfoPrivate;
enum  {
	SEAFILE_SESSION_INFO_0_PROPERTY,
	SEAFILE_SESSION_INFO_DATADIR_PROPERTY,
	SEAFILE_SESSION_INFO_NUM_PROPERTIES
};
static GParamSpec* seafile_session_info_properties[SEAFILE_SESSION_INFO_NUM_PROPERTIES];

#define SEAFILE_TYPE_DIFF_ENTRY (seafile_diff_entry_get_type ())
#define SEAFILE_DIFF_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SEAFILE_TYPE_DIFF_ENTRY, SeafileDiffEntry))
#define SEAFILE_DIFF_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SEAFILE_TYPE_DIFF_ENTRY, SeafileDiffEntryClass))
#define SEAFILE_IS_DIFF_ENTRY(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SEAFILE_TYPE_DIFF_ENTRY))
#define SEAFILE_IS_DIFF_ENTRY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SEAFILE_TYPE_DIFF_ENTRY))
#define SEAFILE_DIFF_ENTRY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SEAFILE_TYPE_DIFF_ENTRY, SeafileDiffEntryClass))

typedef struct _SeafileDiffEntry SeafileDiffEntry;
typedef struct _SeafileDiffEntryClass SeafileDiffEntryClass;
typedef struct _SeafileDiffEntryPrivate SeafileDiffEntryPrivate;
enum  {
	SEAFILE_DIFF_ENTRY_0_PROPERTY,
	SEAFILE_DIFF_ENTRY_STATUS_PROPERTY,
	SEAFILE_DIFF_ENTRY_NAME_PROPERTY,
	SEAFILE_DIFF_ENTRY_NEW_NAME_PROPERTY,
	SEAFILE_DIFF_ENTRY_NUM_PROPERTIES
};
static GParamSpec* seafile_diff_entry_properties[SEAFILE_DIFF_ENTRY_NUM_PROPERTIES];

#define SEAFILE_TYPE_ENCRYPTION_INFO (seafile_encryption_info_get_type ())
#define SEAFILE_ENCRYPTION_INFO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SEAFILE_TYPE_ENCRYPTION_INFO, SeafileEncryptionInfo))
#define SEAFILE_ENCRYPTION_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SEAFILE_TYPE_ENCRYPTION_INFO, SeafileEncryptionInfoClass))
#define SEAFILE_IS_ENCRYPTION_INFO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SEAFILE_TYPE_ENCRYPTION_INFO))
#define SEAFILE_IS_ENCRYPTION_INFO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SEAFILE_TYPE_ENCRYPTION_INFO))
#define SEAFILE_ENCRYPTION_INFO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SEAFILE_TYPE_ENCRYPTION_INFO, SeafileEncryptionInfoClass))

typedef struct _SeafileEncryptionInfo SeafileEncryptionInfo;
typedef struct _SeafileEncryptionInfoClass SeafileEncryptionInfoClass;
typedef struct _SeafileEncryptionInfoPrivate SeafileEncryptionInfoPrivate;
enum  {
	SEAFILE_ENCRYPTION_INFO_0_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_REPO_ID_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_PASSWD_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_ENC_VERSION_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_MAGIC_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_PWD_HASH_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_RANDOM_KEY_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_SALT_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_NUM_PROPERTIES
};
static GParamSpec* seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_NUM_PROPERTIES];

#define SEAFILE_TYPE_FILE_SYNC_ERROR (seafile_file_sync_error_get_type ())
#define SEAFILE_FILE_SYNC_ERROR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SEAFILE_TYPE_FILE_SYNC_ERROR, SeafileFileSyncError))
#define SEAFILE_FILE_SYNC_ERROR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SEAFILE_TYPE_FILE_SYNC_ERROR, SeafileFileSyncErrorClass))
#define SEAFILE_IS_FILE_SYNC_ERROR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SEAFILE_TYPE_FILE_SYNC_ERROR))
#define SEAFILE_IS_FILE_SYNC_ERROR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SEAFILE_TYPE_FILE_SYNC_ERROR))
#define SEAFILE_FILE_SYNC_ERROR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SEAFILE_TYPE_FILE_SYNC_ERROR, SeafileFileSyncErrorClass))

typedef struct _SeafileFileSyncError SeafileFileSyncError;
typedef struct _SeafileFileSyncErrorClass SeafileFileSyncErrorClass;
typedef struct _SeafileFileSyncErrorPrivate SeafileFileSyncErrorPrivate;
enum  {
	SEAFILE_FILE_SYNC_ERROR_0_PROPERTY,
	SEAFILE_FILE_SYNC_ERROR_ID_PROPERTY,
	SEAFILE_FILE_SYNC_ERROR_REPO_ID_PROPERTY,
	SEAFILE_FILE_SYNC_ERROR_REPO_NAME_PROPERTY,
	SEAFILE_FILE_SYNC_ERROR_PATH_PROPERTY,
	SEAFILE_FILE_SYNC_ERROR_ERR_ID_PROPERTY,
	SEAFILE_FILE_SYNC_ERROR_TIMESTAMP_PROPERTY,
	SEAFILE_FILE_SYNC_ERROR_NUM_PROPERTIES
};
static GParamSpec* seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_NUM_PROPERTIES];

struct _SeafileRepo {
	GObject parent_instance;
	SeafileRepoPrivate * priv;
	gchar _id[37];
	gchar* _name;
	gchar* _desc;
	gchar* _worktree;
	gchar* _relay_id;
};

struct _SeafileRepoClass {
	GObjectClass parent_class;
};

struct _SeafileRepoPrivate {
	gint _version;
	gint _last_modify;
	gint64 _size;
	gint64 _file_count;
	gchar* _head_cmmt_id;
	gchar* _root;
	gchar* _repo_id;
	gchar* _repo_name;
	gchar* _repo_desc;
	gint _last_modified;
	gboolean _encrypted;
	gchar* _magic;
	gint _enc_version;
	gchar* _random_key;
	gchar* _salt;
	gint _last_sync_time;
	gboolean _auto_sync;
	gboolean _worktree_invalid;
	gboolean _is_virtual;
	gchar* _origin_repo_id;
	gchar* _origin_repo_name;
	gchar* _origin_path;
	gboolean _is_original_owner;
	gchar* _virtual_perm;
	gchar* _store_id;
	gboolean _is_corrupted;
	gboolean _repaired;
	gchar* _share_type;
	gchar* _permission;
	gchar* _user;
	gint _group_id;
	gboolean _is_shared;
};

struct _SeafileSyncTask {
	GObject parent_instance;
	SeafileSyncTaskPrivate * priv;
};

struct _SeafileSyncTaskClass {
	GObjectClass parent_class;
};

struct _SeafileSyncTaskPrivate {
	gboolean _force_upload;
	gchar* _repo_id;
	gchar* _state;
	gint _error;
};

struct _SeafileSessionInfo {
	GObject parent_instance;
	SeafileSessionInfoPrivate * priv;
};

struct _SeafileSessionInfoClass {
	GObjectClass parent_class;
};

struct _SeafileSessionInfoPrivate {
	gchar* _datadir;
};

struct _SeafileDiffEntry {
	GObject parent_instance;
	SeafileDiffEntryPrivate * priv;
};

struct _SeafileDiffEntryClass {
	GObjectClass parent_class;
};

struct _SeafileDiffEntryPrivate {
	gchar* _status;
	gchar* _name;
	gchar* _new_name;
};

struct _SeafileEncryptionInfo {
	GObject parent_instance;
	SeafileEncryptionInfoPrivate * priv;
};

struct _SeafileEncryptionInfoClass {
	GObjectClass parent_class;
};

struct _SeafileEncryptionInfoPrivate {
	gchar* _repo_id;
	gchar* _passwd;
	gint _enc_version;
	gchar* _magic;
	gchar* _pwd_hash;
	gchar* _random_key;
	gchar* _salt;
};

struct _SeafileFileSyncError {
	GObject parent_instance;
	SeafileFileSyncErrorPrivate * priv;
};

struct _SeafileFileSyncErrorClass {
	GObjectClass parent_class;
};

struct _SeafileFileSyncErrorPrivate {
	gint _id;
	gchar* _repo_id;
	gchar* _repo_name;
	gchar* _path;
	gint _err_id;
	gint64 _timestamp;
};

static gint SeafileRepo_private_offset;
static gpointer seafile_repo_parent_class = NULL;
static gint SeafileSyncTask_private_offset;
static gpointer seafile_sync_task_parent_class = NULL;
static gint SeafileSessionInfo_private_offset;
static gpointer seafile_session_info_parent_class = NULL;
static gint SeafileDiffEntry_private_offset;
static gpointer seafile_diff_entry_parent_class = NULL;
static gint SeafileEncryptionInfo_private_offset;
static gpointer seafile_encryption_info_parent_class = NULL;
static gint SeafileFileSyncError_private_offset;
static gpointer seafile_file_sync_error_parent_class = NULL;

VALA_EXTERN GType seafile_repo_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (SeafileRepo, g_object_unref)
VALA_EXTERN SeafileRepo* seafile_repo_new (void);
VALA_EXTERN SeafileRepo* seafile_repo_construct (GType object_type);
VALA_EXTERN const gchar* seafile_repo_get_id (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_id (SeafileRepo* self,
                          const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_name (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_name (SeafileRepo* self,
                            const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_desc (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_desc (SeafileRepo* self,
                            const gchar* value);
VALA_EXTERN gint seafile_repo_get_version (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_version (SeafileRepo* self,
                               gint value);
VALA_EXTERN gint seafile_repo_get_last_modify (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_last_modify (SeafileRepo* self,
                                   gint value);
VALA_EXTERN gint64 seafile_repo_get_size (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_size (SeafileRepo* self,
                            gint64 value);
VALA_EXTERN gint64 seafile_repo_get_file_count (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_file_count (SeafileRepo* self,
                                  gint64 value);
VALA_EXTERN const gchar* seafile_repo_get_head_cmmt_id (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_head_cmmt_id (SeafileRepo* self,
                                    const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_root (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_root (SeafileRepo* self,
                            const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_repo_id (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_repo_id (SeafileRepo* self,
                               const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_repo_name (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_repo_name (SeafileRepo* self,
                                 const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_repo_desc (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_repo_desc (SeafileRepo* self,
                                 const gchar* value);
VALA_EXTERN gint seafile_repo_get_last_modified (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_last_modified (SeafileRepo* self,
                                     gint value);
VALA_EXTERN gboolean seafile_repo_get_encrypted (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_encrypted (SeafileRepo* self,
                                 gboolean value);
VALA_EXTERN const gchar* seafile_repo_get_magic (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_magic (SeafileRepo* self,
                             const gchar* value);
VALA_EXTERN gint seafile_repo_get_enc_version (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_enc_version (SeafileRepo* self,
                                   gint value);
VALA_EXTERN const gchar* seafile_repo_get_random_key (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_random_key (SeafileRepo* self,
                                  const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_salt (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_salt (SeafileRepo* self,
                            const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_worktree (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_worktree (SeafileRepo* self,
                                const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_relay_id (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_relay_id (SeafileRepo* self,
                                const gchar* value);
VALA_EXTERN gint seafile_repo_get_last_sync_time (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_last_sync_time (SeafileRepo* self,
                                      gint value);
VALA_EXTERN gboolean seafile_repo_get_auto_sync (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_auto_sync (SeafileRepo* self,
                                 gboolean value);
VALA_EXTERN gboolean seafile_repo_get_worktree_invalid (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_worktree_invalid (SeafileRepo* self,
                                        gboolean value);
VALA_EXTERN gboolean seafile_repo_get_is_virtual (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_is_virtual (SeafileRepo* self,
                                  gboolean value);
VALA_EXTERN const gchar* seafile_repo_get_origin_repo_id (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_origin_repo_id (SeafileRepo* self,
                                      const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_origin_repo_name (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_origin_repo_name (SeafileRepo* self,
                                        const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_origin_path (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_origin_path (SeafileRepo* self,
                                   const gchar* value);
VALA_EXTERN gboolean seafile_repo_get_is_original_owner (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_is_original_owner (SeafileRepo* self,
                                         gboolean value);
VALA_EXTERN const gchar* seafile_repo_get_virtual_perm (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_virtual_perm (SeafileRepo* self,
                                    const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_store_id (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_store_id (SeafileRepo* self,
                                const gchar* value);
VALA_EXTERN gboolean seafile_repo_get_is_corrupted (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_is_corrupted (SeafileRepo* self,
                                    gboolean value);
VALA_EXTERN gboolean seafile_repo_get_repaired (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_repaired (SeafileRepo* self,
                                gboolean value);
VALA_EXTERN const gchar* seafile_repo_get_share_type (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_share_type (SeafileRepo* self,
                                  const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_permission (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_permission (SeafileRepo* self,
                                  const gchar* value);
VALA_EXTERN const gchar* seafile_repo_get_user (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_user (SeafileRepo* self,
                            const gchar* value);
VALA_EXTERN gint seafile_repo_get_group_id (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_group_id (SeafileRepo* self,
                                gint value);
VALA_EXTERN gboolean seafile_repo_get_is_shared (SeafileRepo* self);
VALA_EXTERN void seafile_repo_set_is_shared (SeafileRepo* self,
                                 gboolean value);
static void seafile_repo_finalize (GObject * obj);
static GType seafile_repo_get_type_once (void);
static void _vala_seafile_repo_get_property (GObject * object,
                                      guint property_id,
                                      GValue * value,
                                      GParamSpec * pspec);
static void _vala_seafile_repo_set_property (GObject * object,
                                      guint property_id,
                                      const GValue * value,
                                      GParamSpec * pspec);
VALA_EXTERN GType seafile_sync_task_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (SeafileSyncTask, g_object_unref)
VALA_EXTERN SeafileSyncTask* seafile_sync_task_new (void);
VALA_EXTERN SeafileSyncTask* seafile_sync_task_construct (GType object_type);
VALA_EXTERN gboolean seafile_sync_task_get_force_upload (SeafileSyncTask* self);
VALA_EXTERN void seafile_sync_task_set_force_upload (SeafileSyncTask* self,
                                         gboolean value);
VALA_EXTERN const gchar* seafile_sync_task_get_repo_id (SeafileSyncTask* self);
VALA_EXTERN void seafile_sync_task_set_repo_id (SeafileSyncTask* self,
                                    const gchar* value);
VALA_EXTERN const gchar* seafile_sync_task_get_state (SeafileSyncTask* self);
VALA_EXTERN void seafile_sync_task_set_state (SeafileSyncTask* self,
                                  const gchar* value);
VALA_EXTERN gint seafile_sync_task_get_error (SeafileSyncTask* self);
VALA_EXTERN void seafile_sync_task_set_error (SeafileSyncTask* self,
                                  gint value);
static void seafile_sync_task_finalize (GObject * obj);
static GType seafile_sync_task_get_type_once (void);
static void _vala_seafile_sync_task_get_property (GObject * object,
                                           guint property_id,
                                           GValue * value,
                                           GParamSpec * pspec);
static void _vala_seafile_sync_task_set_property (GObject * object,
                                           guint property_id,
                                           const GValue * value,
                                           GParamSpec * pspec);
VALA_EXTERN GType seafile_session_info_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (SeafileSessionInfo, g_object_unref)
VALA_EXTERN SeafileSessionInfo* seafile_session_info_new (void);
VALA_EXTERN SeafileSessionInfo* seafile_session_info_construct (GType object_type);
VALA_EXTERN const gchar* seafile_session_info_get_datadir (SeafileSessionInfo* self);
VALA_EXTERN void seafile_session_info_set_datadir (SeafileSessionInfo* self,
                                       const gchar* value);
static void seafile_session_info_finalize (GObject * obj);
static GType seafile_session_info_get_type_once (void);
static void _vala_seafile_session_info_get_property (GObject * object,
                                              guint property_id,
                                              GValue * value,
                                              GParamSpec * pspec);
static void _vala_seafile_session_info_set_property (GObject * object,
                                              guint property_id,
                                              const GValue * value,
                                              GParamSpec * pspec);
VALA_EXTERN GType seafile_diff_entry_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (SeafileDiffEntry, g_object_unref)
VALA_EXTERN SeafileDiffEntry* seafile_diff_entry_new (void);
VALA_EXTERN SeafileDiffEntry* seafile_diff_entry_construct (GType object_type);
VALA_EXTERN const gchar* seafile_diff_entry_get_status (SeafileDiffEntry* self);
VALA_EXTERN void seafile_diff_entry_set_status (SeafileDiffEntry* self,
                                    const gchar* value);
VALA_EXTERN const gchar* seafile_diff_entry_get_name (SeafileDiffEntry* self);
VALA_EXTERN void seafile_diff_entry_set_name (SeafileDiffEntry* self,
                                  const gchar* value);
VALA_EXTERN const gchar* seafile_diff_entry_get_new_name (SeafileDiffEntry* self);
VALA_EXTERN void seafile_diff_entry_set_new_name (SeafileDiffEntry* self,
                                      const gchar* value);
static void seafile_diff_entry_finalize (GObject * obj);
static GType seafile_diff_entry_get_type_once (void);
static void _vala_seafile_diff_entry_get_property (GObject * object,
                                            guint property_id,
                                            GValue * value,
                                            GParamSpec * pspec);
static void _vala_seafile_diff_entry_set_property (GObject * object,
                                            guint property_id,
                                            const GValue * value,
                                            GParamSpec * pspec);
VALA_EXTERN GType seafile_encryption_info_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (SeafileEncryptionInfo, g_object_unref)
VALA_EXTERN SeafileEncryptionInfo* seafile_encryption_info_new (void);
VALA_EXTERN SeafileEncryptionInfo* seafile_encryption_info_construct (GType object_type);
VALA_EXTERN const gchar* seafile_encryption_info_get_repo_id (SeafileEncryptionInfo* self);
VALA_EXTERN void seafile_encryption_info_set_repo_id (SeafileEncryptionInfo* self,
                                          const gchar* value);
VALA_EXTERN const gchar* seafile_encryption_info_get_passwd (SeafileEncryptionInfo* self);
VALA_EXTERN void seafile_encryption_info_set_passwd (SeafileEncryptionInfo* self,
                                         const gchar* value);
VALA_EXTERN gint seafile_encryption_info_get_enc_version (SeafileEncryptionInfo* self);
VALA_EXTERN void seafile_encryption_info_set_enc_version (SeafileEncryptionInfo* self,
                                              gint value);
VALA_EXTERN const gchar* seafile_encryption_info_get_magic (SeafileEncryptionInfo* self);
VALA_EXTERN void seafile_encryption_info_set_magic (SeafileEncryptionInfo* self,
                                        const gchar* value);
VALA_EXTERN const gchar* seafile_encryption_info_get_pwd_hash (SeafileEncryptionInfo* self);
VALA_EXTERN void seafile_encryption_info_set_pwd_hash (SeafileEncryptionInfo* self,
                                           const gchar* value);
VALA_EXTERN const gchar* seafile_encryption_info_get_random_key (SeafileEncryptionInfo* self);
VALA_EXTERN void seafile_encryption_info_set_random_key (SeafileEncryptionInfo* self,
                                             const gchar* value);
VALA_EXTERN const gchar* seafile_encryption_info_get_salt (SeafileEncryptionInfo* self);
VALA_EXTERN void seafile_encryption_info_set_salt (SeafileEncryptionInfo* self,
                                       const gchar* value);
static void seafile_encryption_info_finalize (GObject * obj);
static GType seafile_encryption_info_get_type_once (void);
static void _vala_seafile_encryption_info_get_property (GObject * object,
                                                 guint property_id,
                                                 GValue * value,
                                                 GParamSpec * pspec);
static void _vala_seafile_encryption_info_set_property (GObject * object,
                                                 guint property_id,
                                                 const GValue * value,
                                                 GParamSpec * pspec);
VALA_EXTERN GType seafile_file_sync_error_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (SeafileFileSyncError, g_object_unref)
VALA_EXTERN SeafileFileSyncError* seafile_file_sync_error_new (void);
VALA_EXTERN SeafileFileSyncError* seafile_file_sync_error_construct (GType object_type);
VALA_EXTERN gint seafile_file_sync_error_get_id (SeafileFileSyncError* self);
VALA_EXTERN void seafile_file_sync_error_set_id (SeafileFileSyncError* self,
                                     gint value);
VALA_EXTERN const gchar* seafile_file_sync_error_get_repo_id (SeafileFileSyncError* self);
VALA_EXTERN void seafile_file_sync_error_set_repo_id (SeafileFileSyncError* self,
                                          const gchar* value);
VALA_EXTERN const gchar* seafile_file_sync_error_get_repo_name (SeafileFileSyncError* self);
VALA_EXTERN void seafile_file_sync_error_set_repo_name (SeafileFileSyncError* self,
                                            const gchar* value);
VALA_EXTERN const gchar* seafile_file_sync_error_get_path (SeafileFileSyncError* self);
VALA_EXTERN void seafile_file_sync_error_set_path (SeafileFileSyncError* self,
                                       const gchar* value);
VALA_EXTERN gint seafile_file_sync_error_get_err_id (SeafileFileSyncError* self);
VALA_EXTERN void seafile_file_sync_error_set_err_id (SeafileFileSyncError* self,
                                         gint value);
VALA_EXTERN gint64 seafile_file_sync_error_get_timestamp (SeafileFileSyncError* self);
VALA_EXTERN void seafile_file_sync_error_set_timestamp (SeafileFileSyncError* self,
                                            gint64 value);
static void seafile_file_sync_error_finalize (GObject * obj);
static GType seafile_file_sync_error_get_type_once (void);
static void _vala_seafile_file_sync_error_get_property (GObject * object,
                                                 guint property_id,
                                                 GValue * value,
                                                 GParamSpec * pspec);
static void _vala_seafile_file_sync_error_set_property (GObject * object,
                                                 guint property_id,
                                                 const GValue * value,
                                                 GParamSpec * pspec);

static inline gpointer
seafile_repo_get_instance_private (SeafileRepo* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileRepo_private_offset);
}

SeafileRepo*
seafile_repo_construct (GType object_type)
{
	SeafileRepo * self = NULL;
	self = (SeafileRepo*) g_object_new (object_type, NULL);
	return self;
}

SeafileRepo*
seafile_repo_new (void)
{
	return seafile_repo_construct (SEAFILE_TYPE_REPO);
}

const gchar*
seafile_repo_get_id (SeafileRepo* self)
{
	const gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	result = (const gchar*) self->_id;
	return result;
}

void
seafile_repo_set_id (SeafileRepo* self,
                     const gchar* value)
{
	g_return_if_fail (self != NULL);
	memcpy (self->_id, value, (gsize) 36);
	self->_id[36] = '\0';
	g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_ID_PROPERTY]);
}

const gchar*
seafile_repo_get_name (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->_name;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_name (SeafileRepo* self,
                       const gchar* value)
{
	gchar* _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = g_strdup (value);
	_g_free0 (self->_name);
	self->_name = _tmp0_;
	g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_NAME_PROPERTY]);
}

const gchar*
seafile_repo_get_desc (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->_desc;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_desc (SeafileRepo* self,
                       const gchar* value)
{
	gchar* _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = g_strdup (value);
	_g_free0 (self->_desc);
	self->_desc = _tmp0_;
	g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_DESC_PROPERTY]);
}

gint
seafile_repo_get_version (SeafileRepo* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_version;
	return result;
}

void
seafile_repo_set_version (SeafileRepo* self,
                          gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_version (self);
	if (old_value != value) {
		self->priv->_version = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_VERSION_PROPERTY]);
	}
}

gint
seafile_repo_get_last_modify (SeafileRepo* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_last_modify;
	return result;
}

void
seafile_repo_set_last_modify (SeafileRepo* self,
                              gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_last_modify (self);
	if (old_value != value) {
		self->priv->_last_modify = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_LAST_MODIFY_PROPERTY]);
	}
}

gint64
seafile_repo_get_size (SeafileRepo* self)
{
	gint64 result;
	g_return_val_if_fail (self != NULL, 0LL);
	result = self->priv->_size;
	return result;
}

void
seafile_repo_set_size (SeafileRepo* self,
                       gint64 value)
{
	gint64 old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_size (self);
	if (old_value != value) {
		self->priv->_size = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_SIZE_PROPERTY]);
	}
}

gint64
seafile_repo_get_file_count (SeafileRepo* self)
{
	gint64 result;
	g_return_val_if_fail (self != NULL, 0LL);
	result = self->priv->_file_count;
	return result;
}

void
seafile_repo_set_file_count (SeafileRepo* self,
                             gint64 value)
{
	gint64 old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_file_count (self);
	if (old_value != value) {
		self->priv->_file_count = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_FILE_COUNT_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_head_cmmt_id (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_head_cmmt_id;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_head_cmmt_id (SeafileRepo* self,
                               const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_head_cmmt_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_head_cmmt_id);
		self->priv->_head_cmmt_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_HEAD_CMMT_ID_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_root (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_root;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_root (SeafileRepo* self,
                       const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_root (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_root);
		self->priv->_root = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_ROOT_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_repo_id (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_repo_id;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_repo_id (SeafileRepo* self,
                          const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_repo_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_repo_id);
		self->priv->_repo_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_REPO_ID_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_repo_name (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_repo_name;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_repo_name (SeafileRepo* self,
                            const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_repo_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_repo_name);
		self->priv->_repo_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_REPO_NAME_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_repo_desc (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_repo_desc;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_repo_desc (SeafileRepo* self,
                            const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_repo_desc (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_repo_desc);
		self->priv->_repo_desc = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_REPO_DESC_PROPERTY]);
	}
}

gint
seafile_repo_get_last_modified (SeafileRepo* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_last_modified;
	return result;
}

void
seafile_repo_set_last_modified (SeafileRepo* self,
                                gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_last_modified (self);
	if (old_value != value) {
		self->priv->_last_modified = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_LAST_MODIFIED_PROPERTY]);
	}
}

gboolean
seafile_repo_get_encrypted (SeafileRepo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_encrypted;
	return result;
}

void
seafile_repo_set_encrypted (SeafileRepo* self,
                            gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_encrypted (self);
	if (old_value != value) {
		self->priv->_encrypted = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_ENCRYPTED_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_magic (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_magic;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_magic (SeafileRepo* self,
                        const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_magic (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_magic);
		self->priv->_magic = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_MAGIC_PROPERTY]);
	}
}

gint
seafile_repo_get_enc_version (SeafileRepo* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_enc_version;
	return result;
}

void
seafile_repo_set_enc_version (SeafileRepo* self,
                              gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_enc_version (self);
	if (old_value != value) {
		self->priv->_enc_version = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_ENC_VERSION_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_random_key (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_random_key;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_random_key (SeafileRepo* self,
                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_random_key (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_random_key);
		self->priv->_random_key = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_RANDOM_KEY_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_salt (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_salt;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_salt (SeafileRepo* self,
                       const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_salt (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_salt);
		self->priv->_salt = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_SALT_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_worktree (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->_worktree;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_worktree (SeafileRepo* self,
                           const gchar* value)
{
	gchar* _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = g_strdup (value);
	_g_free0 (self->_worktree);
	self->_worktree = _tmp0_;
	g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_WORKTREE_PROPERTY]);
}

const gchar*
seafile_repo_get_relay_id (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->_relay_id;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_relay_id (SeafileRepo* self,
                           const gchar* value)
{
	gchar* _tmp0_;
	g_return_if_fail (self != NULL);
	_tmp0_ = g_strdup (value);
	_g_free0 (self->_relay_id);
	self->_relay_id = _tmp0_;
	g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_RELAY_ID_PROPERTY]);
}

gint
seafile_repo_get_last_sync_time (SeafileRepo* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_last_sync_time;
	return result;
}

void
seafile_repo_set_last_sync_time (SeafileRepo* self,
                                 gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_last_sync_time (self);
	if (old_value != value) {
		self->priv->_last_sync_time = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_LAST_SYNC_TIME_PROPERTY]);
	}
}

gboolean
seafile_repo_get_auto_sync (SeafileRepo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_auto_sync;
	return result;
}

void
seafile_repo_set_auto_sync (SeafileRepo* self,
                            gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_auto_sync (self);
	if (old_value != value) {
		self->priv->_auto_sync = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_AUTO_SYNC_PROPERTY]);
	}
}

gboolean
seafile_repo_get_worktree_invalid (SeafileRepo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_worktree_invalid;
	return result;
}

void
seafile_repo_set_worktree_invalid (SeafileRepo* self,
                                   gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_worktree_invalid (self);
	if (old_value != value) {
		self->priv->_worktree_invalid = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_WORKTREE_INVALID_PROPERTY]);
	}
}

gboolean
seafile_repo_get_is_virtual (SeafileRepo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_is_virtual;
	return result;
}

void
seafile_repo_set_is_virtual (SeafileRepo* self,
                             gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_is_virtual (self);
	if (old_value != value) {
		self->priv->_is_virtual = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_IS_VIRTUAL_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_origin_repo_id (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_origin_repo_id;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_origin_repo_id (SeafileRepo* self,
                                 const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_origin_repo_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_origin_repo_id);
		self->priv->_origin_repo_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_ORIGIN_REPO_ID_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_origin_repo_name (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_origin_repo_name;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_origin_repo_name (SeafileRepo* self,
                                   const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_origin_repo_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_origin_repo_name);
		self->priv->_origin_repo_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_ORIGIN_REPO_NAME_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_origin_path (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_origin_path;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_origin_path (SeafileRepo* self,
                              const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_origin_path (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_origin_path);
		self->priv->_origin_path = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_ORIGIN_PATH_PROPERTY]);
	}
}

gboolean
seafile_repo_get_is_original_owner (SeafileRepo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_is_original_owner;
	return result;
}

void
seafile_repo_set_is_original_owner (SeafileRepo* self,
                                    gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_is_original_owner (self);
	if (old_value != value) {
		self->priv->_is_original_owner = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_IS_ORIGINAL_OWNER_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_virtual_perm (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_virtual_perm;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_virtual_perm (SeafileRepo* self,
                               const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_virtual_perm (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_virtual_perm);
		self->priv->_virtual_perm = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_VIRTUAL_PERM_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_store_id (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_store_id;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_store_id (SeafileRepo* self,
                           const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_store_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_store_id);
		self->priv->_store_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_STORE_ID_PROPERTY]);
	}
}

gboolean
seafile_repo_get_is_corrupted (SeafileRepo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_is_corrupted;
	return result;
}

void
seafile_repo_set_is_corrupted (SeafileRepo* self,
                               gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_is_corrupted (self);
	if (old_value != value) {
		self->priv->_is_corrupted = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_IS_CORRUPTED_PROPERTY]);
	}
}

gboolean
seafile_repo_get_repaired (SeafileRepo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_repaired;
	return result;
}

void
seafile_repo_set_repaired (SeafileRepo* self,
                           gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_repaired (self);
	if (old_value != value) {
		self->priv->_repaired = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_REPAIRED_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_share_type (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_share_type;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_share_type (SeafileRepo* self,
                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_share_type (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_share_type);
		self->priv->_share_type = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_SHARE_TYPE_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_permission (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_permission;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_permission (SeafileRepo* self,
                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_permission (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_permission);
		self->priv->_permission = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_PERMISSION_PROPERTY]);
	}
}

const gchar*
seafile_repo_get_user (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_user;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_user (SeafileRepo* self,
                       const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_user (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_user);
		self->priv->_user = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_USER_PROPERTY]);
	}
}

gint
seafile_repo_get_group_id (SeafileRepo* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_group_id;
	return result;
}

void
seafile_repo_set_group_id (SeafileRepo* self,
                           gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_group_id (self);
	if (old_value != value) {
		self->priv->_group_id = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_GROUP_ID_PROPERTY]);
	}
}

gboolean
seafile_repo_get_is_shared (SeafileRepo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_is_shared;
	return result;
}

void
seafile_repo_set_is_shared (SeafileRepo* self,
                            gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_is_shared (self);
	if (old_value != value) {
		self->priv->_is_shared = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_IS_SHARED_PROPERTY]);
	}
}

static void
seafile_repo_class_init (SeafileRepoClass * klass,
                         gpointer klass_data)
{
	seafile_repo_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileRepo_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_repo_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_repo_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_repo_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_ID_PROPERTY, seafile_repo_properties[SEAFILE_REPO_ID_PROPERTY] = g_param_spec_string ("id", "id", "id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_NAME_PROPERTY, seafile_repo_properties[SEAFILE_REPO_NAME_PROPERTY] = g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_DESC_PROPERTY, seafile_repo_properties[SEAFILE_REPO_DESC_PROPERTY] = g_param_spec_string ("desc", "desc", "desc", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_VERSION_PROPERTY, seafile_repo_properties[SEAFILE_REPO_VERSION_PROPERTY] = g_param_spec_int ("version", "version", "version", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_LAST_MODIFY_PROPERTY, seafile_repo_properties[SEAFILE_REPO_LAST_MODIFY_PROPERTY] = g_param_spec_int ("last-modify", "last-modify", "last-modify", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_SIZE_PROPERTY, seafile_repo_properties[SEAFILE_REPO_SIZE_PROPERTY] = g_param_spec_int64 ("size", "size", "size", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_FILE_COUNT_PROPERTY, seafile_repo_properties[SEAFILE_REPO_FILE_COUNT_PROPERTY] = g_param_spec_int64 ("file-count", "file-count", "file-count", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_HEAD_CMMT_ID_PROPERTY, seafile_repo_properties[SEAFILE_REPO_HEAD_CMMT_ID_PROPERTY] = g_param_spec_string ("head-cmmt-id", "head-cmmt-id", "head-cmmt-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_ROOT_PROPERTY, seafile_repo_properties[SEAFILE_REPO_ROOT_PROPERTY] = g_param_spec_string ("root", "root", "root", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_REPO_ID_PROPERTY, seafile_repo_properties[SEAFILE_REPO_REPO_ID_PROPERTY] = g_param_spec_string ("repo-id", "repo-id", "repo-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_REPO_NAME_PROPERTY, seafile_repo_properties[SEAFILE_REPO_REPO_NAME_PROPERTY] = g_param_spec_string ("repo-name", "repo-name", "repo-name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_REPO_DESC_PROPERTY, seafile_repo_properties[SEAFILE_REPO_REPO_DESC_PROPERTY] = g_param_spec_string ("repo-desc", "repo-desc", "repo-desc", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_LAST_MODIFIED_PROPERTY, seafile_repo_properties[SEAFILE_REPO_LAST_MODIFIED_PROPERTY] = g_param_spec_int ("last-modified", "last-modified", "last-modified", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_ENCRYPTED_PROPERTY, seafile_repo_properties[SEAFILE_REPO_ENCRYPTED_PROPERTY] = g_param_spec_boolean ("encrypted", "encrypted", "encrypted", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_MAGIC_PROPERTY, seafile_repo_properties[SEAFILE_REPO_MAGIC_PROPERTY] = g_param_spec_string ("magic", "magic", "magic", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_ENC_VERSION_PROPERTY, seafile_repo_properties[SEAFILE_REPO_ENC_VERSION_PROPERTY] = g_param_spec_int ("enc-version", "enc-version", "enc-version", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_RANDOM_KEY_PROPERTY, seafile_repo_properties[SEAFILE_REPO_RANDOM_KEY_PROPERTY] = g_param_spec_string ("random-key", "random-key", "random-key", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_SALT_PROPERTY, seafile_repo_properties[SEAFILE_REPO_SALT_PROPERTY] = g_param_spec_string ("salt", "salt", "salt", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_WORKTREE_PROPERTY, seafile_repo_properties[SEAFILE_REPO_WORKTREE_PROPERTY] = g_param_spec_string ("worktree", "worktree", "worktree", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_RELAY_ID_PROPERTY, seafile_repo_properties[SEAFILE_REPO_RELAY_ID_PROPERTY] = g_param_spec_string ("relay-id", "relay-id", "relay-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_LAST_SYNC_TIME_PROPERTY, seafile_repo_properties[SEAFILE_REPO_LAST_SYNC_TIME_PROPERTY] = g_param_spec_int ("last-sync-time", "last-sync-time", "last-sync-time", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_AUTO_SYNC_PROPERTY, seafile_repo_properties[SEAFILE_REPO_AUTO_SYNC_PROPERTY] = g_param_spec_boolean ("auto-sync", "auto-sync", "auto-sync", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_WORKTREE_INVALID_PROPERTY, seafile_repo_properties[SEAFILE_REPO_WORKTREE_INVALID_PROPERTY] = g_param_spec_boolean ("worktree-invalid", "worktree-invalid", "worktree-invalid", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_IS_VIRTUAL_PROPERTY, seafile_repo_properties[SEAFILE_REPO_IS_VIRTUAL_PROPERTY] = g_param_spec_boolean ("is-virtual", "is-virtual", "is-virtual", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_ORIGIN_REPO_ID_PROPERTY, seafile_repo_properties[SEAFILE_REPO_ORIGIN_REPO_ID_PROPERTY] = g_param_spec_string ("origin-repo-id", "origin-repo-id", "origin-repo-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_ORIGIN_REPO_NAME_PROPERTY, seafile_repo_properties[SEAFILE_REPO_ORIGIN_REPO_NAME_PROPERTY] = g_param_spec_string ("origin-repo-name", "origin-repo-name", "origin-repo-name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_ORIGIN_PATH_PROPERTY, seafile_repo_properties[SEAFILE_REPO_ORIGIN_PATH_PROPERTY] = g_param_spec_string ("origin-path", "origin-path", "origin-path", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_IS_ORIGINAL_OWNER_PROPERTY, seafile_repo_properties[SEAFILE_REPO_IS_ORIGINAL_OWNER_PROPERTY] = g_param_spec_boolean ("is-original-owner", "is-original-owner", "is-original-owner", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_VIRTUAL_PERM_PROPERTY, seafile_repo_properties[SEAFILE_REPO_VIRTUAL_PERM_PROPERTY] = g_param_spec_string ("virtual-perm", "virtual-perm", "virtual-perm", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_STORE_ID_PROPERTY, seafile_repo_properties[SEAFILE_REPO_STORE_ID_PROPERTY] = g_param_spec_string ("store-id", "store-id", "store-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_IS_CORRUPTED_PROPERTY, seafile_repo_properties[SEAFILE_REPO_IS_CORRUPTED_PROPERTY] = g_param_spec_boolean ("is-corrupted", "is-corrupted", "is-corrupted", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_REPAIRED_PROPERTY, seafile_repo_properties[SEAFILE_REPO_REPAIRED_PROPERTY] = g_param_spec_boolean ("repaired", "repaired", "repaired", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_SHARE_TYPE_PROPERTY, seafile_repo_properties[SEAFILE_REPO_SHARE_TYPE_PROPERTY] = g_param_spec_string ("share-type", "share-type", "share-type", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_PERMISSION_PROPERTY, seafile_repo_properties[SEAFILE_REPO_PERMISSION_PROPERTY] = g_param_spec_string ("permission", "permission", "permission", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_USER_PROPERTY, seafile_repo_properties[SEAFILE_REPO_USER_PROPERTY] = g_param_spec_string ("user", "user", "user", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_GROUP_ID_PROPERTY, seafile_repo_properties[SEAFILE_REPO_GROUP_ID_PROPERTY] = g_param_spec_int ("group-id", "group-id", "group-id", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_IS_SHARED_PROPERTY, seafile_repo_properties[SEAFILE_REPO_IS_SHARED_PROPERTY] = g_param_spec_boolean ("is-shared", "is-shared", "is-shared", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_repo_instance_init (SeafileRepo * self,
                            gpointer klass)
{
	self->priv = seafile_repo_get_instance_private (self);
}

static void
seafile_repo_finalize (GObject * obj)
{
	SeafileRepo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_REPO, SeafileRepo);
	_g_free0 (self->_name);
	_g_free0 (self->_desc);
	_g_free0 (self->priv->_head_cmmt_id);
	_g_free0 (self->priv->_root);
	_g_free0 (self->priv->_repo_id);
	_g_free0 (self->priv->_repo_name);
	_g_free0 (self->priv->_repo_desc);
	_g_free0 (self->priv->_magic);
	_g_free0 (self->priv->_random_key);
	_g_free0 (self->priv->_salt);
	_g_free0 (self->_worktree);
	_g_free0 (self->_relay_id);
	_g_free0 (self->priv->_origin_repo_id);
	_g_free0 (self->priv->_origin_repo_name);
	_g_free0 (self->priv->_origin_path);
	_g_free0 (self->priv->_virtual_perm);
	_g_free0 (self->priv->_store_id);
	_g_free0 (self->priv->_share_type);
	_g_free0 (self->priv->_permission);
	_g_free0 (self->priv->_user);
	G_OBJECT_CLASS (seafile_repo_parent_class)->finalize (obj);
}

static GType
seafile_repo_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileRepoClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_repo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileRepo), 0, (GInstanceInitFunc) seafile_repo_instance_init, NULL };
	GType seafile_repo_type_id;
	seafile_repo_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileRepo", &g_define_type_info, 0);
	SeafileRepo_private_offset = g_type_add_instance_private (seafile_repo_type_id, sizeof (SeafileRepoPrivate));
	return seafile_repo_type_id;
}

GType
seafile_repo_get_type (void)
{
	static volatile gsize seafile_repo_type_id__once = 0;
	if (g_once_init_enter (&seafile_repo_type_id__once)) {
		GType seafile_repo_type_id;
		seafile_repo_type_id = seafile_repo_get_type_once ();
		g_once_init_leave (&seafile_repo_type_id__once, seafile_repo_type_id);
	}
	return seafile_repo_type_id__once;
}

static void
_vala_seafile_repo_get_property (GObject * object,
                                 guint property_id,
                                 GValue * value,
                                 GParamSpec * pspec)
{
	SeafileRepo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_REPO, SeafileRepo);
	switch (property_id) {
		case SEAFILE_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_repo_get_id (self));
		break;
		case SEAFILE_REPO_NAME_PROPERTY:
		g_value_set_string (value, seafile_repo_get_name (self));
		break;
		case SEAFILE_REPO_DESC_PROPERTY:
		g_value_set_string (value, seafile_repo_get_desc (self));
		break;
		case SEAFILE_REPO_VERSION_PROPERTY:
		g_value_set_int (value, seafile_repo_get_version (self));
		break;
		case SEAFILE_REPO_LAST_MODIFY_PROPERTY:
		g_value_set_int (value, seafile_repo_get_last_modify (self));
		break;
		case SEAFILE_REPO_SIZE_PROPERTY:
		g_value_set_int64 (value, seafile_repo_get_size (self));
		break;
		case SEAFILE_REPO_FILE_COUNT_PROPERTY:
		g_value_set_int64 (value, seafile_repo_get_file_count (self));
		break;
		case SEAFILE_REPO_HEAD_CMMT_ID_PROPERTY:
		g_value_set_string (value, seafile_repo_get_head_cmmt_id (self));
		break;
		case SEAFILE_REPO_ROOT_PROPERTY:
		g_value_set_string (value, seafile_repo_get_root (self));
		break;
		case SEAFILE_REPO_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_repo_get_repo_id (self));
		break;
		case SEAFILE_REPO_REPO_NAME_PROPERTY:
		g_value_set_string (value, seafile_repo_get_repo_name (self));
		break;
		case SEAFILE_REPO_REPO_DESC_PROPERTY:
		g_value_set_string (value, seafile_repo_get_repo_desc (self));
		break;
		case SEAFILE_REPO_LAST_MODIFIED_PROPERTY:
		g_value_set_int (value, seafile_repo_get_last_modified (self));
		break;
		case SEAFILE_REPO_ENCRYPTED_PROPERTY:
		g_value_set_boolean (value, seafile_repo_get_encrypted (self));
		break;
		case SEAFILE_REPO_MAGIC_PROPERTY:
		g_value_set_string (value, seafile_repo_get_magic (self));
		break;
		case SEAFILE_REPO_ENC_VERSION_PROPERTY:
		g_value_set_int (value, seafile_repo_get_enc_version (self));
		break;
		case SEAFILE_REPO_RANDOM_KEY_PROPERTY:
		g_value_set_string (value, seafile_repo_get_random_key (self));
		break;
		case SEAFILE_REPO_SALT_PROPERTY:
		g_value_set_string (value, seafile_repo_get_salt (self));
		break;
		case SEAFILE_REPO_WORKTREE_PROPERTY:
		g_value_set_string (value, seafile_repo_get_worktree (self));
		break;
		case SEAFILE_REPO_RELAY_ID_PROPERTY:
		g_value_set_string (value, seafile_repo_get_relay_id (self));
		break;
		case SEAFILE_REPO_LAST_SYNC_TIME_PROPERTY:
		g_value_set_int (value, seafile_repo_get_last_sync_time (self));
		break;
		case SEAFILE_REPO_AUTO_SYNC_PROPERTY:
		g_value_set_boolean (value, seafile_repo_get_auto_sync (self));
		break;
		case SEAFILE_REPO_WORKTREE_INVALID_PROPERTY:
		g_value_set_boolean (value, seafile_repo_get_worktree_invalid (self));
		break;
		case SEAFILE_REPO_IS_VIRTUAL_PROPERTY:
		g_value_set_boolean (value, seafile_repo_get_is_virtual (self));
		break;
		case SEAFILE_REPO_ORIGIN_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_repo_get_origin_repo_id (self));
		break;
		case SEAFILE_REPO_ORIGIN_REPO_NAME_PROPERTY:
		g_value_set_string (value, seafile_repo_get_origin_repo_name (self));
		break;
		case SEAFILE_REPO_ORIGIN_PATH_PROPERTY:
		g_value_set_string (value, seafile_repo_get_origin_path (self));
		break;
		case SEAFILE_REPO_IS_ORIGINAL_OWNER_PROPERTY:
		g_value_set_boolean (value, seafile_repo_get_is_original_owner (self));
		break;
		case SEAFILE_REPO_VIRTUAL_PERM_PROPERTY:
		g_value_set_string (value, seafile_repo_get_virtual_perm (self));
		break;
		case SEAFILE_REPO_STORE_ID_PROPERTY:
		g_value_set_string (value, seafile_repo_get_store_id (self));
		break;
		case SEAFILE_REPO_IS_CORRUPTED_PROPERTY:
		g_value_set_boolean (value, seafile_repo_get_is_corrupted (self));
		break;
		case SEAFILE_REPO_REPAIRED_PROPERTY:
		g_value_set_boolean (value, seafile_repo_get_repaired (self));
		break;
		case SEAFILE_REPO_SHARE_TYPE_PROPERTY:
		g_value_set_string (value, seafile_repo_get_share_type (self));
		break;
		case SEAFILE_REPO_PERMISSION_PROPERTY:
		g_value_set_string (value, seafile_repo_get_permission (self));
		break;
		case SEAFILE_REPO_USER_PROPERTY:
		g_value_set_string (value, seafile_repo_get_user (self));
		break;
		case SEAFILE_REPO_GROUP_ID_PROPERTY:
		g_value_set_int (value, seafile_repo_get_group_id (self));
		break;
		case SEAFILE_REPO_IS_SHARED_PROPERTY:
		g_value_set_boolean (value, seafile_repo_get_is_shared (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_repo_set_property (GObject * object,
                                 guint property_id,
                                 const GValue * value,
                                 GParamSpec * pspec)
{
	SeafileRepo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_REPO, SeafileRepo);
	switch (property_id) {
		case SEAFILE_REPO_ID_PROPERTY:
		seafile_repo_set_id (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_NAME_PROPERTY:
		seafile_repo_set_name (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_DESC_PROPERTY:
		seafile_repo_set_desc (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_VERSION_PROPERTY:
		seafile_repo_set_version (self, g_value_get_int (value));
		break;
		case SEAFILE_REPO_LAST_MODIFY_PROPERTY:
		seafile_repo_set_last_modify (self, g_value_get_int (value));
		break;
		case SEAFILE_REPO_SIZE_PROPERTY:
		seafile_repo_set_size (self, g_value_get_int64 (value));
		break;
		case SEAFILE_REPO_FILE_COUNT_PROPERTY:
		seafile_repo_set_file_count (self, g_value_get_int64 (value));
		break;
		case SEAFILE_REPO_HEAD_CMMT_ID_PROPERTY:
		seafile_repo_set_head_cmmt_id (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_ROOT_PROPERTY:
		seafile_repo_set_root (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_REPO_ID_PROPERTY:
		seafile_repo_set_repo_id (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_REPO_NAME_PROPERTY:
		seafile_repo_set_repo_name (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_REPO_DESC_PROPERTY:
		seafile_repo_set_repo_desc (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_LAST_MODIFIED_PROPERTY:
		seafile_repo_set_last_modified (self, g_value_get_int (value));
		break;
		case SEAFILE_REPO_ENCRYPTED_PROPERTY:
		seafile_repo_set_encrypted (self, g_value_get_boolean (value));
		break;
		case SEAFILE_REPO_MAGIC_PROPERTY:
		seafile_repo_set_magic (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_ENC_VERSION_PROPERTY:
		seafile_repo_set_enc_version (self, g_value_get_int (value));
		break;
		case SEAFILE_REPO_RANDOM_KEY_PROPERTY:
		seafile_repo_set_random_key (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_SALT_PROPERTY:
		seafile_repo_set_salt (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_WORKTREE_PROPERTY:
		seafile_repo_set_worktree (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_RELAY_ID_PROPERTY:
		seafile_repo_set_relay_id (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_LAST_SYNC_TIME_PROPERTY:
		seafile_repo_set_last_sync_time (self, g_value_get_int (value));
		break;
		case SEAFILE_REPO_AUTO_SYNC_PROPERTY:
		seafile_repo_set_auto_sync (self, g_value_get_boolean (value));
		break;
		case SEAFILE_REPO_WORKTREE_INVALID_PROPERTY:
		seafile_repo_set_worktree_invalid (self, g_value_get_boolean (value));
		break;
		case SEAFILE_REPO_IS_VIRTUAL_PROPERTY:
		seafile_repo_set_is_virtual (self, g_value_get_boolean (value));
		break;
		case SEAFILE_REPO_ORIGIN_REPO_ID_PROPERTY:
		seafile_repo_set_origin_repo_id (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_ORIGIN_REPO_NAME_PROPERTY:
		seafile_repo_set_origin_repo_name (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_ORIGIN_PATH_PROPERTY:
		seafile_repo_set_origin_path (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_IS_ORIGINAL_OWNER_PROPERTY:
		seafile_repo_set_is_original_owner (self, g_value_get_boolean (value));
		break;
		case SEAFILE_REPO_VIRTUAL_PERM_PROPERTY:
		seafile_repo_set_virtual_perm (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_STORE_ID_PROPERTY:
		seafile_repo_set_store_id (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_IS_CORRUPTED_PROPERTY:
		seafile_repo_set_is_corrupted (self, g_value_get_boolean (value));
		break;
		case SEAFILE_REPO_REPAIRED_PROPERTY:
		seafile_repo_set_repaired (self, g_value_get_boolean (value));
		break;
		case SEAFILE_REPO_SHARE_TYPE_PROPERTY:
		seafile_repo_set_share_type (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_PERMISSION_PROPERTY:
		seafile_repo_set_permission (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_USER_PROPERTY:
		seafile_repo_set_user (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_GROUP_ID_PROPERTY:
		seafile_repo_set_group_id (self, g_value_get_int (value));
		break;
		case SEAFILE_REPO_IS_SHARED_PROPERTY:
		seafile_repo_set_is_shared (self, g_value_get_boolean (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
seafile_sync_task_get_instance_private (SeafileSyncTask* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileSyncTask_private_offset);
}

SeafileSyncTask*
seafile_sync_task_construct (GType object_type)
{
	SeafileSyncTask * self = NULL;
	self = (SeafileSyncTask*) g_object_new (object_type, NULL);
	return self;
}

SeafileSyncTask*
seafile_sync_task_new (void)
{
	return seafile_sync_task_construct (SEAFILE_TYPE_SYNC_TASK);
}

gboolean
seafile_sync_task_get_force_upload (SeafileSyncTask* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_force_upload;
	return result;
}

void
seafile_sync_task_set_force_upload (SeafileSyncTask* self,
                                    gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_task_get_force_upload (self);
	if (old_value != value) {
		self->priv->_force_upload = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_task_properties[SEAFILE_SYNC_TASK_FORCE_UPLOAD_PROPERTY]);
	}
}

const gchar*
seafile_sync_task_get_repo_id (SeafileSyncTask* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_repo_id;
	result = _tmp0_;
	return result;
}

void
seafile_sync_task_set_repo_id (SeafileSyncTask* self,
                               const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_task_get_repo_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_repo_id);
		self->priv->_repo_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_task_properties[SEAFILE_SYNC_TASK_REPO_ID_PROPERTY]);
	}
}

const gchar*
seafile_sync_task_get_state (SeafileSyncTask* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_state;
	result = _tmp0_;
	return result;
}

void
seafile_sync_task_set_state (SeafileSyncTask* self,
                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_task_get_state (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_state);
		self->priv->_state = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_task_properties[SEAFILE_SYNC_TASK_STATE_PROPERTY]);
	}
}

gint
seafile_sync_task_get_error (SeafileSyncTask* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_error;
	return result;
}

void
seafile_sync_task_set_error (SeafileSyncTask* self,
                             gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_task_get_error (self);
	if (old_value != value) {
		self->priv->_error = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_task_properties[SEAFILE_SYNC_TASK_ERROR_PROPERTY]);
	}
}

static void
seafile_sync_task_class_init (SeafileSyncTaskClass * klass,
                              gpointer klass_data)
{
	seafile_sync_task_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileSyncTask_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_sync_task_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_sync_task_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_sync_task_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SYNC_TASK_FORCE_UPLOAD_PROPERTY, seafile_sync_task_properties[SEAFILE_SYNC_TASK_FORCE_UPLOAD_PROPERTY] = g_param_spec_boolean ("force-upload", "force-upload", "force-upload", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SYNC_TASK_REPO_ID_PROPERTY, seafile_sync_task_properties[SEAFILE_SYNC_TASK_REPO_ID_PROPERTY] = g_param_spec_string ("repo-id", "repo-id", "repo-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SYNC_TASK_STATE_PROPERTY, seafile_sync_task_properties[SEAFILE_SYNC_TASK_STATE_PROPERTY] = g_param_spec_string ("state", "state", "state", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SYNC_TASK_ERROR_PROPERTY, seafile_sync_task_properties[SEAFILE_SYNC_TASK_ERROR_PROPERTY] = g_param_spec_int ("error", "error", "error", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_sync_task_instance_init (SeafileSyncTask * self,
                                 gpointer klass)
{
	self->priv = seafile_sync_task_get_instance_private (self);
}

static void
seafile_sync_task_finalize (GObject * obj)
{
	SeafileSyncTask * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_SYNC_TASK, SeafileSyncTask);
	_g_free0 (self->priv->_repo_id);
	_g_free0 (self->priv->_state);
	G_OBJECT_CLASS (seafile_sync_task_parent_class)->finalize (obj);
}

static GType
seafile_sync_task_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileSyncTaskClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_sync_task_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileSyncTask), 0, (GInstanceInitFunc) seafile_sync_task_instance_init, NULL };
	GType seafile_sync_task_type_id;
	seafile_sync_task_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileSyncTask", &g_define_type_info, 0);
	SeafileSyncTask_private_offset = g_type_add_instance_private (seafile_sync_task_type_id, sizeof (SeafileSyncTaskPrivate));
	return seafile_sync_task_type_id;
}

GType
seafile_sync_task_get_type (void)
{
	static volatile gsize seafile_sync_task_type_id__once = 0;
	if (g_once_init_enter (&seafile_sync_task_type_id__once)) {
		GType seafile_sync_task_type_id;
		seafile_sync_task_type_id = seafile_sync_task_get_type_once ();
		g_once_init_leave (&seafile_sync_task_type_id__once, seafile_sync_task_type_id);
	}
	return seafile_sync_task_type_id__once;
}

static void
_vala_seafile_sync_task_get_property (GObject * object,
                                      guint property_id,
                                      GValue * value,
                                      GParamSpec * pspec)
{
	SeafileSyncTask * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_SYNC_TASK, SeafileSyncTask);
	switch (property_id) {
		case SEAFILE_SYNC_TASK_FORCE_UPLOAD_PROPERTY:
		g_value_set_boolean (value, seafile_sync_task_get_force_upload (self));
		break;
		case SEAFILE_SYNC_TASK_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_sync_task_get_repo_id (self));
		break;
		case SEAFILE_SYNC_TASK_STATE_PROPERTY:
		g_value_set_string (value, seafile_sync_task_get_state (self));
		break;
		case SEAFILE_SYNC_TASK_ERROR_PROPERTY:
		g_value_set_int (value, seafile_sync_task_get_error (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_sync_task_set_property (GObject * object,
                                      guint property_id,
                                      const GValue * value,
                                      GParamSpec * pspec)
{
	SeafileSyncTask * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_SYNC_TASK, SeafileSyncTask);
	switch (property_id) {
		case SEAFILE_SYNC_TASK_FORCE_UPLOAD_PROPERTY:
		seafile_sync_task_set_force_upload (self, g_value_get_boolean (value));
		break;
		case SEAFILE_SYNC_TASK_REPO_ID_PROPERTY:
		seafile_sync_task_set_repo_id (self, g_value_get_string (value));
		break;
		case SEAFILE_SYNC_TASK_STATE_PROPERTY:
		seafile_sync_task_set_state (self, g_value_get_string (value));
		break;
		case SEAFILE_SYNC_TASK_ERROR_PROPERTY:
		seafile_sync_task_set_error (self, g_value_get_int (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
seafile_session_info_get_instance_private (SeafileSessionInfo* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileSessionInfo_private_offset);
}

SeafileSessionInfo*
seafile_session_info_construct (GType object_type)
{
	SeafileSessionInfo * self = NULL;
	self = (SeafileSessionInfo*) g_object_new (object_type, NULL);
	return self;
}

SeafileSessionInfo*
seafile_session_info_new (void)
{
	return seafile_session_info_construct (SEAFILE_TYPE_SESSION_INFO);
}

const gchar*
seafile_session_info_get_datadir (SeafileSessionInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_datadir;
	result = _tmp0_;
	return result;
}

void
seafile_session_info_set_datadir (SeafileSessionInfo* self,
                                  const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_session_info_get_datadir (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_datadir);
		self->priv->_datadir = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_session_info_properties[SEAFILE_SESSION_INFO_DATADIR_PROPERTY]);
	}
}

static void
seafile_session_info_class_init (SeafileSessionInfoClass * klass,
                                 gpointer klass_data)
{
	seafile_session_info_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileSessionInfo_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_session_info_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_session_info_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_session_info_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SESSION_INFO_DATADIR_PROPERTY, seafile_session_info_properties[SEAFILE_SESSION_INFO_DATADIR_PROPERTY] = g_param_spec_string ("datadir", "datadir", "datadir", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_session_info_instance_init (SeafileSessionInfo * self,
                                    gpointer klass)
{
	self->priv = seafile_session_info_get_instance_private (self);
}

static void
seafile_session_info_finalize (GObject * obj)
{
	SeafileSessionInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_SESSION_INFO, SeafileSessionInfo);
	_g_free0 (self->priv->_datadir);
	G_OBJECT_CLASS (seafile_session_info_parent_class)->finalize (obj);
}

static GType
seafile_session_info_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileSessionInfoClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_session_info_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileSessionInfo), 0, (GInstanceInitFunc) seafile_session_info_instance_init, NULL };
	GType seafile_session_info_type_id;
	seafile_session_info_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileSessionInfo", &g_define_type_info, 0);
	SeafileSessionInfo_private_offset = g_type_add_instance_private (seafile_session_info_type_id, sizeof (SeafileSessionInfoPrivate));
	return seafile_session_info_type_id;
}

GType
seafile_session_info_get_type (void)
{
	static volatile gsize seafile_session_info_type_id__once = 0;
	if (g_once_init_enter (&seafile_session_info_type_id__once)) {
		GType seafile_session_info_type_id;
		seafile_session_info_type_id = seafile_session_info_get_type_once ();
		g_once_init_leave (&seafile_session_info_type_id__once, seafile_session_info_type_id);
	}
	return seafile_session_info_type_id__once;
}

static void
_vala_seafile_session_info_get_property (GObject * object,
                                         guint property_id,
                                         GValue * value,
                                         GParamSpec * pspec)
{
	SeafileSessionInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_SESSION_INFO, SeafileSessionInfo);
	switch (property_id) {
		case SEAFILE_SESSION_INFO_DATADIR_PROPERTY:
		g_value_set_string (value, seafile_session_info_get_datadir (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_session_info_set_property (GObject * object,
                                         guint property_id,
                                         const GValue * value,
                                         GParamSpec * pspec)
{
	SeafileSessionInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_SESSION_INFO, SeafileSessionInfo);
	switch (property_id) {
		case SEAFILE_SESSION_INFO_DATADIR_PROPERTY:
		seafile_session_info_set_datadir (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
seafile_diff_entry_get_instance_private (SeafileDiffEntry* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileDiffEntry_private_offset);
}

SeafileDiffEntry*
seafile_diff_entry_construct (GType object_type)
{
	SeafileDiffEntry * self = NULL;
	self = (SeafileDiffEntry*) g_object_new (object_type, NULL);
	return self;
}

SeafileDiffEntry*
seafile_diff_entry_new (void)
{
	return seafile_diff_entry_construct (SEAFILE_TYPE_DIFF_ENTRY);
}

const gchar*
seafile_diff_entry_get_status (SeafileDiffEntry* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_status;
	result = _tmp0_;
	return result;
}

void
seafile_diff_entry_set_status (SeafileDiffEntry* self,
                               const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_diff_entry_get_status (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_status);
		self->priv->_status = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_diff_entry_properties[SEAFILE_DIFF_ENTRY_STATUS_PROPERTY]);
	}
}

const gchar*
seafile_diff_entry_get_name (SeafileDiffEntry* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_name;
	result = _tmp0_;
	return result;
}

void
seafile_diff_entry_set_name (SeafileDiffEntry* self,
                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_diff_entry_get_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_name);
		self->priv->_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_diff_entry_properties[SEAFILE_DIFF_ENTRY_NAME_PROPERTY]);
	}
}

const gchar*
seafile_diff_entry_get_new_name (SeafileDiffEntry* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_new_name;
	result = _tmp0_;
	return result;
}

void
seafile_diff_entry_set_new_name (SeafileDiffEntry* self,
                                 const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_diff_entry_get_new_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_new_name);
		self->priv->_new_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_diff_entry_properties[SEAFILE_DIFF_ENTRY_NEW_NAME_PROPERTY]);
	}
}

static void
seafile_diff_entry_class_init (SeafileDiffEntryClass * klass,
                               gpointer klass_data)
{
	seafile_diff_entry_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileDiffEntry_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_diff_entry_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_diff_entry_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_diff_entry_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_DIFF_ENTRY_STATUS_PROPERTY, seafile_diff_entry_properties[SEAFILE_DIFF_ENTRY_STATUS_PROPERTY] = g_param_spec_string ("status", "status", "status", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_DIFF_ENTRY_NAME_PROPERTY, seafile_diff_entry_properties[SEAFILE_DIFF_ENTRY_NAME_PROPERTY] = g_param_spec_string ("name", "name", "name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_DIFF_ENTRY_NEW_NAME_PROPERTY, seafile_diff_entry_properties[SEAFILE_DIFF_ENTRY_NEW_NAME_PROPERTY] = g_param_spec_string ("new-name", "new-name", "new-name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_diff_entry_instance_init (SeafileDiffEntry * self,
                                  gpointer klass)
{
	self->priv = seafile_diff_entry_get_instance_private (self);
}

static void
seafile_diff_entry_finalize (GObject * obj)
{
	SeafileDiffEntry * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_DIFF_ENTRY, SeafileDiffEntry);
	_g_free0 (self->priv->_status);
	_g_free0 (self->priv->_name);
	_g_free0 (self->priv->_new_name);
	G_OBJECT_CLASS (seafile_diff_entry_parent_class)->finalize (obj);
}

static GType
seafile_diff_entry_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileDiffEntryClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_diff_entry_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileDiffEntry), 0, (GInstanceInitFunc) seafile_diff_entry_instance_init, NULL };
	GType seafile_diff_entry_type_id;
	seafile_diff_entry_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileDiffEntry", &g_define_type_info, 0);
	SeafileDiffEntry_private_offset = g_type_add_instance_private (seafile_diff_entry_type_id, sizeof (SeafileDiffEntryPrivate));
	return seafile_diff_entry_type_id;
}

GType
seafile_diff_entry_get_type (void)
{
	static volatile gsize seafile_diff_entry_type_id__once = 0;
	if (g_once_init_enter (&seafile_diff_entry_type_id__once)) {
		GType seafile_diff_entry_type_id;
		seafile_diff_entry_type_id = seafile_diff_entry_get_type_once ();
		g_once_init_leave (&seafile_diff_entry_type_id__once, seafile_diff_entry_type_id);
	}
	return seafile_diff_entry_type_id__once;
}

static void
_vala_seafile_diff_entry_get_property (GObject * object,
                                       guint property_id,
                                       GValue * value,
                                       GParamSpec * pspec)
{
	SeafileDiffEntry * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_DIFF_ENTRY, SeafileDiffEntry);
	switch (property_id) {
		case SEAFILE_DIFF_ENTRY_STATUS_PROPERTY:
		g_value_set_string (value, seafile_diff_entry_get_status (self));
		break;
		case SEAFILE_DIFF_ENTRY_NAME_PROPERTY:
		g_value_set_string (value, seafile_diff_entry_get_name (self));
		break;
		case SEAFILE_DIFF_ENTRY_NEW_NAME_PROPERTY:
		g_value_set_string (value, seafile_diff_entry_get_new_name (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_diff_entry_set_property (GObject * object,
                                       guint property_id,
                                       const GValue * value,
                                       GParamSpec * pspec)
{
	SeafileDiffEntry * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_DIFF_ENTRY, SeafileDiffEntry);
	switch (property_id) {
		case SEAFILE_DIFF_ENTRY_STATUS_PROPERTY:
		seafile_diff_entry_set_status (self, g_value_get_string (value));
		break;
		case SEAFILE_DIFF_ENTRY_NAME_PROPERTY:
		seafile_diff_entry_set_name (self, g_value_get_string (value));
		break;
		case SEAFILE_DIFF_ENTRY_NEW_NAME_PROPERTY:
		seafile_diff_entry_set_new_name (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
seafile_encryption_info_get_instance_private (SeafileEncryptionInfo* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileEncryptionInfo_private_offset);
}

SeafileEncryptionInfo*
seafile_encryption_info_construct (GType object_type)
{
	SeafileEncryptionInfo * self = NULL;
	self = (SeafileEncryptionInfo*) g_object_new (object_type, NULL);
	return self;
}

SeafileEncryptionInfo*
seafile_encryption_info_new (void)
{
	return seafile_encryption_info_construct (SEAFILE_TYPE_ENCRYPTION_INFO);
}

const gchar*
seafile_encryption_info_get_repo_id (SeafileEncryptionInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_repo_id;
	result = _tmp0_;
	return result;
}

void
seafile_encryption_info_set_repo_id (SeafileEncryptionInfo* self,
                                     const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_encryption_info_get_repo_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_repo_id);
		self->priv->_repo_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_REPO_ID_PROPERTY]);
	}
}

const gchar*
seafile_encryption_info_get_passwd (SeafileEncryptionInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_passwd;
	result = _tmp0_;
	return result;
}

void
seafile_encryption_info_set_passwd (SeafileEncryptionInfo* self,
                                    const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_encryption_info_get_passwd (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_passwd);
		self->priv->_passwd = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_PASSWD_PROPERTY]);
	}
}

gint
seafile_encryption_info_get_enc_version (SeafileEncryptionInfo* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_enc_version;
	return result;
}

void
seafile_encryption_info_set_enc_version (SeafileEncryptionInfo* self,
                                         gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_encryption_info_get_enc_version (self);
	if (old_value != value) {
		self->priv->_enc_version = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_ENC_VERSION_PROPERTY]);
	}
}

const gchar*
seafile_encryption_info_get_magic (SeafileEncryptionInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_magic;
	result = _tmp0_;
	return result;
}

void
seafile_encryption_info_set_magic (SeafileEncryptionInfo* self,
                                   const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_encryption_info_get_magic (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_magic);
		self->priv->_magic = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_MAGIC_PROPERTY]);
	}
}

const gchar*
seafile_encryption_info_get_pwd_hash (SeafileEncryptionInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_pwd_hash;
	result = _tmp0_;
	return result;
}

void
seafile_encryption_info_set_pwd_hash (SeafileEncryptionInfo* self,
                                      const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_encryption_info_get_pwd_hash (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_pwd_hash);
		self->priv->_pwd_hash = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_PWD_HASH_PROPERTY]);
	}
}

const gchar*
seafile_encryption_info_get_random_key (SeafileEncryptionInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_random_key;
	result = _tmp0_;
	return result;
}

void
seafile_encryption_info_set_random_key (SeafileEncryptionInfo* self,
                                        const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_encryption_info_get_random_key (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_random_key);
		self->priv->_random_key = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_RANDOM_KEY_PROPERTY]);
	}
}

const gchar*
seafile_encryption_info_get_salt (SeafileEncryptionInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_salt;
	result = _tmp0_;
	return result;
}

void
seafile_encryption_info_set_salt (SeafileEncryptionInfo* self,
                                  const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_encryption_info_get_salt (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_salt);
		self->priv->_salt = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_SALT_PROPERTY]);
	}
}

static void
seafile_encryption_info_class_init (SeafileEncryptionInfoClass * klass,
                                    gpointer klass_data)
{
	seafile_encryption_info_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileEncryptionInfo_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_encryption_info_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_encryption_info_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_encryption_info_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_ENCRYPTION_INFO_REPO_ID_PROPERTY, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_REPO_ID_PROPERTY] = g_param_spec_string ("repo-id", "repo-id", "repo-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_ENCRYPTION_INFO_PASSWD_PROPERTY, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_PASSWD_PROPERTY] = g_param_spec_string ("passwd", "passwd", "passwd", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_ENCRYPTION_INFO_ENC_VERSION_PROPERTY, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_ENC_VERSION_PROPERTY] = g_param_spec_int ("enc-version", "enc-version", "enc-version", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_ENCRYPTION_INFO_MAGIC_PROPERTY, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_MAGIC_PROPERTY] = g_param_spec_string ("magic", "magic", "magic", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_ENCRYPTION_INFO_PWD_HASH_PROPERTY, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_PWD_HASH_PROPERTY] = g_param_spec_string ("pwd-hash", "pwd-hash", "pwd-hash", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_ENCRYPTION_INFO_RANDOM_KEY_PROPERTY, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_RANDOM_KEY_PROPERTY] = g_param_spec_string ("random-key", "random-key", "random-key", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_ENCRYPTION_INFO_SALT_PROPERTY, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_SALT_PROPERTY] = g_param_spec_string ("salt", "salt", "salt", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_encryption_info_instance_init (SeafileEncryptionInfo * self,
                                       gpointer klass)
{
	self->priv = seafile_encryption_info_get_instance_private (self);
}

static void
seafile_encryption_info_finalize (GObject * obj)
{
	SeafileEncryptionInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_ENCRYPTION_INFO, SeafileEncryptionInfo);
	_g_free0 (self->priv->_repo_id);
	_g_free0 (self->priv->_passwd);
	_g_free0 (self->priv->_magic);
	_g_free0 (self->priv->_pwd_hash);
	_g_free0 (self->priv->_random_key);
	_g_free0 (self->priv->_salt);
	G_OBJECT_CLASS (seafile_encryption_info_parent_class)->finalize (obj);
}

static GType
seafile_encryption_info_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileEncryptionInfoClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_encryption_info_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileEncryptionInfo), 0, (GInstanceInitFunc) seafile_encryption_info_instance_init, NULL };
	GType seafile_encryption_info_type_id;
	seafile_encryption_info_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileEncryptionInfo", &g_define_type_info, 0);
	SeafileEncryptionInfo_private_offset = g_type_add_instance_private (seafile_encryption_info_type_id, sizeof (SeafileEncryptionInfoPrivate));
	return seafile_encryption_info_type_id;
}

GType
seafile_encryption_info_get_type (void)
{
	static volatile gsize seafile_encryption_info_type_id__once = 0;
	if (g_once_init_enter (&seafile_encryption_info_type_id__once)) {
		GType seafile_encryption_info_type_id;
		seafile_encryption_info_type_id = seafile_encryption_info_get_type_once ();
		g_once_init_leave (&seafile_encryption_info_type_id__once, seafile_encryption_info_type_id);
	}
	return seafile_encryption_info_type_id__once;
}

static void
_vala_seafile_encryption_info_get_property (GObject * object,
                                            guint property_id,
                                            GValue * value,
                                            GParamSpec * pspec)
{
	SeafileEncryptionInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_ENCRYPTION_INFO, SeafileEncryptionInfo);
	switch (property_id) {
		case SEAFILE_ENCRYPTION_INFO_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_encryption_info_get_repo_id (self));
		break;
		case SEAFILE_ENCRYPTION_INFO_PASSWD_PROPERTY:
		g_value_set_string (value, seafile_encryption_info_get_passwd (self));
		break;
		case SEAFILE_ENCRYPTION_INFO_ENC_VERSION_PROPERTY:
		g_value_set_int (value, seafile_encryption_info_get_enc_version (self));
		break;
		case SEAFILE_ENCRYPTION_INFO_MAGIC_PROPERTY:
		g_value_set_string (value, seafile_encryption_info_get_magic (self));
		break;
		case SEAFILE_ENCRYPTION_INFO_PWD_HASH_PROPERTY:
		g_value_set_string (value, seafile_encryption_info_get_pwd_hash (self));
		break;
		case SEAFILE_ENCRYPTION_INFO_RANDOM_KEY_PROPERTY:
		g_value_set_string (value, seafile_encryption_info_get_random_key (self));
		break;
		case SEAFILE_ENCRYPTION_INFO_SALT_PROPERTY:
		g_value_set_string (value, seafile_encryption_info_get_salt (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_encryption_info_set_property (GObject * object,
                                            guint property_id,
                                            const GValue * value,
                                            GParamSpec * pspec)
{
	SeafileEncryptionInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_ENCRYPTION_INFO, SeafileEncryptionInfo);
	switch (property_id) {
		case SEAFILE_ENCRYPTION_INFO_REPO_ID_PROPERTY:
		seafile_encryption_info_set_repo_id (self, g_value_get_string (value));
		break;
		case SEAFILE_ENCRYPTION_INFO_PASSWD_PROPERTY:
		seafile_encryption_info_set_passwd (self, g_value_get_string (value));
		break;
		case SEAFILE_ENCRYPTION_INFO_ENC_VERSION_PROPERTY:
		seafile_encryption_info_set_enc_version (self, g_value_get_int (value));
		break;
		case SEAFILE_ENCRYPTION_INFO_MAGIC_PROPERTY:
		seafile_encryption_info_set_magic (self, g_value_get_string (value));
		break;
		case SEAFILE_ENCRYPTION_INFO_PWD_HASH_PROPERTY:
		seafile_encryption_info_set_pwd_hash (self, g_value_get_string (value));
		break;
		case SEAFILE_ENCRYPTION_INFO_RANDOM_KEY_PROPERTY:
		seafile_encryption_info_set_random_key (self, g_value_get_string (value));
		break;
		case SEAFILE_ENCRYPTION_INFO_SALT_PROPERTY:
		seafile_encryption_info_set_salt (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
seafile_file_sync_error_get_instance_private (SeafileFileSyncError* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileFileSyncError_private_offset);
}

SeafileFileSyncError*
seafile_file_sync_error_construct (GType object_type)
{
	SeafileFileSyncError * self = NULL;
	self = (SeafileFileSyncError*) g_object_new (object_type, NULL);
	return self;
}

SeafileFileSyncError*
seafile_file_sync_error_new (void)
{
	return seafile_file_sync_error_construct (SEAFILE_TYPE_FILE_SYNC_ERROR);
}

gint
seafile_file_sync_error_get_id (SeafileFileSyncError* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_id;
	return result;
}

void
seafile_file_sync_error_set_id (SeafileFileSyncError* self,
                                gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_file_sync_error_get_id (self);
	if (old_value != value) {
		self->priv->_id = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_ID_PROPERTY]);
	}
}

const gchar*
seafile_file_sync_error_get_repo_id (SeafileFileSyncError* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_repo_id;
	result = _tmp0_;
	return result;
}

void
seafile_file_sync_error_set_repo_id (SeafileFileSyncError* self,
                                     const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_file_sync_error_get_repo_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_repo_id);
		self->priv->_repo_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_REPO_ID_PROPERTY]);
	}
}

const gchar*
seafile_file_sync_error_get_repo_name (SeafileFileSyncError* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_repo_name;
	result = _tmp0_;
	return result;
}

void
seafile_file_sync_error_set_repo_name (SeafileFileSyncError* self,
                                       const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_file_sync_error_get_repo_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_repo_name);
		self->priv->_repo_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_REPO_NAME_PROPERTY]);
	}
}

const gchar*
seafile_file_sync_error_get_path (SeafileFileSyncError* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_path;
	result = _tmp0_;
	return result;
}

void
seafile_file_sync_error_set_path (SeafileFileSyncError* self,
                                  const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_file_sync_error_get_path (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_path);
		self->priv->_path = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_PATH_PROPERTY]);
	}
}

gint
seafile_file_sync_error_get_err_id (SeafileFileSyncError* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_err_id;
	return result;
}

void
seafile_file_sync_error_set_err_id (SeafileFileSyncError* self,
                                    gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_file_sync_error_get_err_id (self);
	if (old_value != value) {
		self->priv->_err_id = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_ERR_ID_PROPERTY]);
	}
}

gint64
seafile_file_sync_error_get_timestamp (SeafileFileSyncError* self)
{
	gint64 result;
	g_return_val_if_fail (self != NULL, 0LL);
	result = self->priv->_timestamp;
	return result;
}

void
seafile_file_sync_error_set_timestamp (SeafileFileSyncError* self,
                                       gint64 value)
{
	gint64 old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_file_sync_error_get_timestamp (self);
	if (old_value != value) {
		self->priv->_timestamp = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_TIMESTAMP_PROPERTY]);
	}
}

static void
seafile_file_sync_error_class_init (SeafileFileSyncErrorClass * klass,
                                    gpointer klass_data)
{
	seafile_file_sync_error_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileFileSyncError_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_file_sync_error_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_file_sync_error_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_file_sync_error_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_FILE_SYNC_ERROR_ID_PROPERTY, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_ID_PROPERTY] = g_param_spec_int ("id", "id", "id", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_FILE_SYNC_ERROR_REPO_ID_PROPERTY, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_REPO_ID_PROPERTY] = g_param_spec_string ("repo-id", "repo-id", "repo-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_FILE_SYNC_ERROR_REPO_NAME_PROPERTY, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_REPO_NAME_PROPERTY] = g_param_spec_string ("repo-name", "repo-name", "repo-name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_FILE_SYNC_ERROR_PATH_PROPERTY, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_PATH_PROPERTY] = g_param_spec_string ("path", "path", "path", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_FILE_SYNC_ERROR_ERR_ID_PROPERTY, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_ERR_ID_PROPERTY] = g_param_spec_int ("err-id", "err-id", "err-id", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_FILE_SYNC_ERROR_TIMESTAMP_PROPERTY, seafile_file_sync_error_properties[SEAFILE_FILE_SYNC_ERROR_TIMESTAMP_PROPERTY] = g_param_spec_int64 ("timestamp", "timestamp", "timestamp", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_file_sync_error_instance_init (SeafileFileSyncError * self,
                                       gpointer klass)
{
	self->priv = seafile_file_sync_error_get_instance_private (self);
}

static void
seafile_file_sync_error_finalize (GObject * obj)
{
	SeafileFileSyncError * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_FILE_SYNC_ERROR, SeafileFileSyncError);
	_g_free0 (self->priv->_repo_id);
	_g_free0 (self->priv->_repo_name);
	_g_free0 (self->priv->_path);
	G_OBJECT_CLASS (seafile_file_sync_error_parent_class)->finalize (obj);
}

static GType
seafile_file_sync_error_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileFileSyncErrorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_file_sync_error_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileFileSyncError), 0, (GInstanceInitFunc) seafile_file_sync_error_instance_init, NULL };
	GType seafile_file_sync_error_type_id;
	seafile_file_sync_error_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileFileSyncError", &g_define_type_info, 0);
	SeafileFileSyncError_private_offset = g_type_add_instance_private (seafile_file_sync_error_type_id, sizeof (SeafileFileSyncErrorPrivate));
	return seafile_file_sync_error_type_id;
}

GType
seafile_file_sync_error_get_type (void)
{
	static volatile gsize seafile_file_sync_error_type_id__once = 0;
	if (g_once_init_enter (&seafile_file_sync_error_type_id__once)) {
		GType seafile_file_sync_error_type_id;
		seafile_file_sync_error_type_id = seafile_file_sync_error_get_type_once ();
		g_once_init_leave (&seafile_file_sync_error_type_id__once, seafile_file_sync_error_type_id);
	}
	return seafile_file_sync_error_type_id__once;
}

static void
_vala_seafile_file_sync_error_get_property (GObject * object,
                                            guint property_id,
                                            GValue * value,
                                            GParamSpec * pspec)
{
	SeafileFileSyncError * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_FILE_SYNC_ERROR, SeafileFileSyncError);
	switch (property_id) {
		case SEAFILE_FILE_SYNC_ERROR_ID_PROPERTY:
		g_value_set_int (value, seafile_file_sync_error_get_id (self));
		break;
		case SEAFILE_FILE_SYNC_ERROR_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_file_sync_error_get_repo_id (self));
		break;
		case SEAFILE_FILE_SYNC_ERROR_REPO_NAME_PROPERTY:
		g_value_set_string (value, seafile_file_sync_error_get_repo_name (self));
		break;
		case SEAFILE_FILE_SYNC_ERROR_PATH_PROPERTY:
		g_value_set_string (value, seafile_file_sync_error_get_path (self));
		break;
		case SEAFILE_FILE_SYNC_ERROR_ERR_ID_PROPERTY:
		g_value_set_int (value, seafile_file_sync_error_get_err_id (self));
		break;
		case SEAFILE_FILE_SYNC_ERROR_TIMESTAMP_PROPERTY:
		g_value_set_int64 (value, seafile_file_sync_error_get_timestamp (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_file_sync_error_set_property (GObject * object,
                                            guint property_id,
                                            const GValue * value,
                                            GParamSpec * pspec)
{
	SeafileFileSyncError * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_FILE_SYNC_ERROR, SeafileFileSyncError);
	switch (property_id) {
		case SEAFILE_FILE_SYNC_ERROR_ID_PROPERTY:
		seafile_file_sync_error_set_id (self, g_value_get_int (value));
		break;
		case SEAFILE_FILE_SYNC_ERROR_REPO_ID_PROPERTY:
		seafile_file_sync_error_set_repo_id (self, g_value_get_string (value));
		break;
		case SEAFILE_FILE_SYNC_ERROR_REPO_NAME_PROPERTY:
		seafile_file_sync_error_set_repo_name (self, g_value_get_string (value));
		break;
		case SEAFILE_FILE_SYNC_ERROR_PATH_PROPERTY:
		seafile_file_sync_error_set_path (self, g_value_get_string (value));
		break;
		case SEAFILE_FILE_SYNC_ERROR_ERR_ID_PROPERTY:
		seafile_file_sync_error_set_err_id (self, g_value_get_int (value));
		break;
		case SEAFILE_FILE_SYNC_ERROR_TIMESTAMP_PROPERTY:
		seafile_file_sync_error_set_timestamp (self, g_value_get_int64 (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

