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

/*
 * Copyright © 2026 Alain M. (https://github.com/alainm23/planify)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation; either
 * version 3 of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA
 */

#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include <stdio.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
#if !defined(VALA_EXTERN)
#if defined(_MSC_VER)
#define VALA_EXTERN __declspec(dllexport) extern
#elif __GNUC__ >= 4
#define VALA_EXTERN __attribute__((visibility("default"))) extern
#else
#define VALA_EXTERN extern
#endif
#endif

typedef enum  {
	PLANIFY_CLI_COMMAND_TYPE_NONE,
	PLANIFY_CLI_COMMAND_TYPE_ADD,
	PLANIFY_CLI_COMMAND_TYPE_LIST_PROJECTS,
	PLANIFY_CLI_COMMAND_TYPE_LIST,
	PLANIFY_CLI_COMMAND_TYPE_UPDATE,
	PLANIFY_CLI_COMMAND_TYPE_BACKUP
} PlanifyCLICommandType;

#define PLANIFY_CLI_TYPE_COMMAND_TYPE (planify_cli_command_type_get_type ())

#define PLANIFY_CLI_TYPE_TASK_ARGUMENTS (planify_cli_task_arguments_get_type ())
#define PLANIFY_CLI_TASK_ARGUMENTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANIFY_CLI_TYPE_TASK_ARGUMENTS, PlanifyCLITaskArguments))
#define PLANIFY_CLI_TASK_ARGUMENTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANIFY_CLI_TYPE_TASK_ARGUMENTS, PlanifyCLITaskArgumentsClass))
#define PLANIFY_CLI_IS_TASK_ARGUMENTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANIFY_CLI_TYPE_TASK_ARGUMENTS))
#define PLANIFY_CLI_IS_TASK_ARGUMENTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANIFY_CLI_TYPE_TASK_ARGUMENTS))
#define PLANIFY_CLI_TASK_ARGUMENTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANIFY_CLI_TYPE_TASK_ARGUMENTS, PlanifyCLITaskArgumentsClass))

typedef struct _PlanifyCLITaskArguments PlanifyCLITaskArguments;
typedef struct _PlanifyCLITaskArgumentsClass PlanifyCLITaskArgumentsClass;
typedef struct _PlanifyCLITaskArgumentsPrivate PlanifyCLITaskArgumentsPrivate;
enum  {
	PLANIFY_CLI_TASK_ARGUMENTS_0_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_CONTENT_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_DESCRIPTION_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_NAME_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_ID_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_SECTION_NAME_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_SECTION_ID_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_PARENT_ID_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_PRIORITY_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_DUE_DATE_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_LABELS_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_PINNED_PROPERTY,
	PLANIFY_CLI_TASK_ARGUMENTS_NUM_PROPERTIES
};
static GParamSpec* planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_NUM_PROPERTIES];
#define _g_free0(var) (var = (g_free (var), NULL))

#define PLANIFY_CLI_TYPE_LIST_ARGUMENTS (planify_cli_list_arguments_get_type ())
#define PLANIFY_CLI_LIST_ARGUMENTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANIFY_CLI_TYPE_LIST_ARGUMENTS, PlanifyCLIListArguments))
#define PLANIFY_CLI_LIST_ARGUMENTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANIFY_CLI_TYPE_LIST_ARGUMENTS, PlanifyCLIListArgumentsClass))
#define PLANIFY_CLI_IS_LIST_ARGUMENTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANIFY_CLI_TYPE_LIST_ARGUMENTS))
#define PLANIFY_CLI_IS_LIST_ARGUMENTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANIFY_CLI_TYPE_LIST_ARGUMENTS))
#define PLANIFY_CLI_LIST_ARGUMENTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANIFY_CLI_TYPE_LIST_ARGUMENTS, PlanifyCLIListArgumentsClass))

typedef struct _PlanifyCLIListArguments PlanifyCLIListArguments;
typedef struct _PlanifyCLIListArgumentsClass PlanifyCLIListArgumentsClass;
typedef struct _PlanifyCLIListArgumentsPrivate PlanifyCLIListArgumentsPrivate;
enum  {
	PLANIFY_CLI_LIST_ARGUMENTS_0_PROPERTY,
	PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_NAME_PROPERTY,
	PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_ID_PROPERTY,
	PLANIFY_CLI_LIST_ARGUMENTS_NUM_PROPERTIES
};
static GParamSpec* planify_cli_list_arguments_properties[PLANIFY_CLI_LIST_ARGUMENTS_NUM_PROPERTIES];

#define PLANIFY_CLI_TYPE_UPDATE_ARGUMENTS (planify_cli_update_arguments_get_type ())
#define PLANIFY_CLI_UPDATE_ARGUMENTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANIFY_CLI_TYPE_UPDATE_ARGUMENTS, PlanifyCLIUpdateArguments))
#define PLANIFY_CLI_UPDATE_ARGUMENTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANIFY_CLI_TYPE_UPDATE_ARGUMENTS, PlanifyCLIUpdateArgumentsClass))
#define PLANIFY_CLI_IS_UPDATE_ARGUMENTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANIFY_CLI_TYPE_UPDATE_ARGUMENTS))
#define PLANIFY_CLI_IS_UPDATE_ARGUMENTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANIFY_CLI_TYPE_UPDATE_ARGUMENTS))
#define PLANIFY_CLI_UPDATE_ARGUMENTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANIFY_CLI_TYPE_UPDATE_ARGUMENTS, PlanifyCLIUpdateArgumentsClass))

typedef struct _PlanifyCLIUpdateArguments PlanifyCLIUpdateArguments;
typedef struct _PlanifyCLIUpdateArgumentsClass PlanifyCLIUpdateArgumentsClass;
typedef struct _PlanifyCLIUpdateArgumentsPrivate PlanifyCLIUpdateArgumentsPrivate;
enum  {
	PLANIFY_CLI_UPDATE_ARGUMENTS_0_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_TASK_ID_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_CONTENT_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_DESCRIPTION_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_NAME_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_ID_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_NAME_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_ID_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_PARENT_ID_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_PRIORITY_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_DUE_DATE_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_LABELS_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_CHECKED_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_PINNED_PROPERTY,
	PLANIFY_CLI_UPDATE_ARGUMENTS_NUM_PROPERTIES
};
static GParamSpec* planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_NUM_PROPERTIES];

#define PLANIFY_CLI_TYPE_BACKUP_ARGUMENTS (planify_cli_backup_arguments_get_type ())
#define PLANIFY_CLI_BACKUP_ARGUMENTS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANIFY_CLI_TYPE_BACKUP_ARGUMENTS, PlanifyCLIBackupArguments))
#define PLANIFY_CLI_BACKUP_ARGUMENTS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANIFY_CLI_TYPE_BACKUP_ARGUMENTS, PlanifyCLIBackupArgumentsClass))
#define PLANIFY_CLI_IS_BACKUP_ARGUMENTS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANIFY_CLI_TYPE_BACKUP_ARGUMENTS))
#define PLANIFY_CLI_IS_BACKUP_ARGUMENTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANIFY_CLI_TYPE_BACKUP_ARGUMENTS))
#define PLANIFY_CLI_BACKUP_ARGUMENTS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANIFY_CLI_TYPE_BACKUP_ARGUMENTS, PlanifyCLIBackupArgumentsClass))

typedef struct _PlanifyCLIBackupArguments PlanifyCLIBackupArguments;
typedef struct _PlanifyCLIBackupArgumentsClass PlanifyCLIBackupArgumentsClass;
typedef struct _PlanifyCLIBackupArgumentsPrivate PlanifyCLIBackupArgumentsPrivate;
enum  {
	PLANIFY_CLI_BACKUP_ARGUMENTS_0_PROPERTY,
	PLANIFY_CLI_BACKUP_ARGUMENTS_OUTPUT_PROPERTY,
	PLANIFY_CLI_BACKUP_ARGUMENTS_NUM_PROPERTIES
};
static GParamSpec* planify_cli_backup_arguments_properties[PLANIFY_CLI_BACKUP_ARGUMENTS_NUM_PROPERTIES];

#define PLANIFY_CLI_TYPE_PARSED_COMMAND (planify_cli_parsed_command_get_type ())
#define PLANIFY_CLI_PARSED_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANIFY_CLI_TYPE_PARSED_COMMAND, PlanifyCLIParsedCommand))
#define PLANIFY_CLI_PARSED_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANIFY_CLI_TYPE_PARSED_COMMAND, PlanifyCLIParsedCommandClass))
#define PLANIFY_CLI_IS_PARSED_COMMAND(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANIFY_CLI_TYPE_PARSED_COMMAND))
#define PLANIFY_CLI_IS_PARSED_COMMAND_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANIFY_CLI_TYPE_PARSED_COMMAND))
#define PLANIFY_CLI_PARSED_COMMAND_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANIFY_CLI_TYPE_PARSED_COMMAND, PlanifyCLIParsedCommandClass))

typedef struct _PlanifyCLIParsedCommand PlanifyCLIParsedCommand;
typedef struct _PlanifyCLIParsedCommandClass PlanifyCLIParsedCommandClass;
typedef struct _PlanifyCLIParsedCommandPrivate PlanifyCLIParsedCommandPrivate;
enum  {
	PLANIFY_CLI_PARSED_COMMAND_0_PROPERTY,
	PLANIFY_CLI_PARSED_COMMAND_COMMAND_TYPE_PROPERTY,
	PLANIFY_CLI_PARSED_COMMAND_TASK_ARGS_PROPERTY,
	PLANIFY_CLI_PARSED_COMMAND_LIST_ARGS_PROPERTY,
	PLANIFY_CLI_PARSED_COMMAND_UPDATE_ARGS_PROPERTY,
	PLANIFY_CLI_PARSED_COMMAND_BACKUP_ARGS_PROPERTY,
	PLANIFY_CLI_PARSED_COMMAND_NUM_PROPERTIES
};
static GParamSpec* planify_cli_parsed_command_properties[PLANIFY_CLI_PARSED_COMMAND_NUM_PROPERTIES];
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))

#define PLANIFY_CLI_TYPE_ARGUMENT_PARSER (planify_cli_argument_parser_get_type ())
#define PLANIFY_CLI_ARGUMENT_PARSER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PLANIFY_CLI_TYPE_ARGUMENT_PARSER, PlanifyCLIArgumentParser))
#define PLANIFY_CLI_ARGUMENT_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PLANIFY_CLI_TYPE_ARGUMENT_PARSER, PlanifyCLIArgumentParserClass))
#define PLANIFY_CLI_IS_ARGUMENT_PARSER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PLANIFY_CLI_TYPE_ARGUMENT_PARSER))
#define PLANIFY_CLI_IS_ARGUMENT_PARSER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PLANIFY_CLI_TYPE_ARGUMENT_PARSER))
#define PLANIFY_CLI_ARGUMENT_PARSER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PLANIFY_CLI_TYPE_ARGUMENT_PARSER, PlanifyCLIArgumentParserClass))

typedef struct _PlanifyCLIArgumentParser PlanifyCLIArgumentParser;
typedef struct _PlanifyCLIArgumentParserClass PlanifyCLIArgumentParserClass;
typedef struct _PlanifyCLIArgumentParserPrivate PlanifyCLIArgumentParserPrivate;
enum  {
	PLANIFY_CLI_ARGUMENT_PARSER_0_PROPERTY,
	PLANIFY_CLI_ARGUMENT_PARSER_NUM_PROPERTIES
};
static GParamSpec* planify_cli_argument_parser_properties[PLANIFY_CLI_ARGUMENT_PARSER_NUM_PROPERTIES];
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
#define _g_option_context_free0(var) ((var == NULL) ? NULL : (var = (g_option_context_free (var), NULL)))

struct _PlanifyCLITaskArguments {
	GObject parent_instance;
	PlanifyCLITaskArgumentsPrivate * priv;
};

struct _PlanifyCLITaskArgumentsClass {
	GObjectClass parent_class;
};

struct _PlanifyCLITaskArgumentsPrivate {
	gchar* _content;
	gchar* _description;
	gchar* _project_name;
	gchar* _project_id;
	gchar* _section_name;
	gchar* _section_id;
	gchar* _parent_id;
	gint _priority;
	gchar* _due_date;
	gchar* _labels;
	gint _pinned;
};

struct _PlanifyCLIListArguments {
	GObject parent_instance;
	PlanifyCLIListArgumentsPrivate * priv;
};

struct _PlanifyCLIListArgumentsClass {
	GObjectClass parent_class;
};

struct _PlanifyCLIListArgumentsPrivate {
	gchar* _project_name;
	gchar* _project_id;
};

struct _PlanifyCLIUpdateArguments {
	GObject parent_instance;
	PlanifyCLIUpdateArgumentsPrivate * priv;
};

struct _PlanifyCLIUpdateArgumentsClass {
	GObjectClass parent_class;
};

struct _PlanifyCLIUpdateArgumentsPrivate {
	gchar* _task_id;
	gchar* _content;
	gchar* _description;
	gchar* _project_name;
	gchar* _project_id;
	gchar* _section_name;
	gchar* _section_id;
	gchar* _parent_id;
	gint _priority;
	gchar* _due_date;
	gchar* _labels;
	gint _checked;
	gint _pinned;
};

struct _PlanifyCLIBackupArguments {
	GObject parent_instance;
	PlanifyCLIBackupArgumentsPrivate * priv;
};

struct _PlanifyCLIBackupArgumentsClass {
	GObjectClass parent_class;
};

struct _PlanifyCLIBackupArgumentsPrivate {
	gchar* _output;
};

struct _PlanifyCLIParsedCommand {
	GObject parent_instance;
	PlanifyCLIParsedCommandPrivate * priv;
};

struct _PlanifyCLIParsedCommandClass {
	GObjectClass parent_class;
};

struct _PlanifyCLIParsedCommandPrivate {
	PlanifyCLICommandType _command_type;
	PlanifyCLITaskArguments* _task_args;
	PlanifyCLIListArguments* _list_args;
	PlanifyCLIUpdateArguments* _update_args;
	PlanifyCLIBackupArguments* _backup_args;
};

struct _PlanifyCLIArgumentParser {
	GObject parent_instance;
	PlanifyCLIArgumentParserPrivate * priv;
};

struct _PlanifyCLIArgumentParserClass {
	GObjectClass parent_class;
};

static gint PlanifyCLITaskArguments_private_offset;
static gpointer planify_cli_task_arguments_parent_class = NULL;
static gint PlanifyCLIListArguments_private_offset;
static gpointer planify_cli_list_arguments_parent_class = NULL;
static gint PlanifyCLIUpdateArguments_private_offset;
static gpointer planify_cli_update_arguments_parent_class = NULL;
static gint PlanifyCLIBackupArguments_private_offset;
static gpointer planify_cli_backup_arguments_parent_class = NULL;
static gint PlanifyCLIParsedCommand_private_offset;
static gpointer planify_cli_parsed_command_parent_class = NULL;
static gpointer planify_cli_argument_parser_parent_class = NULL;

VALA_EXTERN GType planify_cli_command_type_get_type (void) G_GNUC_CONST ;
VALA_EXTERN GType planify_cli_task_arguments_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlanifyCLITaskArguments, g_object_unref)
VALA_EXTERN PlanifyCLITaskArguments* planify_cli_task_arguments_new (void);
VALA_EXTERN PlanifyCLITaskArguments* planify_cli_task_arguments_construct (GType object_type);
VALA_EXTERN const gchar* planify_cli_task_arguments_get_content (PlanifyCLITaskArguments* self);
VALA_EXTERN void planify_cli_task_arguments_set_content (PlanifyCLITaskArguments* self,
                                             const gchar* value);
VALA_EXTERN const gchar* planify_cli_task_arguments_get_description (PlanifyCLITaskArguments* self);
VALA_EXTERN void planify_cli_task_arguments_set_description (PlanifyCLITaskArguments* self,
                                                 const gchar* value);
VALA_EXTERN const gchar* planify_cli_task_arguments_get_project_name (PlanifyCLITaskArguments* self);
VALA_EXTERN void planify_cli_task_arguments_set_project_name (PlanifyCLITaskArguments* self,
                                                  const gchar* value);
VALA_EXTERN const gchar* planify_cli_task_arguments_get_project_id (PlanifyCLITaskArguments* self);
VALA_EXTERN void planify_cli_task_arguments_set_project_id (PlanifyCLITaskArguments* self,
                                                const gchar* value);
VALA_EXTERN const gchar* planify_cli_task_arguments_get_section_name (PlanifyCLITaskArguments* self);
VALA_EXTERN void planify_cli_task_arguments_set_section_name (PlanifyCLITaskArguments* self,
                                                  const gchar* value);
