
/* Generated data (by glib-mkenums) */

#include "ggit-enum-types.h"

/* enumerations from "./ggit-types.h" */
#include "./ggit-types.h"

GType
ggit_branch_type_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_BRANCH_LOCAL,
			  "GGIT_BRANCH_LOCAL",
			  "local" },
			{ GGIT_BRANCH_REMOTE,
			  "GGIT_BRANCH_REMOTE",
			  "remote" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitBranchType"),
				values);
	}
	return the_type;
}

GType
ggit_feature_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_FEATURE_THREADS,
			  "GGIT_FEATURE_THREADS",
			  "threads" },
			{ GGIT_FEATURE_HTTPS,
			  "GGIT_FEATURE_HTTPS",
			  "https" },
			{ GGIT_FEATURE_SSH,
			  "GGIT_FEATURE_SSH",
			  "ssh" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitFeatureFlags"),
				values);
	}
	return the_type;
}

GType
ggit_blame_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_BLAME_NORMAL,
			  "GGIT_BLAME_NORMAL",
			  "normal" },
			{ GGIT_BLAME_TRACK_COPIES_SAME_FILE,
			  "GGIT_BLAME_TRACK_COPIES_SAME_FILE",
			  "track-copies-same-file" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitBlameFlags"),
				values);
	}
	return the_type;
}

GType
ggit_config_level_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_CONFIG_LEVEL_SYSTEM,
			  "GGIT_CONFIG_LEVEL_SYSTEM",
			  "system" },
			{ GGIT_CONFIG_LEVEL_XDG,
			  "GGIT_CONFIG_LEVEL_XDG",
			  "xdg" },
			{ GGIT_CONFIG_LEVEL_GLOBAL,
			  "GGIT_CONFIG_LEVEL_GLOBAL",
			  "global" },
			{ GGIT_CONFIG_LEVEL_LOCAL,
			  "GGIT_CONFIG_LEVEL_LOCAL",
			  "local" },
			{ GGIT_CONFIG_LEVEL_HIGHEST,
			  "GGIT_CONFIG_LEVEL_HIGHEST",
			  "highest" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitConfigLevel"),
				values);
	}
	return the_type;
}

GType
ggit_create_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_CREATE_NONE,
			  "GGIT_CREATE_NONE",
			  "none" },
			{ GGIT_CREATE_FORCE,
			  "GGIT_CREATE_FORCE",
			  "force" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitCreateFlags"),
				values);
	}
	return the_type;
}

GType
ggit_delta_type_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_DELTA_UNMODIFIED,
			  "GGIT_DELTA_UNMODIFIED",
			  "unmodified" },
			{ GGIT_DELTA_ADDED,
			  "GGIT_DELTA_ADDED",
			  "added" },
			{ GGIT_DELTA_DELETED,
			  "GGIT_DELTA_DELETED",
			  "deleted" },
			{ GGIT_DELTA_MODIFIED,
			  "GGIT_DELTA_MODIFIED",
			  "modified" },
			{ GGIT_DELTA_RENAMED,
			  "GGIT_DELTA_RENAMED",
			  "renamed" },
			{ GGIT_DELTA_COPIED,
			  "GGIT_DELTA_COPIED",
			  "copied" },
			{ GGIT_DELTA_IGNORED,
			  "GGIT_DELTA_IGNORED",
			  "ignored" },
			{ GGIT_DELTA_UNTRACKED,
			  "GGIT_DELTA_UNTRACKED",
			  "untracked" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitDeltaType"),
				values);
	}
	return the_type;
}

GType
ggit_diff_format_type_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_DIFF_FORMAT_PATCH,
			  "GGIT_DIFF_FORMAT_PATCH",
			  "patch" },
			{ GGIT_DIFF_FORMAT_PATCH_HEADER,
			  "GGIT_DIFF_FORMAT_PATCH_HEADER",
			  "patch-header" },
			{ GGIT_DIFF_FORMAT_RAW,
			  "GGIT_DIFF_FORMAT_RAW",
			  "raw" },
			{ GGIT_DIFF_FORMAT_NAME_ONLY,
			  "GGIT_DIFF_FORMAT_NAME_ONLY",
			  "name-only" },
			{ GGIT_DIFF_FORMAT_NAME_STATUS,
			  "GGIT_DIFF_FORMAT_NAME_STATUS",
			  "name-status" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitDiffFormatType"),
				values);
	}
	return the_type;
}

