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

#include "seafile-object.h"
#include <glib.h>
#include <stdlib.h>
#include <string.h>
#include <glib-object.h>

#if !defined(VALA_STRICT_C)
#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
#elif defined(__clang__) && (__clang_major__ >= 16)
#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
#endif
#endif

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_LAST_MODIFIER_PROPERTY,
	SEAFILE_REPO_HEAD_CMMT_ID_PROPERTY,
	SEAFILE_REPO_ROOT_PROPERTY,
	SEAFILE_REPO_STATUS_PROPERTY,
	SEAFILE_REPO_REPO_TYPE_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_PWD_HASH_PROPERTY,
	SEAFILE_REPO_PWD_HASH_ALGO_PROPERTY,
	SEAFILE_REPO_PWD_HASH_PARAMS_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_GROUP_NAME_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))
enum  {
	SEAFILE_TRASH_REPO_0_PROPERTY,
	SEAFILE_TRASH_REPO_REPO_ID_PROPERTY,
	SEAFILE_TRASH_REPO_REPO_NAME_PROPERTY,
	SEAFILE_TRASH_REPO_HEAD_ID_PROPERTY,
	SEAFILE_TRASH_REPO_OWNER_ID_PROPERTY,
	SEAFILE_TRASH_REPO_SIZE_PROPERTY,
	SEAFILE_TRASH_REPO_DEL_TIME_PROPERTY,
	SEAFILE_TRASH_REPO_ENCRYPTED_PROPERTY,
	SEAFILE_TRASH_REPO_NUM_PROPERTIES
};
static GParamSpec* seafile_trash_repo_properties[SEAFILE_TRASH_REPO_NUM_PROPERTIES];
enum  {
	SEAFILE_SYNC_INFO_0_PROPERTY,
	SEAFILE_SYNC_INFO_REPO_ID_PROPERTY,
	SEAFILE_SYNC_INFO_HEAD_COMMIT_PROPERTY,
	SEAFILE_SYNC_INFO_DELETED_ON_RELAY_PROPERTY,
	SEAFILE_SYNC_INFO_BAD_LOCAL_BRANCH_PROPERTY,
	SEAFILE_SYNC_INFO_NEED_FETCH_PROPERTY,
	SEAFILE_SYNC_INFO_NEED_UPLOAD_PROPERTY,
	SEAFILE_SYNC_INFO_NEED_MERGE_PROPERTY,
	SEAFILE_SYNC_INFO_NUM_PROPERTIES
};
static GParamSpec* seafile_sync_info_properties[SEAFILE_SYNC_INFO_NUM_PROPERTIES];
enum  {
	SEAFILE_SYNC_TASK_0_PROPERTY,
	SEAFILE_SYNC_TASK_IS_SYNC_LAN_PROPERTY,
	SEAFILE_SYNC_TASK_FORCE_UPLOAD_PROPERTY,
	SEAFILE_SYNC_TASK_DEST_ID_PROPERTY,
	SEAFILE_SYNC_TASK_REPO_ID_PROPERTY,
	SEAFILE_SYNC_TASK_STATE_PROPERTY,
	SEAFILE_SYNC_TASK_ERROR_PROPERTY,
	SEAFILE_SYNC_TASK_TX_ID_PROPERTY,
	SEAFILE_SYNC_TASK_NUM_PROPERTIES
};
static GParamSpec* seafile_sync_task_properties[SEAFILE_SYNC_TASK_NUM_PROPERTIES];
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];
enum  {
	SEAFILE_CHECKOUT_TASK_0_PROPERTY,
	SEAFILE_CHECKOUT_TASK_REPO_ID_PROPERTY,
	SEAFILE_CHECKOUT_TASK_WORKTREE_PROPERTY,
	SEAFILE_CHECKOUT_TASK_TOTAL_FILES_PROPERTY,
	SEAFILE_CHECKOUT_TASK_FINISHED_FILES_PROPERTY,
	SEAFILE_CHECKOUT_TASK_NUM_PROPERTIES
};
static GParamSpec* seafile_checkout_task_properties[SEAFILE_CHECKOUT_TASK_NUM_PROPERTIES];
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];
enum  {
	SEAFILE_DELETED_ENTRY_0_PROPERTY,
	SEAFILE_DELETED_ENTRY_COMMIT_ID_PROPERTY,
	SEAFILE_DELETED_ENTRY_OBJ_ID_PROPERTY,
	SEAFILE_DELETED_ENTRY_OBJ_NAME_PROPERTY,
	SEAFILE_DELETED_ENTRY_BASEDIR_PROPERTY,
	SEAFILE_DELETED_ENTRY_MODE_PROPERTY,
	SEAFILE_DELETED_ENTRY_DELETE_TIME_PROPERTY,
	SEAFILE_DELETED_ENTRY_FILE_SIZE_PROPERTY,
	SEAFILE_DELETED_ENTRY_SCAN_STAT_PROPERTY,
	SEAFILE_DELETED_ENTRY_NUM_PROPERTIES
};
static GParamSpec* seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_NUM_PROPERTIES];
enum  {
	SEAFILE_REPO_TOKEN_INFO_0_PROPERTY,
	SEAFILE_REPO_TOKEN_INFO_REPO_ID_PROPERTY,
	SEAFILE_REPO_TOKEN_INFO_REPO_NAME_PROPERTY,
	SEAFILE_REPO_TOKEN_INFO_REPO_OWNER_PROPERTY,
	SEAFILE_REPO_TOKEN_INFO_EMAIL_PROPERTY,
	SEAFILE_REPO_TOKEN_INFO_TOKEN_PROPERTY,
	SEAFILE_REPO_TOKEN_INFO_PEER_ID_PROPERTY,
	SEAFILE_REPO_TOKEN_INFO_PEER_IP_PROPERTY,
	SEAFILE_REPO_TOKEN_INFO_PEER_NAME_PROPERTY,
	SEAFILE_REPO_TOKEN_INFO_SYNC_TIME_PROPERTY,
	SEAFILE_REPO_TOKEN_INFO_CLIENT_VER_PROPERTY,
	SEAFILE_REPO_TOKEN_INFO_NUM_PROPERTIES
};
static GParamSpec* seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_NUM_PROPERTIES];
enum  {
	SEAFILE_SHARED_USER_0_PROPERTY,
	SEAFILE_SHARED_USER_REPO_ID_PROPERTY,
	SEAFILE_SHARED_USER_USER_PROPERTY,
	SEAFILE_SHARED_USER_PERM_PROPERTY,
	SEAFILE_SHARED_USER_NUM_PROPERTIES
};
static GParamSpec* seafile_shared_user_properties[SEAFILE_SHARED_USER_NUM_PROPERTIES];
enum  {
	SEAFILE_SHARED_GROUP_0_PROPERTY,
	SEAFILE_SHARED_GROUP_REPO_ID_PROPERTY,
	SEAFILE_SHARED_GROUP_GROUP_ID_PROPERTY,
	SEAFILE_SHARED_GROUP_PERM_PROPERTY,
	SEAFILE_SHARED_GROUP_NUM_PROPERTIES
};
static GParamSpec* seafile_shared_group_properties[SEAFILE_SHARED_GROUP_NUM_PROPERTIES];
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_RANDOM_KEY_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_SALT_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_PWD_HASH_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_PWD_HASH_ALGO_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_PWD_HASH_PARAMS_PROPERTY,
	SEAFILE_ENCRYPTION_INFO_NUM_PROPERTIES
};
static GParamSpec* seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_NUM_PROPERTIES];
enum  {
	SEAFILE_USER_QUOTA_USAGE_0_PROPERTY,
	SEAFILE_USER_QUOTA_USAGE_USER_PROPERTY,
	SEAFILE_USER_QUOTA_USAGE_USAGE_PROPERTY,
	SEAFILE_USER_QUOTA_USAGE_NUM_PROPERTIES
};
static GParamSpec* seafile_user_quota_usage_properties[SEAFILE_USER_QUOTA_USAGE_NUM_PROPERTIES];

struct _SeafileRepoPrivate {
	gint _version;
	gint64 _last_modify;
	gint64 _size;
	gint64 _file_count;
	gchar* _last_modifier;
	gchar* _head_cmmt_id;
	gchar* _root;
	gint _status;
	gchar* _repo_type;
	gchar* _repo_id;
	gchar* _repo_name;
	gchar* _repo_desc;
	gint64 _last_modified;
	gboolean _encrypted;
	gchar* _magic;
	gint _enc_version;
	gchar* _random_key;
	gchar* _salt;
	gchar* _pwd_hash;
	gchar* _pwd_hash_algo;
	gchar* _pwd_hash_params;
	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;
	gchar* _group_name;
	gboolean _is_shared;
};

struct _SeafileTrashRepoPrivate {
	gchar* _repo_id;
	gchar* _repo_name;
	gchar* _head_id;
	gchar* _owner_id;
	gint64 _size;
	gint64 _del_time;
	gboolean _encrypted;
};

struct _SeafileSyncInfoPrivate {
	gchar* _repo_id;
	gchar* _head_commit;
	gboolean _deleted_on_relay;
	gboolean _bad_local_branch;
	gboolean _need_fetch;
	gboolean _need_upload;
	gboolean _need_merge;
};

struct _SeafileSyncTaskPrivate {
	gboolean _is_sync_lan;
	gboolean _force_upload;
	gchar* _dest_id;
	gchar* _repo_id;
	gchar* _state;
	gchar* _error;
	gchar* _tx_id;
};

struct _SeafileSessionInfoPrivate {
	gchar* _datadir;
};

struct _SeafileCheckoutTaskPrivate {
	gchar* _repo_id;
	gchar* _worktree;
	gint _total_files;
	gint _finished_files;
};

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

struct _SeafileDeletedEntryPrivate {
	gchar* _commit_id;
	gchar* _obj_id;
	gchar* _obj_name;
	gchar* _basedir;
	gint _mode;
	gint _delete_time;
	gint64 _file_size;
	gchar* _scan_stat;
};

struct _SeafileRepoTokenInfoPrivate {
	gchar* _repo_id;
	gchar* _repo_name;
	gchar* _repo_owner;
	gchar* _email;
	gchar* _token;
	gchar* _peer_id;
	gchar* _peer_ip;
	gchar* _peer_name;
	gint64 _sync_time;
	gchar* _client_ver;
};

struct _SeafileSharedUserPrivate {
	gchar* _repo_id;
	gchar* _user;
	gchar* _perm;
};

struct _SeafileSharedGroupPrivate {
	gchar* _repo_id;
	gint _group_id;
	gchar* _perm;
};

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

struct _SeafileUserQuotaUsagePrivate {
	gchar* _user;
	gint64 _usage;
};