VALA_EXTERN const gchar* planify_cli_task_arguments_get_section_id (PlanifyCLITaskArguments* self);
VALA_EXTERN void planify_cli_task_arguments_set_section_id (PlanifyCLITaskArguments* self,
                                                const gchar* value);
VALA_EXTERN const gchar* planify_cli_task_arguments_get_parent_id (PlanifyCLITaskArguments* self);
VALA_EXTERN void planify_cli_task_arguments_set_parent_id (PlanifyCLITaskArguments* self,
                                               const gchar* value);
VALA_EXTERN gint planify_cli_task_arguments_get_priority (PlanifyCLITaskArguments* self);
VALA_EXTERN void planify_cli_task_arguments_set_priority (PlanifyCLITaskArguments* self,
                                              gint value);
VALA_EXTERN const gchar* planify_cli_task_arguments_get_due_date (PlanifyCLITaskArguments* self);
VALA_EXTERN void planify_cli_task_arguments_set_due_date (PlanifyCLITaskArguments* self,
                                              const gchar* value);
VALA_EXTERN const gchar* planify_cli_task_arguments_get_labels (PlanifyCLITaskArguments* self);
VALA_EXTERN void planify_cli_task_arguments_set_labels (PlanifyCLITaskArguments* self,
                                            const gchar* value);
VALA_EXTERN gint planify_cli_task_arguments_get_pinned (PlanifyCLITaskArguments* self);
VALA_EXTERN void planify_cli_task_arguments_set_pinned (PlanifyCLITaskArguments* self,
                                            gint value);
static void planify_cli_task_arguments_finalize (GObject * obj);
static GType planify_cli_task_arguments_get_type_once (void);
static void _vala_planify_cli_task_arguments_get_property (GObject * object,
                                                    guint property_id,
                                                    GValue * value,
                                                    GParamSpec * pspec);
static void _vala_planify_cli_task_arguments_set_property (GObject * object,
                                                    guint property_id,
                                                    const GValue * value,
                                                    GParamSpec * pspec);
VALA_EXTERN GType planify_cli_list_arguments_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlanifyCLIListArguments, g_object_unref)
VALA_EXTERN PlanifyCLIListArguments* planify_cli_list_arguments_new (void);
VALA_EXTERN PlanifyCLIListArguments* planify_cli_list_arguments_construct (GType object_type);
VALA_EXTERN const gchar* planify_cli_list_arguments_get_project_name (PlanifyCLIListArguments* self);
VALA_EXTERN void planify_cli_list_arguments_set_project_name (PlanifyCLIListArguments* self,
                                                  const gchar* value);
VALA_EXTERN const gchar* planify_cli_list_arguments_get_project_id (PlanifyCLIListArguments* self);
VALA_EXTERN void planify_cli_list_arguments_set_project_id (PlanifyCLIListArguments* self,
                                                const gchar* value);
static void planify_cli_list_arguments_finalize (GObject * obj);
static GType planify_cli_list_arguments_get_type_once (void);
static void _vala_planify_cli_list_arguments_get_property (GObject * object,
                                                    guint property_id,
                                                    GValue * value,
                                                    GParamSpec * pspec);
static void _vala_planify_cli_list_arguments_set_property (GObject * object,
                                                    guint property_id,
                                                    const GValue * value,
                                                    GParamSpec * pspec);
VALA_EXTERN GType planify_cli_update_arguments_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlanifyCLIUpdateArguments, g_object_unref)
VALA_EXTERN PlanifyCLIUpdateArguments* planify_cli_update_arguments_new (void);
VALA_EXTERN PlanifyCLIUpdateArguments* planify_cli_update_arguments_construct (GType object_type);
VALA_EXTERN const gchar* planify_cli_update_arguments_get_task_id (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_task_id (PlanifyCLIUpdateArguments* self,
                                               const gchar* value);
VALA_EXTERN const gchar* planify_cli_update_arguments_get_content (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_content (PlanifyCLIUpdateArguments* self,
                                               const gchar* value);
VALA_EXTERN const gchar* planify_cli_update_arguments_get_description (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_description (PlanifyCLIUpdateArguments* self,
                                                   const gchar* value);
VALA_EXTERN const gchar* planify_cli_update_arguments_get_project_name (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_project_name (PlanifyCLIUpdateArguments* self,
                                                    const gchar* value);
VALA_EXTERN const gchar* planify_cli_update_arguments_get_project_id (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_project_id (PlanifyCLIUpdateArguments* self,
                                                  const gchar* value);
VALA_EXTERN const gchar* planify_cli_update_arguments_get_section_name (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_section_name (PlanifyCLIUpdateArguments* self,
                                                    const gchar* value);
VALA_EXTERN const gchar* planify_cli_update_arguments_get_section_id (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_section_id (PlanifyCLIUpdateArguments* self,
                                                  const gchar* value);
VALA_EXTERN const gchar* planify_cli_update_arguments_get_parent_id (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_parent_id (PlanifyCLIUpdateArguments* self,
                                                 const gchar* value);
VALA_EXTERN gint planify_cli_update_arguments_get_priority (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_priority (PlanifyCLIUpdateArguments* self,
                                                gint value);
VALA_EXTERN const gchar* planify_cli_update_arguments_get_due_date (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_due_date (PlanifyCLIUpdateArguments* self,
                                                const gchar* value);
VALA_EXTERN const gchar* planify_cli_update_arguments_get_labels (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_labels (PlanifyCLIUpdateArguments* self,
                                              const gchar* value);
VALA_EXTERN gint planify_cli_update_arguments_get_checked (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_checked (PlanifyCLIUpdateArguments* self,
                                               gint value);
VALA_EXTERN gint planify_cli_update_arguments_get_pinned (PlanifyCLIUpdateArguments* self);
VALA_EXTERN void planify_cli_update_arguments_set_pinned (PlanifyCLIUpdateArguments* self,
                                              gint value);
static void planify_cli_update_arguments_finalize (GObject * obj);
static GType planify_cli_update_arguments_get_type_once (void);
static void _vala_planify_cli_update_arguments_get_property (GObject * object,
                                                      guint property_id,
                                                      GValue * value,
                                                      GParamSpec * pspec);
static void _vala_planify_cli_update_arguments_set_property (GObject * object,
                                                      guint property_id,
                                                      const GValue * value,
                                                      GParamSpec * pspec);
VALA_EXTERN GType planify_cli_backup_arguments_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlanifyCLIBackupArguments, g_object_unref)
VALA_EXTERN PlanifyCLIBackupArguments* planify_cli_backup_arguments_new (void);
VALA_EXTERN PlanifyCLIBackupArguments* planify_cli_backup_arguments_construct (GType object_type);
VALA_EXTERN const gchar* planify_cli_backup_arguments_get_output (PlanifyCLIBackupArguments* self);
VALA_EXTERN void planify_cli_backup_arguments_set_output (PlanifyCLIBackupArguments* self,
                                              const gchar* value);
static void planify_cli_backup_arguments_finalize (GObject * obj);
static GType planify_cli_backup_arguments_get_type_once (void);
static void _vala_planify_cli_backup_arguments_get_property (GObject * object,
                                                      guint property_id,
                                                      GValue * value,
                                                      GParamSpec * pspec);
static void _vala_planify_cli_backup_arguments_set_property (GObject * object,
                                                      guint property_id,
                                                      const GValue * value,
                                                      GParamSpec * pspec);
VALA_EXTERN GType planify_cli_parsed_command_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlanifyCLIParsedCommand, g_object_unref)
VALA_EXTERN PlanifyCLIParsedCommand* planify_cli_parsed_command_new (void);
VALA_EXTERN PlanifyCLIParsedCommand* planify_cli_parsed_command_construct (GType object_type);
VALA_EXTERN PlanifyCLICommandType planify_cli_parsed_command_get_command_type (PlanifyCLIParsedCommand* self);
VALA_EXTERN void planify_cli_parsed_command_set_command_type (PlanifyCLIParsedCommand* self,
                                                  PlanifyCLICommandType value);
VALA_EXTERN PlanifyCLITaskArguments* planify_cli_parsed_command_get_task_args (PlanifyCLIParsedCommand* self);
VALA_EXTERN void planify_cli_parsed_command_set_task_args (PlanifyCLIParsedCommand* self,
                                               PlanifyCLITaskArguments* value);
VALA_EXTERN PlanifyCLIListArguments* planify_cli_parsed_command_get_list_args (PlanifyCLIParsedCommand* self);
VALA_EXTERN void planify_cli_parsed_command_set_list_args (PlanifyCLIParsedCommand* self,
                                               PlanifyCLIListArguments* value);
VALA_EXTERN PlanifyCLIUpdateArguments* planify_cli_parsed_command_get_update_args (PlanifyCLIParsedCommand* self);
VALA_EXTERN void planify_cli_parsed_command_set_update_args (PlanifyCLIParsedCommand* self,
                                                 PlanifyCLIUpdateArguments* value);
VALA_EXTERN PlanifyCLIBackupArguments* planify_cli_parsed_command_get_backup_args (PlanifyCLIParsedCommand* self);
VALA_EXTERN void planify_cli_parsed_command_set_backup_args (PlanifyCLIParsedCommand* self,
                                                 PlanifyCLIBackupArguments* value);
static void planify_cli_parsed_command_finalize (GObject * obj);
static GType planify_cli_parsed_command_get_type_once (void);
static void _vala_planify_cli_parsed_command_get_property (GObject * object,
                                                    guint property_id,
                                                    GValue * value,
                                                    GParamSpec * pspec);
static void _vala_planify_cli_parsed_command_set_property (GObject * object,
                                                    guint property_id,
                                                    const GValue * value,
                                                    GParamSpec * pspec);
VALA_EXTERN GType planify_cli_argument_parser_get_type (void) G_GNUC_CONST ;
G_DEFINE_AUTOPTR_CLEANUP_FUNC (PlanifyCLIArgumentParser, g_object_unref)
VALA_EXTERN PlanifyCLIParsedCommand* planify_cli_argument_parser_parse (gchar** args,
                                                            gint args_length1,
                                                            gint* exit_code);
static void planify_cli_argument_parser_print_general_help (const gchar* program_name);
static PlanifyCLIListArguments* planify_cli_argument_parser_parse_list_command (gchar** args,
                                                                         gint args_length1,
                                                                         GError** error);
static PlanifyCLITaskArguments* planify_cli_argument_parser_parse_add_command (gchar** args,
                                                                        gint args_length1,
                                                                        GError** error);
static PlanifyCLIUpdateArguments* planify_cli_argument_parser_parse_update_command (gchar** args,
                                                                             gint args_length1,
                                                                             GError** error);
static PlanifyCLIBackupArguments* planify_cli_argument_parser_parse_backup_command (gchar** args,
                                                                             gint args_length1,
                                                                             GError** error);
static gint planify_cli_argument_parser_parse_boolean_option (const gchar* value,
                                                       GError** error);
VALA_EXTERN PlanifyCLIArgumentParser* planify_cli_argument_parser_new (void);
VALA_EXTERN PlanifyCLIArgumentParser* planify_cli_argument_parser_construct (GType object_type);
static GType planify_cli_argument_parser_get_type_once (void);
static void _vala_array_destroy (gpointer array,
                          gssize array_length,
                          GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array,
                       gssize array_length,
                       GDestroyNotify destroy_func);

static GType
planify_cli_command_type_get_type_once (void)
{
	static const GEnumValue values[] = {{PLANIFY_CLI_COMMAND_TYPE_NONE, "PLANIFY_CLI_COMMAND_TYPE_NONE", "none"}, {PLANIFY_CLI_COMMAND_TYPE_ADD, "PLANIFY_CLI_COMMAND_TYPE_ADD", "add"}, {PLANIFY_CLI_COMMAND_TYPE_LIST_PROJECTS, "PLANIFY_CLI_COMMAND_TYPE_LIST_PROJECTS", "list-projects"}, {PLANIFY_CLI_COMMAND_TYPE_LIST, "PLANIFY_CLI_COMMAND_TYPE_LIST", "list"}, {PLANIFY_CLI_COMMAND_TYPE_UPDATE, "PLANIFY_CLI_COMMAND_TYPE_UPDATE", "update"}, {PLANIFY_CLI_COMMAND_TYPE_BACKUP, "PLANIFY_CLI_COMMAND_TYPE_BACKUP", "backup"}, {0, NULL, NULL}};
	GType planify_cli_command_type_type_id;
	planify_cli_command_type_type_id = g_enum_register_static ("PlanifyCLICommandType", values);
	return planify_cli_command_type_type_id;
}

GType
planify_cli_command_type_get_type (void)
{
	static volatile gsize planify_cli_command_type_type_id__once = 0;
	if (g_once_init_enter (&planify_cli_command_type_type_id__once)) {
		GType planify_cli_command_type_type_id;
		planify_cli_command_type_type_id = planify_cli_command_type_get_type_once ();
		g_once_init_leave (&planify_cli_command_type_type_id__once, planify_cli_command_type_type_id);
	}
	return planify_cli_command_type_type_id__once;
}

static inline gpointer
planify_cli_task_arguments_get_instance_private (PlanifyCLITaskArguments* self)
{
	return G_STRUCT_MEMBER_P (self, PlanifyCLITaskArguments_private_offset);
}

PlanifyCLITaskArguments*
planify_cli_task_arguments_construct (GType object_type)
{
	PlanifyCLITaskArguments * self = NULL;
	self = (PlanifyCLITaskArguments*) g_object_new (object_type, NULL);
	return self;
}

PlanifyCLITaskArguments*
planify_cli_task_arguments_new (void)
{
	return planify_cli_task_arguments_construct (PLANIFY_CLI_TYPE_TASK_ARGUMENTS);
}

const gchar*
planify_cli_task_arguments_get_content (PlanifyCLITaskArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_content;
	result = _tmp0_;
	return result;
}

void
planify_cli_task_arguments_set_content (PlanifyCLITaskArguments* self,
                                        const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_task_arguments_get_content (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_content);
		self->priv->_content = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_CONTENT_PROPERTY]);
	}
}

const gchar*
planify_cli_task_arguments_get_description (PlanifyCLITaskArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_description;
	result = _tmp0_;
	return result;
}

void
planify_cli_task_arguments_set_description (PlanifyCLITaskArguments* self,
                                            const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_task_arguments_get_description (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_description);
		self->priv->_description = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_DESCRIPTION_PROPERTY]);
	}
}

const gchar*
planify_cli_task_arguments_get_project_name (PlanifyCLITaskArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_project_name;
	result = _tmp0_;
	return result;
}

void
planify_cli_task_arguments_set_project_name (PlanifyCLITaskArguments* self,
                                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_task_arguments_get_project_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_project_name);
		self->priv->_project_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_NAME_PROPERTY]);
	}
}

const gchar*
planify_cli_task_arguments_get_project_id (PlanifyCLITaskArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_project_id;
	result = _tmp0_;
	return result;
}

void
planify_cli_task_arguments_set_project_id (PlanifyCLITaskArguments* self,
                                           const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_task_arguments_get_project_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_project_id);
		self->priv->_project_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_ID_PROPERTY]);
	}
}

const gchar*
planify_cli_task_arguments_get_section_name (PlanifyCLITaskArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_section_name;
	result = _tmp0_;
	return result;
}

void
planify_cli_task_arguments_set_section_name (PlanifyCLITaskArguments* self,
                                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_task_arguments_get_section_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_section_name);
		self->priv->_section_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_SECTION_NAME_PROPERTY]);
	}
}

const gchar*
planify_cli_task_arguments_get_section_id (PlanifyCLITaskArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_section_id;
	result = _tmp0_;
	return result;
}

void
planify_cli_task_arguments_set_section_id (PlanifyCLITaskArguments* self,
                                           const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_task_arguments_get_section_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_section_id);
		self->priv->_section_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_SECTION_ID_PROPERTY]);
	}
}

const gchar*
planify_cli_task_arguments_get_parent_id (PlanifyCLITaskArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_parent_id;
	result = _tmp0_;
	return result;
}

void
planify_cli_task_arguments_set_parent_id (PlanifyCLITaskArguments* self,
                                          const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_task_arguments_get_parent_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_parent_id);
		self->priv->_parent_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_PARENT_ID_PROPERTY]);
	}
}

gint
planify_cli_task_arguments_get_priority (PlanifyCLITaskArguments* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, -1);
	result = self->priv->_priority;
	return result;
}

void
planify_cli_task_arguments_set_priority (PlanifyCLITaskArguments* self,
                                         gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_task_arguments_get_priority (self);
	if (old_value != value) {
		self->priv->_priority = value;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_PRIORITY_PROPERTY]);
	}
}