GType
ggit_diff_option_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_DIFF_NORMAL,
			  "GGIT_DIFF_NORMAL",
			  "normal" },
			{ GGIT_DIFF_REVERSE,
			  "GGIT_DIFF_REVERSE",
			  "reverse" },
			{ GGIT_DIFF_INCLUDE_IGNORED,
			  "GGIT_DIFF_INCLUDE_IGNORED",
			  "include-ignored" },
			{ GGIT_DIFF_RECURSE_IGNORED_DIRS,
			  "GGIT_DIFF_RECURSE_IGNORED_DIRS",
			  "recurse-ignored-dirs" },
			{ GGIT_DIFF_INCLUDE_UNTRACKED,
			  "GGIT_DIFF_INCLUDE_UNTRACKED",
			  "include-untracked" },
			{ GGIT_DIFF_RECURSE_UNTRACKED_DIRS,
			  "GGIT_DIFF_RECURSE_UNTRACKED_DIRS",
			  "recurse-untracked-dirs" },
			{ GGIT_DIFF_INCLUDE_UNMODIFIED,
			  "GGIT_DIFF_INCLUDE_UNMODIFIED",
			  "include-unmodified" },
			{ GGIT_DIFF_INCLUDE_TYPECHANGE,
			  "GGIT_DIFF_INCLUDE_TYPECHANGE",
			  "include-typechange" },
			{ GGIT_DIFF_INCLUDE_TYPECHANGE_TREES,
			  "GGIT_DIFF_INCLUDE_TYPECHANGE_TREES",
			  "include-typechange-trees" },
			{ GGIT_DIFF_IGNORE_FILE_MODE,
			  "GGIT_DIFF_IGNORE_FILE_MODE",
			  "ignore-file-mode" },
			{ GGIT_DIFF_IGNORE_SUBMODULES,
			  "GGIT_DIFF_IGNORE_SUBMODULES",
			  "ignore-submodules" },
			{ GGIT_DIFF_IGNORE_CASE,
			  "GGIT_DIFF_IGNORE_CASE",
			  "ignore-case" },
			{ GGIT_DIFF_DISABLE_PATHSPEC_MATCH,
			  "GGIT_DIFF_DISABLE_PATHSPEC_MATCH",
			  "disable-pathspec-match" },
			{ GGIT_DIFF_SKIP_BINARY_CHECK,
			  "GGIT_DIFF_SKIP_BINARY_CHECK",
			  "skip-binary-check" },
			{ GGIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS,
			  "GGIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS",
			  "enable-fast-untracked-dirs" },
			{ GGIT_DIFF_FORCE_TEXT,
			  "GGIT_DIFF_FORCE_TEXT",
			  "force-text" },
			{ GGIT_DIFF_FORCE_BINARY,
			  "GGIT_DIFF_FORCE_BINARY",
			  "force-binary" },
			{ GGIT_DIFF_IGNORE_WHITESPACE,
			  "GGIT_DIFF_IGNORE_WHITESPACE",
			  "ignore-whitespace" },
			{ GGIT_DIFF_IGNORE_WHITESPACE_CHANGE,
			  "GGIT_DIFF_IGNORE_WHITESPACE_CHANGE",
			  "ignore-whitespace-change" },
			{ GGIT_DIFF_IGNORE_WHITESPACE_EOL,
			  "GGIT_DIFF_IGNORE_WHITESPACE_EOL",
			  "ignore-whitespace-eol" },
			{ GGIT_DIFF_SHOW_UNTRACKED_CONTENT,
			  "GGIT_DIFF_SHOW_UNTRACKED_CONTENT",
			  "show-untracked-content" },
			{ GGIT_DIFF_SHOW_UNMODIFIED,
			  "GGIT_DIFF_SHOW_UNMODIFIED",
			  "show-unmodified" },
			{ GGIT_DIFF_PATIENCE,
			  "GGIT_DIFF_PATIENCE",
			  "patience" },
			{ GGIT_DIFF_MINIMAL,
			  "GGIT_DIFF_MINIMAL",
			  "minimal" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitDiffOption"),
				values);
	}
	return the_type;
}

GType
ggit_diff_flag_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_DIFF_FLAG_BINARY,
			  "GGIT_DIFF_FLAG_BINARY",
			  "binary" },
			{ GGIT_DIFF_FLAG_NOT_BINARY,
			  "GGIT_DIFF_FLAG_NOT_BINARY",
			  "not-binary" },
			{ GGIT_DIFF_FLAG_VALID_ID,
			  "GGIT_DIFF_FLAG_VALID_ID",
			  "valid-id" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitDiffFlag"),
				values);
	}
	return the_type;
}