static gint SeafileRepo_private_offset;
static gpointer seafile_repo_parent_class = NULL;
static gint SeafileTrashRepo_private_offset;
static gpointer seafile_trash_repo_parent_class = NULL;
static gint SeafileSyncInfo_private_offset;
static gpointer seafile_sync_info_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 SeafileCheckoutTask_private_offset;
static gpointer seafile_checkout_task_parent_class = NULL;
static gint SeafileDiffEntry_private_offset;
static gpointer seafile_diff_entry_parent_class = NULL;
static gint SeafileDeletedEntry_private_offset;
static gpointer seafile_deleted_entry_parent_class = NULL;
static gint SeafileRepoTokenInfo_private_offset;
static gpointer seafile_repo_token_info_parent_class = NULL;
static gint SeafileSharedUser_private_offset;
static gpointer seafile_shared_user_parent_class = NULL;
static gint SeafileSharedGroup_private_offset;
static gpointer seafile_shared_group_parent_class = NULL;
static gint SeafileEncryptionInfo_private_offset;
static gpointer seafile_encryption_info_parent_class = NULL;
static gint SeafileUserQuotaUsage_private_offset;
static gpointer seafile_user_quota_usage_parent_class = NULL;

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);
static void seafile_trash_repo_finalize (GObject * obj);
static GType seafile_trash_repo_get_type_once (void);
static void _vala_seafile_trash_repo_get_property (GObject * object,
                                            guint property_id,
                                            GValue * value,
                                            GParamSpec * pspec);
static void _vala_seafile_trash_repo_set_property (GObject * object,
                                            guint property_id,
                                            const GValue * value,
                                            GParamSpec * pspec);
static void seafile_sync_info_finalize (GObject * obj);
static GType seafile_sync_info_get_type_once (void);
static void _vala_seafile_sync_info_get_property (GObject * object,
                                           guint property_id,
                                           GValue * value,
                                           GParamSpec * pspec);
static void _vala_seafile_sync_info_set_property (GObject * object,
                                           guint property_id,
                                           const GValue * value,
                                           GParamSpec * pspec);
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);
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);
static void seafile_checkout_task_finalize (GObject * obj);
static GType seafile_checkout_task_get_type_once (void);
static void _vala_seafile_checkout_task_get_property (GObject * object,
                                               guint property_id,
                                               GValue * value,
                                               GParamSpec * pspec);
static void _vala_seafile_checkout_task_set_property (GObject * object,
                                               guint property_id,
                                               const GValue * value,
                                               GParamSpec * pspec);
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);
static void seafile_deleted_entry_finalize (GObject * obj);
static GType seafile_deleted_entry_get_type_once (void);
static void _vala_seafile_deleted_entry_get_property (GObject * object,
                                               guint property_id,
                                               GValue * value,
                                               GParamSpec * pspec);
static void _vala_seafile_deleted_entry_set_property (GObject * object,
                                               guint property_id,
                                               const GValue * value,
                                               GParamSpec * pspec);
static void seafile_repo_token_info_finalize (GObject * obj);
static GType seafile_repo_token_info_get_type_once (void);
static void _vala_seafile_repo_token_info_get_property (GObject * object,
                                                 guint property_id,
                                                 GValue * value,
                                                 GParamSpec * pspec);
static void _vala_seafile_repo_token_info_set_property (GObject * object,
                                                 guint property_id,
                                                 const GValue * value,
                                                 GParamSpec * pspec);
static void seafile_shared_user_finalize (GObject * obj);
static GType seafile_shared_user_get_type_once (void);
static void _vala_seafile_shared_user_get_property (GObject * object,
                                             guint property_id,
                                             GValue * value,
                                             GParamSpec * pspec);
static void _vala_seafile_shared_user_set_property (GObject * object,
                                             guint property_id,
                                             const GValue * value,
                                             GParamSpec * pspec);
static void seafile_shared_group_finalize (GObject * obj);
static GType seafile_shared_group_get_type_once (void);
static void _vala_seafile_shared_group_get_property (GObject * object,
                                              guint property_id,
                                              GValue * value,
                                              GParamSpec * pspec);
static void _vala_seafile_shared_group_set_property (GObject * object,
                                              guint property_id,
                                              const GValue * value,
                                              GParamSpec * pspec);
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);
static void seafile_user_quota_usage_finalize (GObject * obj);
static GType seafile_user_quota_usage_get_type_once (void);
static void _vala_seafile_user_quota_usage_get_property (GObject * object,
                                                  guint property_id,
                                                  GValue * value,
                                                  GParamSpec * pspec);
static void _vala_seafile_user_quota_usage_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, -1);
	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]);
	}
}

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

void
seafile_repo_set_last_modify (SeafileRepo* self,
                              gint64 value)
{
	gint64 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, -1LL);
	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, -1LL);
	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_last_modifier (SeafileRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_last_modifier;
	result = _tmp0_;
	return result;
}

void
seafile_repo_set_last_modifier (SeafileRepo* self,
                                const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_last_modifier (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_last_modifier);
		self->priv->_last_modifier = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_LAST_MODIFIER_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]);
	}
}

gint
seafile_repo_get_status (SeafileRepo* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, -1);
	result = self->priv->_status;
	return result;
}

void
seafile_repo_set_status (SeafileRepo* self,
                         gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_status (self);
	if (old_value != value) {
		self->priv->_status = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_STATUS_PROPERTY]);
	}
}

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

void
seafile_repo_set_repo_type (SeafileRepo* self,
                            const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_repo_type (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_repo_type);
		self->priv->_repo_type = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_REPO_TYPE_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]);
	}
}

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

void
seafile_repo_set_last_modified (SeafileRepo* self,
                                gint64 value)
{
	gint64 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, -1);
	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_pwd_hash (SeafileRepo* 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_repo_set_pwd_hash (SeafileRepo* self,
                           const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_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_repo_properties[SEAFILE_REPO_PWD_HASH_PROPERTY]);
	}
}

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

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

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

void
seafile_repo_set_pwd_hash_params (SeafileRepo* self,
                                  const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_pwd_hash_params (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_pwd_hash_params);
		self->priv->_pwd_hash_params = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_PWD_HASH_PARAMS_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, -1);
	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, -1);
	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]);
	}
}

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