const gchar*
planify_cli_task_arguments_get_due_date (PlanifyCLITaskArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_due_date;
	result = _tmp0_;
	return result;
}

void
planify_cli_task_arguments_set_due_date (PlanifyCLITaskArguments* self,
                                         const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_task_arguments_get_due_date (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_due_date);
		self->priv->_due_date = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_DUE_DATE_PROPERTY]);
	}
}

const gchar*
planify_cli_task_arguments_get_labels (PlanifyCLITaskArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_labels;
	result = _tmp0_;
	return result;
}

void
planify_cli_task_arguments_set_labels (PlanifyCLITaskArguments* self,
                                       const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_task_arguments_get_labels (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_labels);
		self->priv->_labels = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_LABELS_PROPERTY]);
	}
}

gint
planify_cli_task_arguments_get_pinned (PlanifyCLITaskArguments* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, -1);
	result = self->priv->_pinned;
	return result;
}

void
planify_cli_task_arguments_set_pinned (PlanifyCLITaskArguments* self,
                                       gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_task_arguments_get_pinned (self);
	if (old_value != value) {
		self->priv->_pinned = value;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_PINNED_PROPERTY]);
	}
}

static void
planify_cli_task_arguments_class_init (PlanifyCLITaskArgumentsClass * klass,
                                       gpointer klass_data)
{
	planify_cli_task_arguments_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &PlanifyCLITaskArguments_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_planify_cli_task_arguments_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_planify_cli_task_arguments_set_property;
	G_OBJECT_CLASS (klass)->finalize = planify_cli_task_arguments_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_TASK_ARGUMENTS_CONTENT_PROPERTY, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_CONTENT_PROPERTY] = g_param_spec_string ("content", "content", "content", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_TASK_ARGUMENTS_DESCRIPTION_PROPERTY, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_DESCRIPTION_PROPERTY] = g_param_spec_string ("description", "description", "description", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_NAME_PROPERTY, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_NAME_PROPERTY] = g_param_spec_string ("project-name", "project-name", "project-name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_ID_PROPERTY, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_ID_PROPERTY] = g_param_spec_string ("project-id", "project-id", "project-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_TASK_ARGUMENTS_SECTION_NAME_PROPERTY, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_SECTION_NAME_PROPERTY] = g_param_spec_string ("section-name", "section-name", "section-name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_TASK_ARGUMENTS_SECTION_ID_PROPERTY, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_SECTION_ID_PROPERTY] = g_param_spec_string ("section-id", "section-id", "section-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_TASK_ARGUMENTS_PARENT_ID_PROPERTY, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_PARENT_ID_PROPERTY] = g_param_spec_string ("parent-id", "parent-id", "parent-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_TASK_ARGUMENTS_PRIORITY_PROPERTY, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_PRIORITY_PROPERTY] = g_param_spec_int ("priority", "priority", "priority", G_MININT, G_MAXINT, 4, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_TASK_ARGUMENTS_DUE_DATE_PROPERTY, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_DUE_DATE_PROPERTY] = g_param_spec_string ("due-date", "due-date", "due-date", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_TASK_ARGUMENTS_LABELS_PROPERTY, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_LABELS_PROPERTY] = g_param_spec_string ("labels", "labels", "labels", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_TASK_ARGUMENTS_PINNED_PROPERTY, planify_cli_task_arguments_properties[PLANIFY_CLI_TASK_ARGUMENTS_PINNED_PROPERTY] = g_param_spec_int ("pinned", "pinned", "pinned", G_MININT, G_MAXINT, -1, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
planify_cli_task_arguments_instance_init (PlanifyCLITaskArguments * self,
                                          gpointer klass)
{
	self->priv = planify_cli_task_arguments_get_instance_private (self);
	self->priv->_content = NULL;
	self->priv->_description = NULL;
	self->priv->_project_name = NULL;
	self->priv->_project_id = NULL;
	self->priv->_section_name = NULL;
	self->priv->_section_id = NULL;
	self->priv->_parent_id = NULL;
	self->priv->_priority = 4;
	self->priv->_due_date = NULL;
	self->priv->_labels = NULL;
	self->priv->_pinned = -1;
}

static void
planify_cli_task_arguments_finalize (GObject * obj)
{
	PlanifyCLITaskArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PLANIFY_CLI_TYPE_TASK_ARGUMENTS, PlanifyCLITaskArguments);
	_g_free0 (self->priv->_content);
	_g_free0 (self->priv->_description);
	_g_free0 (self->priv->_project_name);
	_g_free0 (self->priv->_project_id);
	_g_free0 (self->priv->_section_name);
	_g_free0 (self->priv->_section_id);
	_g_free0 (self->priv->_parent_id);
	_g_free0 (self->priv->_due_date);
	_g_free0 (self->priv->_labels);
	G_OBJECT_CLASS (planify_cli_task_arguments_parent_class)->finalize (obj);
}

static GType
planify_cli_task_arguments_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (PlanifyCLITaskArgumentsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) planify_cli_task_arguments_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PlanifyCLITaskArguments), 0, (GInstanceInitFunc) planify_cli_task_arguments_instance_init, NULL };
	GType planify_cli_task_arguments_type_id;
	planify_cli_task_arguments_type_id = g_type_register_static (G_TYPE_OBJECT, "PlanifyCLITaskArguments", &g_define_type_info, 0);
	PlanifyCLITaskArguments_private_offset = g_type_add_instance_private (planify_cli_task_arguments_type_id, sizeof (PlanifyCLITaskArgumentsPrivate));
	return planify_cli_task_arguments_type_id;
}

GType
planify_cli_task_arguments_get_type (void)
{
	static volatile gsize planify_cli_task_arguments_type_id__once = 0;
	if (g_once_init_enter (&planify_cli_task_arguments_type_id__once)) {
		GType planify_cli_task_arguments_type_id;
		planify_cli_task_arguments_type_id = planify_cli_task_arguments_get_type_once ();
		g_once_init_leave (&planify_cli_task_arguments_type_id__once, planify_cli_task_arguments_type_id);
	}
	return planify_cli_task_arguments_type_id__once;
}

static void
_vala_planify_cli_task_arguments_get_property (GObject * object,
                                               guint property_id,
                                               GValue * value,
                                               GParamSpec * pspec)
{
	PlanifyCLITaskArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PLANIFY_CLI_TYPE_TASK_ARGUMENTS, PlanifyCLITaskArguments);
	switch (property_id) {
		case PLANIFY_CLI_TASK_ARGUMENTS_CONTENT_PROPERTY:
		g_value_set_string (value, planify_cli_task_arguments_get_content (self));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_DESCRIPTION_PROPERTY:
		g_value_set_string (value, planify_cli_task_arguments_get_description (self));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_NAME_PROPERTY:
		g_value_set_string (value, planify_cli_task_arguments_get_project_name (self));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_ID_PROPERTY:
		g_value_set_string (value, planify_cli_task_arguments_get_project_id (self));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_SECTION_NAME_PROPERTY:
		g_value_set_string (value, planify_cli_task_arguments_get_section_name (self));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_SECTION_ID_PROPERTY:
		g_value_set_string (value, planify_cli_task_arguments_get_section_id (self));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_PARENT_ID_PROPERTY:
		g_value_set_string (value, planify_cli_task_arguments_get_parent_id (self));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_PRIORITY_PROPERTY:
		g_value_set_int (value, planify_cli_task_arguments_get_priority (self));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_DUE_DATE_PROPERTY:
		g_value_set_string (value, planify_cli_task_arguments_get_due_date (self));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_LABELS_PROPERTY:
		g_value_set_string (value, planify_cli_task_arguments_get_labels (self));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_PINNED_PROPERTY:
		g_value_set_int (value, planify_cli_task_arguments_get_pinned (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_planify_cli_task_arguments_set_property (GObject * object,
                                               guint property_id,
                                               const GValue * value,
                                               GParamSpec * pspec)
{
	PlanifyCLITaskArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PLANIFY_CLI_TYPE_TASK_ARGUMENTS, PlanifyCLITaskArguments);
	switch (property_id) {
		case PLANIFY_CLI_TASK_ARGUMENTS_CONTENT_PROPERTY:
		planify_cli_task_arguments_set_content (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_DESCRIPTION_PROPERTY:
		planify_cli_task_arguments_set_description (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_NAME_PROPERTY:
		planify_cli_task_arguments_set_project_name (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_PROJECT_ID_PROPERTY:
		planify_cli_task_arguments_set_project_id (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_SECTION_NAME_PROPERTY:
		planify_cli_task_arguments_set_section_name (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_SECTION_ID_PROPERTY:
		planify_cli_task_arguments_set_section_id (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_PARENT_ID_PROPERTY:
		planify_cli_task_arguments_set_parent_id (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_PRIORITY_PROPERTY:
		planify_cli_task_arguments_set_priority (self, g_value_get_int (value));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_DUE_DATE_PROPERTY:
		planify_cli_task_arguments_set_due_date (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_LABELS_PROPERTY:
		planify_cli_task_arguments_set_labels (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_TASK_ARGUMENTS_PINNED_PROPERTY:
		planify_cli_task_arguments_set_pinned (self, g_value_get_int (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
planify_cli_list_arguments_get_instance_private (PlanifyCLIListArguments* self)
{
	return G_STRUCT_MEMBER_P (self, PlanifyCLIListArguments_private_offset);
}

PlanifyCLIListArguments*
planify_cli_list_arguments_construct (GType object_type)
{
	PlanifyCLIListArguments * self = NULL;
	self = (PlanifyCLIListArguments*) g_object_new (object_type, NULL);
	return self;
}

PlanifyCLIListArguments*
planify_cli_list_arguments_new (void)
{
	return planify_cli_list_arguments_construct (PLANIFY_CLI_TYPE_LIST_ARGUMENTS);
}

const gchar*
planify_cli_list_arguments_get_project_name (PlanifyCLIListArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_project_name;
	result = _tmp0_;
	return result;
}

void
planify_cli_list_arguments_set_project_name (PlanifyCLIListArguments* self,
                                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_list_arguments_get_project_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_project_name);
		self->priv->_project_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_list_arguments_properties[PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_NAME_PROPERTY]);
	}
}

const gchar*
planify_cli_list_arguments_get_project_id (PlanifyCLIListArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_project_id;
	result = _tmp0_;
	return result;
}

void
planify_cli_list_arguments_set_project_id (PlanifyCLIListArguments* self,
                                           const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_list_arguments_get_project_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_project_id);
		self->priv->_project_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_list_arguments_properties[PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_ID_PROPERTY]);
	}
}

static void
planify_cli_list_arguments_class_init (PlanifyCLIListArgumentsClass * klass,
                                       gpointer klass_data)
{
	planify_cli_list_arguments_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &PlanifyCLIListArguments_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_planify_cli_list_arguments_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_planify_cli_list_arguments_set_property;
	G_OBJECT_CLASS (klass)->finalize = planify_cli_list_arguments_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_NAME_PROPERTY, planify_cli_list_arguments_properties[PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_NAME_PROPERTY] = g_param_spec_string ("project-name", "project-name", "project-name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_ID_PROPERTY, planify_cli_list_arguments_properties[PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_ID_PROPERTY] = g_param_spec_string ("project-id", "project-id", "project-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
planify_cli_list_arguments_instance_init (PlanifyCLIListArguments * self,
                                          gpointer klass)
{
	self->priv = planify_cli_list_arguments_get_instance_private (self);
	self->priv->_project_name = NULL;
	self->priv->_project_id = NULL;
}

static void
planify_cli_list_arguments_finalize (GObject * obj)
{
	PlanifyCLIListArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PLANIFY_CLI_TYPE_LIST_ARGUMENTS, PlanifyCLIListArguments);
	_g_free0 (self->priv->_project_name);
	_g_free0 (self->priv->_project_id);
	G_OBJECT_CLASS (planify_cli_list_arguments_parent_class)->finalize (obj);
}

static GType
planify_cli_list_arguments_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (PlanifyCLIListArgumentsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) planify_cli_list_arguments_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PlanifyCLIListArguments), 0, (GInstanceInitFunc) planify_cli_list_arguments_instance_init, NULL };
	GType planify_cli_list_arguments_type_id;
	planify_cli_list_arguments_type_id = g_type_register_static (G_TYPE_OBJECT, "PlanifyCLIListArguments", &g_define_type_info, 0);
	PlanifyCLIListArguments_private_offset = g_type_add_instance_private (planify_cli_list_arguments_type_id, sizeof (PlanifyCLIListArgumentsPrivate));
	return planify_cli_list_arguments_type_id;
}

GType
planify_cli_list_arguments_get_type (void)
{
	static volatile gsize planify_cli_list_arguments_type_id__once = 0;
	if (g_once_init_enter (&planify_cli_list_arguments_type_id__once)) {
		GType planify_cli_list_arguments_type_id;
		planify_cli_list_arguments_type_id = planify_cli_list_arguments_get_type_once ();
		g_once_init_leave (&planify_cli_list_arguments_type_id__once, planify_cli_list_arguments_type_id);
	}
	return planify_cli_list_arguments_type_id__once;
}

static void
_vala_planify_cli_list_arguments_get_property (GObject * object,
                                               guint property_id,
                                               GValue * value,
                                               GParamSpec * pspec)
{
	PlanifyCLIListArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PLANIFY_CLI_TYPE_LIST_ARGUMENTS, PlanifyCLIListArguments);
	switch (property_id) {
		case PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_NAME_PROPERTY:
		g_value_set_string (value, planify_cli_list_arguments_get_project_name (self));
		break;
		case PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_ID_PROPERTY:
		g_value_set_string (value, planify_cli_list_arguments_get_project_id (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_planify_cli_list_arguments_set_property (GObject * object,
                                               guint property_id,
                                               const GValue * value,
                                               GParamSpec * pspec)
{
	PlanifyCLIListArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PLANIFY_CLI_TYPE_LIST_ARGUMENTS, PlanifyCLIListArguments);
	switch (property_id) {
		case PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_NAME_PROPERTY:
		planify_cli_list_arguments_set_project_name (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_LIST_ARGUMENTS_PROJECT_ID_PROPERTY:
		planify_cli_list_arguments_set_project_id (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
planify_cli_update_arguments_get_instance_private (PlanifyCLIUpdateArguments* self)
{
	return G_STRUCT_MEMBER_P (self, PlanifyCLIUpdateArguments_private_offset);
}

PlanifyCLIUpdateArguments*
planify_cli_update_arguments_construct (GType object_type)
{
	PlanifyCLIUpdateArguments * self = NULL;
	self = (PlanifyCLIUpdateArguments*) g_object_new (object_type, NULL);
	return self;
}

PlanifyCLIUpdateArguments*
planify_cli_update_arguments_new (void)
{
	return planify_cli_update_arguments_construct (PLANIFY_CLI_TYPE_UPDATE_ARGUMENTS);
}

const gchar*
planify_cli_update_arguments_get_task_id (PlanifyCLIUpdateArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_task_id;
	result = _tmp0_;
	return result;
}

void
planify_cli_update_arguments_set_task_id (PlanifyCLIUpdateArguments* self,
                                          const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_task_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_task_id);
		self->priv->_task_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_TASK_ID_PROPERTY]);
	}
}

const gchar*
planify_cli_update_arguments_get_content (PlanifyCLIUpdateArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_content;
	result = _tmp0_;
	return result;
}

void
planify_cli_update_arguments_set_content (PlanifyCLIUpdateArguments* self,
                                          const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_content (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_content);
		self->priv->_content = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_CONTENT_PROPERTY]);
	}
}

const gchar*
planify_cli_update_arguments_get_description (PlanifyCLIUpdateArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_description;
	result = _tmp0_;
	return result;
}

void
planify_cli_update_arguments_set_description (PlanifyCLIUpdateArguments* self,
                                              const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_description (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_description);
		self->priv->_description = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_DESCRIPTION_PROPERTY]);
	}
}

const gchar*
planify_cli_update_arguments_get_project_name (PlanifyCLIUpdateArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_project_name;
	result = _tmp0_;
	return result;
}

void
planify_cli_update_arguments_set_project_name (PlanifyCLIUpdateArguments* self,
                                               const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_project_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_project_name);
		self->priv->_project_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_NAME_PROPERTY]);
	}
}

const gchar*
planify_cli_update_arguments_get_project_id (PlanifyCLIUpdateArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_project_id;
	result = _tmp0_;
	return result;
}

void
planify_cli_update_arguments_set_project_id (PlanifyCLIUpdateArguments* self,
                                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_project_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_project_id);
		self->priv->_project_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_ID_PROPERTY]);
	}
}

const gchar*
planify_cli_update_arguments_get_section_name (PlanifyCLIUpdateArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_section_name;
	result = _tmp0_;
	return result;
}