GType
ggit_diff_line_type_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_DIFF_LINE_CONTEXT,
			  "GGIT_DIFF_LINE_CONTEXT",
			  "context" },
			{ GGIT_DIFF_LINE_ADDITION,
			  "GGIT_DIFF_LINE_ADDITION",
			  "addition" },
			{ GGIT_DIFF_LINE_DELETION,
			  "GGIT_DIFF_LINE_DELETION",
			  "deletion" },
			{ GGIT_DIFF_LINE_CONTEXT_EOFNL,
			  "GGIT_DIFF_LINE_CONTEXT_EOFNL",
			  "context-eofnl" },
			{ GGIT_DIFF_LINE_ADD_EOFNL,
			  "GGIT_DIFF_LINE_ADD_EOFNL",
			  "add-eofnl" },
			{ GGIT_DIFF_LINE_DEL_EOFNL,
			  "GGIT_DIFF_LINE_DEL_EOFNL",
			  "del-eofnl" },
			{ GGIT_DIFF_LINE_FILE_HDR,
			  "GGIT_DIFF_LINE_FILE_HDR",
			  "file-hdr" },
			{ GGIT_DIFF_LINE_HUNK_HDR,
			  "GGIT_DIFF_LINE_HUNK_HDR",
			  "hunk-hdr" },
			{ GGIT_DIFF_LINE_BINARY,
			  "GGIT_DIFF_LINE_BINARY",
			  "binary" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitDiffLineType"),
				values);
	}
	return the_type;
}

GType
ggit_error_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_ERROR_GIT_ERROR,
			  "GGIT_ERROR_GIT_ERROR",
			  "git-error" },
			{ GGIT_ERROR_NOTFOUND,
			  "GGIT_ERROR_NOTFOUND",
			  "notfound" },
			{ GGIT_ERROR_EXISTS,
			  "GGIT_ERROR_EXISTS",
			  "exists" },
			{ GGIT_ERROR_AMBIGUOUS,
			  "GGIT_ERROR_AMBIGUOUS",
			  "ambiguous" },
			{ GGIT_ERROR_BUFS,
			  "GGIT_ERROR_BUFS",
			  "bufs" },
			{ GGIT_ERROR_PASSTHROUGH,
			  "GGIT_ERROR_PASSTHROUGH",
			  "passthrough" },
			{ GGIT_ERROR_ITEROVER,
			  "GGIT_ERROR_ITEROVER",
			  "iterover" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitError"),
				values);
	}
	return the_type;
}

GType
ggit_file_mode_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_FILE_MODE_UNREADABLE,
			  "GGIT_FILE_MODE_UNREADABLE",
			  "unreadable" },
			{ GGIT_FILE_MODE_TREE,
			  "GGIT_FILE_MODE_TREE",
			  "tree" },
			{ GGIT_FILE_MODE_BLOB,
			  "GGIT_FILE_MODE_BLOB",
			  "blob" },
			{ GGIT_FILE_MODE_BLOB_EXECUTABLE,
			  "GGIT_FILE_MODE_BLOB_EXECUTABLE",
			  "blob-executable" },
			{ GGIT_FILE_MODE_LINK,
			  "GGIT_FILE_MODE_LINK",
			  "link" },
			{ GGIT_FILE_MODE_COMMIT,
			  "GGIT_FILE_MODE_COMMIT",
			  "commit" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitFileMode"),
				values);
	}
	return the_type;
}

GType
ggit_merge_file_favor_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_MERGE_FILE_FAVOR_NORMAL,
			  "GGIT_MERGE_FILE_FAVOR_NORMAL",
			  "normal" },
			{ GGIT_MERGE_FILE_FAVOR_OURS,
			  "GGIT_MERGE_FILE_FAVOR_OURS",
			  "ours" },
			{ GGIT_MERGE_FILE_FAVOR_THEIRS,
			  "GGIT_MERGE_FILE_FAVOR_THEIRS",
			  "theirs" },
			{ GGIT_MERGE_FILE_FAVOR_UNION,
			  "GGIT_MERGE_FILE_FAVOR_UNION",
			  "union" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitMergeFileFavor"),
				values);
	}
	return the_type;
}

GType
ggit_merge_tree_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_MERGE_TREE_FIND_RENAMES,
			  "GGIT_MERGE_TREE_FIND_RENAMES",
			  "renames" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitMergeTreeFlags"),
				values);
	}
	return the_type;
}

GType
ggit_remote_download_tags_type_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_REMOTE_DOWNLOAD_TAGS_AUTO,
			  "GGIT_REMOTE_DOWNLOAD_TAGS_AUTO",
			  "auto" },
			{ GGIT_REMOTE_DOWNLOAD_TAGS_NONE,
			  "GGIT_REMOTE_DOWNLOAD_TAGS_NONE",
			  "none" },
			{ GGIT_REMOTE_DOWNLOAD_TAGS_ALL,
			  "GGIT_REMOTE_DOWNLOAD_TAGS_ALL",
			  "all" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitRemoteDownloadTagsType"),
				values);
	}
	return the_type;
}