void
seafile_repo_set_group_name (SeafileRepo* self,
                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_get_group_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_group_name);
		self->priv->_group_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_properties[SEAFILE_REPO_GROUP_NAME_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_int64 ("last-modify", "last-modify", "last-modify", 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_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_LAST_MODIFIER_PROPERTY, seafile_repo_properties[SEAFILE_REPO_LAST_MODIFIER_PROPERTY] = g_param_spec_string ("last-modifier", "last-modifier", "last-modifier", NULL, 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_STATUS_PROPERTY, seafile_repo_properties[SEAFILE_REPO_STATUS_PROPERTY] = g_param_spec_int ("status", "status", "status", 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_REPO_TYPE_PROPERTY, seafile_repo_properties[SEAFILE_REPO_REPO_TYPE_PROPERTY] = g_param_spec_string ("repo-type", "repo-type", "repo-type", 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_int64 ("last-modified", "last-modified", "last-modified", 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_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_PWD_HASH_PROPERTY, seafile_repo_properties[SEAFILE_REPO_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_REPO_PWD_HASH_ALGO_PROPERTY, seafile_repo_properties[SEAFILE_REPO_PWD_HASH_ALGO_PROPERTY] = g_param_spec_string ("pwd-hash-algo", "pwd-hash-algo", "pwd-hash-algo", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_PWD_HASH_PARAMS_PROPERTY, seafile_repo_properties[SEAFILE_REPO_PWD_HASH_PARAMS_PROPERTY] = g_param_spec_string ("pwd-hash-params", "pwd-hash-params", "pwd-hash-params", 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_GROUP_NAME_PROPERTY, seafile_repo_properties[SEAFILE_REPO_GROUP_NAME_PROPERTY] = g_param_spec_string ("group-name", "group-name", "group-name", NULL, 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->_last_modifier);
	_g_free0 (self->priv->_head_cmmt_id);
	_g_free0 (self->priv->_root);
	_g_free0 (self->priv->_repo_type);
	_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->priv->_pwd_hash);
	_g_free0 (self->priv->_pwd_hash_algo);
	_g_free0 (self->priv->_pwd_hash_params);
	_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_free0 (self->priv->_group_name);
	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_int64 (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_LAST_MODIFIER_PROPERTY:
		g_value_set_string (value, seafile_repo_get_last_modifier (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_STATUS_PROPERTY:
		g_value_set_int (value, seafile_repo_get_status (self));
		break;
		case SEAFILE_REPO_REPO_TYPE_PROPERTY:
		g_value_set_string (value, seafile_repo_get_repo_type (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_int64 (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_PWD_HASH_PROPERTY:
		g_value_set_string (value, seafile_repo_get_pwd_hash (self));
		break;
		case SEAFILE_REPO_PWD_HASH_ALGO_PROPERTY:
		g_value_set_string (value, seafile_repo_get_pwd_hash_algo (self));
		break;
		case SEAFILE_REPO_PWD_HASH_PARAMS_PROPERTY:
		g_value_set_string (value, seafile_repo_get_pwd_hash_params (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_GROUP_NAME_PROPERTY:
		g_value_set_string (value, seafile_repo_get_group_name (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_int64 (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_LAST_MODIFIER_PROPERTY:
		seafile_repo_set_last_modifier (self, g_value_get_string (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_STATUS_PROPERTY:
		seafile_repo_set_status (self, g_value_get_int (value));
		break;
		case SEAFILE_REPO_REPO_TYPE_PROPERTY:
		seafile_repo_set_repo_type (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_int64 (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_PWD_HASH_PROPERTY:
		seafile_repo_set_pwd_hash (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_PWD_HASH_ALGO_PROPERTY:
		seafile_repo_set_pwd_hash_algo (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_PWD_HASH_PARAMS_PROPERTY:
		seafile_repo_set_pwd_hash_params (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_GROUP_NAME_PROPERTY:
		seafile_repo_set_group_name (self, g_value_get_string (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_trash_repo_get_instance_private (SeafileTrashRepo* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileTrashRepo_private_offset);
}

SeafileTrashRepo*
seafile_trash_repo_construct (GType object_type)
{
	SeafileTrashRepo * self = NULL;
	self = (SeafileTrashRepo*) g_object_new (object_type, NULL);
	return self;
}

SeafileTrashRepo*
seafile_trash_repo_new (void)
{
	return seafile_trash_repo_construct (SEAFILE_TYPE_TRASH_REPO);
}

const gchar*
seafile_trash_repo_get_repo_id (SeafileTrashRepo* 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_trash_repo_set_repo_id (SeafileTrashRepo* self,
                                const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_trash_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_trash_repo_properties[SEAFILE_TRASH_REPO_REPO_ID_PROPERTY]);
	}
}

const gchar*
seafile_trash_repo_get_repo_name (SeafileTrashRepo* 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_trash_repo_set_repo_name (SeafileTrashRepo* self,
                                  const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_trash_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_trash_repo_properties[SEAFILE_TRASH_REPO_REPO_NAME_PROPERTY]);
	}
}

const gchar*
seafile_trash_repo_get_head_id (SeafileTrashRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_head_id;
	result = _tmp0_;
	return result;
}

void
seafile_trash_repo_set_head_id (SeafileTrashRepo* self,
                                const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_trash_repo_get_head_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_head_id);
		self->priv->_head_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_trash_repo_properties[SEAFILE_TRASH_REPO_HEAD_ID_PROPERTY]);
	}
}

const gchar*
seafile_trash_repo_get_owner_id (SeafileTrashRepo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_owner_id;
	result = _tmp0_;
	return result;
}

void
seafile_trash_repo_set_owner_id (SeafileTrashRepo* self,
                                 const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_trash_repo_get_owner_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_owner_id);
		self->priv->_owner_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_trash_repo_properties[SEAFILE_TRASH_REPO_OWNER_ID_PROPERTY]);
	}
}

gint64
seafile_trash_repo_get_size (SeafileTrashRepo* self)
{
	gint64 result;
	g_return_val_if_fail (self != NULL, -1LL);
	result = self->priv->_size;
	return result;
}

void
seafile_trash_repo_set_size (SeafileTrashRepo* self,
                             gint64 value)
{
	gint64 old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_trash_repo_get_size (self);
	if (old_value != value) {
		self->priv->_size = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_trash_repo_properties[SEAFILE_TRASH_REPO_SIZE_PROPERTY]);
	}
}

gint64
seafile_trash_repo_get_del_time (SeafileTrashRepo* self)
{
	gint64 result;
	g_return_val_if_fail (self != NULL, -1LL);
	result = self->priv->_del_time;
	return result;
}

void
seafile_trash_repo_set_del_time (SeafileTrashRepo* self,
                                 gint64 value)
{
	gint64 old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_trash_repo_get_del_time (self);
	if (old_value != value) {
		self->priv->_del_time = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_trash_repo_properties[SEAFILE_TRASH_REPO_DEL_TIME_PROPERTY]);
	}
}

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

void
seafile_trash_repo_set_encrypted (SeafileTrashRepo* self,
                                  gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_trash_repo_get_encrypted (self);
	if (old_value != value) {
		self->priv->_encrypted = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_trash_repo_properties[SEAFILE_TRASH_REPO_ENCRYPTED_PROPERTY]);
	}
}

static void
seafile_trash_repo_class_init (SeafileTrashRepoClass * klass,
                               gpointer klass_data)
{
	seafile_trash_repo_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileTrashRepo_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_trash_repo_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_trash_repo_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_trash_repo_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_TRASH_REPO_REPO_ID_PROPERTY, seafile_trash_repo_properties[SEAFILE_TRASH_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_TRASH_REPO_REPO_NAME_PROPERTY, seafile_trash_repo_properties[SEAFILE_TRASH_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_TRASH_REPO_HEAD_ID_PROPERTY, seafile_trash_repo_properties[SEAFILE_TRASH_REPO_HEAD_ID_PROPERTY] = g_param_spec_string ("head-id", "head-id", "head-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_TRASH_REPO_OWNER_ID_PROPERTY, seafile_trash_repo_properties[SEAFILE_TRASH_REPO_OWNER_ID_PROPERTY] = g_param_spec_string ("owner-id", "owner-id", "owner-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_TRASH_REPO_SIZE_PROPERTY, seafile_trash_repo_properties[SEAFILE_TRASH_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_TRASH_REPO_DEL_TIME_PROPERTY, seafile_trash_repo_properties[SEAFILE_TRASH_REPO_DEL_TIME_PROPERTY] = g_param_spec_int64 ("del-time", "del-time", "del-time", 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_TRASH_REPO_ENCRYPTED_PROPERTY, seafile_trash_repo_properties[SEAFILE_TRASH_REPO_ENCRYPTED_PROPERTY] = g_param_spec_boolean ("encrypted", "encrypted", "encrypted", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_trash_repo_instance_init (SeafileTrashRepo * self,
                                  gpointer klass)
{
	self->priv = seafile_trash_repo_get_instance_private (self);
}

static void
seafile_trash_repo_finalize (GObject * obj)
{
	SeafileTrashRepo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_TRASH_REPO, SeafileTrashRepo);
	_g_free0 (self->priv->_repo_id);
	_g_free0 (self->priv->_repo_name);
	_g_free0 (self->priv->_head_id);
	_g_free0 (self->priv->_owner_id);
	G_OBJECT_CLASS (seafile_trash_repo_parent_class)->finalize (obj);
}

static GType
seafile_trash_repo_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileTrashRepoClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_trash_repo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileTrashRepo), 0, (GInstanceInitFunc) seafile_trash_repo_instance_init, NULL };
	GType seafile_trash_repo_type_id;
	seafile_trash_repo_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileTrashRepo", &g_define_type_info, 0);
	SeafileTrashRepo_private_offset = g_type_add_instance_private (seafile_trash_repo_type_id, sizeof (SeafileTrashRepoPrivate));
	return seafile_trash_repo_type_id;
}

GType
seafile_trash_repo_get_type (void)
{
	static volatile gsize seafile_trash_repo_type_id__once = 0;
	if (g_once_init_enter (&seafile_trash_repo_type_id__once)) {
		GType seafile_trash_repo_type_id;
		seafile_trash_repo_type_id = seafile_trash_repo_get_type_once ();
		g_once_init_leave (&seafile_trash_repo_type_id__once, seafile_trash_repo_type_id);
	}
	return seafile_trash_repo_type_id__once;
}

static void
_vala_seafile_trash_repo_get_property (GObject * object,
                                       guint property_id,
                                       GValue * value,
                                       GParamSpec * pspec)
{
	SeafileTrashRepo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_TRASH_REPO, SeafileTrashRepo);
	switch (property_id) {
		case SEAFILE_TRASH_REPO_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_trash_repo_get_repo_id (self));
		break;
		case SEAFILE_TRASH_REPO_REPO_NAME_PROPERTY:
		g_value_set_string (value, seafile_trash_repo_get_repo_name (self));
		break;
		case SEAFILE_TRASH_REPO_HEAD_ID_PROPERTY:
		g_value_set_string (value, seafile_trash_repo_get_head_id (self));
		break;
		case SEAFILE_TRASH_REPO_OWNER_ID_PROPERTY:
		g_value_set_string (value, seafile_trash_repo_get_owner_id (self));
		break;
		case SEAFILE_TRASH_REPO_SIZE_PROPERTY:
		g_value_set_int64 (value, seafile_trash_repo_get_size (self));
		break;
		case SEAFILE_TRASH_REPO_DEL_TIME_PROPERTY:
		g_value_set_int64 (value, seafile_trash_repo_get_del_time (self));
		break;
		case SEAFILE_TRASH_REPO_ENCRYPTED_PROPERTY:
		g_value_set_boolean (value, seafile_trash_repo_get_encrypted (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_trash_repo_set_property (GObject * object,
                                       guint property_id,
                                       const GValue * value,
                                       GParamSpec * pspec)
{
	SeafileTrashRepo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_TRASH_REPO, SeafileTrashRepo);
	switch (property_id) {
		case SEAFILE_TRASH_REPO_REPO_ID_PROPERTY:
		seafile_trash_repo_set_repo_id (self, g_value_get_string (value));
		break;
		case SEAFILE_TRASH_REPO_REPO_NAME_PROPERTY:
		seafile_trash_repo_set_repo_name (self, g_value_get_string (value));
		break;
		case SEAFILE_TRASH_REPO_HEAD_ID_PROPERTY:
		seafile_trash_repo_set_head_id (self, g_value_get_string (value));
		break;
		case SEAFILE_TRASH_REPO_OWNER_ID_PROPERTY:
		seafile_trash_repo_set_owner_id (self, g_value_get_string (value));
		break;
		case SEAFILE_TRASH_REPO_SIZE_PROPERTY:
		seafile_trash_repo_set_size (self, g_value_get_int64 (value));
		break;
		case SEAFILE_TRASH_REPO_DEL_TIME_PROPERTY:
		seafile_trash_repo_set_del_time (self, g_value_get_int64 (value));
		break;
		case SEAFILE_TRASH_REPO_ENCRYPTED_PROPERTY:
		seafile_trash_repo_set_encrypted (self, g_value_get_boolean (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
seafile_sync_info_get_instance_private (SeafileSyncInfo* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileSyncInfo_private_offset);
}

SeafileSyncInfo*
seafile_sync_info_construct (GType object_type)
{
	SeafileSyncInfo * self = NULL;
	self = (SeafileSyncInfo*) g_object_new (object_type, NULL);
	return self;
}

SeafileSyncInfo*
seafile_sync_info_new (void)
{
	return seafile_sync_info_construct (SEAFILE_TYPE_SYNC_INFO);
}

const gchar*
seafile_sync_info_get_repo_id (SeafileSyncInfo* 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_info_set_repo_id (SeafileSyncInfo* self,
                               const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_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_sync_info_properties[SEAFILE_SYNC_INFO_REPO_ID_PROPERTY]);
	}
}

const gchar*
seafile_sync_info_get_head_commit (SeafileSyncInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_head_commit;
	result = _tmp0_;
	return result;
}

void
seafile_sync_info_set_head_commit (SeafileSyncInfo* self,
                                   const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_info_get_head_commit (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_head_commit);
		self->priv->_head_commit = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_info_properties[SEAFILE_SYNC_INFO_HEAD_COMMIT_PROPERTY]);
	}
}

gboolean
seafile_sync_info_get_deleted_on_relay (SeafileSyncInfo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_deleted_on_relay;
	return result;
}

void
seafile_sync_info_set_deleted_on_relay (SeafileSyncInfo* self,
                                        gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_info_get_deleted_on_relay (self);
	if (old_value != value) {
		self->priv->_deleted_on_relay = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_info_properties[SEAFILE_SYNC_INFO_DELETED_ON_RELAY_PROPERTY]);
	}
}

gboolean
seafile_sync_info_get_bad_local_branch (SeafileSyncInfo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_bad_local_branch;
	return result;
}

void
seafile_sync_info_set_bad_local_branch (SeafileSyncInfo* self,
                                        gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_info_get_bad_local_branch (self);
	if (old_value != value) {
		self->priv->_bad_local_branch = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_info_properties[SEAFILE_SYNC_INFO_BAD_LOCAL_BRANCH_PROPERTY]);
	}
}

gboolean
seafile_sync_info_get_need_fetch (SeafileSyncInfo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_need_fetch;
	return result;
}

void
seafile_sync_info_set_need_fetch (SeafileSyncInfo* self,
                                  gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_info_get_need_fetch (self);
	if (old_value != value) {
		self->priv->_need_fetch = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_info_properties[SEAFILE_SYNC_INFO_NEED_FETCH_PROPERTY]);
	}
}

gboolean
seafile_sync_info_get_need_upload (SeafileSyncInfo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_need_upload;
	return result;
}

void
seafile_sync_info_set_need_upload (SeafileSyncInfo* self,
                                   gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_info_get_need_upload (self);
	if (old_value != value) {
		self->priv->_need_upload = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_info_properties[SEAFILE_SYNC_INFO_NEED_UPLOAD_PROPERTY]);
	}
}

gboolean
seafile_sync_info_get_need_merge (SeafileSyncInfo* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_need_merge;
	return result;
}

void
seafile_sync_info_set_need_merge (SeafileSyncInfo* self,
                                  gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_info_get_need_merge (self);
	if (old_value != value) {
		self->priv->_need_merge = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_info_properties[SEAFILE_SYNC_INFO_NEED_MERGE_PROPERTY]);
	}
}

static void
seafile_sync_info_class_init (SeafileSyncInfoClass * klass,
                              gpointer klass_data)
{
	seafile_sync_info_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileSyncInfo_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_sync_info_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_sync_info_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_sync_info_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SYNC_INFO_REPO_ID_PROPERTY, seafile_sync_info_properties[SEAFILE_SYNC_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_SYNC_INFO_HEAD_COMMIT_PROPERTY, seafile_sync_info_properties[SEAFILE_SYNC_INFO_HEAD_COMMIT_PROPERTY] = g_param_spec_string ("head-commit", "head-commit", "head-commit", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SYNC_INFO_DELETED_ON_RELAY_PROPERTY, seafile_sync_info_properties[SEAFILE_SYNC_INFO_DELETED_ON_RELAY_PROPERTY] = g_param_spec_boolean ("deleted-on-relay", "deleted-on-relay", "deleted-on-relay", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SYNC_INFO_BAD_LOCAL_BRANCH_PROPERTY, seafile_sync_info_properties[SEAFILE_SYNC_INFO_BAD_LOCAL_BRANCH_PROPERTY] = g_param_spec_boolean ("bad-local-branch", "bad-local-branch", "bad-local-branch", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SYNC_INFO_NEED_FETCH_PROPERTY, seafile_sync_info_properties[SEAFILE_SYNC_INFO_NEED_FETCH_PROPERTY] = g_param_spec_boolean ("need-fetch", "need-fetch", "need-fetch", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SYNC_INFO_NEED_UPLOAD_PROPERTY, seafile_sync_info_properties[SEAFILE_SYNC_INFO_NEED_UPLOAD_PROPERTY] = g_param_spec_boolean ("need-upload", "need-upload", "need-upload", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SYNC_INFO_NEED_MERGE_PROPERTY, seafile_sync_info_properties[SEAFILE_SYNC_INFO_NEED_MERGE_PROPERTY] = g_param_spec_boolean ("need-merge", "need-merge", "need-merge", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_sync_info_instance_init (SeafileSyncInfo * self,
                                 gpointer klass)
{
	self->priv = seafile_sync_info_get_instance_private (self);
}

static void
seafile_sync_info_finalize (GObject * obj)
{
	SeafileSyncInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_SYNC_INFO, SeafileSyncInfo);
	_g_free0 (self->priv->_repo_id);
	_g_free0 (self->priv->_head_commit);
	G_OBJECT_CLASS (seafile_sync_info_parent_class)->finalize (obj);
}

static GType
seafile_sync_info_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileSyncInfoClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_sync_info_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileSyncInfo), 0, (GInstanceInitFunc) seafile_sync_info_instance_init, NULL };
	GType seafile_sync_info_type_id;
	seafile_sync_info_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileSyncInfo", &g_define_type_info, 0);
	SeafileSyncInfo_private_offset = g_type_add_instance_private (seafile_sync_info_type_id, sizeof (SeafileSyncInfoPrivate));
	return seafile_sync_info_type_id;
}

GType
seafile_sync_info_get_type (void)
{
	static volatile gsize seafile_sync_info_type_id__once = 0;
	if (g_once_init_enter (&seafile_sync_info_type_id__once)) {
		GType seafile_sync_info_type_id;
		seafile_sync_info_type_id = seafile_sync_info_get_type_once ();
		g_once_init_leave (&seafile_sync_info_type_id__once, seafile_sync_info_type_id);
	}
	return seafile_sync_info_type_id__once;
}

static void
_vala_seafile_sync_info_get_property (GObject * object,
                                      guint property_id,
                                      GValue * value,
                                      GParamSpec * pspec)
{
	SeafileSyncInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_SYNC_INFO, SeafileSyncInfo);
	switch (property_id) {
		case SEAFILE_SYNC_INFO_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_sync_info_get_repo_id (self));
		break;
		case SEAFILE_SYNC_INFO_HEAD_COMMIT_PROPERTY:
		g_value_set_string (value, seafile_sync_info_get_head_commit (self));
		break;
		case SEAFILE_SYNC_INFO_DELETED_ON_RELAY_PROPERTY:
		g_value_set_boolean (value, seafile_sync_info_get_deleted_on_relay (self));
		break;
		case SEAFILE_SYNC_INFO_BAD_LOCAL_BRANCH_PROPERTY:
		g_value_set_boolean (value, seafile_sync_info_get_bad_local_branch (self));
		break;
		case SEAFILE_SYNC_INFO_NEED_FETCH_PROPERTY:
		g_value_set_boolean (value, seafile_sync_info_get_need_fetch (self));
		break;
		case SEAFILE_SYNC_INFO_NEED_UPLOAD_PROPERTY:
		g_value_set_boolean (value, seafile_sync_info_get_need_upload (self));
		break;
		case SEAFILE_SYNC_INFO_NEED_MERGE_PROPERTY:
		g_value_set_boolean (value, seafile_sync_info_get_need_merge (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_sync_info_set_property (GObject * object,
                                      guint property_id,
                                      const GValue * value,
                                      GParamSpec * pspec)
{
	SeafileSyncInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_SYNC_INFO, SeafileSyncInfo);
	switch (property_id) {
		case SEAFILE_SYNC_INFO_REPO_ID_PROPERTY:
		seafile_sync_info_set_repo_id (self, g_value_get_string (value));
		break;
		case SEAFILE_SYNC_INFO_HEAD_COMMIT_PROPERTY:
		seafile_sync_info_set_head_commit (self, g_value_get_string (value));
		break;
		case SEAFILE_SYNC_INFO_DELETED_ON_RELAY_PROPERTY:
		seafile_sync_info_set_deleted_on_relay (self, g_value_get_boolean (value));
		break;
		case SEAFILE_SYNC_INFO_BAD_LOCAL_BRANCH_PROPERTY:
		seafile_sync_info_set_bad_local_branch (self, g_value_get_boolean (value));
		break;
		case SEAFILE_SYNC_INFO_NEED_FETCH_PROPERTY:
		seafile_sync_info_set_need_fetch (self, g_value_get_boolean (value));
		break;
		case SEAFILE_SYNC_INFO_NEED_UPLOAD_PROPERTY:
		seafile_sync_info_set_need_upload (self, g_value_get_boolean (value));
		break;
		case SEAFILE_SYNC_INFO_NEED_MERGE_PROPERTY:
		seafile_sync_info_set_need_merge (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_is_sync_lan (SeafileSyncTask* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_is_sync_lan;
	return result;
}

void
seafile_sync_task_set_is_sync_lan (SeafileSyncTask* self,
                                   gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_task_get_is_sync_lan (self);
	if (old_value != value) {
		self->priv->_is_sync_lan = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_task_properties[SEAFILE_SYNC_TASK_IS_SYNC_LAN_PROPERTY]);
	}
}

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_dest_id (SeafileSyncTask* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_dest_id;
	result = _tmp0_;
	return result;
}

void
seafile_sync_task_set_dest_id (SeafileSyncTask* self,
                               const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_task_get_dest_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_dest_id);
		self->priv->_dest_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_task_properties[SEAFILE_SYNC_TASK_DEST_ID_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]);
	}
}

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

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

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

void
seafile_sync_task_set_tx_id (SeafileSyncTask* self,
                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_sync_task_get_tx_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_tx_id);
		self->priv->_tx_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_sync_task_properties[SEAFILE_SYNC_TASK_TX_ID_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_IS_SYNC_LAN_PROPERTY, seafile_sync_task_properties[SEAFILE_SYNC_TASK_IS_SYNC_LAN_PROPERTY] = g_param_spec_boolean ("is-sync-lan", "is-sync-lan", "is-sync-lan", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	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_DEST_ID_PROPERTY, seafile_sync_task_properties[SEAFILE_SYNC_TASK_DEST_ID_PROPERTY] = g_param_spec_string ("dest-id", "dest-id", "dest-id", NULL, 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_string ("error", "error", "error", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SYNC_TASK_TX_ID_PROPERTY, seafile_sync_task_properties[SEAFILE_SYNC_TASK_TX_ID_PROPERTY] = g_param_spec_string ("tx-id", "tx-id", "tx-id", NULL, 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->_dest_id);
	_g_free0 (self->priv->_repo_id);
	_g_free0 (self->priv->_state);
	_g_free0 (self->priv->_error);
	_g_free0 (self->priv->_tx_id);
	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_IS_SYNC_LAN_PROPERTY:
		g_value_set_boolean (value, seafile_sync_task_get_is_sync_lan (self));
		break;
		case SEAFILE_SYNC_TASK_FORCE_UPLOAD_PROPERTY:
		g_value_set_boolean (value, seafile_sync_task_get_force_upload (self));
		break;
		case SEAFILE_SYNC_TASK_DEST_ID_PROPERTY:
		g_value_set_string (value, seafile_sync_task_get_dest_id (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_string (value, seafile_sync_task_get_error (self));
		break;
		case SEAFILE_SYNC_TASK_TX_ID_PROPERTY:
		g_value_set_string (value, seafile_sync_task_get_tx_id (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_IS_SYNC_LAN_PROPERTY:
		seafile_sync_task_set_is_sync_lan (self, g_value_get_boolean (value));
		break;
		case SEAFILE_SYNC_TASK_FORCE_UPLOAD_PROPERTY:
		seafile_sync_task_set_force_upload (self, g_value_get_boolean (value));
		break;
		case SEAFILE_SYNC_TASK_DEST_ID_PROPERTY:
		seafile_sync_task_set_dest_id (self, g_value_get_string (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_string (value));
		break;
		case SEAFILE_SYNC_TASK_TX_ID_PROPERTY:
		seafile_sync_task_set_tx_id (self, g_value_get_string (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_checkout_task_get_instance_private (SeafileCheckoutTask* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileCheckoutTask_private_offset);
}

SeafileCheckoutTask*
seafile_checkout_task_construct (GType object_type)
{
	SeafileCheckoutTask * self = NULL;
	self = (SeafileCheckoutTask*) g_object_new (object_type, NULL);
	return self;
}

SeafileCheckoutTask*
seafile_checkout_task_new (void)
{
	return seafile_checkout_task_construct (SEAFILE_TYPE_CHECKOUT_TASK);
}

const gchar*
seafile_checkout_task_get_repo_id (SeafileCheckoutTask* 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_checkout_task_set_repo_id (SeafileCheckoutTask* self,
                                   const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_checkout_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_checkout_task_properties[SEAFILE_CHECKOUT_TASK_REPO_ID_PROPERTY]);
	}
}

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

void
seafile_checkout_task_set_worktree (SeafileCheckoutTask* self,
                                    const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_checkout_task_get_worktree (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_worktree);
		self->priv->_worktree = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_checkout_task_properties[SEAFILE_CHECKOUT_TASK_WORKTREE_PROPERTY]);
	}
}

gint
seafile_checkout_task_get_total_files (SeafileCheckoutTask* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, -1);
	result = self->priv->_total_files;
	return result;
}

void
seafile_checkout_task_set_total_files (SeafileCheckoutTask* self,
                                       gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_checkout_task_get_total_files (self);
	if (old_value != value) {
		self->priv->_total_files = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_checkout_task_properties[SEAFILE_CHECKOUT_TASK_TOTAL_FILES_PROPERTY]);
	}
}

gint
seafile_checkout_task_get_finished_files (SeafileCheckoutTask* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, -1);
	result = self->priv->_finished_files;
	return result;
}

void
seafile_checkout_task_set_finished_files (SeafileCheckoutTask* self,
                                          gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_checkout_task_get_finished_files (self);
	if (old_value != value) {
		self->priv->_finished_files = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_checkout_task_properties[SEAFILE_CHECKOUT_TASK_FINISHED_FILES_PROPERTY]);
	}
}

static void
seafile_checkout_task_class_init (SeafileCheckoutTaskClass * klass,
                                  gpointer klass_data)
{
	seafile_checkout_task_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileCheckoutTask_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_checkout_task_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_checkout_task_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_checkout_task_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_CHECKOUT_TASK_REPO_ID_PROPERTY, seafile_checkout_task_properties[SEAFILE_CHECKOUT_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_CHECKOUT_TASK_WORKTREE_PROPERTY, seafile_checkout_task_properties[SEAFILE_CHECKOUT_TASK_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_CHECKOUT_TASK_TOTAL_FILES_PROPERTY, seafile_checkout_task_properties[SEAFILE_CHECKOUT_TASK_TOTAL_FILES_PROPERTY] = g_param_spec_int ("total-files", "total-files", "total-files", 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_CHECKOUT_TASK_FINISHED_FILES_PROPERTY, seafile_checkout_task_properties[SEAFILE_CHECKOUT_TASK_FINISHED_FILES_PROPERTY] = g_param_spec_int ("finished-files", "finished-files", "finished-files", G_MININT, G_MAXINT, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_checkout_task_instance_init (SeafileCheckoutTask * self,
                                     gpointer klass)
{
	self->priv = seafile_checkout_task_get_instance_private (self);
}

static void
seafile_checkout_task_finalize (GObject * obj)
{
	SeafileCheckoutTask * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_CHECKOUT_TASK, SeafileCheckoutTask);
	_g_free0 (self->priv->_repo_id);
	_g_free0 (self->priv->_worktree);
	G_OBJECT_CLASS (seafile_checkout_task_parent_class)->finalize (obj);
}

static GType
seafile_checkout_task_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileCheckoutTaskClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_checkout_task_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileCheckoutTask), 0, (GInstanceInitFunc) seafile_checkout_task_instance_init, NULL };
	GType seafile_checkout_task_type_id;
	seafile_checkout_task_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileCheckoutTask", &g_define_type_info, 0);
	SeafileCheckoutTask_private_offset = g_type_add_instance_private (seafile_checkout_task_type_id, sizeof (SeafileCheckoutTaskPrivate));
	return seafile_checkout_task_type_id;
}

GType
seafile_checkout_task_get_type (void)
{
	static volatile gsize seafile_checkout_task_type_id__once = 0;
	if (g_once_init_enter (&seafile_checkout_task_type_id__once)) {
		GType seafile_checkout_task_type_id;
		seafile_checkout_task_type_id = seafile_checkout_task_get_type_once ();
		g_once_init_leave (&seafile_checkout_task_type_id__once, seafile_checkout_task_type_id);
	}
	return seafile_checkout_task_type_id__once;
}

static void
_vala_seafile_checkout_task_get_property (GObject * object,
                                          guint property_id,
                                          GValue * value,
                                          GParamSpec * pspec)
{
	SeafileCheckoutTask * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_CHECKOUT_TASK, SeafileCheckoutTask);
	switch (property_id) {
		case SEAFILE_CHECKOUT_TASK_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_checkout_task_get_repo_id (self));
		break;
		case SEAFILE_CHECKOUT_TASK_WORKTREE_PROPERTY:
		g_value_set_string (value, seafile_checkout_task_get_worktree (self));
		break;
		case SEAFILE_CHECKOUT_TASK_TOTAL_FILES_PROPERTY:
		g_value_set_int (value, seafile_checkout_task_get_total_files (self));
		break;
		case SEAFILE_CHECKOUT_TASK_FINISHED_FILES_PROPERTY:
		g_value_set_int (value, seafile_checkout_task_get_finished_files (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_checkout_task_set_property (GObject * object,
                                          guint property_id,
                                          const GValue * value,
                                          GParamSpec * pspec)
{
	SeafileCheckoutTask * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_CHECKOUT_TASK, SeafileCheckoutTask);
	switch (property_id) {
		case SEAFILE_CHECKOUT_TASK_REPO_ID_PROPERTY:
		seafile_checkout_task_set_repo_id (self, g_value_get_string (value));
		break;
		case SEAFILE_CHECKOUT_TASK_WORKTREE_PROPERTY:
		seafile_checkout_task_set_worktree (self, g_value_get_string (value));
		break;
		case SEAFILE_CHECKOUT_TASK_TOTAL_FILES_PROPERTY:
		seafile_checkout_task_set_total_files (self, g_value_get_int (value));
		break;
		case SEAFILE_CHECKOUT_TASK_FINISHED_FILES_PROPERTY:
		seafile_checkout_task_set_finished_files (self, g_value_get_int (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_deleted_entry_get_instance_private (SeafileDeletedEntry* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileDeletedEntry_private_offset);
}

SeafileDeletedEntry*
seafile_deleted_entry_construct (GType object_type)
{
	SeafileDeletedEntry * self = NULL;
	self = (SeafileDeletedEntry*) g_object_new (object_type, NULL);
	return self;
}

SeafileDeletedEntry*
seafile_deleted_entry_new (void)
{
	return seafile_deleted_entry_construct (SEAFILE_TYPE_DELETED_ENTRY);
}

const gchar*
seafile_deleted_entry_get_commit_id (SeafileDeletedEntry* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_commit_id;
	result = _tmp0_;
	return result;
}

void
seafile_deleted_entry_set_commit_id (SeafileDeletedEntry* self,
                                     const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_deleted_entry_get_commit_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_commit_id);
		self->priv->_commit_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_COMMIT_ID_PROPERTY]);
	}
}

const gchar*
seafile_deleted_entry_get_obj_id (SeafileDeletedEntry* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_obj_id;
	result = _tmp0_;
	return result;
}

void
seafile_deleted_entry_set_obj_id (SeafileDeletedEntry* self,
                                  const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_deleted_entry_get_obj_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_obj_id);
		self->priv->_obj_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_OBJ_ID_PROPERTY]);
	}
}

const gchar*
seafile_deleted_entry_get_obj_name (SeafileDeletedEntry* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_obj_name;
	result = _tmp0_;
	return result;
}

void
seafile_deleted_entry_set_obj_name (SeafileDeletedEntry* self,
                                    const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_deleted_entry_get_obj_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_obj_name);
		self->priv->_obj_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_OBJ_NAME_PROPERTY]);
	}
}

const gchar*
seafile_deleted_entry_get_basedir (SeafileDeletedEntry* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_basedir;
	result = _tmp0_;
	return result;
}

void
seafile_deleted_entry_set_basedir (SeafileDeletedEntry* self,
                                   const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_deleted_entry_get_basedir (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_basedir);
		self->priv->_basedir = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_BASEDIR_PROPERTY]);
	}
}

gint
seafile_deleted_entry_get_mode (SeafileDeletedEntry* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, -1);
	result = self->priv->_mode;
	return result;
}

void
seafile_deleted_entry_set_mode (SeafileDeletedEntry* self,
                                gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_deleted_entry_get_mode (self);
	if (old_value != value) {
		self->priv->_mode = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_MODE_PROPERTY]);
	}
}

gint
seafile_deleted_entry_get_delete_time (SeafileDeletedEntry* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, -1);
	result = self->priv->_delete_time;
	return result;
}

void
seafile_deleted_entry_set_delete_time (SeafileDeletedEntry* self,
                                       gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_deleted_entry_get_delete_time (self);
	if (old_value != value) {
		self->priv->_delete_time = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_DELETE_TIME_PROPERTY]);
	}
}

gint64
seafile_deleted_entry_get_file_size (SeafileDeletedEntry* self)
{
	gint64 result;
	g_return_val_if_fail (self != NULL, -1LL);
	result = self->priv->_file_size;
	return result;
}

void
seafile_deleted_entry_set_file_size (SeafileDeletedEntry* self,
                                     gint64 value)
{
	gint64 old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_deleted_entry_get_file_size (self);
	if (old_value != value) {
		self->priv->_file_size = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_FILE_SIZE_PROPERTY]);
	}
}

const gchar*
seafile_deleted_entry_get_scan_stat (SeafileDeletedEntry* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_scan_stat;
	result = _tmp0_;
	return result;
}

void
seafile_deleted_entry_set_scan_stat (SeafileDeletedEntry* self,
                                     const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_deleted_entry_get_scan_stat (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_scan_stat);
		self->priv->_scan_stat = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_SCAN_STAT_PROPERTY]);
	}
}

static void
seafile_deleted_entry_class_init (SeafileDeletedEntryClass * klass,
                                  gpointer klass_data)
{
	seafile_deleted_entry_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileDeletedEntry_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_deleted_entry_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_deleted_entry_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_deleted_entry_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_DELETED_ENTRY_COMMIT_ID_PROPERTY, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_COMMIT_ID_PROPERTY] = g_param_spec_string ("commit-id", "commit-id", "commit-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_DELETED_ENTRY_OBJ_ID_PROPERTY, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_OBJ_ID_PROPERTY] = g_param_spec_string ("obj-id", "obj-id", "obj-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_DELETED_ENTRY_OBJ_NAME_PROPERTY, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_OBJ_NAME_PROPERTY] = g_param_spec_string ("obj-name", "obj-name", "obj-name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_DELETED_ENTRY_BASEDIR_PROPERTY, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_BASEDIR_PROPERTY] = g_param_spec_string ("basedir", "basedir", "basedir", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_DELETED_ENTRY_MODE_PROPERTY, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_MODE_PROPERTY] = g_param_spec_int ("mode", "mode", "mode", 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_DELETED_ENTRY_DELETE_TIME_PROPERTY, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_DELETE_TIME_PROPERTY] = g_param_spec_int ("delete-time", "delete-time", "delete-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_DELETED_ENTRY_FILE_SIZE_PROPERTY, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_FILE_SIZE_PROPERTY] = g_param_spec_int64 ("file-size", "file-size", "file-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_DELETED_ENTRY_SCAN_STAT_PROPERTY, seafile_deleted_entry_properties[SEAFILE_DELETED_ENTRY_SCAN_STAT_PROPERTY] = g_param_spec_string ("scan-stat", "scan-stat", "scan-stat", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_deleted_entry_instance_init (SeafileDeletedEntry * self,
                                     gpointer klass)
{
	self->priv = seafile_deleted_entry_get_instance_private (self);
}

static void
seafile_deleted_entry_finalize (GObject * obj)
{
	SeafileDeletedEntry * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_DELETED_ENTRY, SeafileDeletedEntry);
	_g_free0 (self->priv->_commit_id);
	_g_free0 (self->priv->_obj_id);
	_g_free0 (self->priv->_obj_name);
	_g_free0 (self->priv->_basedir);
	_g_free0 (self->priv->_scan_stat);
	G_OBJECT_CLASS (seafile_deleted_entry_parent_class)->finalize (obj);
}