void
planify_cli_update_arguments_set_section_name (PlanifyCLIUpdateArguments* self,
                                               const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_section_name (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_section_name);
		self->priv->_section_name = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_NAME_PROPERTY]);
	}
}

const gchar*
planify_cli_update_arguments_get_section_id (PlanifyCLIUpdateArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_section_id;
	result = _tmp0_;
	return result;
}

void
planify_cli_update_arguments_set_section_id (PlanifyCLIUpdateArguments* self,
                                             const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_section_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_section_id);
		self->priv->_section_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_ID_PROPERTY]);
	}
}

const gchar*
planify_cli_update_arguments_get_parent_id (PlanifyCLIUpdateArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_parent_id;
	result = _tmp0_;
	return result;
}

void
planify_cli_update_arguments_set_parent_id (PlanifyCLIUpdateArguments* self,
                                            const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_parent_id (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_parent_id);
		self->priv->_parent_id = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_PARENT_ID_PROPERTY]);
	}
}

gint
planify_cli_update_arguments_get_priority (PlanifyCLIUpdateArguments* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, -1);
	result = self->priv->_priority;
	return result;
}

void
planify_cli_update_arguments_set_priority (PlanifyCLIUpdateArguments* self,
                                           gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_priority (self);
	if (old_value != value) {
		self->priv->_priority = value;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_PRIORITY_PROPERTY]);
	}
}

const gchar*
planify_cli_update_arguments_get_due_date (PlanifyCLIUpdateArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_due_date;
	result = _tmp0_;
	return result;
}

void
planify_cli_update_arguments_set_due_date (PlanifyCLIUpdateArguments* self,
                                           const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_due_date (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_due_date);
		self->priv->_due_date = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_DUE_DATE_PROPERTY]);
	}
}

const gchar*
planify_cli_update_arguments_get_labels (PlanifyCLIUpdateArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_labels;
	result = _tmp0_;
	return result;
}

void
planify_cli_update_arguments_set_labels (PlanifyCLIUpdateArguments* self,
                                         const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_labels (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_labels);
		self->priv->_labels = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_LABELS_PROPERTY]);
	}
}

gint
planify_cli_update_arguments_get_checked (PlanifyCLIUpdateArguments* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, -1);
	result = self->priv->_checked;
	return result;
}

void
planify_cli_update_arguments_set_checked (PlanifyCLIUpdateArguments* self,
                                          gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_checked (self);
	if (old_value != value) {
		self->priv->_checked = value;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_CHECKED_PROPERTY]);
	}
}

gint
planify_cli_update_arguments_get_pinned (PlanifyCLIUpdateArguments* self)
{
	gint result;
	g_return_val_if_fail (self != NULL, -1);
	result = self->priv->_pinned;
	return result;
}

void
planify_cli_update_arguments_set_pinned (PlanifyCLIUpdateArguments* self,
                                         gint value)
{
	gint old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_update_arguments_get_pinned (self);
	if (old_value != value) {
		self->priv->_pinned = value;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_PINNED_PROPERTY]);
	}
}

static void
planify_cli_update_arguments_class_init (PlanifyCLIUpdateArgumentsClass * klass,
                                         gpointer klass_data)
{
	planify_cli_update_arguments_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &PlanifyCLIUpdateArguments_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_planify_cli_update_arguments_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_planify_cli_update_arguments_set_property;
	G_OBJECT_CLASS (klass)->finalize = planify_cli_update_arguments_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_TASK_ID_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_TASK_ID_PROPERTY] = g_param_spec_string ("task-id", "task-id", "task-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_CONTENT_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_CONTENT_PROPERTY] = g_param_spec_string ("content", "content", "content", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_DESCRIPTION_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_DESCRIPTION_PROPERTY] = g_param_spec_string ("description", "description", "description", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_NAME_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_NAME_PROPERTY] = g_param_spec_string ("project-name", "project-name", "project-name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_ID_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_ID_PROPERTY] = g_param_spec_string ("project-id", "project-id", "project-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_NAME_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_NAME_PROPERTY] = g_param_spec_string ("section-name", "section-name", "section-name", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_ID_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_ID_PROPERTY] = g_param_spec_string ("section-id", "section-id", "section-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_PARENT_ID_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_PARENT_ID_PROPERTY] = g_param_spec_string ("parent-id", "parent-id", "parent-id", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_PRIORITY_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_PRIORITY_PROPERTY] = g_param_spec_int ("priority", "priority", "priority", G_MININT, G_MAXINT, -1, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_DUE_DATE_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_DUE_DATE_PROPERTY] = g_param_spec_string ("due-date", "due-date", "due-date", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_LABELS_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_LABELS_PROPERTY] = g_param_spec_string ("labels", "labels", "labels", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_CHECKED_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_CHECKED_PROPERTY] = g_param_spec_int ("checked", "checked", "checked", G_MININT, G_MAXINT, -1, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_UPDATE_ARGUMENTS_PINNED_PROPERTY, planify_cli_update_arguments_properties[PLANIFY_CLI_UPDATE_ARGUMENTS_PINNED_PROPERTY] = g_param_spec_int ("pinned", "pinned", "pinned", G_MININT, G_MAXINT, -1, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
planify_cli_update_arguments_instance_init (PlanifyCLIUpdateArguments * self,
                                            gpointer klass)
{
	self->priv = planify_cli_update_arguments_get_instance_private (self);
	self->priv->_task_id = NULL;
	self->priv->_content = NULL;
	self->priv->_description = NULL;
	self->priv->_project_name = NULL;
	self->priv->_project_id = NULL;
	self->priv->_section_name = NULL;
	self->priv->_section_id = NULL;
	self->priv->_parent_id = NULL;
	self->priv->_priority = -1;
	self->priv->_due_date = NULL;
	self->priv->_labels = NULL;
	self->priv->_checked = -1;
	self->priv->_pinned = -1;
}

static void
planify_cli_update_arguments_finalize (GObject * obj)
{
	PlanifyCLIUpdateArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PLANIFY_CLI_TYPE_UPDATE_ARGUMENTS, PlanifyCLIUpdateArguments);
	_g_free0 (self->priv->_task_id);
	_g_free0 (self->priv->_content);
	_g_free0 (self->priv->_description);
	_g_free0 (self->priv->_project_name);
	_g_free0 (self->priv->_project_id);
	_g_free0 (self->priv->_section_name);
	_g_free0 (self->priv->_section_id);
	_g_free0 (self->priv->_parent_id);
	_g_free0 (self->priv->_due_date);
	_g_free0 (self->priv->_labels);
	G_OBJECT_CLASS (planify_cli_update_arguments_parent_class)->finalize (obj);
}

static GType
planify_cli_update_arguments_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (PlanifyCLIUpdateArgumentsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) planify_cli_update_arguments_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PlanifyCLIUpdateArguments), 0, (GInstanceInitFunc) planify_cli_update_arguments_instance_init, NULL };
	GType planify_cli_update_arguments_type_id;
	planify_cli_update_arguments_type_id = g_type_register_static (G_TYPE_OBJECT, "PlanifyCLIUpdateArguments", &g_define_type_info, 0);
	PlanifyCLIUpdateArguments_private_offset = g_type_add_instance_private (planify_cli_update_arguments_type_id, sizeof (PlanifyCLIUpdateArgumentsPrivate));
	return planify_cli_update_arguments_type_id;
}

GType
planify_cli_update_arguments_get_type (void)
{
	static volatile gsize planify_cli_update_arguments_type_id__once = 0;
	if (g_once_init_enter (&planify_cli_update_arguments_type_id__once)) {
		GType planify_cli_update_arguments_type_id;
		planify_cli_update_arguments_type_id = planify_cli_update_arguments_get_type_once ();
		g_once_init_leave (&planify_cli_update_arguments_type_id__once, planify_cli_update_arguments_type_id);
	}
	return planify_cli_update_arguments_type_id__once;
}