GType
ggit_remote_completion_type_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_REMOTE_COMPLETION_DOWNLOAD,
			  "GGIT_REMOTE_COMPLETION_DOWNLOAD",
			  "download" },
			{ GGIT_REMOTE_COMPLETION_INDEXING,
			  "GGIT_REMOTE_COMPLETION_INDEXING",
			  "indexing" },
			{ GGIT_REMOTE_COMPLETION_ERROR,
			  "GGIT_REMOTE_COMPLETION_ERROR",
			  "error" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitRemoteCompletionType"),
				values);
	}
	return the_type;
}

GType
ggit_ref_type_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_REF_INVALID,
			  "GGIT_REF_INVALID",
			  "invalid" },
			{ GGIT_REF_OID,
			  "GGIT_REF_OID",
			  "oid" },
			{ GGIT_REF_SYMBOLIC,
			  "GGIT_REF_SYMBOLIC",
			  "symbolic" },
			{ GGIT_REF_LISTALL,
			  "GGIT_REF_LISTALL",
			  "listall" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitRefType"),
				values);
	}
	return the_type;
}

GType
ggit_reset_type_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_RESET_SOFT,
			  "GGIT_RESET_SOFT",
			  "soft" },
			{ GGIT_RESET_MIXED,
			  "GGIT_RESET_MIXED",
			  "mixed" },
			{ GGIT_RESET_HARD,
			  "GGIT_RESET_HARD",
			  "hard" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitResetType"),
				values);
	}
	return the_type;
}

GType
ggit_sort_mode_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_SORT_NONE,
			  "GGIT_SORT_NONE",
			  "none" },
			{ GGIT_SORT_TOPOLOGICAL,
			  "GGIT_SORT_TOPOLOGICAL",
			  "topological" },
			{ GGIT_SORT_TIME,
			  "GGIT_SORT_TIME",
			  "time" },
			{ GGIT_SORT_REVERSE,
			  "GGIT_SORT_REVERSE",
			  "reverse" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitSortMode"),
				values);
	}
	return the_type;
}

GType
ggit_stash_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_STASH_DEFAULT,
			  "GGIT_STASH_DEFAULT",
			  "default" },
			{ GGIT_STASH_KEEP_INDEX,
			  "GGIT_STASH_KEEP_INDEX",
			  "keep-index" },
			{ GGIT_STASH_INCLUDE_UNTRACKED,
			  "GGIT_STASH_INCLUDE_UNTRACKED",
			  "include-untracked" },
			{ GGIT_STASH_INCLUDE_IGNORED,
			  "GGIT_STASH_INCLUDE_IGNORED",
			  "include-ignored" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitStashFlags"),
				values);
	}
	return the_type;
}

GType
ggit_status_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_STATUS_CURRENT,
			  "GGIT_STATUS_CURRENT",
			  "current" },
			{ GGIT_STATUS_INDEX_NEW,
			  "GGIT_STATUS_INDEX_NEW",
			  "index-new" },
			{ GGIT_STATUS_INDEX_MODIFIED,
			  "GGIT_STATUS_INDEX_MODIFIED",
			  "index-modified" },
			{ GGIT_STATUS_INDEX_DELETED,
			  "GGIT_STATUS_INDEX_DELETED",
			  "index-deleted" },
			{ GGIT_STATUS_INDEX_RENAMED,
			  "GGIT_STATUS_INDEX_RENAMED",
			  "index-renamed" },
			{ GGIT_STATUS_INDEX_TYPECHANGE,
			  "GGIT_STATUS_INDEX_TYPECHANGE",
			  "index-typechange" },
			{ GGIT_STATUS_WORKING_TREE_NEW,
			  "GGIT_STATUS_WORKING_TREE_NEW",
			  "working-tree-new" },
			{ GGIT_STATUS_WORKING_TREE_MODIFIED,
			  "GGIT_STATUS_WORKING_TREE_MODIFIED",
			  "working-tree-modified" },
			{ GGIT_STATUS_WORKING_TREE_DELETED,
			  "GGIT_STATUS_WORKING_TREE_DELETED",
			  "working-tree-deleted" },
			{ GGIT_STATUS_WORKING_TREE_TYPECHANGE,
			  "GGIT_STATUS_WORKING_TREE_TYPECHANGE",
			  "working-tree-typechange" },
			{ GGIT_STATUS_IGNORED,
			  "GGIT_STATUS_IGNORED",
			  "ignored" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitStatusFlags"),
				values);
	}
	return the_type;
}

