// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use glib::translate::*;
use ostree_sys;
use std::fmt;

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum DeploymentUnlockedState {
    None,
    Development,
    Hotfix,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for DeploymentUnlockedState {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "DeploymentUnlockedState::{}", match *self {
            DeploymentUnlockedState::None => "None",
            DeploymentUnlockedState::Development => "Development",
            DeploymentUnlockedState::Hotfix => "Hotfix",
            _ => "Unknown",
        })
    }
}

#[doc(hidden)]
impl ToGlib for DeploymentUnlockedState {
    type GlibType = ostree_sys::OstreeDeploymentUnlockedState;

    fn to_glib(&self) -> ostree_sys::OstreeDeploymentUnlockedState {
        match *self {
            DeploymentUnlockedState::None => ostree_sys::OSTREE_DEPLOYMENT_UNLOCKED_NONE,
            DeploymentUnlockedState::Development => ostree_sys::OSTREE_DEPLOYMENT_UNLOCKED_DEVELOPMENT,
            DeploymentUnlockedState::Hotfix => ostree_sys::OSTREE_DEPLOYMENT_UNLOCKED_HOTFIX,
            DeploymentUnlockedState::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeDeploymentUnlockedState> for DeploymentUnlockedState {
    fn from_glib(value: ostree_sys::OstreeDeploymentUnlockedState) -> Self {
        match value {
            0 => DeploymentUnlockedState::None,
            1 => DeploymentUnlockedState::Development,
            2 => DeploymentUnlockedState::Hotfix,
            value => DeploymentUnlockedState::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum GpgSignatureAttr {
    Valid,
    SigExpired,
    KeyExpired,
    KeyRevoked,
    KeyMissing,
    Fingerprint,
    Timestamp,
    ExpTimestamp,
    PubkeyAlgoName,
    HashAlgoName,
    UserName,
    UserEmail,
    FingerprintPrimary,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for GpgSignatureAttr {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "GpgSignatureAttr::{}", match *self {
            GpgSignatureAttr::Valid => "Valid",
            GpgSignatureAttr::SigExpired => "SigExpired",
            GpgSignatureAttr::KeyExpired => "KeyExpired",
            GpgSignatureAttr::KeyRevoked => "KeyRevoked",
            GpgSignatureAttr::KeyMissing => "KeyMissing",
            GpgSignatureAttr::Fingerprint => "Fingerprint",
            GpgSignatureAttr::Timestamp => "Timestamp",
            GpgSignatureAttr::ExpTimestamp => "ExpTimestamp",
            GpgSignatureAttr::PubkeyAlgoName => "PubkeyAlgoName",
            GpgSignatureAttr::HashAlgoName => "HashAlgoName",
            GpgSignatureAttr::UserName => "UserName",
            GpgSignatureAttr::UserEmail => "UserEmail",
            GpgSignatureAttr::FingerprintPrimary => "FingerprintPrimary",
            _ => "Unknown",
        })
    }
}

#[doc(hidden)]
impl ToGlib for GpgSignatureAttr {
    type GlibType = ostree_sys::OstreeGpgSignatureAttr;

    fn to_glib(&self) -> ostree_sys::OstreeGpgSignatureAttr {
        match *self {
            GpgSignatureAttr::Valid => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_VALID,
            GpgSignatureAttr::SigExpired => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_SIG_EXPIRED,
            GpgSignatureAttr::KeyExpired => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_KEY_EXPIRED,
            GpgSignatureAttr::KeyRevoked => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_KEY_REVOKED,
            GpgSignatureAttr::KeyMissing => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_KEY_MISSING,
            GpgSignatureAttr::Fingerprint => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT,
            GpgSignatureAttr::Timestamp => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_TIMESTAMP,
            GpgSignatureAttr::ExpTimestamp => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_EXP_TIMESTAMP,
            GpgSignatureAttr::PubkeyAlgoName => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_PUBKEY_ALGO_NAME,
            GpgSignatureAttr::HashAlgoName => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_HASH_ALGO_NAME,
            GpgSignatureAttr::UserName => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_USER_NAME,
            GpgSignatureAttr::UserEmail => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_USER_EMAIL,
            GpgSignatureAttr::FingerprintPrimary => ostree_sys::OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT_PRIMARY,
            GpgSignatureAttr::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeGpgSignatureAttr> for GpgSignatureAttr {
    fn from_glib(value: ostree_sys::OstreeGpgSignatureAttr) -> Self {
        match value {
            0 => GpgSignatureAttr::Valid,
            1 => GpgSignatureAttr::SigExpired,
            2 => GpgSignatureAttr::KeyExpired,
            3 => GpgSignatureAttr::KeyRevoked,
            4 => GpgSignatureAttr::KeyMissing,
            5 => GpgSignatureAttr::Fingerprint,
            6 => GpgSignatureAttr::Timestamp,
            7 => GpgSignatureAttr::ExpTimestamp,
            8 => GpgSignatureAttr::PubkeyAlgoName,
            9 => GpgSignatureAttr::HashAlgoName,
            10 => GpgSignatureAttr::UserName,
            11 => GpgSignatureAttr::UserEmail,
            12 => GpgSignatureAttr::FingerprintPrimary,
            value => GpgSignatureAttr::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum GpgSignatureFormatFlags {
    GpgSignatureFormatDefault,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for GpgSignatureFormatFlags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "GpgSignatureFormatFlags::{}", match *self {
            GpgSignatureFormatFlags::GpgSignatureFormatDefault => "GpgSignatureFormatDefault",
            _ => "Unknown",
        })
    }
}

#[doc(hidden)]
impl ToGlib for GpgSignatureFormatFlags {
    type GlibType = ostree_sys::OstreeGpgSignatureFormatFlags;

    fn to_glib(&self) -> ostree_sys::OstreeGpgSignatureFormatFlags {
        match *self {
            GpgSignatureFormatFlags::GpgSignatureFormatDefault => ostree_sys::OSTREE_GPG_SIGNATURE_FORMAT_DEFAULT,
            GpgSignatureFormatFlags::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeGpgSignatureFormatFlags> for GpgSignatureFormatFlags {
    fn from_glib(value: ostree_sys::OstreeGpgSignatureFormatFlags) -> Self {
        match value {
            0 => GpgSignatureFormatFlags::GpgSignatureFormatDefault,
            value => GpgSignatureFormatFlags::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum ObjectType {
    File,
    DirTree,
    DirMeta,
    Commit,
    TombstoneCommit,
    CommitMeta,
    PayloadLink,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for ObjectType {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "ObjectType::{}", match *self {
            ObjectType::File => "File",
            ObjectType::DirTree => "DirTree",
            ObjectType::DirMeta => "DirMeta",
            ObjectType::Commit => "Commit",
            ObjectType::TombstoneCommit => "TombstoneCommit",
            ObjectType::CommitMeta => "CommitMeta",
            ObjectType::PayloadLink => "PayloadLink",
            _ => "Unknown",
        })
    }
}

#[doc(hidden)]
impl ToGlib for ObjectType {
    type GlibType = ostree_sys::OstreeObjectType;

    fn to_glib(&self) -> ostree_sys::OstreeObjectType {
        match *self {
            ObjectType::File => ostree_sys::OSTREE_OBJECT_TYPE_FILE,
            ObjectType::DirTree => ostree_sys::OSTREE_OBJECT_TYPE_DIR_TREE,
            ObjectType::DirMeta => ostree_sys::OSTREE_OBJECT_TYPE_DIR_META,
            ObjectType::Commit => ostree_sys::OSTREE_OBJECT_TYPE_COMMIT,
            ObjectType::TombstoneCommit => ostree_sys::OSTREE_OBJECT_TYPE_TOMBSTONE_COMMIT,
            ObjectType::CommitMeta => ostree_sys::OSTREE_OBJECT_TYPE_COMMIT_META,
            ObjectType::PayloadLink => ostree_sys::OSTREE_OBJECT_TYPE_PAYLOAD_LINK,
            ObjectType::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeObjectType> for ObjectType {
    fn from_glib(value: ostree_sys::OstreeObjectType) -> Self {
        match value {
            1 => ObjectType::File,
            2 => ObjectType::DirTree,
            3 => ObjectType::DirMeta,
            4 => ObjectType::Commit,
            5 => ObjectType::TombstoneCommit,
            6 => ObjectType::CommitMeta,
            7 => ObjectType::PayloadLink,
            value => ObjectType::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum RepoCheckoutMode {
    None,
    User,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for RepoCheckoutMode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "RepoCheckoutMode::{}", match *self {
            RepoCheckoutMode::None => "None",
            RepoCheckoutMode::User => "User",
            _ => "Unknown",
        })
    }
}

#[doc(hidden)]
impl ToGlib for RepoCheckoutMode {
    type GlibType = ostree_sys::OstreeRepoCheckoutMode;

    fn to_glib(&self) -> ostree_sys::OstreeRepoCheckoutMode {
        match *self {
            RepoCheckoutMode::None => ostree_sys::OSTREE_REPO_CHECKOUT_MODE_NONE,
            RepoCheckoutMode::User => ostree_sys::OSTREE_REPO_CHECKOUT_MODE_USER,
            RepoCheckoutMode::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoCheckoutMode> for RepoCheckoutMode {
    fn from_glib(value: ostree_sys::OstreeRepoCheckoutMode) -> Self {
        match value {
            0 => RepoCheckoutMode::None,
            1 => RepoCheckoutMode::User,
            value => RepoCheckoutMode::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum RepoCheckoutOverwriteMode {
    None,
    UnionFiles,
    AddFiles,
    UnionIdentical,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for RepoCheckoutOverwriteMode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "RepoCheckoutOverwriteMode::{}", match *self {
            RepoCheckoutOverwriteMode::None => "None",
            RepoCheckoutOverwriteMode::UnionFiles => "UnionFiles",
            RepoCheckoutOverwriteMode::AddFiles => "AddFiles",
            RepoCheckoutOverwriteMode::UnionIdentical => "UnionIdentical",
            _ => "Unknown",
        })
    }
}

#[doc(hidden)]
impl ToGlib for RepoCheckoutOverwriteMode {
    type GlibType = ostree_sys::OstreeRepoCheckoutOverwriteMode;

    fn to_glib(&self) -> ostree_sys::OstreeRepoCheckoutOverwriteMode {
        match *self {
            RepoCheckoutOverwriteMode::None => ostree_sys::OSTREE_REPO_CHECKOUT_OVERWRITE_NONE,
            RepoCheckoutOverwriteMode::UnionFiles => ostree_sys::OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_FILES,
            RepoCheckoutOverwriteMode::AddFiles => ostree_sys::OSTREE_REPO_CHECKOUT_OVERWRITE_ADD_FILES,
            RepoCheckoutOverwriteMode::UnionIdentical => ostree_sys::OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_IDENTICAL,
            RepoCheckoutOverwriteMode::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoCheckoutOverwriteMode> for RepoCheckoutOverwriteMode {
    fn from_glib(value: ostree_sys::OstreeRepoCheckoutOverwriteMode) -> Self {
        match value {
            0 => RepoCheckoutOverwriteMode::None,
            1 => RepoCheckoutOverwriteMode::UnionFiles,
            2 => RepoCheckoutOverwriteMode::AddFiles,
            3 => RepoCheckoutOverwriteMode::UnionIdentical,
            value => RepoCheckoutOverwriteMode::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum RepoMode {
    Bare,
    Archive,
    BareUser,
    BareUserOnly,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for RepoMode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "RepoMode::{}", match *self {
            RepoMode::Bare => "Bare",
            RepoMode::Archive => "Archive",
            RepoMode::BareUser => "BareUser",
            RepoMode::BareUserOnly => "BareUserOnly",
            _ => "Unknown",
        })
    }
}

#[doc(hidden)]
impl ToGlib for RepoMode {
    type GlibType = ostree_sys::OstreeRepoMode;

    fn to_glib(&self) -> ostree_sys::OstreeRepoMode {
        match *self {
            RepoMode::Bare => ostree_sys::OSTREE_REPO_MODE_BARE,
            RepoMode::Archive => ostree_sys::OSTREE_REPO_MODE_ARCHIVE,
            RepoMode::BareUser => ostree_sys::OSTREE_REPO_MODE_BARE_USER,
            RepoMode::BareUserOnly => ostree_sys::OSTREE_REPO_MODE_BARE_USER_ONLY,
            RepoMode::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoMode> for RepoMode {
    fn from_glib(value: ostree_sys::OstreeRepoMode) -> Self {
        match value {
            0 => RepoMode::Bare,
            1 => RepoMode::Archive,
            2 => RepoMode::BareUser,
            3 => RepoMode::BareUserOnly,
            value => RepoMode::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum RepoPruneFlags {
    None,
    NoPrune,
    RefsOnly,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for RepoPruneFlags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "RepoPruneFlags::{}", match *self {
            RepoPruneFlags::None => "None",
            RepoPruneFlags::NoPrune => "NoPrune",
            RepoPruneFlags::RefsOnly => "RefsOnly",
            _ => "Unknown",
        })
    }
}

#[doc(hidden)]
impl ToGlib for RepoPruneFlags {
    type GlibType = ostree_sys::OstreeRepoPruneFlags;

    fn to_glib(&self) -> ostree_sys::OstreeRepoPruneFlags {
        match *self {
            RepoPruneFlags::None => ostree_sys::OSTREE_REPO_PRUNE_FLAGS_NONE,
            RepoPruneFlags::NoPrune => ostree_sys::OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE,
            RepoPruneFlags::RefsOnly => ostree_sys::OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY,
            RepoPruneFlags::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoPruneFlags> for RepoPruneFlags {
    fn from_glib(value: ostree_sys::OstreeRepoPruneFlags) -> Self {
        match value {
            0 => RepoPruneFlags::None,
            1 => RepoPruneFlags::NoPrune,
            2 => RepoPruneFlags::RefsOnly,
            value => RepoPruneFlags::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum RepoRemoteChange {
    Add,
    AddIfNotExists,
    Delete,
    DeleteIfExists,
    Replace,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for RepoRemoteChange {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "RepoRemoteChange::{}", match *self {
            RepoRemoteChange::Add => "Add",
            RepoRemoteChange::AddIfNotExists => "AddIfNotExists",
            RepoRemoteChange::Delete => "Delete",
            RepoRemoteChange::DeleteIfExists => "DeleteIfExists",
            RepoRemoteChange::Replace => "Replace",
            _ => "Unknown",
        })
    }
}

#[doc(hidden)]
impl ToGlib for RepoRemoteChange {
    type GlibType = ostree_sys::OstreeRepoRemoteChange;

    fn to_glib(&self) -> ostree_sys::OstreeRepoRemoteChange {
        match *self {
            RepoRemoteChange::Add => ostree_sys::OSTREE_REPO_REMOTE_CHANGE_ADD,
            RepoRemoteChange::AddIfNotExists => ostree_sys::OSTREE_REPO_REMOTE_CHANGE_ADD_IF_NOT_EXISTS,
            RepoRemoteChange::Delete => ostree_sys::OSTREE_REPO_REMOTE_CHANGE_DELETE,
            RepoRemoteChange::DeleteIfExists => ostree_sys::OSTREE_REPO_REMOTE_CHANGE_DELETE_IF_EXISTS,
            RepoRemoteChange::Replace => ostree_sys::OSTREE_REPO_REMOTE_CHANGE_REPLACE,
            RepoRemoteChange::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeRepoRemoteChange> for RepoRemoteChange {
    fn from_glib(value: ostree_sys::OstreeRepoRemoteChange) -> Self {
        match value {
            0 => RepoRemoteChange::Add,
            1 => RepoRemoteChange::AddIfNotExists,
            2 => RepoRemoteChange::Delete,
            3 => RepoRemoteChange::DeleteIfExists,
            4 => RepoRemoteChange::Replace,
            value => RepoRemoteChange::__Unknown(value),
        }
    }
}

#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[derive(Clone, Copy)]
pub enum StaticDeltaGenerateOpt {
    Lowlatency,
    Major,
    #[doc(hidden)]
    __Unknown(i32),
}

impl fmt::Display for StaticDeltaGenerateOpt {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "StaticDeltaGenerateOpt::{}", match *self {
            StaticDeltaGenerateOpt::Lowlatency => "Lowlatency",
            StaticDeltaGenerateOpt::Major => "Major",
            _ => "Unknown",
        })
    }
}

#[doc(hidden)]
impl ToGlib for StaticDeltaGenerateOpt {
    type GlibType = ostree_sys::OstreeStaticDeltaGenerateOpt;

    fn to_glib(&self) -> ostree_sys::OstreeStaticDeltaGenerateOpt {
        match *self {
            StaticDeltaGenerateOpt::Lowlatency => ostree_sys::OSTREE_STATIC_DELTA_GENERATE_OPT_LOWLATENCY,
            StaticDeltaGenerateOpt::Major => ostree_sys::OSTREE_STATIC_DELTA_GENERATE_OPT_MAJOR,
            StaticDeltaGenerateOpt::__Unknown(value) => value
        }
    }
}

#[doc(hidden)]
impl FromGlib<ostree_sys::OstreeStaticDeltaGenerateOpt> for StaticDeltaGenerateOpt {
    fn from_glib(value: ostree_sys::OstreeStaticDeltaGenerateOpt) -> Self {
        match value {
            0 => StaticDeltaGenerateOpt::Lowlatency,
            1 => StaticDeltaGenerateOpt::Major,
            value => StaticDeltaGenerateOpt::__Unknown(value),
        }
    }
}