static GType
seafile_deleted_entry_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileDeletedEntryClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_deleted_entry_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileDeletedEntry), 0, (GInstanceInitFunc) seafile_deleted_entry_instance_init, NULL };
	GType seafile_deleted_entry_type_id;
	seafile_deleted_entry_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileDeletedEntry", &g_define_type_info, 0);
	SeafileDeletedEntry_private_offset = g_type_add_instance_private (seafile_deleted_entry_type_id, sizeof (SeafileDeletedEntryPrivate));
	return seafile_deleted_entry_type_id;
}

GType
seafile_deleted_entry_get_type (void)
{
	static volatile gsize seafile_deleted_entry_type_id__once = 0;
	if (g_once_init_enter (&seafile_deleted_entry_type_id__once)) {
		GType seafile_deleted_entry_type_id;
		seafile_deleted_entry_type_id = seafile_deleted_entry_get_type_once ();
		g_once_init_leave (&seafile_deleted_entry_type_id__once, seafile_deleted_entry_type_id);
	}
	return seafile_deleted_entry_type_id__once;
}

static void
_vala_seafile_deleted_entry_get_property (GObject * object,
                                          guint property_id,
                                          GValue * value,
                                          GParamSpec * pspec)
{
	SeafileDeletedEntry * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_DELETED_ENTRY, SeafileDeletedEntry);
	switch (property_id) {
		case SEAFILE_DELETED_ENTRY_COMMIT_ID_PROPERTY:
		g_value_set_string (value, seafile_deleted_entry_get_commit_id (self));
		break;
		case SEAFILE_DELETED_ENTRY_OBJ_ID_PROPERTY:
		g_value_set_string (value, seafile_deleted_entry_get_obj_id (self));
		break;
		case SEAFILE_DELETED_ENTRY_OBJ_NAME_PROPERTY:
		g_value_set_string (value, seafile_deleted_entry_get_obj_name (self));
		break;
		case SEAFILE_DELETED_ENTRY_BASEDIR_PROPERTY:
		g_value_set_string (value, seafile_deleted_entry_get_basedir (self));
		break;
		case SEAFILE_DELETED_ENTRY_MODE_PROPERTY:
		g_value_set_int (value, seafile_deleted_entry_get_mode (self));
		break;
		case SEAFILE_DELETED_ENTRY_DELETE_TIME_PROPERTY:
		g_value_set_int (value, seafile_deleted_entry_get_delete_time (self));
		break;
		case SEAFILE_DELETED_ENTRY_FILE_SIZE_PROPERTY:
		g_value_set_int64 (value, seafile_deleted_entry_get_file_size (self));
		break;
		case SEAFILE_DELETED_ENTRY_SCAN_STAT_PROPERTY:
		g_value_set_string (value, seafile_deleted_entry_get_scan_stat (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_deleted_entry_set_property (GObject * object,
                                          guint property_id,
                                          const GValue * value,
                                          GParamSpec * pspec)
{
	SeafileDeletedEntry * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_DELETED_ENTRY, SeafileDeletedEntry);
	switch (property_id) {
		case SEAFILE_DELETED_ENTRY_COMMIT_ID_PROPERTY:
		seafile_deleted_entry_set_commit_id (self, g_value_get_string (value));
		break;
		case SEAFILE_DELETED_ENTRY_OBJ_ID_PROPERTY:
		seafile_deleted_entry_set_obj_id (self, g_value_get_string (value));
		break;
		case SEAFILE_DELETED_ENTRY_OBJ_NAME_PROPERTY:
		seafile_deleted_entry_set_obj_name (self, g_value_get_string (value));
		break;
		case SEAFILE_DELETED_ENTRY_BASEDIR_PROPERTY:
		seafile_deleted_entry_set_basedir (self, g_value_get_string (value));
		break;
		case SEAFILE_DELETED_ENTRY_MODE_PROPERTY:
		seafile_deleted_entry_set_mode (self, g_value_get_int (value));
		break;
		case SEAFILE_DELETED_ENTRY_DELETE_TIME_PROPERTY:
		seafile_deleted_entry_set_delete_time (self, g_value_get_int (value));
		break;
		case SEAFILE_DELETED_ENTRY_FILE_SIZE_PROPERTY:
		seafile_deleted_entry_set_file_size (self, g_value_get_int64 (value));
		break;
		case SEAFILE_DELETED_ENTRY_SCAN_STAT_PROPERTY:
		seafile_deleted_entry_set_scan_stat (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
seafile_repo_token_info_get_instance_private (SeafileRepoTokenInfo* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileRepoTokenInfo_private_offset);
}

SeafileRepoTokenInfo*
seafile_repo_token_info_construct (GType object_type)
{
	SeafileRepoTokenInfo * self = NULL;
	self = (SeafileRepoTokenInfo*) g_object_new (object_type, NULL);
	return self;
}

SeafileRepoTokenInfo*
seafile_repo_token_info_new (void)
{
	return seafile_repo_token_info_construct (SEAFILE_TYPE_REPO_TOKEN_INFO);
}

const gchar*
seafile_repo_token_info_get_repo_id (SeafileRepoTokenInfo* 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_token_info_set_repo_id (SeafileRepoTokenInfo* self,
                                     const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_token_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_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_REPO_ID_PROPERTY]);
	}
}

const gchar*
seafile_repo_token_info_get_repo_name (SeafileRepoTokenInfo* 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_token_info_set_repo_name (SeafileRepoTokenInfo* self,
                                       const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_token_info_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_token_info_properties[SEAFILE_REPO_TOKEN_INFO_REPO_NAME_PROPERTY]);
	}
}

const gchar*
seafile_repo_token_info_get_repo_owner (SeafileRepoTokenInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_repo_owner;
	result = _tmp0_;
	return result;
}

void
seafile_repo_token_info_set_repo_owner (SeafileRepoTokenInfo* self,
                                        const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_token_info_get_repo_owner (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_repo_owner);
		self->priv->_repo_owner = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_REPO_OWNER_PROPERTY]);
	}
}