GType
ggit_submodule_ignore_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_SUBMODULE_IGNORE_RESET,
			  "GGIT_SUBMODULE_IGNORE_RESET",
			  "reset" },
			{ GGIT_SUBMODULE_IGNORE_NONE,
			  "GGIT_SUBMODULE_IGNORE_NONE",
			  "none" },
			{ GGIT_SUBMODULE_IGNORE_UNTRACKED,
			  "GGIT_SUBMODULE_IGNORE_UNTRACKED",
			  "untracked" },
			{ GGIT_SUBMODULE_IGNORE_DIRTY,
			  "GGIT_SUBMODULE_IGNORE_DIRTY",
			  "dirty" },
			{ GGIT_SUBMODULE_IGNORE_ALL,
			  "GGIT_SUBMODULE_IGNORE_ALL",
			  "all" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitSubmoduleIgnore"),
				values);
	}
	return the_type;
}

GType
ggit_submodule_status_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_SUBMODULE_STATUS_IN_HEAD,
			  "GGIT_SUBMODULE_STATUS_IN_HEAD",
			  "in-head" },
			{ GGIT_SUBMODULE_STATUS_IN_INDEX,
			  "GGIT_SUBMODULE_STATUS_IN_INDEX",
			  "in-index" },
			{ GGIT_SUBMODULE_STATUS_IN_CONFIG,
			  "GGIT_SUBMODULE_STATUS_IN_CONFIG",
			  "in-config" },
			{ GGIT_SUBMODULE_STATUS_IN_WD,
			  "GGIT_SUBMODULE_STATUS_IN_WD",
			  "in-wd" },
			{ GGIT_SUBMODULE_STATUS_INDEX_ADDED,
			  "GGIT_SUBMODULE_STATUS_INDEX_ADDED",
			  "index-added" },
			{ GGIT_SUBMODULE_STATUS_INDEX_DELETED,
			  "GGIT_SUBMODULE_STATUS_INDEX_DELETED",
			  "index-deleted" },
			{ GGIT_SUBMODULE_STATUS_INDEX_MODIFIED,
			  "GGIT_SUBMODULE_STATUS_INDEX_MODIFIED",
			  "index-modified" },
			{ GGIT_SUBMODULE_STATUS_WD_UNINITIALIZED,
			  "GGIT_SUBMODULE_STATUS_WD_UNINITIALIZED",
			  "wd-uninitialized" },
			{ GGIT_SUBMODULE_STATUS_WD_ADDED,
			  "GGIT_SUBMODULE_STATUS_WD_ADDED",
			  "wd-added" },
			{ GGIT_SUBMODULE_STATUS_WD_DELETED,
			  "GGIT_SUBMODULE_STATUS_WD_DELETED",
			  "wd-deleted" },
			{ GGIT_SUBMODULE_STATUS_WD_MODIFIED,
			  "GGIT_SUBMODULE_STATUS_WD_MODIFIED",
			  "wd-modified" },
			{ GGIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED,
			  "GGIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED",
			  "wd-index-modified" },
			{ GGIT_SUBMODULE_STATUS_WD_WD_MODIFIED,
			  "GGIT_SUBMODULE_STATUS_WD_WD_MODIFIED",
			  "wd-wd-modified" },
			{ GGIT_SUBMODULE_STATUS_WD_UNTRACKED,
			  "GGIT_SUBMODULE_STATUS_WD_UNTRACKED",
			  "wd-untracked" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitSubmoduleStatus"),
				values);
	}
	return the_type;
}

GType
ggit_submodule_update_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_SUBMODULE_UPDATE_RESET,
			  "GGIT_SUBMODULE_UPDATE_RESET",
			  "reset" },
			{ GGIT_SUBMODULE_UPDATE_CHECKOUT,
			  "GGIT_SUBMODULE_UPDATE_CHECKOUT",
			  "checkout" },
			{ GGIT_SUBMODULE_UPDATE_REBASE,
			  "GGIT_SUBMODULE_UPDATE_REBASE",
			  "rebase" },
			{ GGIT_SUBMODULE_UPDATE_MERGE,
			  "GGIT_SUBMODULE_UPDATE_MERGE",
			  "merge" },
			{ GGIT_SUBMODULE_UPDATE_NONE,
			  "GGIT_SUBMODULE_UPDATE_NONE",
			  "none" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitSubmoduleUpdate"),
				values);
	}
	return the_type;
}

GType
ggit_tree_walk_mode_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_TREE_WALK_MODE_PRE,
			  "GGIT_TREE_WALK_MODE_PRE",
			  "pre" },
			{ GGIT_TREE_WALK_MODE_POST,
			  "GGIT_TREE_WALK_MODE_POST",
			  "post" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitTreeWalkMode"),
				values);
	}
	return the_type;
}