static void
_vala_planify_cli_update_arguments_get_property (GObject * object,
                                                 guint property_id,
                                                 GValue * value,
                                                 GParamSpec * pspec)
{
	PlanifyCLIUpdateArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PLANIFY_CLI_TYPE_UPDATE_ARGUMENTS, PlanifyCLIUpdateArguments);
	switch (property_id) {
		case PLANIFY_CLI_UPDATE_ARGUMENTS_TASK_ID_PROPERTY:
		g_value_set_string (value, planify_cli_update_arguments_get_task_id (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_CONTENT_PROPERTY:
		g_value_set_string (value, planify_cli_update_arguments_get_content (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_DESCRIPTION_PROPERTY:
		g_value_set_string (value, planify_cli_update_arguments_get_description (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_NAME_PROPERTY:
		g_value_set_string (value, planify_cli_update_arguments_get_project_name (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_ID_PROPERTY:
		g_value_set_string (value, planify_cli_update_arguments_get_project_id (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_NAME_PROPERTY:
		g_value_set_string (value, planify_cli_update_arguments_get_section_name (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_ID_PROPERTY:
		g_value_set_string (value, planify_cli_update_arguments_get_section_id (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_PARENT_ID_PROPERTY:
		g_value_set_string (value, planify_cli_update_arguments_get_parent_id (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_PRIORITY_PROPERTY:
		g_value_set_int (value, planify_cli_update_arguments_get_priority (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_DUE_DATE_PROPERTY:
		g_value_set_string (value, planify_cli_update_arguments_get_due_date (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_LABELS_PROPERTY:
		g_value_set_string (value, planify_cli_update_arguments_get_labels (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_CHECKED_PROPERTY:
		g_value_set_int (value, planify_cli_update_arguments_get_checked (self));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_PINNED_PROPERTY:
		g_value_set_int (value, planify_cli_update_arguments_get_pinned (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_planify_cli_update_arguments_set_property (GObject * object,
                                                 guint property_id,
                                                 const GValue * value,
                                                 GParamSpec * pspec)
{
	PlanifyCLIUpdateArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PLANIFY_CLI_TYPE_UPDATE_ARGUMENTS, PlanifyCLIUpdateArguments);
	switch (property_id) {
		case PLANIFY_CLI_UPDATE_ARGUMENTS_TASK_ID_PROPERTY:
		planify_cli_update_arguments_set_task_id (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_CONTENT_PROPERTY:
		planify_cli_update_arguments_set_content (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_DESCRIPTION_PROPERTY:
		planify_cli_update_arguments_set_description (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_NAME_PROPERTY:
		planify_cli_update_arguments_set_project_name (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_PROJECT_ID_PROPERTY:
		planify_cli_update_arguments_set_project_id (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_NAME_PROPERTY:
		planify_cli_update_arguments_set_section_name (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_SECTION_ID_PROPERTY:
		planify_cli_update_arguments_set_section_id (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_PARENT_ID_PROPERTY:
		planify_cli_update_arguments_set_parent_id (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_PRIORITY_PROPERTY:
		planify_cli_update_arguments_set_priority (self, g_value_get_int (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_DUE_DATE_PROPERTY:
		planify_cli_update_arguments_set_due_date (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_LABELS_PROPERTY:
		planify_cli_update_arguments_set_labels (self, g_value_get_string (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_CHECKED_PROPERTY:
		planify_cli_update_arguments_set_checked (self, g_value_get_int (value));
		break;
		case PLANIFY_CLI_UPDATE_ARGUMENTS_PINNED_PROPERTY:
		planify_cli_update_arguments_set_pinned (self, g_value_get_int (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
planify_cli_backup_arguments_get_instance_private (PlanifyCLIBackupArguments* self)
{
	return G_STRUCT_MEMBER_P (self, PlanifyCLIBackupArguments_private_offset);
}

PlanifyCLIBackupArguments*
planify_cli_backup_arguments_construct (GType object_type)
{
	PlanifyCLIBackupArguments * self = NULL;
	self = (PlanifyCLIBackupArguments*) g_object_new (object_type, NULL);
	return self;
}

PlanifyCLIBackupArguments*
planify_cli_backup_arguments_new (void)
{
	return planify_cli_backup_arguments_construct (PLANIFY_CLI_TYPE_BACKUP_ARGUMENTS);
}

const gchar*
planify_cli_backup_arguments_get_output (PlanifyCLIBackupArguments* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_output;
	result = _tmp0_;
	return result;
}

void
planify_cli_backup_arguments_set_output (PlanifyCLIBackupArguments* self,
                                         const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_backup_arguments_get_output (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_output);
		self->priv->_output = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_backup_arguments_properties[PLANIFY_CLI_BACKUP_ARGUMENTS_OUTPUT_PROPERTY]);
	}
}

static void
planify_cli_backup_arguments_class_init (PlanifyCLIBackupArgumentsClass * klass,
                                         gpointer klass_data)
{
	planify_cli_backup_arguments_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &PlanifyCLIBackupArguments_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_planify_cli_backup_arguments_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_planify_cli_backup_arguments_set_property;
	G_OBJECT_CLASS (klass)->finalize = planify_cli_backup_arguments_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_BACKUP_ARGUMENTS_OUTPUT_PROPERTY, planify_cli_backup_arguments_properties[PLANIFY_CLI_BACKUP_ARGUMENTS_OUTPUT_PROPERTY] = g_param_spec_string ("output", "output", "output", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
planify_cli_backup_arguments_instance_init (PlanifyCLIBackupArguments * self,
                                            gpointer klass)
{
	self->priv = planify_cli_backup_arguments_get_instance_private (self);
	self->priv->_output = NULL;
}

static void
planify_cli_backup_arguments_finalize (GObject * obj)
{
	PlanifyCLIBackupArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PLANIFY_CLI_TYPE_BACKUP_ARGUMENTS, PlanifyCLIBackupArguments);
	_g_free0 (self->priv->_output);
	G_OBJECT_CLASS (planify_cli_backup_arguments_parent_class)->finalize (obj);
}

static GType
planify_cli_backup_arguments_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (PlanifyCLIBackupArgumentsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) planify_cli_backup_arguments_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PlanifyCLIBackupArguments), 0, (GInstanceInitFunc) planify_cli_backup_arguments_instance_init, NULL };
	GType planify_cli_backup_arguments_type_id;
	planify_cli_backup_arguments_type_id = g_type_register_static (G_TYPE_OBJECT, "PlanifyCLIBackupArguments", &g_define_type_info, 0);
	PlanifyCLIBackupArguments_private_offset = g_type_add_instance_private (planify_cli_backup_arguments_type_id, sizeof (PlanifyCLIBackupArgumentsPrivate));
	return planify_cli_backup_arguments_type_id;
}

GType
planify_cli_backup_arguments_get_type (void)
{
	static volatile gsize planify_cli_backup_arguments_type_id__once = 0;
	if (g_once_init_enter (&planify_cli_backup_arguments_type_id__once)) {
		GType planify_cli_backup_arguments_type_id;
		planify_cli_backup_arguments_type_id = planify_cli_backup_arguments_get_type_once ();
		g_once_init_leave (&planify_cli_backup_arguments_type_id__once, planify_cli_backup_arguments_type_id);
	}
	return planify_cli_backup_arguments_type_id__once;
}

static void
_vala_planify_cli_backup_arguments_get_property (GObject * object,
                                                 guint property_id,
                                                 GValue * value,
                                                 GParamSpec * pspec)
{
	PlanifyCLIBackupArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PLANIFY_CLI_TYPE_BACKUP_ARGUMENTS, PlanifyCLIBackupArguments);
	switch (property_id) {
		case PLANIFY_CLI_BACKUP_ARGUMENTS_OUTPUT_PROPERTY:
		g_value_set_string (value, planify_cli_backup_arguments_get_output (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_planify_cli_backup_arguments_set_property (GObject * object,
                                                 guint property_id,
                                                 const GValue * value,
                                                 GParamSpec * pspec)
{
	PlanifyCLIBackupArguments * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PLANIFY_CLI_TYPE_BACKUP_ARGUMENTS, PlanifyCLIBackupArguments);
	switch (property_id) {
		case PLANIFY_CLI_BACKUP_ARGUMENTS_OUTPUT_PROPERTY:
		planify_cli_backup_arguments_set_output (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
planify_cli_parsed_command_get_instance_private (PlanifyCLIParsedCommand* self)
{
	return G_STRUCT_MEMBER_P (self, PlanifyCLIParsedCommand_private_offset);
}

PlanifyCLIParsedCommand*
planify_cli_parsed_command_construct (GType object_type)
{
	PlanifyCLIParsedCommand * self = NULL;
	self = (PlanifyCLIParsedCommand*) g_object_new (object_type, NULL);
	return self;
}

PlanifyCLIParsedCommand*
planify_cli_parsed_command_new (void)
{
	return planify_cli_parsed_command_construct (PLANIFY_CLI_TYPE_PARSED_COMMAND);
}

PlanifyCLICommandType
planify_cli_parsed_command_get_command_type (PlanifyCLIParsedCommand* self)
{
	PlanifyCLICommandType result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_command_type;
	return result;
}

void
planify_cli_parsed_command_set_command_type (PlanifyCLIParsedCommand* self,
                                             PlanifyCLICommandType value)
{
	PlanifyCLICommandType old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_parsed_command_get_command_type (self);
	if (old_value != value) {
		self->priv->_command_type = value;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_parsed_command_properties[PLANIFY_CLI_PARSED_COMMAND_COMMAND_TYPE_PROPERTY]);
	}
}

PlanifyCLITaskArguments*
planify_cli_parsed_command_get_task_args (PlanifyCLIParsedCommand* self)
{
	PlanifyCLITaskArguments* result;
	PlanifyCLITaskArguments* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_task_args;
	result = _tmp0_;
	return result;
}

static gpointer
_g_object_ref0 (gpointer self)
{
	return self ? g_object_ref (self) : NULL;
}

void
planify_cli_parsed_command_set_task_args (PlanifyCLIParsedCommand* self,
                                          PlanifyCLITaskArguments* value)
{
	PlanifyCLITaskArguments* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_parsed_command_get_task_args (self);
	if (old_value != value) {
		PlanifyCLITaskArguments* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_task_args);
		self->priv->_task_args = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_parsed_command_properties[PLANIFY_CLI_PARSED_COMMAND_TASK_ARGS_PROPERTY]);
	}
}

PlanifyCLIListArguments*
planify_cli_parsed_command_get_list_args (PlanifyCLIParsedCommand* self)
{
	PlanifyCLIListArguments* result;
	PlanifyCLIListArguments* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_list_args;
	result = _tmp0_;
	return result;
}

void
planify_cli_parsed_command_set_list_args (PlanifyCLIParsedCommand* self,
                                          PlanifyCLIListArguments* value)
{
	PlanifyCLIListArguments* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_parsed_command_get_list_args (self);
	if (old_value != value) {
		PlanifyCLIListArguments* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_list_args);
		self->priv->_list_args = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_parsed_command_properties[PLANIFY_CLI_PARSED_COMMAND_LIST_ARGS_PROPERTY]);
	}
}

PlanifyCLIUpdateArguments*
planify_cli_parsed_command_get_update_args (PlanifyCLIParsedCommand* self)
{
	PlanifyCLIUpdateArguments* result;
	PlanifyCLIUpdateArguments* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_update_args;
	result = _tmp0_;
	return result;
}

void
planify_cli_parsed_command_set_update_args (PlanifyCLIParsedCommand* self,
                                            PlanifyCLIUpdateArguments* value)
{
	PlanifyCLIUpdateArguments* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_parsed_command_get_update_args (self);
	if (old_value != value) {
		PlanifyCLIUpdateArguments* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_update_args);
		self->priv->_update_args = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_parsed_command_properties[PLANIFY_CLI_PARSED_COMMAND_UPDATE_ARGS_PROPERTY]);
	}
}

PlanifyCLIBackupArguments*
planify_cli_parsed_command_get_backup_args (PlanifyCLIParsedCommand* self)
{
	PlanifyCLIBackupArguments* result;
	PlanifyCLIBackupArguments* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_backup_args;
	result = _tmp0_;
	return result;
}

void
planify_cli_parsed_command_set_backup_args (PlanifyCLIParsedCommand* self,
                                            PlanifyCLIBackupArguments* value)
{
	PlanifyCLIBackupArguments* old_value;
	g_return_if_fail (self != NULL);
	old_value = planify_cli_parsed_command_get_backup_args (self);
	if (old_value != value) {
		PlanifyCLIBackupArguments* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_backup_args);
		self->priv->_backup_args = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, planify_cli_parsed_command_properties[PLANIFY_CLI_PARSED_COMMAND_BACKUP_ARGS_PROPERTY]);
	}
}

static void
planify_cli_parsed_command_class_init (PlanifyCLIParsedCommandClass * klass,
                                       gpointer klass_data)
{
	planify_cli_parsed_command_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &PlanifyCLIParsedCommand_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_planify_cli_parsed_command_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_planify_cli_parsed_command_set_property;
	G_OBJECT_CLASS (klass)->finalize = planify_cli_parsed_command_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_PARSED_COMMAND_COMMAND_TYPE_PROPERTY, planify_cli_parsed_command_properties[PLANIFY_CLI_PARSED_COMMAND_COMMAND_TYPE_PROPERTY] = g_param_spec_enum ("command-type", "command-type", "command-type", PLANIFY_CLI_TYPE_COMMAND_TYPE, PLANIFY_CLI_COMMAND_TYPE_NONE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_PARSED_COMMAND_TASK_ARGS_PROPERTY, planify_cli_parsed_command_properties[PLANIFY_CLI_PARSED_COMMAND_TASK_ARGS_PROPERTY] = g_param_spec_object ("task-args", "task-args", "task-args", PLANIFY_CLI_TYPE_TASK_ARGUMENTS, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_PARSED_COMMAND_LIST_ARGS_PROPERTY, planify_cli_parsed_command_properties[PLANIFY_CLI_PARSED_COMMAND_LIST_ARGS_PROPERTY] = g_param_spec_object ("list-args", "list-args", "list-args", PLANIFY_CLI_TYPE_LIST_ARGUMENTS, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_PARSED_COMMAND_UPDATE_ARGS_PROPERTY, planify_cli_parsed_command_properties[PLANIFY_CLI_PARSED_COMMAND_UPDATE_ARGS_PROPERTY] = g_param_spec_object ("update-args", "update-args", "update-args", PLANIFY_CLI_TYPE_UPDATE_ARGUMENTS, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PLANIFY_CLI_PARSED_COMMAND_BACKUP_ARGS_PROPERTY, planify_cli_parsed_command_properties[PLANIFY_CLI_PARSED_COMMAND_BACKUP_ARGS_PROPERTY] = g_param_spec_object ("backup-args", "backup-args", "backup-args", PLANIFY_CLI_TYPE_BACKUP_ARGUMENTS, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
}

static void
planify_cli_parsed_command_instance_init (PlanifyCLIParsedCommand * self,
                                          gpointer klass)
{
	self->priv = planify_cli_parsed_command_get_instance_private (self);
	self->priv->_command_type = PLANIFY_CLI_COMMAND_TYPE_NONE;
	self->priv->_task_args = NULL;
	self->priv->_list_args = NULL;
	self->priv->_update_args = NULL;
	self->priv->_backup_args = NULL;
}

static void
planify_cli_parsed_command_finalize (GObject * obj)
{
	PlanifyCLIParsedCommand * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PLANIFY_CLI_TYPE_PARSED_COMMAND, PlanifyCLIParsedCommand);
	_g_object_unref0 (self->priv->_task_args);
	_g_object_unref0 (self->priv->_list_args);
	_g_object_unref0 (self->priv->_update_args);
	_g_object_unref0 (self->priv->_backup_args);
	G_OBJECT_CLASS (planify_cli_parsed_command_parent_class)->finalize (obj);
}

static GType
planify_cli_parsed_command_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (PlanifyCLIParsedCommandClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) planify_cli_parsed_command_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PlanifyCLIParsedCommand), 0, (GInstanceInitFunc) planify_cli_parsed_command_instance_init, NULL };
	GType planify_cli_parsed_command_type_id;
	planify_cli_parsed_command_type_id = g_type_register_static (G_TYPE_OBJECT, "PlanifyCLIParsedCommand", &g_define_type_info, 0);
	PlanifyCLIParsedCommand_private_offset = g_type_add_instance_private (planify_cli_parsed_command_type_id, sizeof (PlanifyCLIParsedCommandPrivate));
	return planify_cli_parsed_command_type_id;
}

GType
planify_cli_parsed_command_get_type (void)
{
	static volatile gsize planify_cli_parsed_command_type_id__once = 0;
	if (g_once_init_enter (&planify_cli_parsed_command_type_id__once)) {
		GType planify_cli_parsed_command_type_id;
		planify_cli_parsed_command_type_id = planify_cli_parsed_command_get_type_once ();
		g_once_init_leave (&planify_cli_parsed_command_type_id__once, planify_cli_parsed_command_type_id);
	}
	return planify_cli_parsed_command_type_id__once;
}

static void
_vala_planify_cli_parsed_command_get_property (GObject * object,
                                               guint property_id,
                                               GValue * value,
                                               GParamSpec * pspec)
{
	PlanifyCLIParsedCommand * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PLANIFY_CLI_TYPE_PARSED_COMMAND, PlanifyCLIParsedCommand);
	switch (property_id) {
		case PLANIFY_CLI_PARSED_COMMAND_COMMAND_TYPE_PROPERTY:
		g_value_set_enum (value, planify_cli_parsed_command_get_command_type (self));
		break;
		case PLANIFY_CLI_PARSED_COMMAND_TASK_ARGS_PROPERTY:
		g_value_set_object (value, planify_cli_parsed_command_get_task_args (self));
		break;
		case PLANIFY_CLI_PARSED_COMMAND_LIST_ARGS_PROPERTY:
		g_value_set_object (value, planify_cli_parsed_command_get_list_args (self));
		break;
		case PLANIFY_CLI_PARSED_COMMAND_UPDATE_ARGS_PROPERTY:
		g_value_set_object (value, planify_cli_parsed_command_get_update_args (self));
		break;
		case PLANIFY_CLI_PARSED_COMMAND_BACKUP_ARGS_PROPERTY:
		g_value_set_object (value, planify_cli_parsed_command_get_backup_args (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_planify_cli_parsed_command_set_property (GObject * object,
                                               guint property_id,
                                               const GValue * value,
                                               GParamSpec * pspec)
{
	PlanifyCLIParsedCommand * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PLANIFY_CLI_TYPE_PARSED_COMMAND, PlanifyCLIParsedCommand);
	switch (property_id) {
		case PLANIFY_CLI_PARSED_COMMAND_COMMAND_TYPE_PROPERTY:
		planify_cli_parsed_command_set_command_type (self, g_value_get_enum (value));
		break;
		case PLANIFY_CLI_PARSED_COMMAND_TASK_ARGS_PROPERTY:
		planify_cli_parsed_command_set_task_args (self, g_value_get_object (value));
		break;
		case PLANIFY_CLI_PARSED_COMMAND_LIST_ARGS_PROPERTY:
		planify_cli_parsed_command_set_list_args (self, g_value_get_object (value));
		break;
		case PLANIFY_CLI_PARSED_COMMAND_UPDATE_ARGS_PROPERTY:
		planify_cli_parsed_command_set_update_args (self, g_value_get_object (value));
		break;
		case PLANIFY_CLI_PARSED_COMMAND_BACKUP_ARGS_PROPERTY:
		planify_cli_parsed_command_set_backup_args (self, g_value_get_object (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

PlanifyCLIParsedCommand*
planify_cli_argument_parser_parse (gchar** args,
                                   gint args_length1,
                                   gint* exit_code)
{
	gint _vala_exit_code = 0;
	gboolean _tmp0_ = FALSE;
	gchar* command = NULL;
	const gchar* _tmp11_;
	gchar* _tmp12_;
	PlanifyCLIParsedCommand* parsed = NULL;
	PlanifyCLIParsedCommand* _tmp13_;
	gchar** command_args = NULL;
	gchar** _tmp14_;
	gint command_args_length1;
	gint _command_args_size_;
	gchar** _tmp15_;
	gint _tmp15__length1;
	const gchar* _tmp16_;
	gchar* _tmp17_;
	gchar* _tmp18_;
	const gchar* _tmp19_;
	gchar* _tmp20_;
	GError* _inner_error0_ = NULL;
	PlanifyCLIParsedCommand* result;
	_vala_exit_code = 0;
	if (args_length1 >= 2) {
		gboolean _tmp1_ = FALSE;
		const gchar* _tmp2_;
		_tmp2_ = args[1];
		if (g_strcmp0 (_tmp2_, "-h") == 0) {
			_tmp1_ = TRUE;
		} else {
			const gchar* _tmp3_;
			_tmp3_ = args[1];
			_tmp1_ = g_strcmp0 (_tmp3_, "--help") == 0;
		}
		_tmp0_ = _tmp1_;
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		const gchar* _tmp4_;
		_tmp4_ = args[0];
		planify_cli_argument_parser_print_general_help (_tmp4_);
		_vala_exit_code = 0;
		result = NULL;
		if (exit_code) {
			*exit_code = _vala_exit_code;
		}
		return result;
	}
	if (args_length1 < 2) {
		FILE* _tmp5_;
		FILE* _tmp6_;
		const gchar* _tmp7_;
		FILE* _tmp8_;
		FILE* _tmp9_;
		const gchar* _tmp10_;
		_tmp5_ = stderr;
		fprintf (_tmp5_, "Error: No command specified\n");
		_tmp6_ = stderr;
		_tmp7_ = args[0];
		fprintf (_tmp6_, "Usage: %s <command> [OPTIONS]\n", _tmp7_);
		_tmp8_ = stderr;
		fprintf (_tmp8_, "Commands: add, list, update, list-projects\n");
		_tmp9_ = stderr;
		_tmp10_ = args[0];
		fprintf (_tmp9_, "Run '%s --help' for more information\n", _tmp10_);
		_vala_exit_code = 1;
		result = NULL;
		if (exit_code) {
			*exit_code = _vala_exit_code;
		}
		return result;
	}
	_tmp11_ = args[1];
	_tmp12_ = g_strdup (_tmp11_);
	command = _tmp12_;
	_tmp13_ = planify_cli_parsed_command_new ();
	parsed = _tmp13_;
	_tmp14_ = g_new0 (gchar*, (args_length1 - 1) + 1);
	command_args = _tmp14_;
	command_args_length1 = args_length1 - 1;
	_command_args_size_ = command_args_length1;
	_tmp15_ = command_args;
	_tmp15__length1 = command_args_length1;
	_tmp16_ = args[0];
	_tmp17_ = g_strconcat (_tmp16_, " ", NULL);
	_tmp18_ = _tmp17_;
	_tmp19_ = command;
	_tmp20_ = g_strconcat (_tmp18_, _tmp19_, NULL);
	_g_free0 (_tmp15_[0]);
	_tmp15_[0] = _tmp20_;
	_g_free0 (_tmp18_);
	{
		gint i = 0;
		i = 2;
		{
			gboolean _tmp21_ = FALSE;
			_tmp21_ = TRUE;
			while (TRUE) {
				gchar** _tmp23_;
				gint _tmp23__length1;
				const gchar* _tmp24_;
				gchar* _tmp25_;
				if (!_tmp21_) {
					gint _tmp22_;
					_tmp22_ = i;
					i = _tmp22_ + 1;
				}
				_tmp21_ = FALSE;
				if (!(i < args_length1)) {
					break;
				}
				_tmp23_ = command_args;
				_tmp23__length1 = command_args_length1;
				_tmp24_ = args[i];
				_tmp25_ = g_strdup (_tmp24_);
				_g_free0 (_tmp23_[i - 1]);
				_tmp23_[i - 1] = _tmp25_;
			}
		}
	}
	{
		const gchar* _tmp26_;
		const gchar* _tmp27_;
		GQuark _tmp29_ = 0U;
		static GQuark _tmp28_label0 = 0;
		static GQuark _tmp28_label1 = 0;
		static GQuark _tmp28_label2 = 0;
		static GQuark _tmp28_label3 = 0;
		static GQuark _tmp28_label4 = 0;
		_tmp26_ = command;
		_tmp27_ = _tmp26_;
		_tmp29_ = (NULL == _tmp27_) ? 0 : g_quark_from_string (_tmp27_);
		if (_tmp29_ == ((0 != _tmp28_label0) ? _tmp28_label0 : (_tmp28_label0 = g_quark_from_static_string ("list-projects")))) {
			switch (0) {
				default:
				{
					PlanifyCLIParsedCommand* _tmp30_;
					_tmp30_ = parsed;
					planify_cli_parsed_command_set_command_type (_tmp30_, PLANIFY_CLI_COMMAND_TYPE_LIST_PROJECTS);
					result = parsed;
					command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
					_g_free0 (command);
					if (exit_code) {
						*exit_code = _vala_exit_code;
					}
					return result;
				}
			}
		} else if (_tmp29_ == ((0 != _tmp28_label1) ? _tmp28_label1 : (_tmp28_label1 = g_quark_from_static_string ("list")))) {
			switch (0) {
				default:
				{
					PlanifyCLIParsedCommand* _tmp31_;
					PlanifyCLIListArguments* _tmp32_ = NULL;
					gchar** _tmp33_;
					gint _tmp33__length1;
					PlanifyCLIListArguments* _tmp34_;
					PlanifyCLIParsedCommand* _tmp35_;
					_tmp31_ = parsed;
					planify_cli_parsed_command_set_command_type (_tmp31_, PLANIFY_CLI_COMMAND_TYPE_LIST);
					_tmp33_ = command_args;
					_tmp33__length1 = command_args_length1;
					_tmp34_ = planify_cli_argument_parser_parse_list_command (_tmp33_, (gint) _tmp33__length1, &_inner_error0_);
					_tmp32_ = _tmp34_;
					if (G_UNLIKELY (_inner_error0_ != NULL)) {
						if (_inner_error0_->domain == G_OPTION_ERROR) {
							goto __catch0_g_option_error;
						}
						command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
						_g_object_unref0 (parsed);
						_g_free0 (command);
						g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
						g_clear_error (&_inner_error0_);
						return NULL;
					}
					_tmp35_ = parsed;
					planify_cli_parsed_command_set_list_args (_tmp35_, _tmp32_);
					result = parsed;
					_g_object_unref0 (_tmp32_);
					command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
					_g_free0 (command);
					if (exit_code) {
						*exit_code = _vala_exit_code;
					}
					return result;
				}
			}
		} else if (_tmp29_ == ((0 != _tmp28_label2) ? _tmp28_label2 : (_tmp28_label2 = g_quark_from_static_string ("add")))) {
			switch (0) {
				default:
				{
					PlanifyCLIParsedCommand* _tmp36_;
					PlanifyCLITaskArguments* _tmp37_ = NULL;
					gchar** _tmp38_;
					gint _tmp38__length1;
					PlanifyCLITaskArguments* _tmp39_;
					PlanifyCLIParsedCommand* _tmp40_;
					_tmp36_ = parsed;
					planify_cli_parsed_command_set_command_type (_tmp36_, PLANIFY_CLI_COMMAND_TYPE_ADD);
					_tmp38_ = command_args;
					_tmp38__length1 = command_args_length1;
					_tmp39_ = planify_cli_argument_parser_parse_add_command (_tmp38_, (gint) _tmp38__length1, &_inner_error0_);
					_tmp37_ = _tmp39_;
					if (G_UNLIKELY (_inner_error0_ != NULL)) {
						if (_inner_error0_->domain == G_OPTION_ERROR) {
							goto __catch0_g_option_error;
						}
						command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
						_g_object_unref0 (parsed);
						_g_free0 (command);
						g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
						g_clear_error (&_inner_error0_);
						return NULL;
					}
					_tmp40_ = parsed;
					planify_cli_parsed_command_set_task_args (_tmp40_, _tmp37_);
					result = parsed;
					_g_object_unref0 (_tmp37_);
					command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
					_g_free0 (command);
					if (exit_code) {
						*exit_code = _vala_exit_code;
					}
					return result;
				}
			}
		} else if (_tmp29_ == ((0 != _tmp28_label3) ? _tmp28_label3 : (_tmp28_label3 = g_quark_from_static_string ("update")))) {
			switch (0) {
				default:
				{
					PlanifyCLIParsedCommand* _tmp41_;
					PlanifyCLIUpdateArguments* _tmp42_ = NULL;
					gchar** _tmp43_;
					gint _tmp43__length1;
					PlanifyCLIUpdateArguments* _tmp44_;
					PlanifyCLIParsedCommand* _tmp45_;
					_tmp41_ = parsed;
					planify_cli_parsed_command_set_command_type (_tmp41_, PLANIFY_CLI_COMMAND_TYPE_UPDATE);
					_tmp43_ = command_args;
					_tmp43__length1 = command_args_length1;
					_tmp44_ = planify_cli_argument_parser_parse_update_command (_tmp43_, (gint) _tmp43__length1, &_inner_error0_);
					_tmp42_ = _tmp44_;
					if (G_UNLIKELY (_inner_error0_ != NULL)) {
						if (_inner_error0_->domain == G_OPTION_ERROR) {
							goto __catch0_g_option_error;
						}
						command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
						_g_object_unref0 (parsed);
						_g_free0 (command);
						g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
						g_clear_error (&_inner_error0_);
						return NULL;
					}
					_tmp45_ = parsed;
					planify_cli_parsed_command_set_update_args (_tmp45_, _tmp42_);
					result = parsed;
					_g_object_unref0 (_tmp42_);
					command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
					_g_free0 (command);
					if (exit_code) {
						*exit_code = _vala_exit_code;
					}
					return result;
				}
			}
		} else if (_tmp29_ == ((0 != _tmp28_label4) ? _tmp28_label4 : (_tmp28_label4 = g_quark_from_static_string ("backup")))) {
			switch (0) {
				default:
				{
					PlanifyCLIParsedCommand* _tmp46_;
					PlanifyCLIBackupArguments* _tmp47_ = NULL;
					gchar** _tmp48_;
					gint _tmp48__length1;
					PlanifyCLIBackupArguments* _tmp49_;
					PlanifyCLIParsedCommand* _tmp50_;
					_tmp46_ = parsed;
					planify_cli_parsed_command_set_command_type (_tmp46_, PLANIFY_CLI_COMMAND_TYPE_BACKUP);
					_tmp48_ = command_args;
					_tmp48__length1 = command_args_length1;
					_tmp49_ = planify_cli_argument_parser_parse_backup_command (_tmp48_, (gint) _tmp48__length1, &_inner_error0_);
					_tmp47_ = _tmp49_;
					if (G_UNLIKELY (_inner_error0_ != NULL)) {
						if (_inner_error0_->domain == G_OPTION_ERROR) {
							goto __catch0_g_option_error;
						}
						command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
						_g_object_unref0 (parsed);
						_g_free0 (command);
						g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
						g_clear_error (&_inner_error0_);
						return NULL;
					}
					_tmp50_ = parsed;
					planify_cli_parsed_command_set_backup_args (_tmp50_, _tmp47_);
					result = parsed;
					_g_object_unref0 (_tmp47_);
					command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
					_g_free0 (command);
					if (exit_code) {
						*exit_code = _vala_exit_code;
					}
					return result;
				}
			}
		} else {
			switch (0) {
				default:
				{
					FILE* _tmp51_;
					const gchar* _tmp52_;
					FILE* _tmp53_;
					_tmp51_ = stderr;
					_tmp52_ = command;
					fprintf (_tmp51_, "Error: Unknown command '%s'\n", _tmp52_);
					_tmp53_ = stderr;
					fprintf (_tmp53_, "Available commands: add, list, update, list-projects, backup\n");
					_vala_exit_code = 1;
					result = NULL;
					command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
					_g_object_unref0 (parsed);
					_g_free0 (command);
					if (exit_code) {
						*exit_code = _vala_exit_code;
					}
					return result;
				}
			}
		}
	}
	goto __finally0;
	__catch0_g_option_error:
	{
		GError* e = NULL;
		FILE* _tmp54_;
		GError* _tmp55_;
		const gchar* _tmp56_;
		e = _inner_error0_;
		_inner_error0_ = NULL;
		_tmp54_ = stderr;
		_tmp55_ = e;
		_tmp56_ = _tmp55_->message;
		fprintf (_tmp54_, "Error: %s\n", _tmp56_);
		_vala_exit_code = 1;
		result = NULL;
		_g_error_free0 (e);
		command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
		_g_object_unref0 (parsed);
		_g_free0 (command);
		if (exit_code) {
			*exit_code = _vala_exit_code;
		}
		return result;
	}
	__finally0:
	command_args = (_vala_array_free (command_args, command_args_length1, (GDestroyNotify) g_free), NULL);
	_g_object_unref0 (parsed);
	_g_free0 (command);
	g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
	g_clear_error (&_inner_error0_);
	return NULL;
}

static PlanifyCLIListArguments*
planify_cli_argument_parser_parse_list_command (gchar** args,
                                                gint args_length1,
                                                GError** error)
{
	gchar* project_name = NULL;
	gchar* project_id = NULL;
	GOptionEntry* options = NULL;
	GOptionEntry* _tmp0_;
	gint options_length1;
	gint _options_size_;
	GOptionEntry _tmp1_ = {0};
	GOptionEntry _tmp2_ = {0};
	GOptionEntry _tmp3_ = {0};
	GOptionContext* context = NULL;
	GOptionContext* _tmp4_;
	gchar** tmp = NULL;
	gint tmp_length1;
	gint _tmp_size_;
	PlanifyCLIListArguments* list_args = NULL;
	PlanifyCLIListArguments* _tmp5_;
	PlanifyCLIListArguments* _tmp6_;
	PlanifyCLIListArguments* _tmp7_;
	GError* _inner_error0_ = NULL;
	PlanifyCLIListArguments* result;
	project_name = NULL;
	project_id = NULL;
	_tmp0_ = g_new0 (GOptionEntry, 3);
	options = _tmp0_;
	options_length1 = 3;
	_options_size_ = options_length1;
	_tmp1_.long_name = "project";
	_tmp1_.short_name = 'p';
	_tmp1_.flags = (gint) 0;
	_tmp1_.arg = G_OPTION_ARG_STRING;
	_tmp1_.arg_data = &project_name;
	_tmp1_.description = "Project name (defaults to inbox)";
	_tmp1_.arg_description = "PROJECT";
	options[0] = _tmp1_;
	_tmp2_.long_name = "project-id";
	_tmp2_.short_name = 'i';
	_tmp2_.flags = (gint) 0;
	_tmp2_.arg = G_OPTION_ARG_STRING;
	_tmp2_.arg_data = &project_id;
	_tmp2_.description = "Project ID (preferred over name)";
	_tmp2_.arg_description = "ID";
	options[1] = _tmp2_;
	_tmp3_.long_name = NULL;
	options[2] = _tmp3_;
	_tmp4_ = g_option_context_new ("- List tasks from a project");
	context = _tmp4_;
	g_option_context_add_main_entries (context, options, NULL);
	g_option_context_set_help_enabled (context, TRUE);
	tmp = args;
	tmp_length1 = args_length1;
	_tmp_size_ = tmp_length1;
	g_option_context_parse (context, (gint*) (&tmp_length1), &tmp, &_inner_error0_);
	_tmp_size_ = tmp_length1;
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		if (_inner_error0_->domain == G_OPTION_ERROR) {
			g_propagate_error (error, _inner_error0_);
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (project_id);
			_g_free0 (project_name);
			return NULL;
		} else {
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (project_id);
			_g_free0 (project_name);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return NULL;
		}
	}
	_tmp5_ = planify_cli_list_arguments_new ();
	list_args = _tmp5_;
	_tmp6_ = list_args;
	planify_cli_list_arguments_set_project_name (_tmp6_, project_name);
	_tmp7_ = list_args;
	planify_cli_list_arguments_set_project_id (_tmp7_, project_id);
	result = list_args;
	_g_option_context_free0 (context);
	options = (g_free (options), NULL);
	_g_free0 (project_id);
	_g_free0 (project_name);
	return result;
}

static PlanifyCLITaskArguments*
planify_cli_argument_parser_parse_add_command (gchar** args,
                                               gint args_length1,
                                               GError** error)
{
	gchar* content = NULL;
	gchar* description = NULL;
	gchar* project_name = NULL;
	gchar* project_id = NULL;
	gchar* section_name = NULL;
	gchar* section_id = NULL;
	gchar* parent_id = NULL;
	gint priority = 0;
	gchar* due_date = NULL;
	gchar* labels = NULL;
	gchar* pin_str = NULL;
	GOptionEntry* options = NULL;
	GOptionEntry* _tmp0_;
	gint options_length1;
	gint _options_size_;
	GOptionEntry* _tmp1_;
	gint _tmp1__length1;
	GOptionEntry _tmp2_ = {0};
	GOptionEntry* _tmp3_;
	gint _tmp3__length1;
	GOptionEntry _tmp4_ = {0};
	GOptionEntry* _tmp5_;
	gint _tmp5__length1;
	GOptionEntry _tmp6_ = {0};
	GOptionEntry* _tmp7_;
	gint _tmp7__length1;
	GOptionEntry _tmp8_ = {0};
	GOptionEntry* _tmp9_;
	gint _tmp9__length1;
	GOptionEntry _tmp10_ = {0};
	GOptionEntry* _tmp11_;
	gint _tmp11__length1;
	GOptionEntry _tmp12_ = {0};
	GOptionEntry* _tmp13_;
	gint _tmp13__length1;
	GOptionEntry _tmp14_ = {0};
	GOptionEntry* _tmp15_;
	gint _tmp15__length1;
	GOptionEntry _tmp16_ = {0};
	GOptionEntry* _tmp17_;
	gint _tmp17__length1;
	GOptionEntry _tmp18_ = {0};
	GOptionEntry* _tmp19_;
	gint _tmp19__length1;
	GOptionEntry _tmp20_ = {0};
	GOptionEntry* _tmp21_;
	gint _tmp21__length1;
	GOptionEntry _tmp22_ = {0};
	GOptionEntry* _tmp23_;
	gint _tmp23__length1;
	GOptionEntry _tmp24_ = {0};
	GOptionContext* context = NULL;
	GOptionContext* _tmp25_;
	GOptionContext* _tmp26_;
	GOptionEntry* _tmp27_;
	gint _tmp27__length1;
	GOptionContext* _tmp28_;
	gchar** tmp = NULL;
	gint tmp_length1;
	gint _tmp_size_;
	GOptionContext* _tmp29_;
	PlanifyCLITaskArguments* task_args = NULL;
	PlanifyCLITaskArguments* _tmp30_;
	PlanifyCLITaskArguments* _tmp31_;
	const gchar* _tmp32_;
	PlanifyCLITaskArguments* _tmp33_;
	const gchar* _tmp34_;
	PlanifyCLITaskArguments* _tmp35_;
	const gchar* _tmp36_;
	PlanifyCLITaskArguments* _tmp37_;
	const gchar* _tmp38_;
	PlanifyCLITaskArguments* _tmp39_;
	const gchar* _tmp40_;
	PlanifyCLITaskArguments* _tmp41_;
	const gchar* _tmp42_;
	PlanifyCLITaskArguments* _tmp43_;
	const gchar* _tmp44_;
	PlanifyCLITaskArguments* _tmp45_;
	PlanifyCLITaskArguments* _tmp46_;
	const gchar* _tmp47_;
	PlanifyCLITaskArguments* _tmp48_;
	const gchar* _tmp49_;
	gint _tmp50_ = 0;
	const gchar* _tmp51_;
	PlanifyCLITaskArguments* _tmp52_;
	GError* _inner_error0_ = NULL;
	PlanifyCLITaskArguments* result;
	content = NULL;
	description = NULL;
	project_name = NULL;
	project_id = NULL;
	section_name = NULL;
	section_id = NULL;
	parent_id = NULL;
	priority = 4;
	due_date = NULL;
	labels = NULL;
	pin_str = NULL;
	_tmp0_ = g_new0 (GOptionEntry, 12);
	options = _tmp0_;
	options_length1 = 12;
	_options_size_ = options_length1;
	_tmp1_ = options;
	_tmp1__length1 = options_length1;
	_tmp2_.long_name = "content";
	_tmp2_.short_name = 'c';
	_tmp2_.flags = (gint) 0;
	_tmp2_.arg = G_OPTION_ARG_STRING;
	_tmp2_.arg_data = &content;
	_tmp2_.description = "Task content (required)";
	_tmp2_.arg_description = "CONTENT";
	_tmp1_[0] = _tmp2_;
	_tmp3_ = options;
	_tmp3__length1 = options_length1;
	_tmp4_.long_name = "description";
	_tmp4_.short_name = 'd';
	_tmp4_.flags = (gint) 0;
	_tmp4_.arg = G_OPTION_ARG_STRING;
	_tmp4_.arg_data = &description;
	_tmp4_.description = "Task description";
	_tmp4_.arg_description = "DESC";
	_tmp3_[1] = _tmp4_;
	_tmp5_ = options;
	_tmp5__length1 = options_length1;
	_tmp6_.long_name = "project";
	_tmp6_.short_name = 'p';
	_tmp6_.flags = (gint) 0;
	_tmp6_.arg = G_OPTION_ARG_STRING;
	_tmp6_.arg_data = &project_name;
	_tmp6_.description = "Project name (defaults to inbox)";
	_tmp6_.arg_description = "PROJECT";
	_tmp5_[2] = _tmp6_;
	_tmp7_ = options;
	_tmp7__length1 = options_length1;
	_tmp8_.long_name = "project-id";
	_tmp8_.short_name = 'i';
	_tmp8_.flags = (gint) 0;
	_tmp8_.arg = G_OPTION_ARG_STRING;
	_tmp8_.arg_data = &project_id;
	_tmp8_.description = "Project ID (preferred over name)";
	_tmp8_.arg_description = "ID";
	_tmp7_[3] = _tmp8_;
	_tmp9_ = options;
	_tmp9__length1 = options_length1;
	_tmp10_.long_name = "section";
	_tmp10_.short_name = 's';
	_tmp10_.flags = (gint) 0;
	_tmp10_.arg = G_OPTION_ARG_STRING;
	_tmp10_.arg_data = &section_name;
	_tmp10_.description = "Section name";
	_tmp10_.arg_description = "SECTION";
	_tmp9_[4] = _tmp10_;
	_tmp11_ = options;
	_tmp11__length1 = options_length1;
	_tmp12_.long_name = "section-id";
	_tmp12_.short_name = 'S';
	_tmp12_.flags = (gint) 0;
	_tmp12_.arg = G_OPTION_ARG_STRING;
	_tmp12_.arg_data = &section_id;
	_tmp12_.description = "Section ID (preferred over name)";
	_tmp12_.arg_description = "ID";
	_tmp11_[5] = _tmp12_;
	_tmp13_ = options;
	_tmp13__length1 = options_length1;
	_tmp14_.long_name = "parent-id";
	_tmp14_.short_name = 'a';
	_tmp14_.flags = (gint) 0;
	_tmp14_.arg = G_OPTION_ARG_STRING;
	_tmp14_.arg_data = &parent_id;
	_tmp14_.description = "Parent task ID (creates a subtask)";
	_tmp14_.arg_description = "ID";
	_tmp13_[6] = _tmp14_;
	_tmp15_ = options;
	_tmp15__length1 = options_length1;
	_tmp16_.long_name = "priority";
	_tmp16_.short_name = 'P';
	_tmp16_.flags = (gint) 0;
	_tmp16_.arg = G_OPTION_ARG_INT;
	_tmp16_.arg_data = &priority;
	_tmp16_.description = "Priority: 1=high, 2=medium, 3=low, 4=none (default: 4)";
	_tmp16_.arg_description = "1-4";
	_tmp15_[7] = _tmp16_;
	_tmp17_ = options;
	_tmp17__length1 = options_length1;
	_tmp18_.long_name = "due";
	_tmp18_.short_name = 'D';
	_tmp18_.flags = (gint) 0;
	_tmp18_.arg = G_OPTION_ARG_STRING;
	_tmp18_.arg_data = &due_date;
	_tmp18_.description = "Due date in YYYY-MM-DD format";
	_tmp18_.arg_description = "DATE";
	_tmp17_[8] = _tmp18_;
	_tmp19_ = options;
	_tmp19__length1 = options_length1;
	_tmp20_.long_name = "labels";
	_tmp20_.short_name = 'l';
	_tmp20_.flags = (gint) 0;
	_tmp20_.arg = G_OPTION_ARG_STRING;
	_tmp20_.arg_data = &labels;
	_tmp20_.description = "Comma-separated list of label names";
	_tmp20_.arg_description = "LABELS";
	_tmp19_[9] = _tmp20_;
	_tmp21_ = options;
	_tmp21__length1 = options_length1;
	_tmp22_.long_name = "pin";
	_tmp22_.short_name = (gchar) 0;
	_tmp22_.flags = (gint) 0;
	_tmp22_.arg = G_OPTION_ARG_STRING;
	_tmp22_.arg_data = &pin_str;
	_tmp22_.description = "Pin or unpin the task";
	_tmp22_.arg_description = "true|false";
	_tmp21_[10] = _tmp22_;
	_tmp23_ = options;
	_tmp23__length1 = options_length1;
	_tmp24_.long_name = NULL;
	_tmp23_[11] = _tmp24_;
	_tmp25_ = g_option_context_new ("- Add a new task to Planify");
	context = _tmp25_;
	_tmp26_ = context;
	_tmp27_ = options;
	_tmp27__length1 = options_length1;
	g_option_context_add_main_entries (_tmp26_, _tmp27_, NULL);
	_tmp28_ = context;
	g_option_context_set_help_enabled (_tmp28_, TRUE);
	tmp = args;
	tmp_length1 = args_length1;
	_tmp_size_ = tmp_length1;
	_tmp29_ = context;
	g_option_context_parse (_tmp29_, (gint*) (&tmp_length1), &tmp, &_inner_error0_);
	_tmp_size_ = tmp_length1;
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		if (_inner_error0_->domain == G_OPTION_ERROR) {
			g_propagate_error (error, _inner_error0_);
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (pin_str);
			_g_free0 (labels);
			_g_free0 (due_date);
			_g_free0 (parent_id);
			_g_free0 (section_id);
			_g_free0 (section_name);
			_g_free0 (project_id);
			_g_free0 (project_name);
			_g_free0 (description);
			_g_free0 (content);
			return NULL;
		} else {
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (pin_str);
			_g_free0 (labels);
			_g_free0 (due_date);
			_g_free0 (parent_id);
			_g_free0 (section_id);
			_g_free0 (section_name);
			_g_free0 (project_id);
			_g_free0 (project_name);
			_g_free0 (description);
			_g_free0 (content);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return NULL;
		}
	}
	_tmp30_ = planify_cli_task_arguments_new ();
	task_args = _tmp30_;
	_tmp31_ = task_args;
	_tmp32_ = content;
	planify_cli_task_arguments_set_content (_tmp31_, _tmp32_);
	_tmp33_ = task_args;
	_tmp34_ = description;
	planify_cli_task_arguments_set_description (_tmp33_, _tmp34_);
	_tmp35_ = task_args;
	_tmp36_ = project_name;
	planify_cli_task_arguments_set_project_name (_tmp35_, _tmp36_);
	_tmp37_ = task_args;
	_tmp38_ = project_id;
	planify_cli_task_arguments_set_project_id (_tmp37_, _tmp38_);
	_tmp39_ = task_args;
	_tmp40_ = section_name;
	planify_cli_task_arguments_set_section_name (_tmp39_, _tmp40_);
	_tmp41_ = task_args;
	_tmp42_ = section_id;
	planify_cli_task_arguments_set_section_id (_tmp41_, _tmp42_);
	_tmp43_ = task_args;
	_tmp44_ = parent_id;
	planify_cli_task_arguments_set_parent_id (_tmp43_, _tmp44_);
	_tmp45_ = task_args;
	planify_cli_task_arguments_set_priority (_tmp45_, priority);
	_tmp46_ = task_args;
	_tmp47_ = due_date;
	planify_cli_task_arguments_set_due_date (_tmp46_, _tmp47_);
	_tmp48_ = task_args;
	_tmp49_ = labels;
	planify_cli_task_arguments_set_labels (_tmp48_, _tmp49_);
	_tmp51_ = pin_str;
	_tmp50_ = planify_cli_argument_parser_parse_boolean_option (_tmp51_, &_inner_error0_);
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		if (_inner_error0_->domain == G_OPTION_ERROR) {
			g_propagate_error (error, _inner_error0_);
			_g_object_unref0 (task_args);
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (pin_str);
			_g_free0 (labels);
			_g_free0 (due_date);
			_g_free0 (parent_id);
			_g_free0 (section_id);
			_g_free0 (section_name);
			_g_free0 (project_id);
			_g_free0 (project_name);
			_g_free0 (description);
			_g_free0 (content);
			return NULL;
		} else {
			_g_object_unref0 (task_args);
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (pin_str);
			_g_free0 (labels);
			_g_free0 (due_date);
			_g_free0 (parent_id);
			_g_free0 (section_id);
			_g_free0 (section_name);
			_g_free0 (project_id);
			_g_free0 (project_name);
			_g_free0 (description);
			_g_free0 (content);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return NULL;
		}
	}
	_tmp52_ = task_args;
	planify_cli_task_arguments_set_pinned (_tmp52_, _tmp50_);
	result = task_args;
	_g_option_context_free0 (context);
	options = (g_free (options), NULL);
	_g_free0 (pin_str);
	_g_free0 (labels);
	_g_free0 (due_date);
	_g_free0 (parent_id);
	_g_free0 (section_id);
	_g_free0 (section_name);
	_g_free0 (project_id);
	_g_free0 (project_name);
	_g_free0 (description);
	_g_free0 (content);
	return result;
}

static PlanifyCLIUpdateArguments*
planify_cli_argument_parser_parse_update_command (gchar** args,
                                                  gint args_length1,
                                                  GError** error)
{
	gchar* task_id = NULL;
	gchar* content = NULL;
	gchar* description = NULL;
	gchar* project_name = NULL;
	gchar* project_id = NULL;
	gchar* section_name = NULL;
	gchar* section_id = NULL;
	gchar* parent_id = NULL;
	gint priority = 0;
	gchar* due_date = NULL;
	gchar* labels = NULL;
	gchar* complete_str = NULL;
	gchar* pin_str = NULL;
	GOptionEntry* options = NULL;
	GOptionEntry* _tmp0_;
	gint options_length1;
	gint _options_size_;
	GOptionEntry* _tmp1_;
	gint _tmp1__length1;
	GOptionEntry _tmp2_ = {0};
	GOptionEntry* _tmp3_;
	gint _tmp3__length1;
	GOptionEntry _tmp4_ = {0};
	GOptionEntry* _tmp5_;
	gint _tmp5__length1;
	GOptionEntry _tmp6_ = {0};
	GOptionEntry* _tmp7_;
	gint _tmp7__length1;
	GOptionEntry _tmp8_ = {0};
	GOptionEntry* _tmp9_;
	gint _tmp9__length1;
	GOptionEntry _tmp10_ = {0};
	GOptionEntry* _tmp11_;
	gint _tmp11__length1;
	GOptionEntry _tmp12_ = {0};
	GOptionEntry* _tmp13_;
	gint _tmp13__length1;
	GOptionEntry _tmp14_ = {0};
	GOptionEntry* _tmp15_;
	gint _tmp15__length1;
	GOptionEntry _tmp16_ = {0};
	GOptionEntry* _tmp17_;
	gint _tmp17__length1;
	GOptionEntry _tmp18_ = {0};
	GOptionEntry* _tmp19_;
	gint _tmp19__length1;
	GOptionEntry _tmp20_ = {0};
	GOptionEntry* _tmp21_;
	gint _tmp21__length1;
	GOptionEntry _tmp22_ = {0};
	GOptionEntry* _tmp23_;
	gint _tmp23__length1;
	GOptionEntry _tmp24_ = {0};
	GOptionEntry* _tmp25_;
	gint _tmp25__length1;
	GOptionEntry _tmp26_ = {0};
	GOptionEntry* _tmp27_;
	gint _tmp27__length1;
	GOptionEntry _tmp28_ = {0};
	GOptionContext* context = NULL;
	GOptionContext* _tmp29_;
	GOptionContext* _tmp30_;
	GOptionEntry* _tmp31_;
	gint _tmp31__length1;
	GOptionContext* _tmp32_;
	gchar** tmp = NULL;
	gint tmp_length1;
	gint _tmp_size_;
	GOptionContext* _tmp33_;
	PlanifyCLIUpdateArguments* update_args = NULL;
	PlanifyCLIUpdateArguments* _tmp34_;
	PlanifyCLIUpdateArguments* _tmp35_;
	const gchar* _tmp36_;
	PlanifyCLIUpdateArguments* _tmp37_;
	const gchar* _tmp38_;
	PlanifyCLIUpdateArguments* _tmp39_;
	const gchar* _tmp40_;
	PlanifyCLIUpdateArguments* _tmp41_;
	const gchar* _tmp42_;
	PlanifyCLIUpdateArguments* _tmp43_;
	const gchar* _tmp44_;
	PlanifyCLIUpdateArguments* _tmp45_;
	const gchar* _tmp46_;
	PlanifyCLIUpdateArguments* _tmp47_;
	const gchar* _tmp48_;
	PlanifyCLIUpdateArguments* _tmp49_;
	const gchar* _tmp50_;
	PlanifyCLIUpdateArguments* _tmp51_;
	PlanifyCLIUpdateArguments* _tmp52_;
	const gchar* _tmp53_;
	PlanifyCLIUpdateArguments* _tmp54_;
	const gchar* _tmp55_;
	gint _tmp56_ = 0;
	const gchar* _tmp57_;
	PlanifyCLIUpdateArguments* _tmp58_;
	gint _tmp59_ = 0;
	const gchar* _tmp60_;
	PlanifyCLIUpdateArguments* _tmp61_;
	GError* _inner_error0_ = NULL;
	PlanifyCLIUpdateArguments* result;
	task_id = NULL;
	content = NULL;
	description = NULL;
	project_name = NULL;
	project_id = NULL;
	section_name = NULL;
	section_id = NULL;
	parent_id = NULL;
	priority = -1;
	due_date = NULL;
	labels = NULL;
	complete_str = NULL;
	pin_str = NULL;
	_tmp0_ = g_new0 (GOptionEntry, 14);
	options = _tmp0_;
	options_length1 = 14;
	_options_size_ = options_length1;
	_tmp1_ = options;
	_tmp1__length1 = options_length1;
	_tmp2_.long_name = "task-id";
	_tmp2_.short_name = 't';
	_tmp2_.flags = (gint) 0;
	_tmp2_.arg = G_OPTION_ARG_STRING;
	_tmp2_.arg_data = &task_id;
	_tmp2_.description = "Task ID to update (required)";
	_tmp2_.arg_description = "ID";
	_tmp1_[0] = _tmp2_;
	_tmp3_ = options;
	_tmp3__length1 = options_length1;
	_tmp4_.long_name = "content";
	_tmp4_.short_name = 'c';
	_tmp4_.flags = (gint) 0;
	_tmp4_.arg = G_OPTION_ARG_STRING;
	_tmp4_.arg_data = &content;
	_tmp4_.description = "New task content";
	_tmp4_.arg_description = "CONTENT";
	_tmp3_[1] = _tmp4_;
	_tmp5_ = options;
	_tmp5__length1 = options_length1;
	_tmp6_.long_name = "description";
	_tmp6_.short_name = 'd';
	_tmp6_.flags = (gint) 0;
	_tmp6_.arg = G_OPTION_ARG_STRING;
	_tmp6_.arg_data = &description;
	_tmp6_.description = "New task description";
	_tmp6_.arg_description = "DESC";
	_tmp5_[2] = _tmp6_;
	_tmp7_ = options;
	_tmp7__length1 = options_length1;
	_tmp8_.long_name = "project";
	_tmp8_.short_name = 'p';
	_tmp8_.flags = (gint) 0;
	_tmp8_.arg = G_OPTION_ARG_STRING;
	_tmp8_.arg_data = &project_name;
	_tmp8_.description = "Move to project by name";
	_tmp8_.arg_description = "PROJECT";
	_tmp7_[3] = _tmp8_;
	_tmp9_ = options;
	_tmp9__length1 = options_length1;
	_tmp10_.long_name = "project-id";
	_tmp10_.short_name = 'i';
	_tmp10_.flags = (gint) 0;
	_tmp10_.arg = G_OPTION_ARG_STRING;
	_tmp10_.arg_data = &project_id;
	_tmp10_.description = "Move to project by ID (preferred over name)";
	_tmp10_.arg_description = "ID";
	_tmp9_[4] = _tmp10_;
	_tmp11_ = options;
	_tmp11__length1 = options_length1;
	_tmp12_.long_name = "section";
	_tmp12_.short_name = 's';
	_tmp12_.flags = (gint) 0;
	_tmp12_.arg = G_OPTION_ARG_STRING;
	_tmp12_.arg_data = &section_name;
	_tmp12_.description = "Section name";
	_tmp12_.arg_description = "SECTION";
	_tmp11_[5] = _tmp12_;
	_tmp13_ = options;
	_tmp13__length1 = options_length1;
	_tmp14_.long_name = "section-id";
	_tmp14_.short_name = 'S';
	_tmp14_.flags = (gint) 0;
	_tmp14_.arg = G_OPTION_ARG_STRING;
	_tmp14_.arg_data = &section_id;
	_tmp14_.description = "Section ID (preferred over name)";
	_tmp14_.arg_description = "ID";
	_tmp13_[6] = _tmp14_;
	_tmp15_ = options;
	_tmp15__length1 = options_length1;
	_tmp16_.long_name = "parent-id";
	_tmp16_.short_name = 'a';
	_tmp16_.flags = (gint) 0;
	_tmp16_.arg = G_OPTION_ARG_STRING;
	_tmp16_.arg_data = &parent_id;
	_tmp16_.description = "New parent task ID";
	_tmp16_.arg_description = "ID";
	_tmp15_[7] = _tmp16_;
	_tmp17_ = options;
	_tmp17__length1 = options_length1;
	_tmp18_.long_name = "priority";
	_tmp18_.short_name = 'P';
	_tmp18_.flags = (gint) 0;
	_tmp18_.arg = G_OPTION_ARG_INT;
	_tmp18_.arg_data = &priority;
	_tmp18_.description = "Priority: 1=high, 2=medium, 3=low, 4=none";
	_tmp18_.arg_description = "1-4";
	_tmp17_[8] = _tmp18_;
	_tmp19_ = options;
	_tmp19__length1 = options_length1;
	_tmp20_.long_name = "due";
	_tmp20_.short_name = 'D';
	_tmp20_.flags = (gint) 0;
	_tmp20_.arg = G_OPTION_ARG_STRING;
	_tmp20_.arg_data = &due_date;
	_tmp20_.description = "Due date in YYYY-MM-DD format";
	_tmp20_.arg_description = "DATE";
	_tmp19_[9] = _tmp20_;
	_tmp21_ = options;
	_tmp21__length1 = options_length1;
	_tmp22_.long_name = "labels";
	_tmp22_.short_name = 'l';
	_tmp22_.flags = (gint) 0;
	_tmp22_.arg = G_OPTION_ARG_STRING;
	_tmp22_.arg_data = &labels;
	_tmp22_.description = "Comma-separated list of label names";
	_tmp22_.arg_description = "LABELS";
	_tmp21_[10] = _tmp22_;
	_tmp23_ = options;
	_tmp23__length1 = options_length1;
	_tmp24_.long_name = "complete";
	_tmp24_.short_name = (gchar) 0;
	_tmp24_.flags = (gint) 0;
	_tmp24_.arg = G_OPTION_ARG_STRING;
	_tmp24_.arg_data = &complete_str;
	_tmp24_.description = "Mark task as complete or incomplete";
	_tmp24_.arg_description = "true|false";
	_tmp23_[11] = _tmp24_;
	_tmp25_ = options;
	_tmp25__length1 = options_length1;
	_tmp26_.long_name = "pin";
	_tmp26_.short_name = (gchar) 0;
	_tmp26_.flags = (gint) 0;
	_tmp26_.arg = G_OPTION_ARG_STRING;
	_tmp26_.arg_data = &pin_str;
	_tmp26_.description = "Pin or unpin the task";
	_tmp26_.arg_description = "true|false";
	_tmp25_[12] = _tmp26_;
	_tmp27_ = options;
	_tmp27__length1 = options_length1;
	_tmp28_.long_name = NULL;
	_tmp27_[13] = _tmp28_;
	_tmp29_ = g_option_context_new ("- Update an existing task. Only provided fields will be changed.");
	context = _tmp29_;
	_tmp30_ = context;
	_tmp31_ = options;
	_tmp31__length1 = options_length1;
	g_option_context_add_main_entries (_tmp30_, _tmp31_, NULL);
	_tmp32_ = context;
	g_option_context_set_help_enabled (_tmp32_, TRUE);
	tmp = args;
	tmp_length1 = args_length1;
	_tmp_size_ = tmp_length1;
	_tmp33_ = context;
	g_option_context_parse (_tmp33_, (gint*) (&tmp_length1), &tmp, &_inner_error0_);
	_tmp_size_ = tmp_length1;
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		if (_inner_error0_->domain == G_OPTION_ERROR) {
			g_propagate_error (error, _inner_error0_);
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (pin_str);
			_g_free0 (complete_str);
			_g_free0 (labels);
			_g_free0 (due_date);
			_g_free0 (parent_id);
			_g_free0 (section_id);
			_g_free0 (section_name);
			_g_free0 (project_id);
			_g_free0 (project_name);
			_g_free0 (description);
			_g_free0 (content);
			_g_free0 (task_id);
			return NULL;
		} else {
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (pin_str);
			_g_free0 (complete_str);
			_g_free0 (labels);
			_g_free0 (due_date);
			_g_free0 (parent_id);
			_g_free0 (section_id);
			_g_free0 (section_name);
			_g_free0 (project_id);
			_g_free0 (project_name);
			_g_free0 (description);
			_g_free0 (content);
			_g_free0 (task_id);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return NULL;
		}
	}
	_tmp34_ = planify_cli_update_arguments_new ();
	update_args = _tmp34_;
	_tmp35_ = update_args;
	_tmp36_ = task_id;
	planify_cli_update_arguments_set_task_id (_tmp35_, _tmp36_);
	_tmp37_ = update_args;
	_tmp38_ = content;
	planify_cli_update_arguments_set_content (_tmp37_, _tmp38_);
	_tmp39_ = update_args;
	_tmp40_ = description;
	planify_cli_update_arguments_set_description (_tmp39_, _tmp40_);
	_tmp41_ = update_args;
	_tmp42_ = project_name;
	planify_cli_update_arguments_set_project_name (_tmp41_, _tmp42_);
	_tmp43_ = update_args;
	_tmp44_ = project_id;
	planify_cli_update_arguments_set_project_id (_tmp43_, _tmp44_);
	_tmp45_ = update_args;
	_tmp46_ = section_name;
	planify_cli_update_arguments_set_section_name (_tmp45_, _tmp46_);
	_tmp47_ = update_args;
	_tmp48_ = section_id;
	planify_cli_update_arguments_set_section_id (_tmp47_, _tmp48_);
	_tmp49_ = update_args;
	_tmp50_ = parent_id;
	planify_cli_update_arguments_set_parent_id (_tmp49_, _tmp50_);
	_tmp51_ = update_args;
	planify_cli_update_arguments_set_priority (_tmp51_, priority);
	_tmp52_ = update_args;
	_tmp53_ = due_date;
	planify_cli_update_arguments_set_due_date (_tmp52_, _tmp53_);
	_tmp54_ = update_args;
	_tmp55_ = labels;
	planify_cli_update_arguments_set_labels (_tmp54_, _tmp55_);
	_tmp57_ = complete_str;
	_tmp56_ = planify_cli_argument_parser_parse_boolean_option (_tmp57_, &_inner_error0_);
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		if (_inner_error0_->domain == G_OPTION_ERROR) {
			g_propagate_error (error, _inner_error0_);
			_g_object_unref0 (update_args);
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (pin_str);
			_g_free0 (complete_str);
			_g_free0 (labels);
			_g_free0 (due_date);
			_g_free0 (parent_id);
			_g_free0 (section_id);
			_g_free0 (section_name);
			_g_free0 (project_id);
			_g_free0 (project_name);
			_g_free0 (description);
			_g_free0 (content);
			_g_free0 (task_id);
			return NULL;
		} else {
			_g_object_unref0 (update_args);
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (pin_str);
			_g_free0 (complete_str);
			_g_free0 (labels);
			_g_free0 (due_date);
			_g_free0 (parent_id);
			_g_free0 (section_id);
			_g_free0 (section_name);
			_g_free0 (project_id);
			_g_free0 (project_name);
			_g_free0 (description);
			_g_free0 (content);
			_g_free0 (task_id);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return NULL;
		}
	}
	_tmp58_ = update_args;
	planify_cli_update_arguments_set_checked (_tmp58_, _tmp56_);
	_tmp60_ = pin_str;
	_tmp59_ = planify_cli_argument_parser_parse_boolean_option (_tmp60_, &_inner_error0_);
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		if (_inner_error0_->domain == G_OPTION_ERROR) {
			g_propagate_error (error, _inner_error0_);
			_g_object_unref0 (update_args);
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (pin_str);
			_g_free0 (complete_str);
			_g_free0 (labels);
			_g_free0 (due_date);
			_g_free0 (parent_id);
			_g_free0 (section_id);
			_g_free0 (section_name);
			_g_free0 (project_id);
			_g_free0 (project_name);
			_g_free0 (description);
			_g_free0 (content);
			_g_free0 (task_id);
			return NULL;
		} else {
			_g_object_unref0 (update_args);
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (pin_str);
			_g_free0 (complete_str);
			_g_free0 (labels);
			_g_free0 (due_date);
			_g_free0 (parent_id);
			_g_free0 (section_id);
			_g_free0 (section_name);
			_g_free0 (project_id);
			_g_free0 (project_name);
			_g_free0 (description);
			_g_free0 (content);
			_g_free0 (task_id);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return NULL;
		}
	}
	_tmp61_ = update_args;
	planify_cli_update_arguments_set_pinned (_tmp61_, _tmp59_);
	result = update_args;
	_g_option_context_free0 (context);
	options = (g_free (options), NULL);
	_g_free0 (pin_str);
	_g_free0 (complete_str);
	_g_free0 (labels);
	_g_free0 (due_date);
	_g_free0 (parent_id);
	_g_free0 (section_id);
	_g_free0 (section_name);
	_g_free0 (project_id);
	_g_free0 (project_name);
	_g_free0 (description);
	_g_free0 (content);
	_g_free0 (task_id);
	return result;
}

static gint
planify_cli_argument_parser_parse_boolean_option (const gchar* value,
                                                  GError** error)
{
	gchar* lower_value = NULL;
	gchar* _tmp0_;
	const gchar* _tmp1_;
	GError* _inner_error0_ = NULL;
	gint result;
	if (value == NULL) {
		result = -1;
		return result;
	}
	_tmp0_ = g_utf8_strdown (value, (gssize) -1);
	lower_value = _tmp0_;
	_tmp1_ = lower_value;
	if (g_strcmp0 (_tmp1_, "true") == 0) {
		result = 1;
		_g_free0 (lower_value);
		return result;
	} else {
		const gchar* _tmp2_;
		_tmp2_ = lower_value;
		if (g_strcmp0 (_tmp2_, "false") == 0) {
			result = 0;
			_g_free0 (lower_value);
			return result;
		} else {
			GError* _tmp3_;
			_tmp3_ = g_error_new_literal (G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE, "Boolean option requires 'true' or 'false'");
			_inner_error0_ = _tmp3_;
			if (_inner_error0_->domain == G_OPTION_ERROR) {
				gint _tmp4_ = -1;
				g_propagate_error (error, _inner_error0_);
				_g_free0 (lower_value);
				return _tmp4_;
			} else {
				gint _tmp5_ = -1;
				_g_free0 (lower_value);
				g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
				g_clear_error (&_inner_error0_);
				return _tmp5_;
			}
		}
	}
}

static PlanifyCLIBackupArguments*
planify_cli_argument_parser_parse_backup_command (gchar** args,
                                                  gint args_length1,
                                                  GError** error)
{
	gchar* output = NULL;
	GOptionEntry* options = NULL;
	GOptionEntry* _tmp0_;
	gint options_length1;
	gint _options_size_;
	GOptionEntry _tmp1_ = {0};
	GOptionEntry _tmp2_ = {0};
	GOptionContext* context = NULL;
	GOptionContext* _tmp3_;
	gchar** tmp = NULL;
	gint tmp_length1;
	gint _tmp_size_;
	PlanifyCLIBackupArguments* backup_args = NULL;
	PlanifyCLIBackupArguments* _tmp4_;
	PlanifyCLIBackupArguments* _tmp5_;
	GError* _inner_error0_ = NULL;
	PlanifyCLIBackupArguments* result;
	output = NULL;
	_tmp0_ = g_new0 (GOptionEntry, 2);
	options = _tmp0_;
	options_length1 = 2;
	_options_size_ = options_length1;
	_tmp1_.long_name = "output";
	_tmp1_.short_name = 'o';
	_tmp1_.flags = (gint) 0;
	_tmp1_.arg = G_OPTION_ARG_STRING;
	_tmp1_.arg_data = &output;
	_tmp1_.description = "Output file path (default: stdout)";
	_tmp1_.arg_description = "FILE";
	options[0] = _tmp1_;
	_tmp2_.long_name = NULL;
	options[1] = _tmp2_;
	_tmp3_ = g_option_context_new ("- Export a JSON backup of all tasks and projects");
	context = _tmp3_;
	g_option_context_add_main_entries (context, options, NULL);
	g_option_context_set_help_enabled (context, TRUE);
	tmp = args;
	tmp_length1 = args_length1;
	_tmp_size_ = tmp_length1;
	g_option_context_parse (context, (gint*) (&tmp_length1), &tmp, &_inner_error0_);
	_tmp_size_ = tmp_length1;
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		if (_inner_error0_->domain == G_OPTION_ERROR) {
			g_propagate_error (error, _inner_error0_);
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (output);
			return NULL;
		} else {
			_g_option_context_free0 (context);
			options = (g_free (options), NULL);
			_g_free0 (output);
			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
			g_clear_error (&_inner_error0_);
			return NULL;
		}
	}
	_tmp4_ = planify_cli_backup_arguments_new ();
	backup_args = _tmp4_;
	_tmp5_ = backup_args;
	planify_cli_backup_arguments_set_output (_tmp5_, output);
	result = backup_args;
	_g_option_context_free0 (context);
	options = (g_free (options), NULL);
	_g_free0 (output);
	return result;
}

static void
planify_cli_argument_parser_print_general_help (const gchar* program_name)
{
	FILE* _tmp0_;
	FILE* _tmp1_;
	FILE* _tmp2_;
	FILE* _tmp3_;
	FILE* _tmp4_;
	FILE* _tmp5_;
	FILE* _tmp6_;
	FILE* _tmp7_;
	FILE* _tmp8_;
	FILE* _tmp9_;
	FILE* _tmp10_;
	FILE* _tmp11_;
	g_return_if_fail (program_name != NULL);
	_tmp0_ = stdout;
	fprintf (_tmp0_, "Usage: %s <command> [OPTIONS]\n\n", program_name);
	_tmp1_ = stdout;
	fprintf (_tmp1_, "Commands:\n");
	_tmp2_ = stdout;
	fprintf (_tmp2_, "  add              Add a new task\n");
	_tmp3_ = stdout;
	fprintf (_tmp3_, "  list             List tasks from a project\n");
	_tmp4_ = stdout;
	fprintf (_tmp4_, "  update           Update an existing task\n");
	_tmp5_ = stdout;
	fprintf (_tmp5_, "  list-projects    List all projects\n");
	_tmp6_ = stdout;
	fprintf (_tmp6_, "  backup           Export a JSON backup\n\n");
	_tmp7_ = stdout;
	fprintf (_tmp7_, "Run '%s <command> --help' for command-specific options\n\n", program_name);
	_tmp8_ = stdout;
	fprintf (_tmp8_, "Examples:\n");
	_tmp9_ = stdout;
	fprintf (_tmp9_, "  %s add --help\n", program_name);
	_tmp10_ = stdout;
	fprintf (_tmp10_, "  %s list --help\n", program_name);
	_tmp11_ = stdout;
	fprintf (_tmp11_, "  %s update --help\n", program_name);
}

PlanifyCLIArgumentParser*
planify_cli_argument_parser_construct (GType object_type)
{
	PlanifyCLIArgumentParser * self = NULL;
	self = (PlanifyCLIArgumentParser*) g_object_new (object_type, NULL);
	return self;
}

PlanifyCLIArgumentParser*
planify_cli_argument_parser_new (void)
{
	return planify_cli_argument_parser_construct (PLANIFY_CLI_TYPE_ARGUMENT_PARSER);
}

static void
planify_cli_argument_parser_class_init (PlanifyCLIArgumentParserClass * klass,
                                        gpointer klass_data)
{
	planify_cli_argument_parser_parent_class = g_type_class_peek_parent (klass);
}

static void
planify_cli_argument_parser_instance_init (PlanifyCLIArgumentParser * self,
                                           gpointer klass)
{
}

static GType
planify_cli_argument_parser_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (PlanifyCLIArgumentParserClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) planify_cli_argument_parser_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (PlanifyCLIArgumentParser), 0, (GInstanceInitFunc) planify_cli_argument_parser_instance_init, NULL };
	GType planify_cli_argument_parser_type_id;
	planify_cli_argument_parser_type_id = g_type_register_static (G_TYPE_OBJECT, "PlanifyCLIArgumentParser", &g_define_type_info, 0);
	return planify_cli_argument_parser_type_id;
}

GType
planify_cli_argument_parser_get_type (void)
{
	static volatile gsize planify_cli_argument_parser_type_id__once = 0;
	if (g_once_init_enter (&planify_cli_argument_parser_type_id__once)) {
		GType planify_cli_argument_parser_type_id;
		planify_cli_argument_parser_type_id = planify_cli_argument_parser_get_type_once ();
		g_once_init_leave (&planify_cli_argument_parser_type_id__once, planify_cli_argument_parser_type_id);
	}
	return planify_cli_argument_parser_type_id__once;
}

static void
_vala_array_destroy (gpointer array,
                     gssize array_length,
                     GDestroyNotify destroy_func)
{
	if ((array != NULL) && (destroy_func != NULL)) {
		gssize i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}

static void
_vala_array_free (gpointer array,
                  gssize array_length,
                  GDestroyNotify destroy_func)
{
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}