const gchar*
seafile_repo_token_info_get_email (SeafileRepoTokenInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_email;
	result = _tmp0_;
	return result;
}

void
seafile_repo_token_info_set_email (SeafileRepoTokenInfo* self,
                                   const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_token_info_get_email (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_email);
		self->priv->_email = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_EMAIL_PROPERTY]);
	}
}

const gchar*
seafile_repo_token_info_get_token (SeafileRepoTokenInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_token;
	result = _tmp0_;
	return result;
}

void
seafile_repo_token_info_set_token (SeafileRepoTokenInfo* self,
                                   const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_token_info_get_token (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_token);
		self->priv->_token = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_TOKEN_PROPERTY]);
	}
}

const gchar*
seafile_repo_token_info_get_peer_id (SeafileRepoTokenInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_peer_id;
	result = _tmp0_;
	return result;
}

void
seafile_repo_token_info_set_peer_id (SeafileRepoTokenInfo* self,
                                     const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_token_info_get_peer_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_peer_id);
		self->priv->_peer_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_PEER_ID_PROPERTY]);
	}
}

const gchar*
seafile_repo_token_info_get_peer_ip (SeafileRepoTokenInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_peer_ip;
	result = _tmp0_;
	return result;
}

void
seafile_repo_token_info_set_peer_ip (SeafileRepoTokenInfo* self,
                                     const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_token_info_get_peer_ip (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_peer_ip);
		self->priv->_peer_ip = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_PEER_IP_PROPERTY]);
	}
}