GType
ggit_status_option_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_STATUS_OPTION_INCLUDE_UNTRACKED,
			  "GGIT_STATUS_OPTION_INCLUDE_UNTRACKED",
			  "include-untracked" },
			{ GGIT_STATUS_OPTION_INCLUDE_IGNORED,
			  "GGIT_STATUS_OPTION_INCLUDE_IGNORED",
			  "include-ignored" },
			{ GGIT_STATUS_OPTION_INCLUDE_UNMODIFIED,
			  "GGIT_STATUS_OPTION_INCLUDE_UNMODIFIED",
			  "include-unmodified" },
			{ GGIT_STATUS_OPTION_EXCLUDE_SUBMODULES,
			  "GGIT_STATUS_OPTION_EXCLUDE_SUBMODULES",
			  "exclude-submodules" },
			{ GGIT_STATUS_OPTION_RECURSE_UNTRACKED_DIRS,
			  "GGIT_STATUS_OPTION_RECURSE_UNTRACKED_DIRS",
			  "recurse-untracked-dirs" },
			{ GGIT_STATUS_OPTION_DISABLE_PATHSPEC_MATCH,
			  "GGIT_STATUS_OPTION_DISABLE_PATHSPEC_MATCH",
			  "disable-pathspec-match" },
			{ GGIT_STATUS_OPTION_RECURSE_IGNORED_DIRS,
			  "GGIT_STATUS_OPTION_RECURSE_IGNORED_DIRS",
			  "recurse-ignored-dirs" },
			{ GGIT_STATUS_OPTION_RENAMES_HEAD_TO_INDEX,
			  "GGIT_STATUS_OPTION_RENAMES_HEAD_TO_INDEX",
			  "renames-head-to-index" },
			{ GGIT_STATUS_OPTION_RENAMES_INDEX_TO_WORKDIR,
			  "GGIT_STATUS_OPTION_RENAMES_INDEX_TO_WORKDIR",
			  "renames-index-to-workdir" },
			{ GGIT_STATUS_OPTION_SORT_CASE_SENSITIVELY,
			  "GGIT_STATUS_OPTION_SORT_CASE_SENSITIVELY",
			  "sort-case-sensitively" },
			{ GGIT_STATUS_OPTION_SORT_CASE_INSENSITIVELY,
			  "GGIT_STATUS_OPTION_SORT_CASE_INSENSITIVELY",
			  "sort-case-insensitively" },
			{ GGIT_STATUS_OPTION_DEFAULT,
			  "GGIT_STATUS_OPTION_DEFAULT",
			  "default" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitStatusOption"),
				values);
	}
	return the_type;
}

GType
ggit_status_show_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_STATUS_SHOW_INDEX_AND_WORKDIR,
			  "GGIT_STATUS_SHOW_INDEX_AND_WORKDIR",
			  "index-and-workdir" },
			{ GGIT_STATUS_SHOW_INDEX_ONLY,
			  "GGIT_STATUS_SHOW_INDEX_ONLY",
			  "index-only" },
			{ GGIT_STATUS_SHOW_WORKDIR_ONLY,
			  "GGIT_STATUS_SHOW_WORKDIR_ONLY",
			  "workdir-only" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitStatusShow"),
				values);
	}
	return the_type;
}

GType
ggit_attribute_check_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_ATTRIBUTE_CHECK_FILE_THEN_INDEX,
			  "GGIT_ATTRIBUTE_CHECK_FILE_THEN_INDEX",
			  "file-then-index" },
			{ GGIT_ATTRIBUTE_CHECK_INDEX_THEN_FILE,
			  "GGIT_ATTRIBUTE_CHECK_INDEX_THEN_FILE",
			  "index-then-file" },
			{ GGIT_ATTRIBUTE_CHECK_INDEX_ONLY,
			  "GGIT_ATTRIBUTE_CHECK_INDEX_ONLY",
			  "index-only" },
			{ GGIT_ATTRIBUTE_CHECK_NO_SYSTEM,
			  "GGIT_ATTRIBUTE_CHECK_NO_SYSTEM",
			  "no-system" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitAttributeCheckFlags"),
				values);
	}
	return the_type;
}

GType
ggit_packbuilder_stage_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_PACKBUILDER_STAGE_ADDING_OBJECTS,
			  "GGIT_PACKBUILDER_STAGE_ADDING_OBJECTS",
			  "adding-objects" },
			{ GGIT_PACKBUILDER_STAGE_DELTAFICATION,
			  "GGIT_PACKBUILDER_STAGE_DELTAFICATION",
			  "deltafication" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitPackbuilderStage"),
				values);
	}
	return the_type;
}

