
/* This file is generated by glib-mkenums, do not modify it. This code is licensed under the same license as the containing project. Note that it links to GLib, so must comply with the LGPL linking clauses. */

#include "ggit-enum-types.h"
#include "ggit-annotated-commit.h"
#include "ggit-blame.h"
#include "ggit-blame-options.h"
#include "ggit-blob.h"
#include "ggit-blob-output-stream.h"
#include "ggit-branch.h"
#include "ggit-branch-enumerator.h"
#include "ggit-checkout-options.h"
#include "ggit-cherry-pick-options.h"
#include "ggit-clone-options.h"
#include "ggit-config.h"
#include "ggit-commit.h"
#include "ggit-commit-parents.h"
#include "ggit-config-entry.h"
#include "ggit-cred.h"
#include "ggit-cred-plaintext.h"
#include "ggit-diff.h"
#include "ggit-diff-binary.h"
#include "ggit-diff-binary-file.h"
#include "ggit-diff-delta.h"
#include "ggit-diff-file.h"
#include "ggit-diff-find-options.h"
#include "ggit-diff-format-email-options.h"
#include "ggit-diff-hunk.h"
#include "ggit-diff-line.h"
#include "ggit-diff-options.h"
#include "ggit-diff-similarity-metric.h"
#include "ggit-error.h"
#include "ggit-fetch-options.h"
#include "ggit-index.h"
#include "ggit-index-entry.h"
#include "ggit-index-entry-resolve-undo.h"
#include "ggit-main.h"
#include "ggit-mailmap.h"
#include "ggit-message.h"
#include "ggit-merge-options.h"
#include "ggit-native.h"
#include "ggit-note.h"
#include "ggit-object.h"
#include "ggit-object-factory.h"
#include "ggit-object-factory-base.h"
#include "ggit-oid.h"
#include "ggit-patch.h"
#include "ggit-proxy-options.h"
#include "ggit-push-options.h"
#include "ggit-rebase-operation.h"
#include "ggit-rebase-options.h"
#include "ggit-rebase.h"
#include "ggit-ref.h"
#include "ggit-ref-spec.h"
#include "ggit-reflog.h"
#include "ggit-reflog-entry.h"
#include "ggit-remote.h"
#include "ggit-remote-callbacks.h"
#include "ggit-repository.h"
#include "ggit-revert-options.h"
#include "ggit-revision-walker.h"
#include "ggit-signature.h"
#include "ggit-status-options.h"
#include "ggit-submodule.h"
#include "ggit-submodule-update-options.h"
#include "ggit-tag.h"
#include "ggit-transfer-progress.h"
#include "ggit-tree.h"
#include "ggit-tree-builder.h"
#include "ggit-tree-entry.h"
#include "ggit-types.h"
#include "ggit-version.h"
#include "ggit-cred-ssh-interactive.h"
#include "ggit-cred-ssh-key-from-agent.h"

#define C_ENUM(v) ((gint) v)
#define C_FLAGS(v) ((guint) v)

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