const gchar*
seafile_repo_token_info_get_peer_name (SeafileRepoTokenInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_peer_name;
	result = _tmp0_;
	return result;
}

void
seafile_repo_token_info_set_peer_name (SeafileRepoTokenInfo* self,
                                       const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_token_info_get_peer_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_peer_name);
		self->priv->_peer_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_PEER_NAME_PROPERTY]);
	}
}

gint64
seafile_repo_token_info_get_sync_time (SeafileRepoTokenInfo* self)
{
	gint64 result;
	g_return_val_if_fail (self != NULL, -1LL);
	result = self->priv->_sync_time;
	return result;
}

void
seafile_repo_token_info_set_sync_time (SeafileRepoTokenInfo* self,
                                       gint64 value)
{
	gint64 old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_token_info_get_sync_time (self);
	if (old_value != value) {
		self->priv->_sync_time = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_SYNC_TIME_PROPERTY]);
	}
}

const gchar*
seafile_repo_token_info_get_client_ver (SeafileRepoTokenInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_client_ver;
	result = _tmp0_;
	return result;
}

void
seafile_repo_token_info_set_client_ver (SeafileRepoTokenInfo* self,
                                        const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_repo_token_info_get_client_ver (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_client_ver);
		self->priv->_client_ver = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_CLIENT_VER_PROPERTY]);
	}
}

static void
seafile_repo_token_info_class_init (SeafileRepoTokenInfoClass * klass,
                                    gpointer klass_data)
{
	seafile_repo_token_info_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileRepoTokenInfo_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_repo_token_info_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_repo_token_info_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_repo_token_info_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_TOKEN_INFO_REPO_ID_PROPERTY, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_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_REPO_TOKEN_INFO_REPO_NAME_PROPERTY, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_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_TOKEN_INFO_REPO_OWNER_PROPERTY, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_REPO_OWNER_PROPERTY] = g_param_spec_string ("repo-owner", "repo-owner", "repo-owner", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_TOKEN_INFO_EMAIL_PROPERTY, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_EMAIL_PROPERTY] = g_param_spec_string ("email", "email", "email", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_TOKEN_INFO_TOKEN_PROPERTY, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_TOKEN_PROPERTY] = g_param_spec_string ("token", "token", "token", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_TOKEN_INFO_PEER_ID_PROPERTY, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_PEER_ID_PROPERTY] = g_param_spec_string ("peer-id", "peer-id", "peer-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_TOKEN_INFO_PEER_IP_PROPERTY, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_PEER_IP_PROPERTY] = g_param_spec_string ("peer-ip", "peer-ip", "peer-ip", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_TOKEN_INFO_PEER_NAME_PROPERTY, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_PEER_NAME_PROPERTY] = g_param_spec_string ("peer-name", "peer-name", "peer-name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_REPO_TOKEN_INFO_SYNC_TIME_PROPERTY, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_SYNC_TIME_PROPERTY] = g_param_spec_int64 ("sync-time", "sync-time", "sync-time", 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_TOKEN_INFO_CLIENT_VER_PROPERTY, seafile_repo_token_info_properties[SEAFILE_REPO_TOKEN_INFO_CLIENT_VER_PROPERTY] = g_param_spec_string ("client-ver", "client-ver", "client-ver", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_repo_token_info_instance_init (SeafileRepoTokenInfo * self,
                                       gpointer klass)
{
	self->priv = seafile_repo_token_info_get_instance_private (self);
}

static void
seafile_repo_token_info_finalize (GObject * obj)
{
	SeafileRepoTokenInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_REPO_TOKEN_INFO, SeafileRepoTokenInfo);
	_g_free0 (self->priv->_repo_id);
	_g_free0 (self->priv->_repo_name);
	_g_free0 (self->priv->_repo_owner);
	_g_free0 (self->priv->_email);
	_g_free0 (self->priv->_token);
	_g_free0 (self->priv->_peer_id);
	_g_free0 (self->priv->_peer_ip);
	_g_free0 (self->priv->_peer_name);
	_g_free0 (self->priv->_client_ver);
	G_OBJECT_CLASS (seafile_repo_token_info_parent_class)->finalize (obj);
}

static GType
seafile_repo_token_info_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileRepoTokenInfoClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_repo_token_info_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileRepoTokenInfo), 0, (GInstanceInitFunc) seafile_repo_token_info_instance_init, NULL };
	GType seafile_repo_token_info_type_id;
	seafile_repo_token_info_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileRepoTokenInfo", &g_define_type_info, 0);
	SeafileRepoTokenInfo_private_offset = g_type_add_instance_private (seafile_repo_token_info_type_id, sizeof (SeafileRepoTokenInfoPrivate));
	return seafile_repo_token_info_type_id;
}