GType
ggit_checkout_strategy_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_CHECKOUT_NONE,
			  "GGIT_CHECKOUT_NONE",
			  "none" },
			{ GGIT_CHECKOUT_SAFE,
			  "GGIT_CHECKOUT_SAFE",
			  "safe" },
			{ GGIT_CHECKOUT_SAFE_CREATE,
			  "GGIT_CHECKOUT_SAFE_CREATE",
			  "safe-create" },
			{ GGIT_CHECKOUT_FORCE,
			  "GGIT_CHECKOUT_FORCE",
			  "force" },
			{ GGIT_CHECKOUT_ALLOW_CONFLICTS,
			  "GGIT_CHECKOUT_ALLOW_CONFLICTS",
			  "allow-conflicts" },
			{ GGIT_CHECKOUT_REMOVE_UNTRACKED,
			  "GGIT_CHECKOUT_REMOVE_UNTRACKED",
			  "remove-untracked" },
			{ GGIT_CHECKOUT_REMOVE_IGNORED,
			  "GGIT_CHECKOUT_REMOVE_IGNORED",
			  "remove-ignored" },
			{ GGIT_CHECKOUT_UPDATE_ONLY,
			  "GGIT_CHECKOUT_UPDATE_ONLY",
			  "update-only" },
			{ GGIT_CHECKOUT_DONT_UPDATE_INDEX,
			  "GGIT_CHECKOUT_DONT_UPDATE_INDEX",
			  "dont-update-index" },
			{ GGIT_CHECKOUT_NO_REFRESH,
			  "GGIT_CHECKOUT_NO_REFRESH",
			  "no-refresh" },
			{ GGIT_CHECKOUT_SKIP_UNMERGED,
			  "GGIT_CHECKOUT_SKIP_UNMERGED",
			  "skip-unmerged" },
			{ GGIT_CHECKOUT_USE_OURS,
			  "GGIT_CHECKOUT_USE_OURS",
			  "use-ours" },
			{ GGIT_CHECKOUT_USE_THEIRS,
			  "GGIT_CHECKOUT_USE_THEIRS",
			  "use-theirs" },
			{ GGIT_CHECKOUT_DISABLE_PATHSPEC_MATCH,
			  "GGIT_CHECKOUT_DISABLE_PATHSPEC_MATCH",
			  "disable-pathspec-match" },
			{ GGIT_CHECKOUT_SKIP_LOCKED_DIRECTORIES,
			  "GGIT_CHECKOUT_SKIP_LOCKED_DIRECTORIES",
			  "skip-locked-directories" },
			{ GGIT_CHECKOUT_DONT_OVERWRITE_IGNORED,
			  "GGIT_CHECKOUT_DONT_OVERWRITE_IGNORED",
			  "dont-overwrite-ignored" },
			{ GGIT_CHECKOUT_CONFLICT_STYLE_MERGE,
			  "GGIT_CHECKOUT_CONFLICT_STYLE_MERGE",
			  "conflict-style-merge" },
			{ GGIT_CHECKOUT_CONFLICT_STYLE_DIFF3,
			  "GGIT_CHECKOUT_CONFLICT_STYLE_DIFF3",
			  "conflict-style-diff3" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitCheckoutStrategy"),
				values);
	}
	return the_type;
}

GType
ggit_checkout_notify_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_CHECKOUT_NOTIFY_NONE,
			  "GGIT_CHECKOUT_NOTIFY_NONE",
			  "none" },
			{ GGIT_CHECKOUT_NOTIFY_CONFLICT,
			  "GGIT_CHECKOUT_NOTIFY_CONFLICT",
			  "conflict" },
			{ GGIT_CHECKOUT_NOTIFY_DIRTY,
			  "GGIT_CHECKOUT_NOTIFY_DIRTY",
			  "dirty" },
			{ GGIT_CHECKOUT_NOTIFY_UPDATED,
			  "GGIT_CHECKOUT_NOTIFY_UPDATED",
			  "updated" },
			{ GGIT_CHECKOUT_NOTIFY_UNTRACKED,
			  "GGIT_CHECKOUT_NOTIFY_UNTRACKED",
			  "untracked" },
			{ GGIT_CHECKOUT_NOTIFY_IGNORED,
			  "GGIT_CHECKOUT_NOTIFY_IGNORED",
			  "ignored" },
			{ GGIT_CHECKOUT_NOTIFY_ALL,
			  "GGIT_CHECKOUT_NOTIFY_ALL",
			  "all" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitCheckoutNotifyFlags"),
				values);
	}
	return the_type;
}