GType
ggit_branch_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_BRANCH_LOCAL), "GGIT_BRANCH_LOCAL", "local" },
    { C_ENUM(GGIT_BRANCH_REMOTE), "GGIT_BRANCH_REMOTE", "remote" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitBranchType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_feature_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GGIT_FEATURE_THREADS), "GGIT_FEATURE_THREADS", "threads" },
    { C_FLAGS(GGIT_FEATURE_HTTPS), "GGIT_FEATURE_HTTPS", "https" },
    { C_FLAGS(GGIT_FEATURE_SSH), "GGIT_FEATURE_SSH", "ssh" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GgitFeatureFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_diff_binary_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_DIFF_BINARY_NONE), "GGIT_DIFF_BINARY_NONE", "none" },
    { C_ENUM(GGIT_DIFF_BINARY_LITERAL), "GGIT_DIFF_BINARY_LITERAL", "literal" },
    { C_ENUM(GGIT_DIFF_BINARY_DELTA), "GGIT_DIFF_BINARY_DELTA", "delta" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitDiffBinaryType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

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

GType
ggit_config_level_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_CONFIG_LEVEL_PROGRAMDATA), "GGIT_CONFIG_LEVEL_PROGRAMDATA", "programdata" },
    { C_ENUM(GGIT_CONFIG_LEVEL_SYSTEM), "GGIT_CONFIG_LEVEL_SYSTEM", "system" },
    { C_ENUM(GGIT_CONFIG_LEVEL_XDG), "GGIT_CONFIG_LEVEL_XDG", "xdg" },
    { C_ENUM(GGIT_CONFIG_LEVEL_GLOBAL), "GGIT_CONFIG_LEVEL_GLOBAL", "global" },
    { C_ENUM(GGIT_CONFIG_LEVEL_LOCAL), "GGIT_CONFIG_LEVEL_LOCAL", "local" },
    { C_ENUM(GGIT_CONFIG_LEVEL_APP), "GGIT_CONFIG_LEVEL_APP", "app" },
    { C_ENUM(GGIT_CONFIG_LEVEL_HIGHEST), "GGIT_CONFIG_LEVEL_HIGHEST", "highest" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitConfigLevel"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_create_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GGIT_CREATE_NONE), "GGIT_CREATE_NONE", "none" },
    { C_FLAGS(GGIT_CREATE_FORCE), "GGIT_CREATE_FORCE", "force" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GgitCreateFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_delta_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_DELTA_UNMODIFIED), "GGIT_DELTA_UNMODIFIED", "unmodified" },
    { C_ENUM(GGIT_DELTA_ADDED), "GGIT_DELTA_ADDED", "added" },
    { C_ENUM(GGIT_DELTA_DELETED), "GGIT_DELTA_DELETED", "deleted" },
    { C_ENUM(GGIT_DELTA_MODIFIED), "GGIT_DELTA_MODIFIED", "modified" },
    { C_ENUM(GGIT_DELTA_RENAMED), "GGIT_DELTA_RENAMED", "renamed" },
    { C_ENUM(GGIT_DELTA_COPIED), "GGIT_DELTA_COPIED", "copied" },
    { C_ENUM(GGIT_DELTA_IGNORED), "GGIT_DELTA_IGNORED", "ignored" },
    { C_ENUM(GGIT_DELTA_UNTRACKED), "GGIT_DELTA_UNTRACKED", "untracked" },
    { C_ENUM(GGIT_DELTA_TYPECHANGE), "GGIT_DELTA_TYPECHANGE", "typechange" },
    { C_ENUM(GGIT_DELTA_UNREADABLE), "GGIT_DELTA_UNREADABLE", "unreadable" },
    { C_ENUM(GGIT_DELTA_CONFLICTED), "GGIT_DELTA_CONFLICTED", "conflicted" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitDeltaType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

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

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

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

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

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

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

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

GType
ggit_merge_file_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GGIT_MERGE_FILE_DEFAULT), "GGIT_MERGE_FILE_DEFAULT", "default" },
    { C_FLAGS(GGIT_MERGE_FILE_STYLE_MERGE), "GGIT_MERGE_FILE_STYLE_MERGE", "style-merge" },
    { C_FLAGS(GGIT_MERGE_FILE_STYLE_DIFF3), "GGIT_MERGE_FILE_STYLE_DIFF3", "style-diff3" },
    { C_FLAGS(GGIT_MERGE_FILE_SIMPLIFY_ALNUM), "GGIT_MERGE_FILE_SIMPLIFY_ALNUM", "simplify-alnum" },
    { C_FLAGS(GGIT_MERGE_FILE_IGNORE_WHITESPACE), "GGIT_MERGE_FILE_IGNORE_WHITESPACE", "ignore-whitespace" },
    { C_FLAGS(GGIT_MERGE_FILE_IGNORE_WHITESPACE_CHANGE), "GGIT_MERGE_FILE_IGNORE_WHITESPACE_CHANGE", "ignore-whitespace-change" },
    { C_FLAGS(GGIT_MERGE_FILE_IGNORE_WHITESPACE_EOL), "GGIT_MERGE_FILE_IGNORE_WHITESPACE_EOL", "ignore-whitespace-eol" },
    { C_FLAGS(GGIT_MERGE_FILE_DIFF_PATIENCE), "GGIT_MERGE_FILE_DIFF_PATIENCE", "diff-patience" },
    { C_FLAGS(GGIT_MERGE_FILE_DIFF_MINIMAL), "GGIT_MERGE_FILE_DIFF_MINIMAL", "diff-minimal" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GgitMergeFileFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_merge_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GGIT_MERGE_FIND_RENAMES), "GGIT_MERGE_FIND_RENAMES", "find-renames" },
    { C_FLAGS(GGIT_MERGE_FAIL_ON_CONFLICT), "GGIT_MERGE_FAIL_ON_CONFLICT", "fail-on-conflict" },
    { C_FLAGS(GGIT_MERGE_SKIP_REUC), "GGIT_MERGE_SKIP_REUC", "skip-reuc" },
    { C_FLAGS(GGIT_MERGE_NO_RECURSIVE), "GGIT_MERGE_NO_RECURSIVE", "no-recursive" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GgitMergeFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_proxy_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_PROXY_NONE), "GGIT_PROXY_NONE", "none" },
    { C_ENUM(GGIT_PROXY_AUTO), "GGIT_PROXY_AUTO", "auto" },
    { C_ENUM(GGIT_PROXY_SPECIFIED), "GGIT_PROXY_SPECIFIED", "specified" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitProxyType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_rebase_operation_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_REBASE_OPERATION_PICK), "GGIT_REBASE_OPERATION_PICK", "pick" },
    { C_ENUM(GGIT_REBASE_OPERATION_REWORD), "GGIT_REBASE_OPERATION_REWORD", "reword" },
    { C_ENUM(GGIT_REBASE_OPERATION_EDIT), "GGIT_REBASE_OPERATION_EDIT", "edit" },
    { C_ENUM(GGIT_REBASE_OPERATION_SQUASH), "GGIT_REBASE_OPERATION_SQUASH", "squash" },
    { C_ENUM(GGIT_REBASE_OPERATION_FIXUP), "GGIT_REBASE_OPERATION_FIXUP", "fixup" },
    { C_ENUM(GGIT_REBASE_OPERATION_EXEC), "GGIT_REBASE_OPERATION_EXEC", "exec" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitRebaseOperationType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_remote_download_tags_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED), "GGIT_REMOTE_DOWNLOAD_TAGS_UNSPECIFIED", "unspecified" },
    { C_ENUM(GGIT_REMOTE_DOWNLOAD_TAGS_AUTO), "GGIT_REMOTE_DOWNLOAD_TAGS_AUTO", "auto" },
    { C_ENUM(GGIT_REMOTE_DOWNLOAD_TAGS_NONE), "GGIT_REMOTE_DOWNLOAD_TAGS_NONE", "none" },
    { C_ENUM(GGIT_REMOTE_DOWNLOAD_TAGS_ALL), "GGIT_REMOTE_DOWNLOAD_TAGS_ALL", "all" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitRemoteDownloadTagsType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_remote_completion_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_REMOTE_COMPLETION_DOWNLOAD), "GGIT_REMOTE_COMPLETION_DOWNLOAD", "download" },
    { C_ENUM(GGIT_REMOTE_COMPLETION_INDEXING), "GGIT_REMOTE_COMPLETION_INDEXING", "indexing" },
    { C_ENUM(GGIT_REMOTE_COMPLETION_ERROR), "GGIT_REMOTE_COMPLETION_ERROR", "error" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitRemoteCompletionType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

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

GType
ggit_reset_type_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_RESET_SOFT), "GGIT_RESET_SOFT", "soft" },
    { C_ENUM(GGIT_RESET_MIXED), "GGIT_RESET_MIXED", "mixed" },
    { C_ENUM(GGIT_RESET_HARD), "GGIT_RESET_HARD", "hard" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitResetType"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

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

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

GType
ggit_status_flags_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GGIT_STATUS_CURRENT), "GGIT_STATUS_CURRENT", "current" },
    { C_FLAGS(GGIT_STATUS_INDEX_NEW), "GGIT_STATUS_INDEX_NEW", "index-new" },
    { C_FLAGS(GGIT_STATUS_INDEX_MODIFIED), "GGIT_STATUS_INDEX_MODIFIED", "index-modified" },
    { C_FLAGS(GGIT_STATUS_INDEX_DELETED), "GGIT_STATUS_INDEX_DELETED", "index-deleted" },
    { C_FLAGS(GGIT_STATUS_INDEX_RENAMED), "GGIT_STATUS_INDEX_RENAMED", "index-renamed" },
    { C_FLAGS(GGIT_STATUS_INDEX_TYPECHANGE), "GGIT_STATUS_INDEX_TYPECHANGE", "index-typechange" },
    { C_FLAGS(GGIT_STATUS_WORKING_TREE_NEW), "GGIT_STATUS_WORKING_TREE_NEW", "working-tree-new" },
    { C_FLAGS(GGIT_STATUS_WORKING_TREE_MODIFIED), "GGIT_STATUS_WORKING_TREE_MODIFIED", "working-tree-modified" },
    { C_FLAGS(GGIT_STATUS_WORKING_TREE_DELETED), "GGIT_STATUS_WORKING_TREE_DELETED", "working-tree-deleted" },
    { C_FLAGS(GGIT_STATUS_WORKING_TREE_TYPECHANGE), "GGIT_STATUS_WORKING_TREE_TYPECHANGE", "working-tree-typechange" },
    { C_FLAGS(GGIT_STATUS_WORKING_TREE_RENAMED), "GGIT_STATUS_WORKING_TREE_RENAMED", "working-tree-renamed" },
    { C_FLAGS(GGIT_STATUS_WORKING_TREE_UNREADABLE), "GGIT_STATUS_WORKING_TREE_UNREADABLE", "working-tree-unreadable" },
    { C_FLAGS(GGIT_STATUS_IGNORED), "GGIT_STATUS_IGNORED", "ignored" },
    { C_FLAGS(GGIT_STATUS_CONFLICTED), "GGIT_STATUS_CONFLICTED", "conflicted" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GgitStatusFlags"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_submodule_ignore_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_SUBMODULE_IGNORE_UNSPECIFIED), "GGIT_SUBMODULE_IGNORE_UNSPECIFIED", "unspecified" },
    { C_ENUM(GGIT_SUBMODULE_IGNORE_NONE), "GGIT_SUBMODULE_IGNORE_NONE", "none" },
    { C_ENUM(GGIT_SUBMODULE_IGNORE_UNTRACKED), "GGIT_SUBMODULE_IGNORE_UNTRACKED", "untracked" },
    { C_ENUM(GGIT_SUBMODULE_IGNORE_DIRTY), "GGIT_SUBMODULE_IGNORE_DIRTY", "dirty" },
    { C_ENUM(GGIT_SUBMODULE_IGNORE_ALL), "GGIT_SUBMODULE_IGNORE_ALL", "all" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitSubmoduleIgnore"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_submodule_recurse_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_SUBMODULE_RECURSE_NO), "GGIT_SUBMODULE_RECURSE_NO", "no" },
    { C_ENUM(GGIT_SUBMODULE_RECURSE_YES), "GGIT_SUBMODULE_RECURSE_YES", "yes" },
    { C_ENUM(GGIT_SUBMODULE_RECURSE_ONDEMAND), "GGIT_SUBMODULE_RECURSE_ONDEMAND", "ondemand" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitSubmoduleRecurse"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

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

GType
ggit_submodule_update_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_SUBMODULE_UPDATE_CHECKOUT), "GGIT_SUBMODULE_UPDATE_CHECKOUT", "checkout" },
    { C_ENUM(GGIT_SUBMODULE_UPDATE_REBASE), "GGIT_SUBMODULE_UPDATE_REBASE", "rebase" },
    { C_ENUM(GGIT_SUBMODULE_UPDATE_MERGE), "GGIT_SUBMODULE_UPDATE_MERGE", "merge" },
    { C_ENUM(GGIT_SUBMODULE_UPDATE_NONE), "GGIT_SUBMODULE_UPDATE_NONE", "none" },
    { C_ENUM(GGIT_SUBMODULE_UPDATE_DEFAULT), "GGIT_SUBMODULE_UPDATE_DEFAULT", "default" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitSubmoduleUpdate"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_tree_walk_mode_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_TREE_WALK_MODE_PRE), "GGIT_TREE_WALK_MODE_PRE", "pre" },
    { C_ENUM(GGIT_TREE_WALK_MODE_POST), "GGIT_TREE_WALK_MODE_POST", "post" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitTreeWalkMode"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

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

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

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

GType
ggit_packbuilder_stage_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_PACKBUILDER_STAGE_ADDING_OBJECTS), "GGIT_PACKBUILDER_STAGE_ADDING_OBJECTS", "adding-objects" },
    { C_ENUM(GGIT_PACKBUILDER_STAGE_DELTAFICATION), "GGIT_PACKBUILDER_STAGE_DELTAFICATION", "deltafication" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitPackbuilderStage"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_checkout_strategy_get_type (void)
{
static gsize gtype_id = 0;
static const GFlagsValue values[] = {
    { C_FLAGS(GGIT_CHECKOUT_NONE), "GGIT_CHECKOUT_NONE", "none" },
    { C_FLAGS(GGIT_CHECKOUT_SAFE), "GGIT_CHECKOUT_SAFE", "safe" },
    { C_FLAGS(GGIT_CHECKOUT_FORCE), "GGIT_CHECKOUT_FORCE", "force" },
    { C_FLAGS(GGIT_CHECKOUT_RECREATE_MISSING), "GGIT_CHECKOUT_RECREATE_MISSING", "recreate-missing" },
    { C_FLAGS(GGIT_CHECKOUT_ALLOW_CONFLICTS), "GGIT_CHECKOUT_ALLOW_CONFLICTS", "allow-conflicts" },
    { C_FLAGS(GGIT_CHECKOUT_REMOVE_UNTRACKED), "GGIT_CHECKOUT_REMOVE_UNTRACKED", "remove-untracked" },
    { C_FLAGS(GGIT_CHECKOUT_REMOVE_IGNORED), "GGIT_CHECKOUT_REMOVE_IGNORED", "remove-ignored" },
    { C_FLAGS(GGIT_CHECKOUT_UPDATE_ONLY), "GGIT_CHECKOUT_UPDATE_ONLY", "update-only" },
    { C_FLAGS(GGIT_CHECKOUT_DONT_UPDATE_INDEX), "GGIT_CHECKOUT_DONT_UPDATE_INDEX", "dont-update-index" },
    { C_FLAGS(GGIT_CHECKOUT_NO_REFRESH), "GGIT_CHECKOUT_NO_REFRESH", "no-refresh" },
    { C_FLAGS(GGIT_CHECKOUT_SKIP_UNMERGED), "GGIT_CHECKOUT_SKIP_UNMERGED", "skip-unmerged" },
    { C_FLAGS(GGIT_CHECKOUT_USE_OURS), "GGIT_CHECKOUT_USE_OURS", "use-ours" },
    { C_FLAGS(GGIT_CHECKOUT_USE_THEIRS), "GGIT_CHECKOUT_USE_THEIRS", "use-theirs" },
    { C_FLAGS(GGIT_CHECKOUT_DISABLE_PATHSPEC_MATCH), "GGIT_CHECKOUT_DISABLE_PATHSPEC_MATCH", "disable-pathspec-match" },
    { C_FLAGS(GGIT_CHECKOUT_SKIP_LOCKED_DIRECTORIES), "GGIT_CHECKOUT_SKIP_LOCKED_DIRECTORIES", "skip-locked-directories" },
    { C_FLAGS(GGIT_CHECKOUT_DONT_OVERWRITE_IGNORED), "GGIT_CHECKOUT_DONT_OVERWRITE_IGNORED", "dont-overwrite-ignored" },
    { C_FLAGS(GGIT_CHECKOUT_CONFLICT_STYLE_MERGE), "GGIT_CHECKOUT_CONFLICT_STYLE_MERGE", "conflict-style-merge" },
    { C_FLAGS(GGIT_CHECKOUT_CONFLICT_STYLE_DIFF3), "GGIT_CHECKOUT_CONFLICT_STYLE_DIFF3", "conflict-style-diff3" },
    { C_FLAGS(GGIT_CHECKOUT_DONT_REMOVE_EXISTING), "GGIT_CHECKOUT_DONT_REMOVE_EXISTING", "dont-remove-existing" },
    { C_FLAGS(GGIT_CHECKOUT_DONT_WRITE_INDEX), "GGIT_CHECKOUT_DONT_WRITE_INDEX", "dont-write-index" },
    { C_FLAGS(GGIT_CHECKOUT_UPDATE_SUBMODULES), "GGIT_CHECKOUT_UPDATE_SUBMODULES", "update-submodules" },
    { C_FLAGS(GGIT_CHECKOUT_UPDATE_SUBMODULES_IF_CHANGED), "GGIT_CHECKOUT_UPDATE_SUBMODULES_IF_CHANGED", "update-submodules-if-changed" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_flags_register_static (g_intern_static_string ("GgitCheckoutStrategy"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

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

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

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

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

GType
ggit_direction_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_DIRECTION_FETCH), "GGIT_DIRECTION_FETCH", "fetch" },
    { C_ENUM(GGIT_DIRECTION_PUSH), "GGIT_DIRECTION_PUSH", "push" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitDirection"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

GType
ggit_clone_local_get_type (void)
{
static gsize gtype_id = 0;
static const GEnumValue values[] = {
    { C_ENUM(GGIT_CLONE_LOCAL_AUTO), "GGIT_CLONE_LOCAL_AUTO", "auto" },
    { C_ENUM(GGIT_CLONE_LOCAL_LOCAL), "GGIT_CLONE_LOCAL_LOCAL", "local" },
    { C_ENUM(GGIT_CLONE_LOCAL_NO_LOCAL), "GGIT_CLONE_LOCAL_NO_LOCAL", "no-local" },
    { C_ENUM(GGIT_CLONE_LOCAL_NO_LINKS), "GGIT_CLONE_LOCAL_NO_LINKS", "no-links" },
{ 0, NULL, NULL }
        };
        if (g_once_init_enter (&gtype_id)) {
            GType new_type = g_enum_register_static (g_intern_static_string ("GgitCloneLocal"), values);
            g_once_init_leave (&gtype_id, new_type);
        }
        return (GType) gtype_id;
        }

/* Generated data ends here */