GType
seafile_repo_token_info_get_type (void)
{
	static volatile gsize seafile_repo_token_info_type_id__once = 0;
	if (g_once_init_enter (&seafile_repo_token_info_type_id__once)) {
		GType seafile_repo_token_info_type_id;
		seafile_repo_token_info_type_id = seafile_repo_token_info_get_type_once ();
		g_once_init_leave (&seafile_repo_token_info_type_id__once, seafile_repo_token_info_type_id);
	}
	return seafile_repo_token_info_type_id__once;
}

static void
_vala_seafile_repo_token_info_get_property (GObject * object,
                                            guint property_id,
                                            GValue * value,
                                            GParamSpec * pspec)
{
	SeafileRepoTokenInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_REPO_TOKEN_INFO, SeafileRepoTokenInfo);
	switch (property_id) {
		case SEAFILE_REPO_TOKEN_INFO_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_repo_token_info_get_repo_id (self));
		break;
		case SEAFILE_REPO_TOKEN_INFO_REPO_NAME_PROPERTY:
		g_value_set_string (value, seafile_repo_token_info_get_repo_name (self));
		break;
		case SEAFILE_REPO_TOKEN_INFO_REPO_OWNER_PROPERTY:
		g_value_set_string (value, seafile_repo_token_info_get_repo_owner (self));
		break;
		case SEAFILE_REPO_TOKEN_INFO_EMAIL_PROPERTY:
		g_value_set_string (value, seafile_repo_token_info_get_email (self));
		break;
		case SEAFILE_REPO_TOKEN_INFO_TOKEN_PROPERTY:
		g_value_set_string (value, seafile_repo_token_info_get_token (self));
		break;
		case SEAFILE_REPO_TOKEN_INFO_PEER_ID_PROPERTY:
		g_value_set_string (value, seafile_repo_token_info_get_peer_id (self));
		break;
		case SEAFILE_REPO_TOKEN_INFO_PEER_IP_PROPERTY:
		g_value_set_string (value, seafile_repo_token_info_get_peer_ip (self));
		break;
		case SEAFILE_REPO_TOKEN_INFO_PEER_NAME_PROPERTY:
		g_value_set_string (value, seafile_repo_token_info_get_peer_name (self));
		break;
		case SEAFILE_REPO_TOKEN_INFO_SYNC_TIME_PROPERTY:
		g_value_set_int64 (value, seafile_repo_token_info_get_sync_time (self));
		break;
		case SEAFILE_REPO_TOKEN_INFO_CLIENT_VER_PROPERTY:
		g_value_set_string (value, seafile_repo_token_info_get_client_ver (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_repo_token_info_set_property (GObject * object,
                                            guint property_id,
                                            const GValue * value,
                                            GParamSpec * pspec)
{
	SeafileRepoTokenInfo * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_REPO_TOKEN_INFO, SeafileRepoTokenInfo);
	switch (property_id) {
		case SEAFILE_REPO_TOKEN_INFO_REPO_ID_PROPERTY:
		seafile_repo_token_info_set_repo_id (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_TOKEN_INFO_REPO_NAME_PROPERTY:
		seafile_repo_token_info_set_repo_name (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_TOKEN_INFO_REPO_OWNER_PROPERTY:
		seafile_repo_token_info_set_repo_owner (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_TOKEN_INFO_EMAIL_PROPERTY:
		seafile_repo_token_info_set_email (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_TOKEN_INFO_TOKEN_PROPERTY:
		seafile_repo_token_info_set_token (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_TOKEN_INFO_PEER_ID_PROPERTY:
		seafile_repo_token_info_set_peer_id (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_TOKEN_INFO_PEER_IP_PROPERTY:
		seafile_repo_token_info_set_peer_ip (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_TOKEN_INFO_PEER_NAME_PROPERTY:
		seafile_repo_token_info_set_peer_name (self, g_value_get_string (value));
		break;
		case SEAFILE_REPO_TOKEN_INFO_SYNC_TIME_PROPERTY:
		seafile_repo_token_info_set_sync_time (self, g_value_get_int64 (value));
		break;
		case SEAFILE_REPO_TOKEN_INFO_CLIENT_VER_PROPERTY:
		seafile_repo_token_info_set_client_ver (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
seafile_shared_user_get_instance_private (SeafileSharedUser* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileSharedUser_private_offset);
}

SeafileSharedUser*
seafile_shared_user_construct (GType object_type)
{
	SeafileSharedUser * self = NULL;
	self = (SeafileSharedUser*) g_object_new (object_type, NULL);
	return self;
}

SeafileSharedUser*
seafile_shared_user_new (void)
{
	return seafile_shared_user_construct (SEAFILE_TYPE_SHARED_USER);
}

const gchar*
seafile_shared_user_get_repo_id (SeafileSharedUser* 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_shared_user_set_repo_id (SeafileSharedUser* self,
                                 const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_shared_user_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_shared_user_properties[SEAFILE_SHARED_USER_REPO_ID_PROPERTY]);
	}
}

const gchar*
seafile_shared_user_get_user (SeafileSharedUser* 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_shared_user_set_user (SeafileSharedUser* self,
                              const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_shared_user_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_shared_user_properties[SEAFILE_SHARED_USER_USER_PROPERTY]);
	}
}

const gchar*
seafile_shared_user_get_perm (SeafileSharedUser* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_perm;
	result = _tmp0_;
	return result;
}

void
seafile_shared_user_set_perm (SeafileSharedUser* self,
                              const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_shared_user_get_perm (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_perm);
		self->priv->_perm = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_shared_user_properties[SEAFILE_SHARED_USER_PERM_PROPERTY]);
	}
}

static void
seafile_shared_user_class_init (SeafileSharedUserClass * klass,
                                gpointer klass_data)
{
	seafile_shared_user_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileSharedUser_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_shared_user_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_shared_user_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_shared_user_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SHARED_USER_REPO_ID_PROPERTY, seafile_shared_user_properties[SEAFILE_SHARED_USER_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_SHARED_USER_USER_PROPERTY, seafile_shared_user_properties[SEAFILE_SHARED_USER_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_SHARED_USER_PERM_PROPERTY, seafile_shared_user_properties[SEAFILE_SHARED_USER_PERM_PROPERTY] = g_param_spec_string ("perm", "perm", "perm", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_shared_user_instance_init (SeafileSharedUser * self,
                                   gpointer klass)
{
	self->priv = seafile_shared_user_get_instance_private (self);
}

static void
seafile_shared_user_finalize (GObject * obj)
{
	SeafileSharedUser * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_SHARED_USER, SeafileSharedUser);
	_g_free0 (self->priv->_repo_id);
	_g_free0 (self->priv->_user);
	_g_free0 (self->priv->_perm);
	G_OBJECT_CLASS (seafile_shared_user_parent_class)->finalize (obj);
}

static GType
seafile_shared_user_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileSharedUserClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_shared_user_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileSharedUser), 0, (GInstanceInitFunc) seafile_shared_user_instance_init, NULL };
	GType seafile_shared_user_type_id;
	seafile_shared_user_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileSharedUser", &g_define_type_info, 0);
	SeafileSharedUser_private_offset = g_type_add_instance_private (seafile_shared_user_type_id, sizeof (SeafileSharedUserPrivate));
	return seafile_shared_user_type_id;
}

GType
seafile_shared_user_get_type (void)
{
	static volatile gsize seafile_shared_user_type_id__once = 0;
	if (g_once_init_enter (&seafile_shared_user_type_id__once)) {
		GType seafile_shared_user_type_id;
		seafile_shared_user_type_id = seafile_shared_user_get_type_once ();
		g_once_init_leave (&seafile_shared_user_type_id__once, seafile_shared_user_type_id);
	}
	return seafile_shared_user_type_id__once;
}

static void
_vala_seafile_shared_user_get_property (GObject * object,
                                        guint property_id,
                                        GValue * value,
                                        GParamSpec * pspec)
{
	SeafileSharedUser * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_SHARED_USER, SeafileSharedUser);
	switch (property_id) {
		case SEAFILE_SHARED_USER_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_shared_user_get_repo_id (self));
		break;
		case SEAFILE_SHARED_USER_USER_PROPERTY:
		g_value_set_string (value, seafile_shared_user_get_user (self));
		break;
		case SEAFILE_SHARED_USER_PERM_PROPERTY:
		g_value_set_string (value, seafile_shared_user_get_perm (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_shared_user_set_property (GObject * object,
                                        guint property_id,
                                        const GValue * value,
                                        GParamSpec * pspec)
{
	SeafileSharedUser * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_SHARED_USER, SeafileSharedUser);
	switch (property_id) {
		case SEAFILE_SHARED_USER_REPO_ID_PROPERTY:
		seafile_shared_user_set_repo_id (self, g_value_get_string (value));
		break;
		case SEAFILE_SHARED_USER_USER_PROPERTY:
		seafile_shared_user_set_user (self, g_value_get_string (value));
		break;
		case SEAFILE_SHARED_USER_PERM_PROPERTY:
		seafile_shared_user_set_perm (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
seafile_shared_group_get_instance_private (SeafileSharedGroup* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileSharedGroup_private_offset);
}

SeafileSharedGroup*
seafile_shared_group_construct (GType object_type)
{
	SeafileSharedGroup * self = NULL;
	self = (SeafileSharedGroup*) g_object_new (object_type, NULL);
	return self;
}

SeafileSharedGroup*
seafile_shared_group_new (void)
{
	return seafile_shared_group_construct (SEAFILE_TYPE_SHARED_GROUP);
}

const gchar*
seafile_shared_group_get_repo_id (SeafileSharedGroup* 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_shared_group_set_repo_id (SeafileSharedGroup* self,
                                  const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_shared_group_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_shared_group_properties[SEAFILE_SHARED_GROUP_REPO_ID_PROPERTY]);
	}
}

gint
seafile_shared_group_get_group_id (SeafileSharedGroup* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, -1);
	result = self->priv->_group_id;
	return result;
}

void
seafile_shared_group_set_group_id (SeafileSharedGroup* self,
                                   gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_shared_group_get_group_id (self);
	if (old_value != value) {
		self->priv->_group_id = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_shared_group_properties[SEAFILE_SHARED_GROUP_GROUP_ID_PROPERTY]);
	}
}

const gchar*
seafile_shared_group_get_perm (SeafileSharedGroup* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_perm;
	result = _tmp0_;
	return result;
}

void
seafile_shared_group_set_perm (SeafileSharedGroup* self,
                               const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_shared_group_get_perm (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_perm);
		self->priv->_perm = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_shared_group_properties[SEAFILE_SHARED_GROUP_PERM_PROPERTY]);
	}
}

static void
seafile_shared_group_class_init (SeafileSharedGroupClass * klass,
                                 gpointer klass_data)
{
	seafile_shared_group_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileSharedGroup_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_shared_group_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_shared_group_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_shared_group_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_SHARED_GROUP_REPO_ID_PROPERTY, seafile_shared_group_properties[SEAFILE_SHARED_GROUP_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_SHARED_GROUP_GROUP_ID_PROPERTY, seafile_shared_group_properties[SEAFILE_SHARED_GROUP_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_SHARED_GROUP_PERM_PROPERTY, seafile_shared_group_properties[SEAFILE_SHARED_GROUP_PERM_PROPERTY] = g_param_spec_string ("perm", "perm", "perm", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_shared_group_instance_init (SeafileSharedGroup * self,
                                    gpointer klass)
{
	self->priv = seafile_shared_group_get_instance_private (self);
}

static void
seafile_shared_group_finalize (GObject * obj)
{
	SeafileSharedGroup * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_SHARED_GROUP, SeafileSharedGroup);
	_g_free0 (self->priv->_repo_id);
	_g_free0 (self->priv->_perm);
	G_OBJECT_CLASS (seafile_shared_group_parent_class)->finalize (obj);
}

static GType
seafile_shared_group_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileSharedGroupClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_shared_group_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileSharedGroup), 0, (GInstanceInitFunc) seafile_shared_group_instance_init, NULL };
	GType seafile_shared_group_type_id;
	seafile_shared_group_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileSharedGroup", &g_define_type_info, 0);
	SeafileSharedGroup_private_offset = g_type_add_instance_private (seafile_shared_group_type_id, sizeof (SeafileSharedGroupPrivate));
	return seafile_shared_group_type_id;
}

GType
seafile_shared_group_get_type (void)
{
	static volatile gsize seafile_shared_group_type_id__once = 0;
	if (g_once_init_enter (&seafile_shared_group_type_id__once)) {
		GType seafile_shared_group_type_id;
		seafile_shared_group_type_id = seafile_shared_group_get_type_once ();
		g_once_init_leave (&seafile_shared_group_type_id__once, seafile_shared_group_type_id);
	}
	return seafile_shared_group_type_id__once;
}

static void
_vala_seafile_shared_group_get_property (GObject * object,
                                         guint property_id,
                                         GValue * value,
                                         GParamSpec * pspec)
{
	SeafileSharedGroup * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_SHARED_GROUP, SeafileSharedGroup);
	switch (property_id) {
		case SEAFILE_SHARED_GROUP_REPO_ID_PROPERTY:
		g_value_set_string (value, seafile_shared_group_get_repo_id (self));
		break;
		case SEAFILE_SHARED_GROUP_GROUP_ID_PROPERTY:
		g_value_set_int (value, seafile_shared_group_get_group_id (self));
		break;
		case SEAFILE_SHARED_GROUP_PERM_PROPERTY:
		g_value_set_string (value, seafile_shared_group_get_perm (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_shared_group_set_property (GObject * object,
                                         guint property_id,
                                         const GValue * value,
                                         GParamSpec * pspec)
{
	SeafileSharedGroup * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_SHARED_GROUP, SeafileSharedGroup);
	switch (property_id) {
		case SEAFILE_SHARED_GROUP_REPO_ID_PROPERTY:
		seafile_shared_group_set_repo_id (self, g_value_get_string (value));
		break;
		case SEAFILE_SHARED_GROUP_GROUP_ID_PROPERTY:
		seafile_shared_group_set_group_id (self, g_value_get_int (value));
		break;
		case SEAFILE_SHARED_GROUP_PERM_PROPERTY:
		seafile_shared_group_set_perm (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, -1);
	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_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]);
	}
}

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_pwd_hash_algo (SeafileEncryptionInfo* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_pwd_hash_algo;
	result = _tmp0_;
	return result;
}

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

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

void
seafile_encryption_info_set_pwd_hash_params (SeafileEncryptionInfo* self,
                                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_encryption_info_get_pwd_hash_params (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_pwd_hash_params);
		self->priv->_pwd_hash_params = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_PWD_HASH_PARAMS_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_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));
	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_PWD_HASH_ALGO_PROPERTY, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_PWD_HASH_ALGO_PROPERTY] = g_param_spec_string ("pwd-hash-algo", "pwd-hash-algo", "pwd-hash-algo", 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_PARAMS_PROPERTY, seafile_encryption_info_properties[SEAFILE_ENCRYPTION_INFO_PWD_HASH_PARAMS_PROPERTY] = g_param_spec_string ("pwd-hash-params", "pwd-hash-params", "pwd-hash-params", 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->_random_key);
	_g_free0 (self->priv->_salt);
	_g_free0 (self->priv->_pwd_hash);
	_g_free0 (self->priv->_pwd_hash_algo);
	_g_free0 (self->priv->_pwd_hash_params);
	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_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;
		case SEAFILE_ENCRYPTION_INFO_PWD_HASH_PROPERTY:
		g_value_set_string (value, seafile_encryption_info_get_pwd_hash (self));
		break;
		case SEAFILE_ENCRYPTION_INFO_PWD_HASH_ALGO_PROPERTY:
		g_value_set_string (value, seafile_encryption_info_get_pwd_hash_algo (self));
		break;
		case SEAFILE_ENCRYPTION_INFO_PWD_HASH_PARAMS_PROPERTY:
		g_value_set_string (value, seafile_encryption_info_get_pwd_hash_params (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_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;
		case SEAFILE_ENCRYPTION_INFO_PWD_HASH_PROPERTY:
		seafile_encryption_info_set_pwd_hash (self, g_value_get_string (value));
		break;
		case SEAFILE_ENCRYPTION_INFO_PWD_HASH_ALGO_PROPERTY:
		seafile_encryption_info_set_pwd_hash_algo (self, g_value_get_string (value));
		break;
		case SEAFILE_ENCRYPTION_INFO_PWD_HASH_PARAMS_PROPERTY:
		seafile_encryption_info_set_pwd_hash_params (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
seafile_user_quota_usage_get_instance_private (SeafileUserQuotaUsage* self)
{
	return G_STRUCT_MEMBER_P (self, SeafileUserQuotaUsage_private_offset);
}

SeafileUserQuotaUsage*
seafile_user_quota_usage_construct (GType object_type)
{
	SeafileUserQuotaUsage * self = NULL;
	self = (SeafileUserQuotaUsage*) g_object_new (object_type, NULL);
	return self;
}

SeafileUserQuotaUsage*
seafile_user_quota_usage_new (void)
{
	return seafile_user_quota_usage_construct (SEAFILE_TYPE_USER_QUOTA_USAGE);
}

const gchar*
seafile_user_quota_usage_get_user (SeafileUserQuotaUsage* 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_user_quota_usage_set_user (SeafileUserQuotaUsage* self,
                                   const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_user_quota_usage_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_user_quota_usage_properties[SEAFILE_USER_QUOTA_USAGE_USER_PROPERTY]);
	}
}

gint64
seafile_user_quota_usage_get_usage (SeafileUserQuotaUsage* self)
{
	gint64 result;
	g_return_val_if_fail (self != NULL, -1LL);
	result = self->priv->_usage;
	return result;
}

void
seafile_user_quota_usage_set_usage (SeafileUserQuotaUsage* self,
                                    gint64 value)
{
	gint64 old_value;
	g_return_if_fail (self != NULL);
	old_value = seafile_user_quota_usage_get_usage (self);
	if (old_value != value) {
		self->priv->_usage = value;
		g_object_notify_by_pspec ((GObject *) self, seafile_user_quota_usage_properties[SEAFILE_USER_QUOTA_USAGE_USAGE_PROPERTY]);
	}
}

static void
seafile_user_quota_usage_class_init (SeafileUserQuotaUsageClass * klass,
                                     gpointer klass_data)
{
	seafile_user_quota_usage_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &SeafileUserQuotaUsage_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_seafile_user_quota_usage_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_seafile_user_quota_usage_set_property;
	G_OBJECT_CLASS (klass)->finalize = seafile_user_quota_usage_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), SEAFILE_USER_QUOTA_USAGE_USER_PROPERTY, seafile_user_quota_usage_properties[SEAFILE_USER_QUOTA_USAGE_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_USER_QUOTA_USAGE_USAGE_PROPERTY, seafile_user_quota_usage_properties[SEAFILE_USER_QUOTA_USAGE_USAGE_PROPERTY] = g_param_spec_int64 ("usage", "usage", "usage", G_MININT64, G_MAXINT64, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
seafile_user_quota_usage_instance_init (SeafileUserQuotaUsage * self,
                                        gpointer klass)
{
	self->priv = seafile_user_quota_usage_get_instance_private (self);
}

static void
seafile_user_quota_usage_finalize (GObject * obj)
{
	SeafileUserQuotaUsage * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, SEAFILE_TYPE_USER_QUOTA_USAGE, SeafileUserQuotaUsage);
	_g_free0 (self->priv->_user);
	G_OBJECT_CLASS (seafile_user_quota_usage_parent_class)->finalize (obj);
}

static GType
seafile_user_quota_usage_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (SeafileUserQuotaUsageClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) seafile_user_quota_usage_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (SeafileUserQuotaUsage), 0, (GInstanceInitFunc) seafile_user_quota_usage_instance_init, NULL };
	GType seafile_user_quota_usage_type_id;
	seafile_user_quota_usage_type_id = g_type_register_static (G_TYPE_OBJECT, "SeafileUserQuotaUsage", &g_define_type_info, 0);
	SeafileUserQuotaUsage_private_offset = g_type_add_instance_private (seafile_user_quota_usage_type_id, sizeof (SeafileUserQuotaUsagePrivate));
	return seafile_user_quota_usage_type_id;
}

GType
seafile_user_quota_usage_get_type (void)
{
	static volatile gsize seafile_user_quota_usage_type_id__once = 0;
	if (g_once_init_enter (&seafile_user_quota_usage_type_id__once)) {
		GType seafile_user_quota_usage_type_id;
		seafile_user_quota_usage_type_id = seafile_user_quota_usage_get_type_once ();
		g_once_init_leave (&seafile_user_quota_usage_type_id__once, seafile_user_quota_usage_type_id);
	}
	return seafile_user_quota_usage_type_id__once;
}

static void
_vala_seafile_user_quota_usage_get_property (GObject * object,
                                             guint property_id,
                                             GValue * value,
                                             GParamSpec * pspec)
{
	SeafileUserQuotaUsage * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_USER_QUOTA_USAGE, SeafileUserQuotaUsage);
	switch (property_id) {
		case SEAFILE_USER_QUOTA_USAGE_USER_PROPERTY:
		g_value_set_string (value, seafile_user_quota_usage_get_user (self));
		break;
		case SEAFILE_USER_QUOTA_USAGE_USAGE_PROPERTY:
		g_value_set_int64 (value, seafile_user_quota_usage_get_usage (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_seafile_user_quota_usage_set_property (GObject * object,
                                             guint property_id,
                                             const GValue * value,
                                             GParamSpec * pspec)
{
	SeafileUserQuotaUsage * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, SEAFILE_TYPE_USER_QUOTA_USAGE, SeafileUserQuotaUsage);
	switch (property_id) {
		case SEAFILE_USER_QUOTA_USAGE_USER_PROPERTY:
		seafile_user_quota_usage_set_user (self, g_value_get_string (value));
		break;
		case SEAFILE_USER_QUOTA_USAGE_USAGE_PROPERTY:
		seafile_user_quota_usage_set_usage (self, g_value_get_int64 (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