GType
ggit_diff_find_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_DIFF_FIND_BY_CONFIG,
			  "GGIT_DIFF_FIND_BY_CONFIG",
			  "find-by-config" },
			{ GGIT_DIFF_FIND_RENAMES,
			  "GGIT_DIFF_FIND_RENAMES",
			  "find-renames" },
			{ GGIT_DIFF_FIND_RENAMES_FROM_REWRITES,
			  "GGIT_DIFF_FIND_RENAMES_FROM_REWRITES",
			  "find-renames-from-rewrites" },
			{ GGIT_DIFF_FIND_COPIES,
			  "GGIT_DIFF_FIND_COPIES",
			  "find-copies" },
			{ GGIT_DIFF_FIND_COPIES_FROM_UNMODIFIED,
			  "GGIT_DIFF_FIND_COPIES_FROM_UNMODIFIED",
			  "find-copies-from-unmodified" },
			{ GGIT_DIFF_FIND_REWRITES,
			  "GGIT_DIFF_FIND_REWRITES",
			  "find-rewrites" },
			{ GGIT_DIFF_BREAK_REWRITES,
			  "GGIT_DIFF_BREAK_REWRITES",
			  "break-rewrites" },
			{ GGIT_DIFF_FIND_AND_BREAK_REWRITES,
			  "GGIT_DIFF_FIND_AND_BREAK_REWRITES",
			  "find-and-break-rewrites" },
			{ GGIT_DIFF_FIND_FOR_UNTRACKED,
			  "GGIT_DIFF_FIND_FOR_UNTRACKED",
			  "find-for-untracked" },
			{ GGIT_DIFF_FIND_ALL,
			  "GGIT_DIFF_FIND_ALL",
			  "find-all" },
			{ GGIT_DIFF_FIND_IGNORE_LEADING_WHITESPACE,
			  "GGIT_DIFF_FIND_IGNORE_LEADING_WHITESPACE",
			  "find-ignore-leading-whitespace" },
			{ GGIT_DIFF_FIND_IGNORE_WHITESPACE,
			  "GGIT_DIFF_FIND_IGNORE_WHITESPACE",
			  "find-ignore-whitespace" },
			{ GGIT_DIFF_FIND_DONT_IGNORE_WHITESPACE,
			  "GGIT_DIFF_FIND_DONT_IGNORE_WHITESPACE",
			  "find-dont-ignore-whitespace" },
			{ GGIT_DIFF_FIND_EXACT_MATCH_ONLY,
			  "GGIT_DIFF_FIND_EXACT_MATCH_ONLY",
			  "find-exact-match-only" },
			{ GGIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY,
			  "GGIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY",
			  "break-rewrites-for-renames-only" },
			{ GGIT_DIFF_FIND_REMOVE_UNMODIFIED,
			  "GGIT_DIFF_FIND_REMOVE_UNMODIFIED",
			  "find-remove-unmodified" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitDiffFindFlags"),
				values);
	}
	return the_type;
}

GType
ggit_diff_format_email_flags_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_DIFF_FORMAT_EMAIL_NONE,
			  "GGIT_DIFF_FORMAT_EMAIL_NONE",
			  "none" },
			{ GGIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER,
			  "GGIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER",
			  "exclude-subject-patch-marker" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitDiffFormatEmailFlags"),
				values);
	}
	return the_type;
}

GType
ggit_credtype_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GFlagsValue values[] = {
			{ GGIT_CREDTYPE_USERPASS_PLAINTEXT,
			  "GGIT_CREDTYPE_USERPASS_PLAINTEXT",
			  "userpass-plaintext" },
			{ GGIT_CREDTYPE_SSH_KEY,
			  "GGIT_CREDTYPE_SSH_KEY",
			  "ssh-key" },
			{ GGIT_CREDTYPE_SSH_CUSTOM,
			  "GGIT_CREDTYPE_SSH_CUSTOM",
			  "ssh-custom" },
			{ GGIT_CREDTYPE_DEFAULT,
			  "GGIT_CREDTYPE_DEFAULT",
			  "default" },
			{ GGIT_CREDTYPE_SSH_INTERACTIVE,
			  "GGIT_CREDTYPE_SSH_INTERACTIVE",
			  "ssh-interactive" },
			{ 0, NULL, NULL }
		};
		the_type = g_flags_register_static (
				g_intern_static_string ("GgitCredtype"),
				values);
	}
	return the_type;
}

GType
ggit_direction_get_type (void)
{
	static GType the_type = 0;
	
	if (the_type == 0)
	{
		static const GEnumValue values[] = {
			{ GGIT_DIRECTION_FETCH,
			  "GGIT_DIRECTION_FETCH",
			  "fetch" },
			{ GGIT_DIRECTION_PUSH,
			  "GGIT_DIRECTION_PUSH",
			  "push" },
			{ 0, NULL, NULL }
		};
		the_type = g_enum_register_static (
				g_intern_static_string ("GgitDirection"),
				values);
	}
	return the_type;
}


/* Generated data ends here */

