-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | OSTree bindings
--   
--   Bindings for OSTree, autogenerated by haskell-gi.
@package gi-ostree
@version 1.0.19


-- | Build time configuration used during code generation.
module GI.OSTree.Config

-- | Overrides used when generating these bindings.
overrides :: Text


module GI.OSTree.Constants

-- | ostree year version component (e.g. 2017 if <a>VERSION</a> is 2017.2)
--   
--   <i>Since: 2017.4</i>
pattern YEAR_VERSION :: Int32

-- | ostree version, encoded as a string, useful for printing and
--   concatenation.
--   
--   <i>Since: 2017.4</i>
pattern VERSION_S :: Text

-- | ostree version.
--   
--   <i>Since: 2017.4</i>
pattern VERSION :: Double

-- | <i>No description available in the introspection data.</i>
pattern TREE_GVARIANT_STRING :: Text

-- | The mtime used for stored files. This was originally 0, changed to 1
--   for a few releases, then was reverted due to regressions it introduced
--   from users who had been using zero before.
pattern TIMESTAMP :: Int32

-- | <i>No description available in the introspection data.</i>
pattern SUMMARY_SIG_GVARIANT_STRING :: Text

-- | <i>No description available in the introspection data.</i>
pattern SUMMARY_GVARIANT_STRING :: Text

-- | The name of the default ed25519 signing type.
--   
--   <i>Since: 2020.4</i>
pattern SIGN_NAME_ED25519 :: Text

-- | Length of a sha256 digest when expressed as a hexadecimal string
pattern SHA256_STRING_LEN :: Int32

-- | Length of a sha256 digest when expressed as raw bytes
pattern SHA256_DIGEST_LEN :: Int32

-- | The name of a ref which is used to store metadata for the entire
--   repository, such as its expected update time
--   (<tt>ostree.summary.expires</tt>), name, or new GPG keys. Metadata is
--   stored on contentless commits in the ref, and hence is signed with the
--   commits.
--   
--   This supersedes the additional metadata dictionary in the
--   <tt>summary</tt> file (see <a>repoRegenerateSummary</a>), as the use
--   of a ref means that the metadata for multiple upstream repositories
--   can be included in a single mirror repository, disambiguating the refs
--   using collection IDs. In order to support peer to peer redistribution
--   of repository metadata, repositories must set a collection ID
--   (<a>repoSetCollectionId</a>).
--   
--   Users of OSTree may place arbitrary metadata in commits on this ref,
--   but the keys must be namespaced by product or developer. For example,
--   <tt>exampleos.end-of-life</tt>. The <tt>ostree.</tt> prefix is
--   reserved.
--   
--   <i>Since: 2018.6</i>
pattern REPO_METADATA_REF :: Text

-- | ostree release version component (e.g. 2 if <a>VERSION</a> is 2017.2)
--   
--   <i>Since: 2017.4</i>
pattern RELEASE_VERSION :: Int32

-- | Filesystem path that is created on an ostree-booted system.
--   
--   <i>Since: 2022.2</i>
pattern PATH_BOOTED :: Text

-- | The name of a <tt>GKeyFile</tt> group for data that should not be
--   carried across upgrades. For more information, see
--   <a>deploymentOriginRemoveTransientState</a>.
--   
--   <i>Since: 2018.3</i>
pattern ORIGIN_TRANSIENT_GROUP :: Text

-- | GVariant type <tt>s</tt>. This key can be used in the repo metadata
--   which is stored in OSTREE_REPO_METADATA_REF as well as in the summary.
--   The semantics of this are that the remote repository wants clients to
--   update their remote config to add this collection ID (clients can't do
--   P2P operations involving a remote without a collection ID configured
--   on it, even if one is configured on the server side). Clients must
--   never change or remove a collection ID already set in their remote
--   config.
--   
--   Currently, OSTree does not implement changing a remote config based on
--   this key, but it may do so in a later release, and until then clients
--   such as Flatpak may implement it.
--   
--   This is a replacement for the similar metadata key implemented by
--   flatpak, <tt>xa.collection-id</tt>, which is now deprecated as clients
--   which supported it had bugs with their P2P implementations.
--   
--   <i>Since: 2018.9</i>
pattern META_KEY_DEPLOY_COLLECTION_ID :: Text

-- | GVariant type <tt>s</tt>: Contains the Linux kernel release (i.e.
--   <tt>uname -r</tt>)
--   
--   <i>Since: 2021.1</i>
pattern METADATA_KEY_LINUX :: Text

-- | GVariant type <tt>b</tt>: Set if this commit is intended to be
--   bootable
--   
--   <i>Since: 2021.1</i>
pattern METADATA_KEY_BOOTABLE :: Text

-- | This variable is no longer meaningful, it is kept only for
--   compatibility.
pattern MAX_METADATA_WARN_SIZE :: Int32

-- | Default limit for maximum permitted size in bytes of metadata objects
--   fetched over HTTP (including repo/config files, refs, and
--   commit/dirtree/dirmeta objects). This is an arbitrary number intended
--   to mitigate disk space exhaustion attacks.
pattern MAX_METADATA_SIZE :: Int32

-- | <i>No description available in the introspection data.</i>
pattern GPG_KEY_GVARIANT_STRING :: Text

-- | <i>No description available in the introspection data.</i>
pattern FILEMETA_GVARIANT_STRING :: Text

-- | <i>No description available in the introspection data.</i>
pattern DIRMETA_GVARIANT_STRING :: Text

-- | GVariant type <tt>s</tt>. This metadata key is used for version
--   numbers. A freeform string; the intention is that systems using ostree
--   do not interpret this semantically as traditional package managers do.
--   
--   This is the only ostree-defined metadata key that does not start with
--   <tt>ostree.</tt>.
--   
--   <i>Since: 2014.9</i>
pattern COMMIT_META_KEY_VERSION :: Text

-- | GVariant type <tt>s</tt>. This should hold a relatively short single
--   line value containing a human-readable "source" for a commit, intended
--   to be displayed near the origin ref. This is particularly useful for
--   systems that inject content into an OSTree commit from elsewhere - for
--   example, generating from an OCI or qcow2 image. Or if generating from
--   packages, the enabled repository names and their versions.
--   
--   Try to keep this key short (e.g. &lt; 80 characters) and
--   human-readable; if you desire machine readable data, consider
--   injecting separate metadata keys.
--   
--   <i>Since: 2017.13</i>
pattern COMMIT_META_KEY_SOURCE_TITLE :: Text

-- | GVariant type <tt>as</tt>; each element is a branch name. If this is
--   added to a commit, <tt>ostree_repo_pull()</tt> will enforce that the
--   commit was retrieved from one of the branch names in this array. This
--   prevents "sidegrade" attacks. The rationale for having this support
--   multiple branch names is that it helps support a "promotion" model of
--   taking a commit and moving it between development and production
--   branches.
--   
--   <i>Since: 2017.9</i>
pattern COMMIT_META_KEY_REF_BINDING :: Text

-- | GVariant type <tt>s</tt>. Should contain a refspec defining a new
--   target branch; <tt>ostree admin upgrade</tt> and
--   <tt>OstreeSysrootUpgrader</tt> will automatically initiate a rebase
--   upon encountering this metadata key.
--   
--   <i>Since: 2017.7</i>
pattern COMMIT_META_KEY_ENDOFLIFE_REBASE :: Text

-- | GVariant type <tt>s</tt>. This metadata key is used to display
--   vendor's message when an update stream for a particular branch ends.
--   It usually provides update instructions for the users.
--   
--   <i>Since: 2017.7</i>
pattern COMMIT_META_KEY_ENDOFLIFE :: Text

-- | GVariant type <tt>s</tt>. If this is added to a commit,
--   <tt>ostree_repo_pull()</tt> will enforce that the commit was retrieved
--   from a repository which has the same collection ID. See
--   <tt>ostree_repo_set_collection_id()</tt>. This is most useful in
--   concert with <tt>OSTREE_COMMIT_META_KEY_REF_BINDING</tt>, as it more
--   strongly binds the commit to the repository and branch.
--   
--   <i>Since: 2018.6</i>
pattern COMMIT_META_KEY_COLLECTION_BINDING :: Text

-- | GVariant type <tt>s</tt>. Intended to describe the CPU architecture.
--   This is a freeform string, and some distributions which have existing
--   package managers might want to match that schema. If you don't have a
--   prior schema, it's recommended to use <tt>uname -m</tt> by default
--   (i.e. the Linux kernel schema). In the future ostree might include a
--   builtin function to compare architectures.
--   
--   <i>Since: 2020.4</i>
pattern COMMIT_META_KEY_ARCHITECTURE :: Text

-- | <i>No description available in the introspection data.</i>
pattern COMMIT_GVARIANT_STRING :: Text


module GI.OSTree.Enums

-- | <i>No description available in the introspection data.</i>
data DeploymentUnlockedState

-- | <i>No description available in the introspection data.</i>
DeploymentUnlockedStateNone :: DeploymentUnlockedState

-- | <i>No description available in the introspection data.</i>
DeploymentUnlockedStateDevelopment :: DeploymentUnlockedState

-- | <i>No description available in the introspection data.</i>
DeploymentUnlockedStateHotfix :: DeploymentUnlockedState

-- | <i>No description available in the introspection data.</i>
DeploymentUnlockedStateTransient :: DeploymentUnlockedState

-- | Catch-all for unknown values
AnotherDeploymentUnlockedState :: Int -> DeploymentUnlockedState

-- | Errors returned by signature creation and verification operations in
--   OSTree. These may be returned by any API which creates or verifies
--   signatures.
--   
--   <i>Since: 2017.10</i>
data GpgError

-- | A signature was expected, but not found.
GpgErrorNoSignature :: GpgError

-- | A signature was malformed.
GpgErrorInvalidSignature :: GpgError

-- | A signature was found, but was created with a key not in the
--   configured keyrings.
GpgErrorMissingKey :: GpgError

-- | A signature was expired. Since: 2020.1.
GpgErrorExpiredSignature :: GpgError

-- | A signature was found, but the key used to sign it has expired. Since:
--   2020.1.
GpgErrorExpiredKey :: GpgError

-- | A signature was found, but the key used to sign it has been revoked.
--   Since: 2020.1.
GpgErrorRevokedKey :: GpgError

-- | Catch-all for unknown values
AnotherGpgError :: Int -> GpgError

-- | Catch exceptions of type <a>GpgError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchGpgError :: IO a -> (GpgError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>GpgError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleGpgError :: (GpgError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Signature attributes available from an <a>GpgVerifyResult</a>. The
--   attribute's <a>VariantType</a> is shown in brackets.
data GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_BOOLEAN</i></tt></i> Is the signature
--   valid?</li>
--   </ul>
GpgSignatureAttrValid :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_BOOLEAN</i></tt></i> Has the signature
--   expired?</li>
--   </ul>
GpgSignatureAttrSigExpired :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_BOOLEAN</i></tt></i> Has the signing key
--   expired?</li>
--   </ul>
GpgSignatureAttrKeyExpired :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_BOOLEAN</i></tt></i> Has the signing key
--   been revoked?</li>
--   </ul>
GpgSignatureAttrKeyRevoked :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_BOOLEAN</i></tt></i> Is the signing key
--   missing?</li>
--   </ul>
GpgSignatureAttrKeyMissing :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_STRING</i></tt></i> Fingerprint of the
--   signing key</li>
--   </ul>
GpgSignatureAttrFingerprint :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_INT64</i></tt></i> Signature creation
--   Unix timestamp</li>
--   </ul>
GpgSignatureAttrTimestamp :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_INT64</i></tt></i> Signature expiration
--   Unix timestamp (0 if no expiration)</li>
--   </ul>
GpgSignatureAttrExpTimestamp :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_STRING</i></tt></i> Name of the public
--   key algorithm used to create the signature</li>
--   </ul>
GpgSignatureAttrPubkeyAlgoName :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_STRING</i></tt></i> Name of the hash
--   algorithm used to create the signature</li>
--   </ul>
GpgSignatureAttrHashAlgoName :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_STRING</i></tt></i> The name of the
--   signing key's primary user</li>
--   </ul>
GpgSignatureAttrUserName :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_STRING</i></tt></i> The email address of
--   the signing key's primary user</li>
--   </ul>
GpgSignatureAttrUserEmail :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_STRING</i></tt></i> Fingerprint of the
--   signing key's primary key (will be the same as
--   OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT if the the signature is already
--   from the primary key rather than a subkey, and will be the empty
--   string if the key is missing.)</li>
--   </ul>
GpgSignatureAttrFingerprintPrimary :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_INT64</i></tt></i> Key expiration Unix
--   timestamp (0 if no expiration or if the key is missing)</li>
--   </ul>
GpgSignatureAttrKeyExpTimestamp :: GpgSignatureAttr

-- | <ul>
--   <li><i><tt><i>G_VARIANT_TYPE_INT64</i></tt></i> Key expiration Unix
--   timestamp of the signing key's primary key (will be the same as
--   OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP if the signing key is the
--   primary key and 0 if no expiration or if the key is missing)</li>
--   </ul>
GpgSignatureAttrKeyExpTimestampPrimary :: GpgSignatureAttr

-- | Catch-all for unknown values
AnotherGpgSignatureAttr :: Int -> GpgSignatureAttr

-- | Enumeration for core object types; <a>ObjectTypeFile</a> is for
--   content, the other types are metadata.
data ObjectType

-- | Content; regular file, symbolic link
ObjectTypeFile :: ObjectType

-- | List of children (trees or files), and metadata
ObjectTypeDirTree :: ObjectType

-- | Directory metadata
ObjectTypeDirMeta :: ObjectType

-- | Toplevel object, refers to tree and dirmeta for root
ObjectTypeCommit :: ObjectType

-- | Toplevel object, refers to a deleted commit
ObjectTypeTombstoneCommit :: ObjectType

-- | Detached metadata for a commit
ObjectTypeCommitMeta :: ObjectType

-- | Symlink to a .file given its checksum on the payload only.
ObjectTypePayloadLink :: ObjectType

-- | Detached xattrs content, for 'bare-split-xattrs' mode.
ObjectTypeFileXattrs :: ObjectType

-- | Hardlink to a .file-xattrs given the checksum of its .file object.
ObjectTypeFileXattrsLink :: ObjectType

-- | Catch-all for unknown values
AnotherObjectType :: Int -> ObjectType

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2018.2</i>
data RepoCheckoutFilterResult

-- | Do checkout this object
RepoCheckoutFilterResultAllow :: RepoCheckoutFilterResult

-- | Ignore this object
RepoCheckoutFilterResultSkip :: RepoCheckoutFilterResult

-- | Catch-all for unknown values
AnotherRepoCheckoutFilterResult :: Int -> RepoCheckoutFilterResult

-- | <i>No description available in the introspection data.</i>
data RepoCheckoutMode

-- | No special options
RepoCheckoutModeNone :: RepoCheckoutMode

-- | Ignore uid/gid of files
RepoCheckoutModeUser :: RepoCheckoutMode

-- | Catch-all for unknown values
AnotherRepoCheckoutMode :: Int -> RepoCheckoutMode

-- | <i>No description available in the introspection data.</i>
data RepoCheckoutOverwriteMode

-- | No special options
RepoCheckoutOverwriteModeNone :: RepoCheckoutOverwriteMode

-- | When layering checkouts, <tt><i>unlink()</i></tt> and replace existing
--   files, but do not modify existing directories (unless whiteouts are
--   enabled, then directories are replaced)
RepoCheckoutOverwriteModeUnionFiles :: RepoCheckoutOverwriteMode

-- | Only add new files/directories
RepoCheckoutOverwriteModeAddFiles :: RepoCheckoutOverwriteMode

-- | Like UNION_FILES, but error if files are not identical (requires
--   hardlink checkouts)
RepoCheckoutOverwriteModeUnionIdentical :: RepoCheckoutOverwriteMode

-- | Catch-all for unknown values
AnotherRepoCheckoutOverwriteMode :: Int -> RepoCheckoutOverwriteMode

-- | <i>No description available in the introspection data.</i>
data RepoCommitFilterResult

-- | Do commit this object
RepoCommitFilterResultAllow :: RepoCommitFilterResult

-- | Ignore this object
RepoCommitFilterResultSkip :: RepoCommitFilterResult

-- | Catch-all for unknown values
AnotherRepoCommitFilterResult :: Int -> RepoCommitFilterResult

-- | <i>No description available in the introspection data.</i>
data RepoCommitIterResult

-- | <i>No description available in the introspection data.</i>
RepoCommitIterResultError :: RepoCommitIterResult

-- | <i>No description available in the introspection data.</i>
RepoCommitIterResultEnd :: RepoCommitIterResult

-- | <i>No description available in the introspection data.</i>
RepoCommitIterResultFile :: RepoCommitIterResult

-- | <i>No description available in the introspection data.</i>
RepoCommitIterResultDir :: RepoCommitIterResult

-- | Catch-all for unknown values
AnotherRepoCommitIterResult :: Int -> RepoCommitIterResult

-- | Flags controlling repository locking.
--   
--   <i>Since: 2021.3</i>
data RepoLockType

-- | A "read only" lock; multiple readers are allowed.
RepoLockTypeShared :: RepoLockType

-- | A writable lock at most one writer can be active, and zero readers.
RepoLockTypeExclusive :: RepoLockType

-- | Catch-all for unknown values
AnotherRepoLockType :: Int -> RepoLockType

-- | See the documentation of <a>Repo</a> for more information about the
--   possible modes.
data RepoMode

-- | Files are stored as themselves; checkouts are hardlinks; can only be
--   written as root
RepoModeBare :: RepoMode

-- | Files are compressed, should be owned by non-root. Can be served via
--   HTTP. Since: 2017.12
RepoModeArchive :: RepoMode

-- | Legacy alias for <tt>OSTREE_REPO_MODE_ARCHIVE</tt>
RepoModeArchiveZ2 :: RepoMode

-- | Files are stored as themselves, except ownership; can be written by
--   user. Hardlinks work only in user checkouts.
RepoModeBareUser :: RepoMode

-- | Same as BARE_USER, but all metadata is not stored, so it can only be
--   used for user checkouts. Does not need xattrs.
RepoModeBareUserOnly :: RepoMode

-- | Same as BARE_USER, but xattrs are stored separately from file content,
--   with dedicated object types.
RepoModeBareSplitXattrs :: RepoMode

-- | Catch-all for unknown values
AnotherRepoMode :: Int -> RepoMode

-- | The remote change operation.
data RepoRemoteChange

-- | Add a remote
RepoRemoteChangeAdd :: RepoRemoteChange

-- | Like above, but do nothing if the remote exists
RepoRemoteChangeAddIfNotExists :: RepoRemoteChange

-- | Delete a remote
RepoRemoteChangeDelete :: RepoRemoteChange

-- | Delete a remote, do nothing if the remote does not exist
RepoRemoteChangeDeleteIfExists :: RepoRemoteChange

-- | Add or replace a remote (Since: 2019.2)
RepoRemoteChangeReplace :: RepoRemoteChange

-- | Catch-all for unknown values
AnotherRepoRemoteChange :: Int -> RepoRemoteChange

-- | Parameters controlling optimization of static deltas.
data StaticDeltaGenerateOpt

-- | Optimize for speed of delta creation over space
StaticDeltaGenerateOptLowlatency :: StaticDeltaGenerateOpt

-- | Optimize for delta size (may be very slow)
StaticDeltaGenerateOptMajor :: StaticDeltaGenerateOpt

-- | Catch-all for unknown values
AnotherStaticDeltaGenerateOpt :: Int -> StaticDeltaGenerateOpt

-- | Flags controlling static delta index generation.
data StaticDeltaIndexFlags

-- | No special flags
StaticDeltaIndexFlagsStaticDeltaIndexFlagsNone :: StaticDeltaIndexFlags

-- | Catch-all for unknown values
AnotherStaticDeltaIndexFlags :: Int -> StaticDeltaIndexFlags
instance GHC.Classes.Eq GI.OSTree.Enums.StaticDeltaIndexFlags
instance GHC.Show.Show GI.OSTree.Enums.StaticDeltaIndexFlags
instance GHC.Classes.Eq GI.OSTree.Enums.StaticDeltaGenerateOpt
instance GHC.Show.Show GI.OSTree.Enums.StaticDeltaGenerateOpt
instance GHC.Classes.Eq GI.OSTree.Enums.RepoRemoteChange
instance GHC.Show.Show GI.OSTree.Enums.RepoRemoteChange
instance GHC.Classes.Eq GI.OSTree.Enums.RepoMode
instance GHC.Show.Show GI.OSTree.Enums.RepoMode
instance GHC.Classes.Eq GI.OSTree.Enums.RepoLockType
instance GHC.Show.Show GI.OSTree.Enums.RepoLockType
instance GHC.Classes.Eq GI.OSTree.Enums.RepoCommitIterResult
instance GHC.Show.Show GI.OSTree.Enums.RepoCommitIterResult
instance GHC.Classes.Eq GI.OSTree.Enums.RepoCommitFilterResult
instance GHC.Show.Show GI.OSTree.Enums.RepoCommitFilterResult
instance GHC.Classes.Eq GI.OSTree.Enums.RepoCheckoutOverwriteMode
instance GHC.Show.Show GI.OSTree.Enums.RepoCheckoutOverwriteMode
instance GHC.Classes.Eq GI.OSTree.Enums.RepoCheckoutMode
instance GHC.Show.Show GI.OSTree.Enums.RepoCheckoutMode
instance GHC.Classes.Eq GI.OSTree.Enums.RepoCheckoutFilterResult
instance GHC.Show.Show GI.OSTree.Enums.RepoCheckoutFilterResult
instance GHC.Classes.Eq GI.OSTree.Enums.ObjectType
instance GHC.Show.Show GI.OSTree.Enums.ObjectType
instance GHC.Classes.Eq GI.OSTree.Enums.GpgSignatureAttr
instance GHC.Show.Show GI.OSTree.Enums.GpgSignatureAttr
instance GHC.Classes.Eq GI.OSTree.Enums.GpgError
instance GHC.Show.Show GI.OSTree.Enums.GpgError
instance GHC.Classes.Eq GI.OSTree.Enums.DeploymentUnlockedState
instance GHC.Show.Show GI.OSTree.Enums.DeploymentUnlockedState
instance GHC.Enum.Enum GI.OSTree.Enums.DeploymentUnlockedState
instance GHC.Classes.Ord GI.OSTree.Enums.DeploymentUnlockedState
instance GHC.Enum.Enum GI.OSTree.Enums.GpgError
instance GHC.Classes.Ord GI.OSTree.Enums.GpgError
instance Data.GI.Base.GError.GErrorClass GI.OSTree.Enums.GpgError
instance GHC.Enum.Enum GI.OSTree.Enums.GpgSignatureAttr
instance GHC.Classes.Ord GI.OSTree.Enums.GpgSignatureAttr
instance GHC.Enum.Enum GI.OSTree.Enums.ObjectType
instance GHC.Classes.Ord GI.OSTree.Enums.ObjectType
instance GHC.Enum.Enum GI.OSTree.Enums.RepoCheckoutFilterResult
instance GHC.Classes.Ord GI.OSTree.Enums.RepoCheckoutFilterResult
instance GHC.Enum.Enum GI.OSTree.Enums.RepoCheckoutMode
instance GHC.Classes.Ord GI.OSTree.Enums.RepoCheckoutMode
instance GHC.Enum.Enum GI.OSTree.Enums.RepoCheckoutOverwriteMode
instance GHC.Classes.Ord GI.OSTree.Enums.RepoCheckoutOverwriteMode
instance GHC.Enum.Enum GI.OSTree.Enums.RepoCommitFilterResult
instance GHC.Classes.Ord GI.OSTree.Enums.RepoCommitFilterResult
instance GHC.Enum.Enum GI.OSTree.Enums.RepoCommitIterResult
instance GHC.Classes.Ord GI.OSTree.Enums.RepoCommitIterResult
instance GHC.Enum.Enum GI.OSTree.Enums.RepoLockType
instance GHC.Classes.Ord GI.OSTree.Enums.RepoLockType
instance GHC.Enum.Enum GI.OSTree.Enums.RepoMode
instance GHC.Classes.Ord GI.OSTree.Enums.RepoMode
instance GHC.Enum.Enum GI.OSTree.Enums.RepoRemoteChange
instance GHC.Classes.Ord GI.OSTree.Enums.RepoRemoteChange
instance GHC.Enum.Enum GI.OSTree.Enums.StaticDeltaGenerateOpt
instance GHC.Classes.Ord GI.OSTree.Enums.StaticDeltaGenerateOpt
instance GHC.Enum.Enum GI.OSTree.Enums.StaticDeltaIndexFlags
instance GHC.Classes.Ord GI.OSTree.Enums.StaticDeltaIndexFlags


module GI.OSTree.Flags

-- | Flags influencing checksumming logic.
--   
--   <i>Since: 2017.13</i>
data ChecksumFlags

-- | Default checksumming without tweaks. (Since: 2017.13.)
ChecksumFlagsNone :: ChecksumFlags

-- | Ignore xattrs when checksumming. (Since: 2017.13.)
ChecksumFlagsIgnoreXattrs :: ChecksumFlags

-- | Use canonical uid/gid/mode values, for bare-user-only mode. (Since:
--   2021.4.)
ChecksumFlagsCanonicalPermissions :: ChecksumFlags

-- | Catch-all for unknown values
AnotherChecksumFlags :: Int -> ChecksumFlags

-- | <i>No description available in the introspection data.</i>
data DiffFlags

-- | <i>No description available in the introspection data.</i>
DiffFlagsNone :: DiffFlags

-- | <i>No description available in the introspection data.</i>
DiffFlagsIgnoreXattrs :: DiffFlags

-- | Catch-all for unknown values
AnotherDiffFlags :: Int -> DiffFlags

-- | Formatting flags for <a>gpgVerifyResultDescribe</a>. Currently there's
--   only one possible output format, but this enumeration allows for
--   future variations.
data GpgSignatureFormatFlags

-- | Use the default output format
GpgSignatureFormatFlagsGpgSignatureFormatDefault :: GpgSignatureFormatFlags

-- | Catch-all for unknown values
AnotherGpgSignatureFormatFlags :: Int -> GpgSignatureFormatFlags

-- | Flags modifying commit behavior. In bare-user-only mode,
--   <i><tt>oSTREEREPOCOMMITMODIFIERFLAGSCANONICALPERMISSIONS</tt></i> and
--   <i><tt>oSTREEREPOCOMMITMODIFIERFLAGSSKIPXATTRS</tt></i> are
--   automatically enabled.
data RepoCommitModifierFlags

-- | No special flags
RepoCommitModifierFlagsNone :: RepoCommitModifierFlags

-- | Do not process extended attributes
RepoCommitModifierFlagsSkipXattrs :: RepoCommitModifierFlags

-- | Generate size information.
RepoCommitModifierFlagsGenerateSizes :: RepoCommitModifierFlags

-- | Canonicalize permissions.
RepoCommitModifierFlagsCanonicalPermissions :: RepoCommitModifierFlags

-- | Emit an error if configured SELinux policy does not provide a label
RepoCommitModifierFlagsErrorOnUnlabeled :: RepoCommitModifierFlags

-- | Delete added files/directories after commit; Since: 2017.13
RepoCommitModifierFlagsConsume :: RepoCommitModifierFlags

-- | If a devino cache hit is found, skip modifier filters (non-directories
--   only); Since: 2017.14
RepoCommitModifierFlagsDevinoCanonical :: RepoCommitModifierFlags

-- | For SELinux and other systems, label /usr/etc as if it was /etc.
RepoCommitModifierFlagsSelinuxLabelV1 :: RepoCommitModifierFlags

-- | Catch-all for unknown values
AnotherRepoCommitModifierFlags :: Int -> RepoCommitModifierFlags

-- | Flags representing the state of a commit in the local repository, as
--   returned by <a>repoLoadCommit</a>.
--   
--   <i>Since: 2015.7</i>
data RepoCommitState

-- | Commit is complete. This is the default. (Since: 2017.14.)
RepoCommitStateNormal :: RepoCommitState

-- | One or more objects are missing from the local copy of the commit, but
--   metadata is present. (Since: 2015.7.)
RepoCommitStatePartial :: RepoCommitState

-- | One or more objects are missing from the local copy of the commit, due
--   to an fsck --delete. (Since: 2019.4.)
RepoCommitStateFsckPartial :: RepoCommitState

-- | Catch-all for unknown values
AnotherRepoCommitState :: Int -> RepoCommitState

-- | <i>No description available in the introspection data.</i>
data RepoCommitTraverseFlags

-- | No special options for traverse
RepoCommitTraverseFlagsNone :: RepoCommitTraverseFlags

-- | Traverse and retrieve only commit objects. (Since: 2022.2)
RepoCommitTraverseFlagsCommitOnly :: RepoCommitTraverseFlags

-- | Catch-all for unknown values
AnotherRepoCommitTraverseFlags :: Int -> RepoCommitTraverseFlags

-- | <i>No description available in the introspection data.</i>
data RepoListObjectsFlags

-- | List only loose (plain file) objects
RepoListObjectsFlagsLoose :: RepoListObjectsFlags

-- | List only packed (compacted into blobs) objects
RepoListObjectsFlagsPacked :: RepoListObjectsFlags

-- | List all objects
RepoListObjectsFlagsAll :: RepoListObjectsFlags

-- | Only list objects in this repo, not parents
RepoListObjectsFlagsNoParents :: RepoListObjectsFlags

-- | Catch-all for unknown values
AnotherRepoListObjectsFlags :: Int -> RepoListObjectsFlags

-- | <i>No description available in the introspection data.</i>
data RepoListRefsExtFlags

-- | No flags.
RepoListRefsExtFlagsNone :: RepoListRefsExtFlags

-- | Only list aliases. Since: 2017.10
RepoListRefsExtFlagsAliases :: RepoListRefsExtFlags

-- | Exclude remote refs. Since: 2017.11
RepoListRefsExtFlagsExcludeRemotes :: RepoListRefsExtFlags

-- | Exclude mirrored refs. Since: 2019.2
RepoListRefsExtFlagsExcludeMirrors :: RepoListRefsExtFlags

-- | Catch-all for unknown values
AnotherRepoListRefsExtFlags :: Int -> RepoListRefsExtFlags

-- | <i>No description available in the introspection data.</i>
data RepoPruneFlags

-- | No special options for pruning
RepoPruneFlagsNone :: RepoPruneFlags

-- | Don't actually delete objects
RepoPruneFlagsNoPrune :: RepoPruneFlags

-- | Do not traverse individual commit objects, only follow refs for
--   reachability calculations
RepoPruneFlagsRefsOnly :: RepoPruneFlags

-- | Only traverse commit objects. (Since 2022.2)
RepoPruneFlagsCommitOnly :: RepoPruneFlags

-- | Catch-all for unknown values
AnotherRepoPruneFlags :: Int -> RepoPruneFlags

-- | <i>No description available in the introspection data.</i>
data RepoPullFlags

-- | No special options for pull
RepoPullFlagsNone :: RepoPullFlags

-- | Write out refs suitable for mirrors and fetch all refs if none
--   requested
RepoPullFlagsMirror :: RepoPullFlags

-- | Fetch only the commit metadata
RepoPullFlagsCommitOnly :: RepoPullFlags

-- | Do verify checksums of local (filesystem-accessible) repositories
--   (defaults on for HTTP)
RepoPullFlagsUntrusted :: RepoPullFlags

-- | Since 2017.7. Reject writes of content objects with modes outside of
--   0775.
RepoPullFlagsBareuseronlyFiles :: RepoPullFlags

-- | Don't verify checksums of objects HTTP repositories (Since: 2017.12)
RepoPullFlagsTrustedHttp :: RepoPullFlags

-- | Catch-all for unknown values
AnotherRepoPullFlags :: Int -> RepoPullFlags

-- | <i>No description available in the introspection data.</i>
data RepoResolveRevExtFlags

-- | No flags.
RepoResolveRevExtFlagsNone :: RepoResolveRevExtFlags

-- | Exclude remote and mirrored refs. Since: 2019.2
RepoResolveRevExtFlagsLocalOnly :: RepoResolveRevExtFlags

-- | Catch-all for unknown values
AnotherRepoResolveRevExtFlags :: Int -> RepoResolveRevExtFlags

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2021.4</i>
data RepoVerifyFlags

-- | No flags
RepoVerifyFlagsNone :: RepoVerifyFlags

-- | Skip GPG verification
RepoVerifyFlagsNoGpg :: RepoVerifyFlags

-- | Skip all other signature verification methods
RepoVerifyFlagsNoSignapi :: RepoVerifyFlags

-- | Catch-all for unknown values
AnotherRepoVerifyFlags :: Int -> RepoVerifyFlags

-- | <i>No description available in the introspection data.</i>
data SePolicyRestoreconFlags

-- | <i>No description available in the introspection data.</i>
SePolicyRestoreconFlagsNone :: SePolicyRestoreconFlags

-- | <i>No description available in the introspection data.</i>
SePolicyRestoreconFlagsAllowNolabel :: SePolicyRestoreconFlags

-- | <i>No description available in the introspection data.</i>
SePolicyRestoreconFlagsKeepExisting :: SePolicyRestoreconFlags

-- | Catch-all for unknown values
AnotherSePolicyRestoreconFlags :: Int -> SePolicyRestoreconFlags

-- | <i>No description available in the introspection data.</i>
data SysrootSimpleWriteDeploymentFlags

-- | <i>No description available in the introspection data.</i>
SysrootSimpleWriteDeploymentFlagsNone :: SysrootSimpleWriteDeploymentFlags

-- | <i>No description available in the introspection data.</i>
SysrootSimpleWriteDeploymentFlagsRetain :: SysrootSimpleWriteDeploymentFlags

-- | <i>No description available in the introspection data.</i>
SysrootSimpleWriteDeploymentFlagsNotDefault :: SysrootSimpleWriteDeploymentFlags

-- | <i>No description available in the introspection data.</i>
SysrootSimpleWriteDeploymentFlagsNoClean :: SysrootSimpleWriteDeploymentFlags

-- | <i>No description available in the introspection data.</i>
SysrootSimpleWriteDeploymentFlagsRetainPending :: SysrootSimpleWriteDeploymentFlags

-- | <i>No description available in the introspection data.</i>
SysrootSimpleWriteDeploymentFlagsRetainRollback :: SysrootSimpleWriteDeploymentFlags

-- | Catch-all for unknown values
AnotherSysrootSimpleWriteDeploymentFlags :: Int -> SysrootSimpleWriteDeploymentFlags

-- | Flags controlling operation of an <a>SysrootUpgrader</a>.
data SysrootUpgraderFlags

-- | Do not error if the origin has an unconfigured-state key
SysrootUpgraderFlagsIgnoreUnconfigured :: SysrootUpgraderFlags

-- | Enable "staging" (finalization at shutdown); recommended (Since:
--   2021.4)
SysrootUpgraderFlagsStage :: SysrootUpgraderFlags

-- | <i>No description available in the introspection data.</i>
SysrootUpgraderFlagsKexec :: SysrootUpgraderFlags

-- | Catch-all for unknown values
AnotherSysrootUpgraderFlags :: Int -> SysrootUpgraderFlags

-- | <i>No description available in the introspection data.</i>
data SysrootUpgraderPullFlags

-- | <i>No description available in the introspection data.</i>
SysrootUpgraderPullFlagsNone :: SysrootUpgraderPullFlags

-- | <i>No description available in the introspection data.</i>
SysrootUpgraderPullFlagsAllowOlder :: SysrootUpgraderPullFlags

-- | <i>No description available in the introspection data.</i>
SysrootUpgraderPullFlagsSynthetic :: SysrootUpgraderPullFlags

-- | Catch-all for unknown values
AnotherSysrootUpgraderPullFlags :: Int -> SysrootUpgraderPullFlags
instance GHC.Classes.Eq GI.OSTree.Flags.SysrootUpgraderPullFlags
instance GHC.Show.Show GI.OSTree.Flags.SysrootUpgraderPullFlags
instance GHC.Classes.Eq GI.OSTree.Flags.SysrootUpgraderFlags
instance GHC.Show.Show GI.OSTree.Flags.SysrootUpgraderFlags
instance GHC.Classes.Eq GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlags
instance GHC.Show.Show GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlags
instance GHC.Classes.Eq GI.OSTree.Flags.SePolicyRestoreconFlags
instance GHC.Show.Show GI.OSTree.Flags.SePolicyRestoreconFlags
instance GHC.Classes.Eq GI.OSTree.Flags.RepoVerifyFlags
instance GHC.Show.Show GI.OSTree.Flags.RepoVerifyFlags
instance GHC.Classes.Eq GI.OSTree.Flags.RepoResolveRevExtFlags
instance GHC.Show.Show GI.OSTree.Flags.RepoResolveRevExtFlags
instance GHC.Classes.Eq GI.OSTree.Flags.RepoPullFlags
instance GHC.Show.Show GI.OSTree.Flags.RepoPullFlags
instance GHC.Classes.Eq GI.OSTree.Flags.RepoPruneFlags
instance GHC.Show.Show GI.OSTree.Flags.RepoPruneFlags
instance GHC.Classes.Eq GI.OSTree.Flags.RepoListRefsExtFlags
instance GHC.Show.Show GI.OSTree.Flags.RepoListRefsExtFlags
instance GHC.Classes.Eq GI.OSTree.Flags.RepoListObjectsFlags
instance GHC.Show.Show GI.OSTree.Flags.RepoListObjectsFlags
instance GHC.Classes.Eq GI.OSTree.Flags.RepoCommitTraverseFlags
instance GHC.Show.Show GI.OSTree.Flags.RepoCommitTraverseFlags
instance GHC.Classes.Eq GI.OSTree.Flags.RepoCommitState
instance GHC.Show.Show GI.OSTree.Flags.RepoCommitState
instance GHC.Classes.Eq GI.OSTree.Flags.RepoCommitModifierFlags
instance GHC.Show.Show GI.OSTree.Flags.RepoCommitModifierFlags
instance GHC.Classes.Eq GI.OSTree.Flags.GpgSignatureFormatFlags
instance GHC.Show.Show GI.OSTree.Flags.GpgSignatureFormatFlags
instance GHC.Classes.Eq GI.OSTree.Flags.DiffFlags
instance GHC.Show.Show GI.OSTree.Flags.DiffFlags
instance GHC.Classes.Eq GI.OSTree.Flags.ChecksumFlags
instance GHC.Show.Show GI.OSTree.Flags.ChecksumFlags
instance GHC.Enum.Enum GI.OSTree.Flags.ChecksumFlags
instance GHC.Classes.Ord GI.OSTree.Flags.ChecksumFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.ChecksumFlags
instance GHC.Enum.Enum GI.OSTree.Flags.DiffFlags
instance GHC.Classes.Ord GI.OSTree.Flags.DiffFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.DiffFlags
instance GHC.Enum.Enum GI.OSTree.Flags.GpgSignatureFormatFlags
instance GHC.Classes.Ord GI.OSTree.Flags.GpgSignatureFormatFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.GpgSignatureFormatFlags
instance GHC.Enum.Enum GI.OSTree.Flags.RepoCommitModifierFlags
instance GHC.Classes.Ord GI.OSTree.Flags.RepoCommitModifierFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.RepoCommitModifierFlags
instance GHC.Enum.Enum GI.OSTree.Flags.RepoCommitState
instance GHC.Classes.Ord GI.OSTree.Flags.RepoCommitState
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.RepoCommitState
instance GHC.Enum.Enum GI.OSTree.Flags.RepoCommitTraverseFlags
instance GHC.Classes.Ord GI.OSTree.Flags.RepoCommitTraverseFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.RepoCommitTraverseFlags
instance GHC.Enum.Enum GI.OSTree.Flags.RepoListObjectsFlags
instance GHC.Classes.Ord GI.OSTree.Flags.RepoListObjectsFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.RepoListObjectsFlags
instance GHC.Enum.Enum GI.OSTree.Flags.RepoListRefsExtFlags
instance GHC.Classes.Ord GI.OSTree.Flags.RepoListRefsExtFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.RepoListRefsExtFlags
instance GHC.Enum.Enum GI.OSTree.Flags.RepoPruneFlags
instance GHC.Classes.Ord GI.OSTree.Flags.RepoPruneFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.RepoPruneFlags
instance GHC.Enum.Enum GI.OSTree.Flags.RepoPullFlags
instance GHC.Classes.Ord GI.OSTree.Flags.RepoPullFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.RepoPullFlags
instance GHC.Enum.Enum GI.OSTree.Flags.RepoResolveRevExtFlags
instance GHC.Classes.Ord GI.OSTree.Flags.RepoResolveRevExtFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.RepoResolveRevExtFlags
instance GHC.Enum.Enum GI.OSTree.Flags.RepoVerifyFlags
instance GHC.Classes.Ord GI.OSTree.Flags.RepoVerifyFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.RepoVerifyFlags
instance GHC.Enum.Enum GI.OSTree.Flags.SePolicyRestoreconFlags
instance GHC.Classes.Ord GI.OSTree.Flags.SePolicyRestoreconFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.SePolicyRestoreconFlags
instance GHC.Enum.Enum GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlags
instance GHC.Classes.Ord GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.SysrootSimpleWriteDeploymentFlags
instance GHC.Enum.Enum GI.OSTree.Flags.SysrootUpgraderFlags
instance GHC.Classes.Ord GI.OSTree.Flags.SysrootUpgraderFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Flags.SysrootUpgraderFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Flags.SysrootUpgraderFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.OSTree.Flags.SysrootUpgraderFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.SysrootUpgraderFlags
instance GHC.Enum.Enum GI.OSTree.Flags.SysrootUpgraderPullFlags
instance GHC.Classes.Ord GI.OSTree.Flags.SysrootUpgraderPullFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.OSTree.Flags.SysrootUpgraderPullFlags


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.AsyncProgress

-- | Memory-managed wrapper type.
newtype AsyncProgress
AsyncProgress :: ManagedPtr AsyncProgress -> AsyncProgress

-- | Type class for types which can be safely cast to <a>AsyncProgress</a>,
--   for instance with <a>toAsyncProgress</a>.
class (GObject o, IsDescendantOf AsyncProgress o) => IsAsyncProgress o

-- | Cast to <a>AsyncProgress</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toAsyncProgress :: (MonadIO m, IsAsyncProgress o) => o -> m AsyncProgress

-- | Atomically copies all the state from <i><tt>self</tt></i> to
--   <i><tt>dest</tt></i>, without invoking the callback. This is used for
--   proxying progress objects across different
--   <tt><i>GMainContexts</i></tt>.
--   
--   <i>Since: 2019.6</i>
asyncProgressCopyState :: (HasCallStack, MonadIO m, IsAsyncProgress a, IsAsyncProgress b) => a -> b -> m ()

-- | Process any pending signals, ensuring the main context is cleared of
--   sources used by this object. Also ensures that no further events will
--   be queued.
asyncProgressFinish :: (HasCallStack, MonadIO m, IsAsyncProgress a) => a -> m ()

-- | Get the human-readable status string from the <a>AsyncProgress</a>.
--   This operation is thread-safe. The retuned value may be <a>Nothing</a>
--   if no status is set.
--   
--   This is a convenience function to get the well-known <tt>status</tt>
--   key.
--   
--   <i>Since: 2017.6</i>
asyncProgressGetStatus :: (HasCallStack, MonadIO m, IsAsyncProgress a) => a -> m (Maybe Text)

-- | <i>No description available in the introspection data.</i>
asyncProgressGetUint :: (HasCallStack, MonadIO m, IsAsyncProgress a) => a -> Text -> m Word32

-- | <i>No description available in the introspection data.</i>
asyncProgressGetUint64 :: (HasCallStack, MonadIO m, IsAsyncProgress a) => a -> Text -> m Word64

-- | Look up a key in the <a>AsyncProgress</a> and return the
--   <a>GVariant</a> associated with it. The lookup is thread-safe.
--   
--   <i>Since: 2017.6</i>
asyncProgressGetVariant :: (HasCallStack, MonadIO m, IsAsyncProgress a) => a -> Text -> m (Maybe GVariant)

-- | <i>No description available in the introspection data.</i>
asyncProgressNew :: (HasCallStack, MonadIO m) => m AsyncProgress

-- | Set the human-readable status string for the <a>AsyncProgress</a>.
--   This operation is thread-safe. <a>Nothing</a> may be passed to clear
--   the status.
--   
--   This is a convenience function to set the well-known <tt>status</tt>
--   key.
--   
--   <i>Since: 2017.6</i>
asyncProgressSetStatus :: (HasCallStack, MonadIO m, IsAsyncProgress a) => a -> Maybe Text -> m ()

-- | <i>No description available in the introspection data.</i>
asyncProgressSetUint :: (HasCallStack, MonadIO m, IsAsyncProgress a) => a -> Text -> Word32 -> m ()

-- | <i>No description available in the introspection data.</i>
asyncProgressSetUint64 :: (HasCallStack, MonadIO m, IsAsyncProgress a) => a -> Text -> Word64 -> m ()

-- | Assign a new <i><tt>value</tt></i> to the given <i><tt>key</tt></i>,
--   replacing any existing value. The operation is thread-safe.
--   <i><tt>value</tt></i> may be a floating reference;
--   <a>variantRefSink</a> will be called on it.
--   
--   Any watchers of the <a>AsyncProgress</a> will be notified of the
--   change if <i><tt>value</tt></i> differs from the existing value for
--   <i><tt>key</tt></i>.
--   
--   <i>Since: 2017.6</i>
asyncProgressSetVariant :: (HasCallStack, MonadIO m, IsAsyncProgress a) => a -> Text -> GVariant -> m ()

-- | Emitted when <i><tt>self</tt></i> has been changed.
type AsyncProgressChangedCallback = IO ()

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> asyncProgress #changed callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterAsyncProgressChanged :: (IsAsyncProgress a, MonadIO m) => a -> ((?self :: a) => AsyncProgressChangedCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>changed</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> asyncProgress #changed callback
--   </pre>
onAsyncProgressChanged :: (IsAsyncProgress a, MonadIO m) => a -> ((?self :: a) => AsyncProgressChangedCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.OSTree.Objects.AsyncProgress.AsyncProgress
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.AsyncProgress.AsyncProgress o) => GI.OSTree.Objects.AsyncProgress.IsAsyncProgress o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.AsyncProgress.AsyncProgress
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.AsyncProgress.AsyncProgress
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.AsyncProgress.AsyncProgress
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.AsyncProgress.AsyncProgress
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.AsyncProgress.AsyncProgress)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.BootconfigParser

-- | Memory-managed wrapper type.
newtype BootconfigParser
BootconfigParser :: ManagedPtr BootconfigParser -> BootconfigParser

-- | Type class for types which can be safely cast to
--   <a>BootconfigParser</a>, for instance with <a>toBootconfigParser</a>.
class (GObject o, IsDescendantOf BootconfigParser o) => IsBootconfigParser o

-- | Cast to <a>BootconfigParser</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toBootconfigParser :: (MonadIO m, IsBootconfigParser o) => o -> m BootconfigParser

-- | <i>No description available in the introspection data.</i>
bootconfigParserClone :: (HasCallStack, MonadIO m, IsBootconfigParser a) => a -> m BootconfigParser

-- | Get the value corresponding to <i><tt>key</tt></i> from the boot
--   configuration dictionary.
bootconfigParserGet :: (HasCallStack, MonadIO m, IsBootconfigParser a) => a -> Text -> m (Maybe Text)

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2020.7</i>
bootconfigParserGetOverlayInitrds :: (HasCallStack, MonadIO m, IsBootconfigParser a) => a -> m (Maybe [Text])

-- | <i>No description available in the introspection data.</i>
bootconfigParserNew :: (HasCallStack, MonadIO m) => m BootconfigParser

-- | <i>No description available in the introspection data.</i>
bootconfigParserParse :: (HasCallStack, MonadIO m, IsBootconfigParser a, IsFile b, IsCancellable c) => a -> b -> Maybe c -> m ()

-- | Initialize a bootconfig from the given file.
bootconfigParserParseAt :: (HasCallStack, MonadIO m, IsBootconfigParser a, IsCancellable b) => a -> Int32 -> Text -> Maybe b -> m ()

-- | Set the <i><tt>key</tt></i>/<i><tt>value</tt></i> pair to the boot
--   configuration dictionary.
bootconfigParserSet :: (HasCallStack, MonadIO m, IsBootconfigParser a) => a -> Text -> Text -> m ()

-- | These are rendered as additional <tt>initrd</tt> keys in the final
--   bootloader configs. The base initrd is part of the primary keys.
--   
--   <i>Since: 2020.7</i>
bootconfigParserSetOverlayInitrds :: (HasCallStack, MonadIO m, IsBootconfigParser a) => a -> Maybe [Text] -> m ()

-- | <i>No description available in the introspection data.</i>
bootconfigParserWrite :: (HasCallStack, MonadIO m, IsBootconfigParser a, IsFile b, IsCancellable c) => a -> b -> Maybe c -> m ()

-- | <i>No description available in the introspection data.</i>
bootconfigParserWriteAt :: (HasCallStack, MonadIO m, IsBootconfigParser a, IsCancellable b) => a -> Int32 -> Text -> Maybe b -> m ()
instance GHC.Classes.Eq GI.OSTree.Objects.BootconfigParser.BootconfigParser
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.BootconfigParser.BootconfigParser o) => GI.OSTree.Objects.BootconfigParser.IsBootconfigParser o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.BootconfigParser.BootconfigParser
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.BootconfigParser.BootconfigParser
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.BootconfigParser.BootconfigParser
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.BootconfigParser.BootconfigParser
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.BootconfigParser.BootconfigParser)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.ContentWriter

-- | Memory-managed wrapper type.
newtype ContentWriter
ContentWriter :: ManagedPtr ContentWriter -> ContentWriter

-- | Type class for types which can be safely cast to <a>ContentWriter</a>,
--   for instance with <a>toContentWriter</a>.
class (GObject o, IsDescendantOf ContentWriter o) => IsContentWriter o

-- | Cast to <a>ContentWriter</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toContentWriter :: (MonadIO m, IsContentWriter o) => o -> m ContentWriter

-- | Complete the object write and return the checksum.
contentWriterFinish :: (HasCallStack, MonadIO m, IsContentWriter a, IsCancellable b) => a -> Maybe b -> m Text
instance GHC.Classes.Eq GI.OSTree.Objects.ContentWriter.ContentWriter
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.ContentWriter.ContentWriter o) => GI.OSTree.Objects.ContentWriter.IsContentWriter o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.ContentWriter.ContentWriter
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.ContentWriter.ContentWriter
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.ContentWriter.ContentWriter
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.ContentWriter.ContentWriter
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.ContentWriter.ContentWriter)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.Deployment

-- | Memory-managed wrapper type.
newtype Deployment
Deployment :: ManagedPtr Deployment -> Deployment

-- | Type class for types which can be safely cast to <a>Deployment</a>,
--   for instance with <a>toDeployment</a>.
class (GObject o, IsDescendantOf Deployment o) => IsDeployment o

-- | Cast to <a>Deployment</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toDeployment :: (MonadIO m, IsDeployment o) => o -> m Deployment

-- | <i>No description available in the introspection data.</i>
deploymentClone :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Deployment

-- | <i>No description available in the introspection data.</i>
deploymentEqual :: (HasCallStack, MonadIO m, IsDeployment a, IsDeployment b) => a -> b -> m Bool

-- | <i>No description available in the introspection data.</i>
deploymentGetBootconfig :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m (Maybe BootconfigParser)

-- | <i>No description available in the introspection data.</i>
deploymentGetBootcsum :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Text

-- | <i>No description available in the introspection data.</i>
deploymentGetBootserial :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Int32

-- | <i>No description available in the introspection data.</i>
deploymentGetCsum :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Text

-- | <i>No description available in the introspection data.</i>
deploymentGetDeployserial :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Int32

-- | <i>No description available in the introspection data.</i>
deploymentGetIndex :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Int32

-- | <i>No description available in the introspection data.</i>
deploymentGetOrigin :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m (Maybe KeyFile)

-- | Note this function only returns a *relative* path - if you want to
--   access, it, you must either use fd-relative api such as
--   <tt><i>openat()</i></tt>, or concatenate it with the full
--   <a>sysrootGetPath</a>.
deploymentGetOriginRelpath :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Text

-- | <i>No description available in the introspection data.</i>
deploymentGetOsname :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Text

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2016.4</i>
deploymentGetUnlocked :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m DeploymentUnlockedState

-- | <i>No description available in the introspection data.</i>
deploymentHash :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Word32

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2023.8</i>
deploymentIsFinalizationLocked :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Bool

-- | See <a>sysrootDeploymentSetPinned</a>.
--   
--   <i>Since: 2018.3</i>
deploymentIsPinned :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Bool

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2018.3</i>
deploymentIsStaged :: (HasCallStack, MonadIO m, IsDeployment a) => a -> m Bool

-- | <i>No description available in the introspection data.</i>
deploymentNew :: (HasCallStack, MonadIO m) => Int32 -> Text -> Text -> Int32 -> Maybe Text -> Int32 -> m Deployment

-- | The intention of an origin file is primarily describe the "inputs"
--   that resulted in a deployment, and it's commonly used to derive the
--   new state. For example, a key value (in pure libostree mode) is the
--   "refspec". However, libostree (or other applications) may want to
--   store "transient" state that should not be carried across upgrades.
--   
--   This function just removes all members of the
--   <tt>libostree-transient</tt> group. The name of that group is
--   available to all libostree users; best practice would be to prefix
--   values underneath there with a short identifier for your software.
--   
--   Additionally, this function will remove the <tt>origin/unlocked</tt>
--   and <tt>origin/override-commit</tt> members; these should be
--   considered transient state that should have been under an explicit
--   group.
--   
--   <i>Since: 2018.3</i>
deploymentOriginRemoveTransientState :: (HasCallStack, MonadIO m) => KeyFile -> m ()

-- | Set or clear the bootloader configuration.
deploymentSetBootconfig :: (HasCallStack, MonadIO m, IsDeployment a, IsBootconfigParser b) => a -> Maybe b -> m ()

-- | Should never have been made public API; don't use this.
deploymentSetBootserial :: (HasCallStack, MonadIO m, IsDeployment a) => a -> Int32 -> m ()

-- | Sets the global index into the bootloader ordering.
deploymentSetIndex :: (HasCallStack, MonadIO m, IsDeployment a) => a -> Int32 -> m ()

-- | Replace the "origin", which is a description of the source of the
--   deployment and how to update to the next version.
deploymentSetOrigin :: (HasCallStack, MonadIO m, IsDeployment a) => a -> Maybe KeyFile -> m ()

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2016.4</i>
deploymentUnlockedStateToString :: (HasCallStack, MonadIO m) => DeploymentUnlockedState -> m Text
instance GHC.Classes.Eq GI.OSTree.Objects.Deployment.Deployment
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.Deployment.Deployment o) => GI.OSTree.Objects.Deployment.IsDeployment o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.Deployment.Deployment
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.Deployment.Deployment
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.Deployment.Deployment
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.Deployment.Deployment
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.Deployment.Deployment)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.GpgVerifyResult

-- | Memory-managed wrapper type.
newtype GpgVerifyResult
GpgVerifyResult :: ManagedPtr GpgVerifyResult -> GpgVerifyResult

-- | Type class for types which can be safely cast to
--   <a>GpgVerifyResult</a>, for instance with <a>toGpgVerifyResult</a>.
class (GObject o, IsDescendantOf GpgVerifyResult o) => IsGpgVerifyResult o

-- | Cast to <a>GpgVerifyResult</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toGpgVerifyResult :: (MonadIO m, IsGpgVerifyResult o) => o -> m GpgVerifyResult

-- | Counts all the signatures in <i><tt>result</tt></i>.
gpgVerifyResultCountAll :: (HasCallStack, MonadIO m, IsGpgVerifyResult a) => a -> m Word32

-- | Counts only the valid signatures in <i><tt>result</tt></i>.
gpgVerifyResultCountValid :: (HasCallStack, MonadIO m, IsGpgVerifyResult a) => a -> m Word32

-- | Appends a brief, human-readable description of the GPG signature at
--   <i><tt>signatureIndex</tt></i> in <i><tt>result</tt></i> to the
--   <i><tt>outputBuffer</tt></i>. The description spans multiple lines. A
--   <i><tt>linePrefix</tt></i> string, if given, will precede each line of
--   the description.
--   
--   The <i><tt>flags</tt></i> argument is reserved for future variations
--   to the description format. Currently must be 0.
--   
--   It is a programmer error to request an invalid
--   <i><tt>signatureIndex</tt></i>. Use <a>gpgVerifyResultCountAll</a> to
--   find the number of signatures in <i><tt>result</tt></i>.
gpgVerifyResultDescribe :: (HasCallStack, MonadIO m, IsGpgVerifyResult a) => a -> Word32 -> String -> Maybe Text -> [GpgSignatureFormatFlags] -> m ()

-- | Similar to <a>gpgVerifyResultDescribe</a> but takes a <a>GVariant</a>
--   of all attributes for a GPG signature instead of an
--   <a>GpgVerifyResult</a> and signature index.
--   
--   The <i><tt>variant</tt></i> &lt;emphasis&gt;MUST&lt;/emphasis&gt; have
--   been created by <a>gpgVerifyResultGetAll</a>.
gpgVerifyResultDescribeVariant :: (HasCallStack, MonadIO m) => GVariant -> String -> Maybe Text -> [GpgSignatureFormatFlags] -> m ()

-- | Builds a <a>GVariant</a> tuple of requested attributes for the GPG
--   signature at <i><tt>signatureIndex</tt></i> in <i><tt>result</tt></i>.
--   See the <a>GpgSignatureAttr</a> description for the <a>VariantType</a>
--   of each available attribute.
--   
--   It is a programmer error to request an invalid <a>GpgSignatureAttr</a>
--   or an invalid <i><tt>signatureIndex</tt></i>. Use
--   <a>gpgVerifyResultCountAll</a> to find the number of signatures in
--   <i><tt>result</tt></i>.
gpgVerifyResultGet :: (HasCallStack, MonadIO m, IsGpgVerifyResult a) => a -> Word32 -> [GpgSignatureAttr] -> m GVariant

-- | Builds a <a>GVariant</a> tuple of all available attributes for the GPG
--   signature at <i><tt>signatureIndex</tt></i> in <i><tt>result</tt></i>.
--   
--   The child values in the returned <a>GVariant</a> tuple are ordered to
--   match the <a>GpgSignatureAttr</a> enumeration, which means the enum
--   values can be used as index values in functions like
--   <tt><i>g_variant_get_child()</i></tt>. See the <a>GpgSignatureAttr</a>
--   description for the <a>VariantType</a> of each available attribute.
--   
--   &lt;note&gt; &lt;para&gt; The <a>GpgSignatureAttr</a> enumeration may
--   be extended in the future with new attributes, which would affect the
--   <a>GVariant</a> tuple returned by this function. While the position
--   and type of current child values in the <a>GVariant</a> tuple will not
--   change, to avoid backward-compatibility issues &lt;emphasis&gt;please
--   do not depend on the tuple's overall size or type
--   signature&lt;/emphasis&gt;. &lt;/para&gt; &lt;/note&gt;
--   
--   It is a programmer error to request an invalid
--   <i><tt>signatureIndex</tt></i>. Use <a>gpgVerifyResultCountAll</a> to
--   find the number of signatures in <i><tt>result</tt></i>.
gpgVerifyResultGetAll :: (HasCallStack, MonadIO m, IsGpgVerifyResult a) => a -> Word32 -> m GVariant

-- | Searches <i><tt>result</tt></i> for a signature signed by
--   <i><tt>keyId</tt></i>. If a match is found, the function returns
--   <a>True</a> and sets <i><tt>outSignatureIndex</tt></i> so that further
--   signature details can be obtained through <a>gpgVerifyResultGet</a>.
--   If no match is found, the function returns <a>False</a> and leaves
--   <i><tt>outSignatureIndex</tt></i> unchanged.
gpgVerifyResultLookup :: (HasCallStack, MonadIO m, IsGpgVerifyResult a) => a -> Text -> m (Bool, Word32)

-- | Checks if the result contains at least one signature from the trusted
--   keyring. You can call this function immediately after
--   <a>repoVerifySummary</a> or <a>repoVerifyCommitExt</a> - it will
--   handle the <a>Nothing</a> <i><tt>result</tt></i> and filled
--   <i><tt>error</tt></i> too.
--   
--   <i>Since: 2016.6</i>
gpgVerifyResultRequireValidSignature :: (HasCallStack, MonadIO m, IsGpgVerifyResult a) => Maybe a -> m ()
instance GHC.Classes.Eq GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult o) => GI.OSTree.Objects.GpgVerifyResult.IsGpgVerifyResult o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult)


-- | A structure which globally uniquely identifies a ref as the tuple
--   (<i><tt>collectionId</tt></i>, <i><tt>refName</tt></i>). For backwards
--   compatibility, <i><tt>collectionId</tt></i> may be <a>Nothing</a>,
--   indicating a ref name which is not globally unique.
--   
--   <i>Since: 2018.6</i>
module GI.OSTree.Structs.CollectionRef

-- | Memory-managed wrapper type.
newtype CollectionRef
CollectionRef :: ManagedPtr CollectionRef -> CollectionRef

-- | Construct a <a>CollectionRef</a> struct initialized to zero.
newZeroCollectionRef :: MonadIO m => m CollectionRef

-- | Create a copy of the given <i><tt>ref</tt></i>.
--   
--   <i>Since: 2018.6</i>
collectionRefDup :: (HasCallStack, MonadIO m) => CollectionRef -> m CollectionRef

-- | Copy an array of <tt><i>OstreeCollectionRefs</i></tt>, including deep
--   copies of all its elements. <i><tt>refs</tt></i> must be
--   <a>Nothing</a>-terminated; it may be empty, but must not be
--   <a>Nothing</a>.
--   
--   <i>Since: 2018.6</i>
collectionRefDupv :: (HasCallStack, MonadIO m) => [CollectionRef] -> m [CollectionRef]

-- | Compare <i><tt>ref1</tt></i> and <i><tt>ref2</tt></i> and return
--   <a>True</a> if they have the same collection ID and ref name, and
--   <a>False</a> otherwise. Both <i><tt>ref1</tt></i> and
--   <i><tt>ref2</tt></i> must be non-<a>Nothing</a>.
--   
--   <i>Since: 2018.6</i>
collectionRefEqual :: (HasCallStack, MonadIO m) => CollectionRef -> CollectionRef -> m Bool

-- | Free the given <i><tt>ref</tt></i>.
--   
--   <i>Since: 2018.6</i>
collectionRefFree :: (HasCallStack, MonadIO m) => CollectionRef -> m ()

-- | Free the given array of <i><tt>refs</tt></i>, including freeing all
--   its elements. <i><tt>refs</tt></i> must be <a>Nothing</a>-terminated;
--   it may be empty, but must not be <a>Nothing</a>.
--   
--   <i>Since: 2018.6</i>
collectionRefFreev :: (HasCallStack, MonadIO m) => [CollectionRef] -> m ()

-- | Hash the given <i><tt>ref</tt></i>. This function is suitable for use
--   with <a>HashTable</a>. <i><tt>ref</tt></i> must be non-<a>Nothing</a>.
--   
--   <i>Since: 2018.6</i>
collectionRefHash :: (HasCallStack, MonadIO m) => CollectionRef -> m Word32

-- | Create a new <a>CollectionRef</a> containing
--   (<i><tt>collectionId</tt></i>, <i><tt>refName</tt></i>). If
--   <i><tt>collectionId</tt></i> is <a>Nothing</a>, this is equivalent to
--   a plain ref name string (not a refspec; no remote name is included),
--   which can be used for non-P2P operations.
--   
--   <i>Since: 2018.6</i>
collectionRefNew :: (HasCallStack, MonadIO m) => Maybe Text -> Text -> m CollectionRef

-- | Set the value of the “<tt>collection_id</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #collectionId
--   </pre>
clearCollectionRefCollectionId :: MonadIO m => CollectionRef -> m ()

-- | Get the value of the “<tt>collection_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> collectionRef #collectionId
--   </pre>
getCollectionRefCollectionId :: MonadIO m => CollectionRef -> m (Maybe Text)

-- | Set the value of the “<tt>collection_id</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> collectionRef [ #collectionId <a>:=</a> value ]
--   </pre>
setCollectionRefCollectionId :: MonadIO m => CollectionRef -> CString -> m ()

-- | Set the value of the “<tt>ref_name</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #refName
--   </pre>
clearCollectionRefRefName :: MonadIO m => CollectionRef -> m ()

-- | Get the value of the “<tt>ref_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> collectionRef #refName
--   </pre>
getCollectionRefRefName :: MonadIO m => CollectionRef -> m (Maybe Text)

-- | Set the value of the “<tt>ref_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> collectionRef [ #refName <a>:=</a> value ]
--   </pre>
setCollectionRefRefName :: MonadIO m => CollectionRef -> CString -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.CollectionRef.CollectionRef
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.CollectionRef.CollectionRef
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Structs.CollectionRef.CollectionRef
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Structs.CollectionRef.CollectionRef
instance Data.GI.Base.BasicTypes.GBoxed GI.OSTree.Structs.CollectionRef.CollectionRef
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Structs.CollectionRef.CollectionRef)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.CollectionRef.CollectionRef tag


-- | Structure representing an entry in the "ostree.sizes" commit metadata.
--   Each entry corresponds to an object in the associated commit.
--   
--   <i>Since: 2020.1</i>
module GI.OSTree.Structs.CommitSizesEntry

-- | Memory-managed wrapper type.
newtype CommitSizesEntry
CommitSizesEntry :: ManagedPtr CommitSizesEntry -> CommitSizesEntry

-- | Construct a <a>CommitSizesEntry</a> struct initialized to zero.
newZeroCommitSizesEntry :: MonadIO m => m CommitSizesEntry

-- | Create a copy of the given <i><tt>entry</tt></i>.
--   
--   <i>Since: 2020.1</i>
commitSizesEntryCopy :: (HasCallStack, MonadIO m) => CommitSizesEntry -> m (Maybe CommitSizesEntry)

-- | Free given <i><tt>entry</tt></i>.
--   
--   <i>Since: 2020.1</i>
commitSizesEntryFree :: (HasCallStack, MonadIO m) => CommitSizesEntry -> m ()

-- | Create a new <a>CommitSizesEntry</a> for representing an object in a
--   commit's "ostree.sizes" metadata.
--   
--   <i>Since: 2020.1</i>
commitSizesEntryNew :: (HasCallStack, MonadIO m) => Text -> ObjectType -> Word64 -> Word64 -> m (Maybe CommitSizesEntry)

-- | Get the value of the “<tt>archived</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> commitSizesEntry #archived
--   </pre>
getCommitSizesEntryArchived :: MonadIO m => CommitSizesEntry -> m Word64

-- | Set the value of the “<tt>archived</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> commitSizesEntry [ #archived <a>:=</a> value ]
--   </pre>
setCommitSizesEntryArchived :: MonadIO m => CommitSizesEntry -> Word64 -> m ()

-- | Set the value of the “<tt>checksum</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #checksum
--   </pre>
clearCommitSizesEntryChecksum :: MonadIO m => CommitSizesEntry -> m ()

-- | Get the value of the “<tt>checksum</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> commitSizesEntry #checksum
--   </pre>
getCommitSizesEntryChecksum :: MonadIO m => CommitSizesEntry -> m (Maybe Text)

-- | Set the value of the “<tt>checksum</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> commitSizesEntry [ #checksum <a>:=</a> value ]
--   </pre>
setCommitSizesEntryChecksum :: MonadIO m => CommitSizesEntry -> CString -> m ()

-- | Get the value of the “<tt>objtype</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> commitSizesEntry #objtype
--   </pre>
getCommitSizesEntryObjtype :: MonadIO m => CommitSizesEntry -> m ObjectType

-- | Set the value of the “<tt>objtype</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> commitSizesEntry [ #objtype <a>:=</a> value ]
--   </pre>
setCommitSizesEntryObjtype :: MonadIO m => CommitSizesEntry -> ObjectType -> m ()

-- | Get the value of the “<tt>unpacked</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> commitSizesEntry #unpacked
--   </pre>
getCommitSizesEntryUnpacked :: MonadIO m => CommitSizesEntry -> m Word64

-- | Set the value of the “<tt>unpacked</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> commitSizesEntry [ #unpacked <a>:=</a> value ]
--   </pre>
setCommitSizesEntryUnpacked :: MonadIO m => CommitSizesEntry -> Word64 -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.CommitSizesEntry.CommitSizesEntry
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.CommitSizesEntry.CommitSizesEntry
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Structs.CommitSizesEntry.CommitSizesEntry
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Structs.CommitSizesEntry.CommitSizesEntry
instance Data.GI.Base.BasicTypes.GBoxed GI.OSTree.Structs.CommitSizesEntry.CommitSizesEntry
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Structs.CommitSizesEntry.CommitSizesEntry)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.CommitSizesEntry.CommitSizesEntry tag


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Structs.DiffItem

-- | Memory-managed wrapper type.
newtype DiffItem
DiffItem :: ManagedPtr DiffItem -> DiffItem

-- | Construct a <a>DiffItem</a> struct initialized to zero.
newZeroDiffItem :: MonadIO m => m DiffItem

-- | <i>No description available in the introspection data.</i>
diffItemRef :: (HasCallStack, MonadIO m) => DiffItem -> m DiffItem

-- | <i>No description available in the introspection data.</i>
diffItemUnref :: (HasCallStack, MonadIO m) => DiffItem -> m ()

-- | Get the value of the “<tt>refcount</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffItem #refcount
--   </pre>
getDiffItemRefcount :: MonadIO m => DiffItem -> m Int32

-- | Set the value of the “<tt>refcount</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffItem [ #refcount <a>:=</a> value ]
--   </pre>
setDiffItemRefcount :: MonadIO m => DiffItem -> Int32 -> m ()

-- | Set the value of the “<tt>src</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #src
--   </pre>
clearDiffItemSrc :: MonadIO m => DiffItem -> m ()

-- | Get the value of the “<tt>src</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffItem #src
--   </pre>
getDiffItemSrc :: MonadIO m => DiffItem -> m (Maybe File)

-- | Set the value of the “<tt>src</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffItem [ #src <a>:=</a> value ]
--   </pre>
setDiffItemSrc :: MonadIO m => DiffItem -> Ptr File -> m ()

-- | Set the value of the “<tt>src_checksum</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #srcChecksum
--   </pre>
clearDiffItemSrcChecksum :: MonadIO m => DiffItem -> m ()

-- | Get the value of the “<tt>src_checksum</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffItem #srcChecksum
--   </pre>
getDiffItemSrcChecksum :: MonadIO m => DiffItem -> m (Maybe Text)

-- | Set the value of the “<tt>src_checksum</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffItem [ #srcChecksum <a>:=</a> value ]
--   </pre>
setDiffItemSrcChecksum :: MonadIO m => DiffItem -> CString -> m ()

-- | Set the value of the “<tt>src_info</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #srcInfo
--   </pre>
clearDiffItemSrcInfo :: MonadIO m => DiffItem -> m ()

-- | Get the value of the “<tt>src_info</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffItem #srcInfo
--   </pre>
getDiffItemSrcInfo :: MonadIO m => DiffItem -> m (Maybe FileInfo)

-- | Set the value of the “<tt>src_info</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffItem [ #srcInfo <a>:=</a> value ]
--   </pre>
setDiffItemSrcInfo :: MonadIO m => DiffItem -> Ptr FileInfo -> m ()

-- | Set the value of the “<tt>target</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #target
--   </pre>
clearDiffItemTarget :: MonadIO m => DiffItem -> m ()

-- | Get the value of the “<tt>target</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffItem #target
--   </pre>
getDiffItemTarget :: MonadIO m => DiffItem -> m (Maybe File)

-- | Set the value of the “<tt>target</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffItem [ #target <a>:=</a> value ]
--   </pre>
setDiffItemTarget :: MonadIO m => DiffItem -> Ptr File -> m ()

-- | Set the value of the “<tt>target_checksum</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #targetChecksum
--   </pre>
clearDiffItemTargetChecksum :: MonadIO m => DiffItem -> m ()

-- | Get the value of the “<tt>target_checksum</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffItem #targetChecksum
--   </pre>
getDiffItemTargetChecksum :: MonadIO m => DiffItem -> m (Maybe Text)

-- | Set the value of the “<tt>target_checksum</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffItem [ #targetChecksum <a>:=</a> value ]
--   </pre>
setDiffItemTargetChecksum :: MonadIO m => DiffItem -> CString -> m ()

-- | Set the value of the “<tt>target_info</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #targetInfo
--   </pre>
clearDiffItemTargetInfo :: MonadIO m => DiffItem -> m ()

-- | Get the value of the “<tt>target_info</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffItem #targetInfo
--   </pre>
getDiffItemTargetInfo :: MonadIO m => DiffItem -> m (Maybe FileInfo)

-- | Set the value of the “<tt>target_info</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffItem [ #targetInfo <a>:=</a> value ]
--   </pre>
setDiffItemTargetInfo :: MonadIO m => DiffItem -> Ptr FileInfo -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.DiffItem.DiffItem
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.DiffItem.DiffItem
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Structs.DiffItem.DiffItem
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Structs.DiffItem.DiffItem
instance Data.GI.Base.BasicTypes.GBoxed GI.OSTree.Structs.DiffItem.DiffItem
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Structs.DiffItem.DiffItem)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.DiffItem.DiffItem tag


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Structs.KernelArgs

-- | Memory-managed wrapper type.
newtype KernelArgs
KernelArgs :: ManagedPtr KernelArgs -> KernelArgs

-- | Appends <i><tt>arg</tt></i> which is in the form of key=value pair to
--   the hash table kargs-&gt;table (appends to the value list if key is
--   already in the hash table) and appends key to kargs-&gt;order if it is
--   not in the hash table already.
--   
--   <i>Since: 2019.3</i>
kernelArgsAppend :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m ()

-- | Appends each value in <i><tt>argv</tt></i> to the corresponding value
--   array and appends key to kargs-&gt;order if it is not in the hash
--   table already.
--   
--   <i>Since: 2019.3</i>
kernelArgsAppendArgv :: (HasCallStack, MonadIO m) => KernelArgs -> [Text] -> m ()

-- | Appends each argument that does not have one of the
--   <i><tt>prefixes</tt></i> as prefix to the <i><tt>kargs</tt></i>
--   
--   <i>Since: 2019.3</i>
kernelArgsAppendArgvFiltered :: (HasCallStack, MonadIO m) => KernelArgs -> [Text] -> [Text] -> m ()

-- | Appends <i><tt>arg</tt></i> which is in the form of key=value pair to
--   the hash table kargs-&gt;table (appends to the value list if key is
--   not in the hash table) and appends key to kargs-&gt;order if it is not
--   in the hash table.
--   
--   <i>Since: 2022.5</i>
kernelArgsAppendIfMissing :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m ()

-- | Appends the command line arguments in the file "/proc/cmdline" that
--   does not have "BOOT_IMAGE=" and "initrd=" as prefixes to the
--   <i><tt>kargs</tt></i>
--   
--   <i>Since: 2019.3</i>
kernelArgsAppendProcCmdline :: (HasCallStack, MonadIO m, IsCancellable a) => KernelArgs -> Maybe a -> m ()

-- | Frees the OstreeKernelArgs structure pointed by *loc
--   
--   <i>Since: 2019.3</i>
kernelArgsCleanup :: (HasCallStack, MonadIO m) => Ptr () -> m ()

-- | Search for <i><tt>arg</tt></i> which is in the form of key=value pair
--   at the hash table kargs-&gt;table and returns true if finds it.
--   
--   <i>Since: 2022.7</i>
kernelArgsContains :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m Bool

-- | There are few scenarios being handled for deletion:
--   
--   1: for input arg with a single key(i.e without = for split), the
--   key/value pair will be deleted if there is only one value that is
--   associated with the key
--   
--   2: for input arg wth key/value pair, the specific key value pair will
--   be deleted from the pointer array if those exist.
--   
--   3: If the found key has only one value associated with it, the key
--   entry in the table will also be removed, and the key will be removed
--   from order table
--   
--   Returns: <a>True</a> on success, <a>False</a> on failure
--   
--   Since: 2019.3
kernelArgsDelete :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m ()

-- | Deletes <i><tt>arg</tt></i> which is in the form of key=value pair
--   from the hash table kargs-&gt;table.
--   
--   <i>Since: 2022.7</i>
kernelArgsDeleteIfPresent :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m ()

-- | This function removes the key entry from the hashtable as well from
--   the order pointer array inside kargs
--   
--   Note: since both table and order inside kernel args are with free
--   function, no extra free functions are being called as they are done
--   automatically by GLib
--   
--   <i>Since: 2019.3</i>
kernelArgsDeleteKeyEntry :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m ()

-- | Frees the kargs structure
--   
--   <i>Since: 2019.3</i>
kernelArgsFree :: (HasCallStack, MonadIO m) => KernelArgs -> m ()

-- | Finds and returns the last element of value array corresponding to the
--   <i><tt>key</tt></i> in <i><tt>kargs</tt></i> hash table. Note that the
--   application will be terminated if the <i><tt>key</tt></i> is found but
--   the value array is empty
--   
--   <i>Since: 2019.3</i>
kernelArgsGetLastValue :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m (Maybe Text)

-- | This function implements the basic logic behind key/value pair
--   replacement. Do note that the arg need to be properly formatted
--   
--   When replacing key with exact one value, the arg can be in the form:
--   key, key=new_val, or key=old_val=new_val The first one swaps the
--   old_val with the key to an empty value The second and third replace
--   the old_val into the new_val
--   
--   When replacing key with multiple values, the arg can only be in the
--   form of: key=old_val=new_val. Unless there is a special case where
--   there is an empty value associated with the key, then key=new_val will
--   work because old_val is empty. The empty val will be swapped with the
--   new_val in that case
--   
--   <i>Since: 2019.3</i>
kernelArgsNewReplace :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m ()

-- | Parses <i><tt>options</tt></i> by separating it by whitespaces and
--   appends each argument to <i><tt>kargs</tt></i>
--   
--   <i>Since: 2019.3</i>
kernelArgsParseAppend :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m ()

-- | Finds and replaces the old key if <i><tt>arg</tt></i> is already in
--   the hash table, otherwise adds <i><tt>arg</tt></i> as new key and
--   split_keyeq (arg) as value. Note that when replacing old key value
--   pair, the old values are freed.
--   
--   <i>Since: 2019.3</i>
kernelArgsReplace :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m ()

-- | Finds and replaces each non-null arguments of <i><tt>argv</tt></i> in
--   the hash table, otherwise adds individual arg as new key and
--   split_keyeq (arg) as value. Note that when replacing old key value
--   pair, the old values are freed.
--   
--   <i>Since: 2019.3</i>
kernelArgsReplaceArgv :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m ()

-- | Finds and replaces the old key if <i><tt>arg</tt></i> is already in
--   the hash table, otherwise adds <i><tt>arg</tt></i> as new key and
--   split_keyeq (arg) as value. Note that when replacing old key, the old
--   values are freed.
--   
--   <i>Since: 2019.3</i>
kernelArgsReplaceTake :: (HasCallStack, MonadIO m) => KernelArgs -> Text -> m ()

-- | Extracts all key value pairs in <i><tt>kargs</tt></i> and appends to a
--   temporary GString in forms of "key=value" or "key" if value is NULL
--   separated by a single whitespace, and returns the temporary string
--   with the GString wrapper freed
--   
--   Note: the application will be terminated if one of the values array in
--   <i><tt>kargs</tt></i> is NULL
--   
--   <i>Since: 2019.3</i>
kernelArgsToString :: (HasCallStack, MonadIO m) => KernelArgs -> m Text

-- | Extracts all key value pairs in <i><tt>kargs</tt></i> and appends to a
--   temporary array in forms of "key=value" or "key" if value is NULL, and
--   returns the temporary array with the GPtrArray wrapper freed
--   
--   <i>Since: 2019.3</i>
kernelArgsToStrv :: (HasCallStack, MonadIO m) => KernelArgs -> m [Text]
instance GHC.Classes.Eq GI.OSTree.Structs.KernelArgs.KernelArgs
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.KernelArgs.KernelArgs
instance Data.GI.Base.BasicTypes.BoxedPtr GI.OSTree.Structs.KernelArgs.KernelArgs


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Structs.MutableTreeIter

-- | Memory-managed wrapper type.
newtype MutableTreeIter
MutableTreeIter :: ManagedPtr MutableTreeIter -> MutableTreeIter

-- | Construct a <a>MutableTreeIter</a> struct initialized to zero.
newZeroMutableTreeIter :: MonadIO m => m MutableTreeIter

-- | Get the value of the “<tt>in_files</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mutableTreeIter #inFiles
--   </pre>
getMutableTreeIterInFiles :: MonadIO m => MutableTreeIter -> m Bool

-- | Set the value of the “<tt>in_files</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> mutableTreeIter [ #inFiles <a>:=</a> value ]
--   </pre>
setMutableTreeIterInFiles :: MonadIO m => MutableTreeIter -> Bool -> m ()

-- | Get the value of the “<tt>iter</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> mutableTreeIter #iter
--   </pre>
getMutableTreeIterIter :: MonadIO m => MutableTreeIter -> m HashTableIter
instance GHC.Classes.Eq GI.OSTree.Structs.MutableTreeIter.MutableTreeIter
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.MutableTreeIter.MutableTreeIter
instance Data.GI.Base.BasicTypes.BoxedPtr GI.OSTree.Structs.MutableTreeIter.MutableTreeIter
instance Data.GI.Base.BasicTypes.CallocPtr GI.OSTree.Structs.MutableTreeIter.MutableTreeIter
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.MutableTreeIter.MutableTreeIter tag


-- | This represents the configuration for a single remote repository.
--   Currently, remotes can only be passed around as (reference counted)
--   opaque handles. In future, more API may be added to create and
--   interrogate them.
--   
--   <i>Since: 2018.6</i>
module GI.OSTree.Structs.Remote

-- | Memory-managed wrapper type.
newtype Remote
Remote :: ManagedPtr Remote -> Remote

-- | Get the human-readable name of the remote. This is what the user
--   configured, if the remote was explicitly configured; and will
--   otherwise be a stable, arbitrary, string.
--   
--   <i>Since: 2018.6</i>
remoteGetName :: (HasCallStack, MonadIO m) => Remote -> m Text

-- | Get the URL from the remote.
--   
--   <i>Since: 2018.6</i>
remoteGetUrl :: (HasCallStack, MonadIO m) => Remote -> m (Maybe Text)

-- | Increase the reference count on the given <i><tt>remote</tt></i>.
--   
--   <i>Since: 2018.6</i>
remoteRef :: (HasCallStack, MonadIO m) => Remote -> m Remote

-- | Decrease the reference count on the given <i><tt>remote</tt></i> and
--   free it if the reference count reaches 0.
--   
--   <i>Since: 2018.6</i>
remoteUnref :: (HasCallStack, MonadIO m) => Remote -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.Remote.Remote
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.Remote.Remote
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Structs.Remote.Remote
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Structs.Remote.Remote
instance Data.GI.Base.BasicTypes.GBoxed GI.OSTree.Structs.Remote.Remote
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Structs.Remote.Remote)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Structs.RepoDevInoCache

-- | Memory-managed wrapper type.
newtype RepoDevInoCache
RepoDevInoCache :: ManagedPtr RepoDevInoCache -> RepoDevInoCache

-- | OSTree has support for pairing
--   <tt><i>ostree_repo_checkout_tree_at()</i></tt> using hardlinks in
--   combination with a later <a>repoWriteDirectoryToMtree</a> using a
--   (normally modified) directory. In order for OSTree to optimally detect
--   just the new files, use this function and fill in the
--   <tt>devino_to_csum_cache</tt> member of
--   <tt>OstreeRepoCheckoutAtOptions</tt>, then call
--   <tt><i>ostree_repo_commit_set_devino_cache()</i></tt>.
repoDevInoCacheNew :: (HasCallStack, MonadIO m) => m RepoDevInoCache

-- | <i>No description available in the introspection data.</i>
repoDevInoCacheRef :: (HasCallStack, MonadIO m) => RepoDevInoCache -> m RepoDevInoCache

-- | <i>No description available in the introspection data.</i>
repoDevInoCacheUnref :: (HasCallStack, MonadIO m) => RepoDevInoCache -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.RepoDevInoCache.RepoDevInoCache
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.RepoDevInoCache.RepoDevInoCache
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Structs.RepoDevInoCache.RepoDevInoCache
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Structs.RepoDevInoCache.RepoDevInoCache
instance Data.GI.Base.BasicTypes.GBoxed GI.OSTree.Structs.RepoDevInoCache.RepoDevInoCache
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Structs.RepoDevInoCache.RepoDevInoCache)


-- | An extensible options structure controlling diff dirs. Make sure that
--   owner_uid/gid is set to -1 when not used. This is used by
--   <a>diffDirsWithOptions</a>.
module GI.OSTree.Structs.DiffDirsOptions

-- | Memory-managed wrapper type.
newtype DiffDirsOptions
DiffDirsOptions :: ManagedPtr DiffDirsOptions -> DiffDirsOptions

-- | Construct a <a>DiffDirsOptions</a> struct initialized to zero.
newZeroDiffDirsOptions :: MonadIO m => m DiffDirsOptions

-- | Set the value of the “<tt>devino_to_csum_cache</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #devinoToCsumCache
--   </pre>
clearDiffDirsOptionsDevinoToCsumCache :: MonadIO m => DiffDirsOptions -> m ()

-- | Get the value of the “<tt>devino_to_csum_cache</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffDirsOptions #devinoToCsumCache
--   </pre>
getDiffDirsOptionsDevinoToCsumCache :: MonadIO m => DiffDirsOptions -> m (Maybe RepoDevInoCache)

-- | Set the value of the “<tt>devino_to_csum_cache</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffDirsOptions [ #devinoToCsumCache <a>:=</a> value ]
--   </pre>
setDiffDirsOptionsDevinoToCsumCache :: MonadIO m => DiffDirsOptions -> Ptr RepoDevInoCache -> m ()

-- | Get the value of the “<tt>owner_gid</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffDirsOptions #ownerGid
--   </pre>
getDiffDirsOptionsOwnerGid :: MonadIO m => DiffDirsOptions -> m Int32

-- | Set the value of the “<tt>owner_gid</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffDirsOptions [ #ownerGid <a>:=</a> value ]
--   </pre>
setDiffDirsOptionsOwnerGid :: MonadIO m => DiffDirsOptions -> Int32 -> m ()

-- | Get the value of the “<tt>owner_uid</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> diffDirsOptions #ownerUid
--   </pre>
getDiffDirsOptionsOwnerUid :: MonadIO m => DiffDirsOptions -> m Int32

-- | Set the value of the “<tt>owner_uid</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> diffDirsOptions [ #ownerUid <a>:=</a> value ]
--   </pre>
setDiffDirsOptionsOwnerUid :: MonadIO m => DiffDirsOptions -> Int32 -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.DiffDirsOptions.DiffDirsOptions
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.DiffDirsOptions.DiffDirsOptions
instance Data.GI.Base.BasicTypes.BoxedPtr GI.OSTree.Structs.DiffDirsOptions.DiffDirsOptions
instance Data.GI.Base.BasicTypes.CallocPtr GI.OSTree.Structs.DiffDirsOptions.DiffDirsOptions
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.DiffDirsOptions.DiffDirsOptions tag


module GI.OSTree.Functions

-- | In many cases using libostree, a program may need to "break" hardlinks
--   by performing a copy. For example, in order to logically append to a
--   file.
--   
--   This function performs full copying, including e.g. extended
--   attributes and permissions of both regular files and symbolic links.
--   
--   If the file is not hardlinked, this function does nothing and returns
--   successfully.
--   
--   This function does not perform synchronization via <tt>fsync()</tt> or
--   <tt>fdatasync()</tt>; the idea is this will commonly be done as part
--   of an <tt>ostree_repo_commit_transaction()</tt>, which itself takes
--   care of synchronization.
--   
--   <i>Since: 2017.15</i>
breakHardlink :: (HasCallStack, MonadIO m, IsCancellable a) => Int32 -> Text -> Bool -> Maybe a -> m ()

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2017.4</i>
checkVersion :: (HasCallStack, MonadIO m) => Word32 -> Word32 -> m Bool

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2016.8</i>
checksumB64FromBytes :: (HasCallStack, MonadIO m) => ByteString -> m Text

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2016.8</i>
checksumB64ToBytes :: (HasCallStack, MonadIO m) => Text -> m ByteString

-- | <i>No description available in the introspection data.</i>
checksumBytesPeek :: (HasCallStack, MonadIO m) => GVariant -> m ByteString

-- | Like <a>checksumBytesPeek</a>, but also throws <i><tt>error</tt></i>.
checksumBytesPeekValidate :: (HasCallStack, MonadIO m) => GVariant -> m ByteString

-- | Compute the OSTree checksum for a given file.
checksumFile :: (HasCallStack, MonadIO m, IsFile a, IsCancellable b) => a -> ObjectType -> Maybe b -> m ByteString

-- | Asynchronously compute the OSTree checksum for a given file; complete
--   with <a>checksumFileAsyncFinish</a>.
checksumFileAsync :: (HasCallStack, MonadIO m, IsFile a, IsCancellable b) => a -> ObjectType -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()

-- | Finish computing the OSTree checksum for a given file; see
--   <a>checksumFileAsync</a>.
checksumFileAsyncFinish :: (HasCallStack, MonadIO m, IsFile a, IsAsyncResult b) => a -> b -> m ByteString

-- | Compute the OSTree checksum for a given file. This is an fd-relative
--   version of <a>checksumFile</a> which also takes flags and fills in a
--   caller allocated buffer.
--   
--   <i>Since: 2017.13</i>
checksumFileAt :: (HasCallStack, MonadIO m, IsCancellable a) => Int32 -> Text -> Ptr () -> ObjectType -> [ChecksumFlags] -> Text -> Maybe a -> m ()

-- | Compute the OSTree checksum for a given input.
checksumFileFromInput :: (HasCallStack, MonadIO m, IsFileInfo a, IsInputStream b, IsCancellable c) => a -> Maybe GVariant -> Maybe b -> ObjectType -> Maybe c -> m ByteString

-- | <i>No description available in the introspection data.</i>
checksumFromBytes :: (HasCallStack, MonadIO m) => ByteString -> m Text

-- | <i>No description available in the introspection data.</i>
checksumFromBytesV :: (HasCallStack, MonadIO m) => GVariant -> m Text

-- | Convert <i><tt>checksum</tt></i> from a string to binary in-place,
--   without allocating memory. Use this function in hot code paths.
checksumInplaceToBytes :: (HasCallStack, MonadIO m) => Text -> Word8 -> m ()

-- | <i>No description available in the introspection data.</i>
checksumToBytes :: (HasCallStack, MonadIO m) => Text -> m ByteString

-- | <i>No description available in the introspection data.</i>
checksumToBytesV :: (HasCallStack, MonadIO m) => Text -> m GVariant

-- | Compare two binary checksums, using <tt><i>memcmp()</i></tt>.
cmpChecksumBytes :: (HasCallStack, MonadIO m) => Word8 -> Word8 -> m Int32

-- | There are use cases where one wants a checksum just of the content of
--   a commit. OSTree commits by default capture the current timestamp, and
--   may have additional metadata, which means that re-committing identical
--   content often results in a new checksum.
--   
--   By comparing checksums of content, it's possible to easily distinguish
--   cases where nothing actually changed.
--   
--   The content checksums is simply defined as <tt>SHA256(root
--   dirtree_checksum || root_dirmeta_checksum)</tt>, i.e. the SHA-256 of
--   the root "dirtree" object's checksum concatenated with the root
--   "dirmeta" checksum (both in binary form, not hexadecimal).
--   
--   <i>Since: 2018.2</i>
commitGetContentChecksum :: (HasCallStack, MonadIO m) => GVariant -> m (Maybe Text)

-- | Reads a commit's "ostree.sizes" metadata and returns an array of
--   <a>CommitSizesEntry</a> in <i><tt>outSizesEntries</tt></i>. Each
--   element represents an object in the commit. If the commit does not
--   contain the "ostree.sizes" metadata, a <a>IOErrorEnumNotFound</a>
--   error will be returned.
--   
--   <i>Since: 2020.1</i>
commitGetObjectSizes :: (HasCallStack, MonadIO m) => GVariant -> m [CommitSizesEntry]

-- | <i>No description available in the introspection data.</i>
commitGetParent :: (HasCallStack, MonadIO m) => GVariant -> m (Maybe Text)

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2016.3</i>
commitGetTimestamp :: (HasCallStack, MonadIO m) => GVariant -> m Word64

-- | Update provided <i><tt>dict</tt></i> with standard metadata for
--   bootable OSTree commits.
--   
--   <i>Since: 2021.1</i>
commitMetadataForBootable :: (HasCallStack, MonadIO m, IsFile a, IsCancellable b) => a -> VariantDict -> Maybe b -> m ()

-- | A thin wrapper for <a>contentStreamParse</a>; this function converts
--   an object content stream back into components.
contentFileParse :: (HasCallStack, MonadIO m, IsFile a, IsCancellable b) => Bool -> a -> Bool -> Maybe b -> m (InputStream, FileInfo, GVariant)

-- | A thin wrapper for <a>contentStreamParse</a>; this function converts
--   an object content stream back into components.
contentFileParseAt :: (HasCallStack, MonadIO m, IsCancellable a) => Bool -> Int32 -> Text -> Bool -> Maybe a -> m (InputStream, FileInfo, GVariant)

-- | The reverse of <a>rawFileToContentStream</a>; this function converts
--   an object content stream back into components.
contentStreamParse :: (HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) => Bool -> a -> Word64 -> Bool -> Maybe b -> m (InputStream, FileInfo, GVariant)

-- | <i>No description available in the introspection data.</i>
createDirectoryMetadata :: (HasCallStack, MonadIO m, IsFileInfo a) => a -> Maybe GVariant -> m GVariant

-- | Compute the difference between directory <i><tt>a</tt></i> and
--   <i><tt>b</tt></i> as 3 separate sets of <a>DiffItem</a> in
--   <i><tt>modified</tt></i>, <i><tt>removed</tt></i>, and
--   <i><tt>added</tt></i>.
diffDirs :: (HasCallStack, MonadIO m, IsFile a, IsFile b, IsCancellable c) => [DiffFlags] -> a -> b -> [DiffItem] -> [File] -> [File] -> Maybe c -> m ()

-- | Compute the difference between directory <i><tt>a</tt></i> and
--   <i><tt>b</tt></i> as 3 separate sets of <a>DiffItem</a> in
--   <i><tt>modified</tt></i>, <i><tt>removed</tt></i>, and
--   <i><tt>added</tt></i>.
--   
--   <i>Since: 2017.4</i>
diffDirsWithOptions :: (HasCallStack, MonadIO m, IsFile a, IsFile b, IsCancellable c) => [DiffFlags] -> a -> b -> [DiffItem] -> [File] -> [File] -> Maybe DiffDirsOptions -> Maybe c -> m ()

-- | Print the contents of a diff to stdout.
diffPrint :: (HasCallStack, MonadIO m, IsFile a, IsFile b) => a -> b -> [DiffItem] -> [File] -> [File] -> m ()

-- | Retrieve all extended attributes in a canonical (sorted) order from
--   the given file descriptor.
fsGetAllXattrs :: (HasCallStack, MonadIO m, IsCancellable a) => Int32 -> Maybe a -> m GVariant

-- | Retrieve all extended attributes in a canonical (sorted) order from
--   the given path, relative to the provided directory file descriptor.
--   The target path will not be dereferenced. Currently on Linux, this API
--   must be used currently to retrieve extended attributes for symbolic
--   links because while <tt>O_PATH</tt> exists, it cannot be used with
--   <tt>fgetxattr()</tt>.
fsGetAllXattrsAt :: (HasCallStack, MonadIO m, IsCancellable a) => Int32 -> Text -> Maybe a -> m GVariant

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2017.10</i>
gpgErrorQuark :: (HasCallStack, MonadIO m) => m Word32

-- | Use this function with <a>HashTable</a> and
--   <a>objectNameSerialize</a>.
hashObjectName :: (HasCallStack, MonadIO m) => Ptr () -> m Word32

-- | <i>No description available in the introspection data.</i>
metadataVariantType :: (HasCallStack, MonadIO m) => ObjectType -> m VariantType

-- | Reverse <a>objectToString</a>.
objectFromString :: (HasCallStack, MonadIO m) => Text -> m (Text, ObjectType)

-- | Reverse <a>objectNameSerialize</a>. Note that
--   <i><tt>outChecksum</tt></i> is only valid for the lifetime of
--   <i><tt>variant</tt></i>, and must not be freed.
objectNameDeserialize :: (HasCallStack, MonadIO m) => GVariant -> m (Text, ObjectType)

-- | <i>No description available in the introspection data.</i>
objectNameSerialize :: (HasCallStack, MonadIO m) => Text -> ObjectType -> m GVariant

-- | <i>No description available in the introspection data.</i>
objectToString :: (HasCallStack, MonadIO m) => Text -> ObjectType -> m Text

-- | The reverse of <a>objectTypeToString</a>.
objectTypeFromString :: (HasCallStack, MonadIO m) => Text -> m ObjectType

-- | Serialize <i><tt>objtype</tt></i> to a string; this is used for file
--   extensions.
objectTypeToString :: (HasCallStack, MonadIO m) => ObjectType -> m Text

-- | Split a refspec like <tt>gnome-ostree:gnome-ostree/buildmain</tt> or
--   just <tt>gnome-ostree/buildmain</tt> into two parts. In the first
--   case, <i><tt>outRemote</tt></i> will be set to <tt>gnome-ostree</tt>,
--   and <i><tt>outRef</tt></i> to <tt>gnome-ostree/buildmain</tt>. In the
--   second case (a local ref), <i><tt>outRemote</tt></i> will be
--   <a>Nothing</a>, and <i><tt>outRef</tt></i> will be
--   <tt>gnome-ostree/buildmain</tt>. In both cases, <a>True</a> will be
--   returned.
parseRefspec :: (HasCallStack, MonadIO m) => Text -> m (Maybe Text, Text)

-- | Convert from a "bare" file representation into an
--   OSTREE_OBJECT_TYPE_FILE stream suitable for ostree pull.
--   
--   <i>Since: 2016.6</i>
rawFileToArchiveZ2Stream :: (HasCallStack, MonadIO m, IsInputStream a, IsFileInfo b, IsCancellable c) => a -> b -> Maybe GVariant -> Maybe c -> m InputStream

-- | Like <a>rawFileToArchiveZ2Stream</a>, but supports an extensible set
--   of flags. The following flags are currently defined:
--   
--   <ul>
--   <li><tt>compression-level</tt> (<tt>i</tt>): Level of compression to
--   use, 0–9, with 0 being the least compression, and &lt;0 giving the
--   default level (currently 6).</li>
--   </ul>
--   
--   <i>Since: 2017.3</i>
rawFileToArchiveZ2StreamWithOptions :: (HasCallStack, MonadIO m, IsInputStream a, IsFileInfo b, IsCancellable c) => a -> b -> Maybe GVariant -> Maybe GVariant -> Maybe c -> m InputStream

-- | Convert from a "bare" file representation into an
--   OSTREE_OBJECT_TYPE_FILE stream. This is a fundamental operation for
--   writing data to an <a>Repo</a>.
rawFileToContentStream :: (HasCallStack, MonadIO m, IsInputStream a, IsFileInfo b, IsCancellable c) => a -> b -> Maybe GVariant -> Maybe c -> m (InputStream, Word64)

-- | Use this function to see if input strings are checksums.
validateChecksumString :: (HasCallStack, MonadIO m) => Text -> m ()

-- | Check whether the given <i><tt>collectionId</tt></i> is valid. Return
--   an error if it is invalid or <a>Nothing</a>.
--   
--   Valid collection IDs are reverse DNS names: * They are composed of 1
--   or more elements separated by a period (<tt>.</tt>) character. All
--   elements must contain at least one character. * Each element must only
--   contain the ASCII characters <tt>[A-Z][a-z][0-9]_</tt> and must not
--   begin with a digit. * They must contain at least one <tt>.</tt>
--   (period) character (and thus at least two elements). * They must not
--   begin with a <tt>.</tt> (period) character. * They must not exceed 255
--   characters in length.
--   
--   (This makes their format identical to D-Bus interface names, for
--   consistency.)
--   
--   <i>Since: 2018.6</i>
validateCollectionId :: (HasCallStack, MonadIO m) => Maybe Text -> m ()

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2017.8</i>
validateRemoteName :: (HasCallStack, MonadIO m) => Text -> m ()

-- | <i>No description available in the introspection data.</i>
validateRev :: (HasCallStack, MonadIO m) => Text -> m ()

-- | <i>No description available in the introspection data.</i>
validateStructureofChecksumString :: (HasCallStack, MonadIO m) => Text -> m ()

-- | Use this to validate the basic structure of <i><tt>commit</tt></i>,
--   independent of any other objects it references.
validateStructureofCommit :: (HasCallStack, MonadIO m) => GVariant -> m ()

-- | <i>No description available in the introspection data.</i>
validateStructureofCsumV :: (HasCallStack, MonadIO m) => GVariant -> m ()

-- | Use this to validate the basic structure of <i><tt>dirmeta</tt></i>.
validateStructureofDirmeta :: (HasCallStack, MonadIO m) => GVariant -> m ()

-- | Use this to validate the basic structure of <i><tt>dirtree</tt></i>,
--   independent of any other objects it references.
validateStructureofDirtree :: (HasCallStack, MonadIO m) => GVariant -> m ()

-- | <i>No description available in the introspection data.</i>
validateStructureofFileMode :: (HasCallStack, MonadIO m) => Word32 -> m ()

-- | <i>No description available in the introspection data.</i>
validateStructureofObjtype :: (HasCallStack, MonadIO m) => Word8 -> m ()


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Structs.RepoPruneOptions

-- | Memory-managed wrapper type.
newtype RepoPruneOptions
RepoPruneOptions :: ManagedPtr RepoPruneOptions -> RepoPruneOptions

-- | Construct a <a>RepoPruneOptions</a> struct initialized to zero.
newZeroRepoPruneOptions :: MonadIO m => m RepoPruneOptions

-- | Get the value of the “<tt>flags</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoPruneOptions #flags
--   </pre>
getRepoPruneOptionsFlags :: MonadIO m => RepoPruneOptions -> m [RepoPruneFlags]

-- | Set the value of the “<tt>flags</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoPruneOptions [ #flags <a>:=</a> value ]
--   </pre>
setRepoPruneOptionsFlags :: MonadIO m => RepoPruneOptions -> [RepoPruneFlags] -> m ()

-- | Set the value of the “<tt>reachable</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #reachable
--   </pre>
clearRepoPruneOptionsReachable :: MonadIO m => RepoPruneOptions -> m ()

-- | Get the value of the “<tt>reachable</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoPruneOptions #reachable
--   </pre>
getRepoPruneOptionsReachable :: MonadIO m => RepoPruneOptions -> m (Maybe (Map (Ptr ()) (Ptr ())))

-- | Set the value of the “<tt>reachable</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoPruneOptions [ #reachable <a>:=</a> value ]
--   </pre>
setRepoPruneOptionsReachable :: MonadIO m => RepoPruneOptions -> Ptr (GHashTable (Ptr ()) (Ptr ())) -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.RepoPruneOptions.RepoPruneOptions
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.RepoPruneOptions.RepoPruneOptions
instance Data.GI.Base.BasicTypes.BoxedPtr GI.OSTree.Structs.RepoPruneOptions.RepoPruneOptions
instance Data.GI.Base.BasicTypes.CallocPtr GI.OSTree.Structs.RepoPruneOptions.RepoPruneOptions
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.RepoPruneOptions.RepoPruneOptions tag


-- | A list of statistics for each transaction that may be interesting for
--   reporting purposes.
module GI.OSTree.Structs.RepoTransactionStats

-- | Memory-managed wrapper type.
newtype RepoTransactionStats
RepoTransactionStats :: ManagedPtr RepoTransactionStats -> RepoTransactionStats

-- | Construct a <a>RepoTransactionStats</a> struct initialized to zero.
newZeroRepoTransactionStats :: MonadIO m => m RepoTransactionStats

-- | Get the value of the “<tt>content_bytes_written</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoTransactionStats #contentBytesWritten
--   </pre>
getRepoTransactionStatsContentBytesWritten :: MonadIO m => RepoTransactionStats -> m Word64

-- | Set the value of the “<tt>content_bytes_written</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoTransactionStats [ #contentBytesWritten <a>:=</a> value ]
--   </pre>
setRepoTransactionStatsContentBytesWritten :: MonadIO m => RepoTransactionStats -> Word64 -> m ()

-- | Get the value of the “<tt>content_objects_total</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoTransactionStats #contentObjectsTotal
--   </pre>
getRepoTransactionStatsContentObjectsTotal :: MonadIO m => RepoTransactionStats -> m Word32

-- | Set the value of the “<tt>content_objects_total</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoTransactionStats [ #contentObjectsTotal <a>:=</a> value ]
--   </pre>
setRepoTransactionStatsContentObjectsTotal :: MonadIO m => RepoTransactionStats -> Word32 -> m ()

-- | Get the value of the “<tt>content_objects_written</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoTransactionStats #contentObjectsWritten
--   </pre>
getRepoTransactionStatsContentObjectsWritten :: MonadIO m => RepoTransactionStats -> m Word32

-- | Set the value of the “<tt>content_objects_written</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoTransactionStats [ #contentObjectsWritten <a>:=</a> value ]
--   </pre>
setRepoTransactionStatsContentObjectsWritten :: MonadIO m => RepoTransactionStats -> Word32 -> m ()

-- | Get the value of the “<tt>devino_cache_hits</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoTransactionStats #devinoCacheHits
--   </pre>
getRepoTransactionStatsDevinoCacheHits :: MonadIO m => RepoTransactionStats -> m Word32

-- | Set the value of the “<tt>devino_cache_hits</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoTransactionStats [ #devinoCacheHits <a>:=</a> value ]
--   </pre>
setRepoTransactionStatsDevinoCacheHits :: MonadIO m => RepoTransactionStats -> Word32 -> m ()

-- | Get the value of the “<tt>metadata_objects_total</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoTransactionStats #metadataObjectsTotal
--   </pre>
getRepoTransactionStatsMetadataObjectsTotal :: MonadIO m => RepoTransactionStats -> m Word32

-- | Set the value of the “<tt>metadata_objects_total</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoTransactionStats [ #metadataObjectsTotal <a>:=</a> value ]
--   </pre>
setRepoTransactionStatsMetadataObjectsTotal :: MonadIO m => RepoTransactionStats -> Word32 -> m ()

-- | Get the value of the “<tt>metadata_objects_written</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoTransactionStats #metadataObjectsWritten
--   </pre>
getRepoTransactionStatsMetadataObjectsWritten :: MonadIO m => RepoTransactionStats -> m Word32

-- | Set the value of the “<tt>metadata_objects_written</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoTransactionStats [ #metadataObjectsWritten <a>:=</a> value ]
--   </pre>
setRepoTransactionStatsMetadataObjectsWritten :: MonadIO m => RepoTransactionStats -> Word32 -> m ()

-- | Get the value of the “<tt>padding1</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoTransactionStats #padding1
--   </pre>
getRepoTransactionStatsPadding1 :: MonadIO m => RepoTransactionStats -> m Word32

-- | Set the value of the “<tt>padding1</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoTransactionStats [ #padding1 <a>:=</a> value ]
--   </pre>
setRepoTransactionStatsPadding1 :: MonadIO m => RepoTransactionStats -> Word32 -> m ()

-- | Get the value of the “<tt>padding2</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoTransactionStats #padding2
--   </pre>
getRepoTransactionStatsPadding2 :: MonadIO m => RepoTransactionStats -> m Word64

-- | Set the value of the “<tt>padding2</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoTransactionStats [ #padding2 <a>:=</a> value ]
--   </pre>
setRepoTransactionStatsPadding2 :: MonadIO m => RepoTransactionStats -> Word64 -> m ()

-- | Get the value of the “<tt>padding3</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoTransactionStats #padding3
--   </pre>
getRepoTransactionStatsPadding3 :: MonadIO m => RepoTransactionStats -> m Word64

-- | Set the value of the “<tt>padding3</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoTransactionStats [ #padding3 <a>:=</a> value ]
--   </pre>
setRepoTransactionStatsPadding3 :: MonadIO m => RepoTransactionStats -> Word64 -> m ()

-- | Get the value of the “<tt>padding4</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoTransactionStats #padding4
--   </pre>
getRepoTransactionStatsPadding4 :: MonadIO m => RepoTransactionStats -> m Word64

-- | Set the value of the “<tt>padding4</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoTransactionStats [ #padding4 <a>:=</a> value ]
--   </pre>
setRepoTransactionStatsPadding4 :: MonadIO m => RepoTransactionStats -> Word64 -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.RepoTransactionStats.RepoTransactionStats
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.RepoTransactionStats.RepoTransactionStats
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Structs.RepoTransactionStats.RepoTransactionStats
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Structs.RepoTransactionStats.RepoTransactionStats
instance Data.GI.Base.BasicTypes.GBoxed GI.OSTree.Structs.RepoTransactionStats.RepoTransactionStats
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Structs.RepoTransactionStats.RepoTransactionStats)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.RepoTransactionStats.RepoTransactionStats tag


module GI.OSTree.Callbacks

-- | Type for the callback on the (unwrapped) C side.
type C_RepoCheckoutFilter = Ptr Repo -> CString -> Ptr () -> Ptr () -> IO CUInt

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2018.2</i>
type RepoCheckoutFilter = -- | /@repo@/: Repo Repo -> -- | /@path@/: Path to file Text -> -- | /@stbuf@/: File information Ptr () -> -- | __Returns:__ t'GI.OSTree.Enums.RepoCheckoutFilterResult' saying whether or not to checkout this file IO RepoCheckoutFilterResult

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2018.2</i>
type RepoCheckoutFilter_WithClosures = -- | /@repo@/: Repo Repo -> -- | /@path@/: Path to file Text -> -- | /@stbuf@/: File information Ptr () -> -- | /@userData@/: User data Ptr () -> -- | __Returns:__ t'GI.OSTree.Enums.RepoCheckoutFilterResult' saying whether or not to checkout this file IO RepoCheckoutFilterResult

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoCheckoutFilter :: RepoCheckoutFilter -> RepoCheckoutFilter_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_RepoCheckoutFilter :: (HasCallStack, MonadIO m, IsRepo a) => FunPtr C_RepoCheckoutFilter -> a -> Text -> Ptr () -> Ptr () -> m RepoCheckoutFilterResult

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RepoCheckoutFilter :: MonadIO m => RepoCheckoutFilter -> m (GClosure C_RepoCheckoutFilter)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RepoCheckoutFilter</a>.
mk_RepoCheckoutFilter :: C_RepoCheckoutFilter -> IO (FunPtr C_RepoCheckoutFilter)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RepoCheckoutFilter</a></tt>.
noRepoCheckoutFilter :: Maybe RepoCheckoutFilter

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RepoCheckoutFilter_WithClosures</a></tt>.
noRepoCheckoutFilter_WithClosures :: Maybe RepoCheckoutFilter_WithClosures

-- | Wrap a <a>RepoCheckoutFilter</a> into a <a>C_RepoCheckoutFilter</a>.
wrap_RepoCheckoutFilter :: Maybe (Ptr (FunPtr C_RepoCheckoutFilter)) -> RepoCheckoutFilter_WithClosures -> C_RepoCheckoutFilter

-- | Type for the callback on the (unwrapped) C side.
type C_RepoCommitFilter = Ptr Repo -> CString -> Ptr FileInfo -> Ptr () -> IO CUInt

-- | <i>No description available in the introspection data.</i>
type RepoCommitFilter = -- | /@repo@/: Repo Repo -> -- | /@path@/: Path to file Text -> -- | /@fileInfo@/: File information FileInfo -> -- | __Returns:__ t'GI.OSTree.Enums.RepoCommitFilterResult' saying whether or not to commit this file IO RepoCommitFilterResult

-- | <i>No description available in the introspection data.</i>
type RepoCommitFilter_WithClosures = -- | /@repo@/: Repo Repo -> -- | /@path@/: Path to file Text -> -- | /@fileInfo@/: File information FileInfo -> -- | /@userData@/: User data Ptr () -> -- | __Returns:__ t'GI.OSTree.Enums.RepoCommitFilterResult' saying whether or not to commit this file IO RepoCommitFilterResult

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoCommitFilter :: RepoCommitFilter -> RepoCommitFilter_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_RepoCommitFilter :: (HasCallStack, MonadIO m, IsRepo a, IsFileInfo b) => FunPtr C_RepoCommitFilter -> a -> Text -> b -> Ptr () -> m RepoCommitFilterResult

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RepoCommitFilter :: MonadIO m => RepoCommitFilter -> m (GClosure C_RepoCommitFilter)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RepoCommitFilter</a>.
mk_RepoCommitFilter :: C_RepoCommitFilter -> IO (FunPtr C_RepoCommitFilter)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RepoCommitFilter</a></tt>.
noRepoCommitFilter :: Maybe RepoCommitFilter

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RepoCommitFilter_WithClosures</a></tt>.
noRepoCommitFilter_WithClosures :: Maybe RepoCommitFilter_WithClosures

-- | Wrap a <a>RepoCommitFilter</a> into a <a>C_RepoCommitFilter</a>.
wrap_RepoCommitFilter :: Maybe (Ptr (FunPtr C_RepoCommitFilter)) -> RepoCommitFilter_WithClosures -> C_RepoCommitFilter

-- | Type for the callback on the (unwrapped) C side.
type C_RepoCommitModifierXattrCallback = Ptr Repo -> CString -> Ptr FileInfo -> Ptr () -> IO (Ptr GVariant)

-- | <i>No description available in the introspection data.</i>
type RepoCommitModifierXattrCallback = Repo -> Text -> FileInfo -> IO GVariant

-- | <i>No description available in the introspection data.</i>
type RepoCommitModifierXattrCallback_WithClosures = Repo -> Text -> FileInfo -> Ptr () -> IO GVariant

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoCommitModifierXattrCallback :: RepoCommitModifierXattrCallback -> RepoCommitModifierXattrCallback_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_RepoCommitModifierXattrCallback :: (HasCallStack, MonadIO m, IsRepo a, IsFileInfo b) => FunPtr C_RepoCommitModifierXattrCallback -> a -> Text -> b -> Ptr () -> m GVariant

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RepoCommitModifierXattrCallback :: MonadIO m => RepoCommitModifierXattrCallback -> m (GClosure C_RepoCommitModifierXattrCallback)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RepoCommitModifierXattrCallback</a>.
mk_RepoCommitModifierXattrCallback :: C_RepoCommitModifierXattrCallback -> IO (FunPtr C_RepoCommitModifierXattrCallback)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RepoCommitModifierXattrCallback</a></tt>.
noRepoCommitModifierXattrCallback :: Maybe RepoCommitModifierXattrCallback

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RepoCommitModifierXattrCallback_WithClosures</a></tt>.
noRepoCommitModifierXattrCallback_WithClosures :: Maybe RepoCommitModifierXattrCallback_WithClosures

-- | Wrap a <a>RepoCommitModifierXattrCallback</a> into a
--   <a>C_RepoCommitModifierXattrCallback</a>.
wrap_RepoCommitModifierXattrCallback :: Maybe (Ptr (FunPtr C_RepoCommitModifierXattrCallback)) -> RepoCommitModifierXattrCallback_WithClosures -> C_RepoCommitModifierXattrCallback

-- | Type for the callback on the (unwrapped) C side.
type C_RepoImportArchiveTranslatePathname = Ptr Repo -> Ptr () -> CString -> Ptr () -> IO CString

-- | Possibly change a pathname while importing an archive. If
--   <a>Nothing</a> is returned, then <i><tt>srcPath</tt></i> will be used
--   unchanged. Otherwise, return a new pathname which will be freed via
--   <tt>g_free()</tt>.
--   
--   This pathname translation will be performed *before* any processing
--   from an active <tt>OstreeRepoCommitModifier</tt>. Will be invoked for
--   all directory and file types, first with outer directories, then their
--   sub-files and directories.
--   
--   Note that enabling pathname translation will always override the
--   setting for <tt>use_ostree_convention</tt>.
--   
--   <i>Since: 2017.11</i>
type RepoImportArchiveTranslatePathname = -- | /@repo@/: Repo Repo -> -- | /@stbuf@/: Stat buffer Ptr () -> -- | /@srcPath@/: Path in the archive Text -> IO Text

-- | Possibly change a pathname while importing an archive. If
--   <a>Nothing</a> is returned, then <i><tt>srcPath</tt></i> will be used
--   unchanged. Otherwise, return a new pathname which will be freed via
--   <tt>g_free()</tt>.
--   
--   This pathname translation will be performed *before* any processing
--   from an active <tt>OstreeRepoCommitModifier</tt>. Will be invoked for
--   all directory and file types, first with outer directories, then their
--   sub-files and directories.
--   
--   Note that enabling pathname translation will always override the
--   setting for <tt>use_ostree_convention</tt>.
--   
--   <i>Since: 2017.11</i>
type RepoImportArchiveTranslatePathname_WithClosures = -- | /@repo@/: Repo Repo -> -- | /@stbuf@/: Stat buffer Ptr () -> -- | /@srcPath@/: Path in the archive Text -> -- | /@userData@/: User data Ptr () -> IO Text

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RepoImportArchiveTranslatePathname :: RepoImportArchiveTranslatePathname -> RepoImportArchiveTranslatePathname_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_RepoImportArchiveTranslatePathname :: (HasCallStack, MonadIO m, IsRepo a) => FunPtr C_RepoImportArchiveTranslatePathname -> a -> Ptr () -> Text -> Ptr () -> m Text

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RepoImportArchiveTranslatePathname :: MonadIO m => RepoImportArchiveTranslatePathname -> m (GClosure C_RepoImportArchiveTranslatePathname)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RepoImportArchiveTranslatePathname</a>.
mk_RepoImportArchiveTranslatePathname :: C_RepoImportArchiveTranslatePathname -> IO (FunPtr C_RepoImportArchiveTranslatePathname)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RepoImportArchiveTranslatePathname</a></tt>.
noRepoImportArchiveTranslatePathname :: Maybe RepoImportArchiveTranslatePathname

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RepoImportArchiveTranslatePathname_WithClosures</a></tt>.
noRepoImportArchiveTranslatePathname_WithClosures :: Maybe RepoImportArchiveTranslatePathname_WithClosures

-- | Wrap a <a>RepoImportArchiveTranslatePathname</a> into a
--   <a>C_RepoImportArchiveTranslatePathname</a>.
wrap_RepoImportArchiveTranslatePathname :: Maybe (Ptr (FunPtr C_RepoImportArchiveTranslatePathname)) -> RepoImportArchiveTranslatePathname_WithClosures -> C_RepoImportArchiveTranslatePathname


-- | <a>RepoFinderResult</a> gives a single result from an
--   <a>repoFinderResolveAsync</a> or <a>repoFinderResolveAllAsync</a>
--   operation. This represents a single remote which provides none, some
--   or all of the refs being resolved. The structure includes various bits
--   of metadata which allow <a>repoPullFromRemotesAsync</a> (for example)
--   to prioritise how to pull the refs.
--   
--   An <a>RepoFinderResult</a> is immutable after construction.
--   
--   The <i><tt>priority</tt></i> is used as one input of many to ordering
--   functions like <a>repoFinderResultCompare</a>.
--   
--   <i><tt>refToChecksum</tt></i> indicates which refs (out of the ones
--   queried for as inputs to <a>repoFinderResolveAsync</a>) are provided
--   by this remote. The refs are present as keys (of type
--   <a>CollectionRef</a>), and the corresponding values are the checksums
--   of the commits the remote currently has for those refs. (These might
--   not be the latest commits available out of all results.) A checksum
--   may be <a>Nothing</a> if the remote does not advertise the
--   corresponding ref. After <a>repoFinderResolveAsync</a> has been
--   called, the commit metadata should be available locally, so the
--   details for each checksum can be looked up using
--   <a>repoLoadCommit</a>.
--   
--   <i><tt>refToTimestamp</tt></i> provides timestamps for the set of refs
--   in <i><tt>refToChecksum</tt></i>. The refs are keys (of type
--   <a>CollectionRef</a>) and the values are guint64 pointers with the
--   timestamp associated with the checksum provided in
--   <i><tt>refToChecksum</tt></i>. <i><tt>refToTimestamp</tt></i> can be
--   <a>Nothing</a>, and when it's not, the timestamps are zero when any of
--   the following conditions are met: (1) the override-commit-ids option
--   was used on ostree_repo_find_remotes_async (2) there was an error in
--   trying to get the commit metadata (3) the checksum for this ref is
--   <a>Nothing</a> in <i><tt>refToChecksum</tt></i>.
--   
--   <i>Since: 2018.6</i>
module GI.OSTree.Structs.RepoFinderResult

-- | Memory-managed wrapper type.
newtype RepoFinderResult
RepoFinderResult :: ManagedPtr RepoFinderResult -> RepoFinderResult

-- | Construct a <a>RepoFinderResult</a> struct initialized to zero.
newZeroRepoFinderResult :: MonadIO m => m RepoFinderResult

-- | Compare two <a>RepoFinderResult</a> instances to work out which one is
--   better to pull from, and hence needs to be ordered before the other.
--   
--   <i>Since: 2018.6</i>
repoFinderResultCompare :: (HasCallStack, MonadIO m) => RepoFinderResult -> RepoFinderResult -> m Int32

-- | Copy an <a>RepoFinderResult</a>.
--   
--   <i>Since: 2018.6</i>
repoFinderResultDup :: (HasCallStack, MonadIO m) => RepoFinderResult -> m RepoFinderResult

-- | Free the given <i><tt>result</tt></i>.
--   
--   <i>Since: 2018.6</i>
repoFinderResultFree :: (HasCallStack, MonadIO m) => RepoFinderResult -> m ()

-- | Free the given <i><tt>results</tt></i> array, freeing each element and
--   the container.
--   
--   <i>Since: 2018.6</i>
repoFinderResultFreev :: (HasCallStack, MonadIO m) => [RepoFinderResult] -> m ()

-- | Set the value of the “<tt>finder</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #finder
--   </pre>
clearRepoFinderResultFinder :: MonadIO m => RepoFinderResult -> m ()

-- | Get the value of the “<tt>finder</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoFinderResult #finder
--   </pre>
getRepoFinderResultFinder :: MonadIO m => RepoFinderResult -> m (Maybe RepoFinder)

-- | Set the value of the “<tt>finder</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoFinderResult [ #finder <a>:=</a> value ]
--   </pre>
setRepoFinderResultFinder :: MonadIO m => RepoFinderResult -> Ptr RepoFinder -> m ()

-- | Get the value of the “<tt>priority</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoFinderResult #priority
--   </pre>
getRepoFinderResultPriority :: MonadIO m => RepoFinderResult -> m Int32

-- | Set the value of the “<tt>priority</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoFinderResult [ #priority <a>:=</a> value ]
--   </pre>
setRepoFinderResultPriority :: MonadIO m => RepoFinderResult -> Int32 -> m ()

-- | Set the value of the “<tt>remote</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #remote
--   </pre>
clearRepoFinderResultRemote :: MonadIO m => RepoFinderResult -> m ()

-- | Get the value of the “<tt>remote</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoFinderResult #remote
--   </pre>
getRepoFinderResultRemote :: MonadIO m => RepoFinderResult -> m (Maybe Remote)

-- | Set the value of the “<tt>remote</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoFinderResult [ #remote <a>:=</a> value ]
--   </pre>
setRepoFinderResultRemote :: MonadIO m => RepoFinderResult -> Ptr Remote -> m ()

-- | Get the value of the “<tt>summary_last_modified</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoFinderResult #summaryLastModified
--   </pre>
getRepoFinderResultSummaryLastModified :: MonadIO m => RepoFinderResult -> m Word64

-- | Set the value of the “<tt>summary_last_modified</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoFinderResult [ #summaryLastModified <a>:=</a> value ]
--   </pre>
setRepoFinderResultSummaryLastModified :: MonadIO m => RepoFinderResult -> Word64 -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.RepoFinderResult.RepoFinderResult
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.RepoFinderResult.RepoFinderResult
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Structs.RepoFinderResult.RepoFinderResult
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Structs.RepoFinderResult.RepoFinderResult
instance Data.GI.Base.BasicTypes.GBoxed GI.OSTree.Structs.RepoFinderResult.RepoFinderResult
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Structs.RepoFinderResult.RepoFinderResult)
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.RepoFinderResult.RepoFinderResult tag


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Structs.RepoCommitTraverseIter

-- | Memory-managed wrapper type.
newtype RepoCommitTraverseIter
RepoCommitTraverseIter :: ManagedPtr RepoCommitTraverseIter -> RepoCommitTraverseIter

-- | Construct a <a>RepoCommitTraverseIter</a> struct initialized to zero.
newZeroRepoCommitTraverseIter :: MonadIO m => m RepoCommitTraverseIter

-- | <i>No description available in the introspection data.</i>
repoCommitTraverseIterCleanup :: (HasCallStack, MonadIO m) => Ptr () -> m ()

-- | <i>No description available in the introspection data.</i>
repoCommitTraverseIterClear :: (HasCallStack, MonadIO m) => RepoCommitTraverseIter -> m ()

-- | Return information on the current directory. This function may only be
--   called if <a>RepoCommitIterResultDir</a> was returned from
--   <a>repoCommitTraverseIterNext</a>.
repoCommitTraverseIterGetDir :: (HasCallStack, MonadIO m) => RepoCommitTraverseIter -> m (Text, Text, Text)

-- | Return information on the current file. This function may only be
--   called if <a>RepoCommitIterResultFile</a> was returned from
--   <a>repoCommitTraverseIterNext</a>.
repoCommitTraverseIterGetFile :: (HasCallStack, MonadIO m) => RepoCommitTraverseIter -> m (Text, Text)

-- | Initialize (in place) an iterator over the root of a commit object.
repoCommitTraverseIterInitCommit :: (HasCallStack, MonadIO m, IsRepo a) => RepoCommitTraverseIter -> a -> GVariant -> [RepoCommitTraverseFlags] -> m ()

-- | Initialize (in place) an iterator over a directory tree.
repoCommitTraverseIterInitDirtree :: (HasCallStack, MonadIO m, IsRepo a) => RepoCommitTraverseIter -> a -> GVariant -> [RepoCommitTraverseFlags] -> m ()

-- | Step the interator to the next item. Files will be returned first,
--   then subdirectories. Call this in a loop; upon encountering
--   <a>RepoCommitIterResultEnd</a>, there will be no more files or
--   directories. If <a>RepoCommitIterResultDir</a> is returned, then call
--   <a>repoCommitTraverseIterGetDir</a> to retrieve data for that
--   directory. Similarly, if <a>RepoCommitIterResultFile</a> is returned,
--   call <a>repoCommitTraverseIterGetFile</a>.
--   
--   If <a>RepoCommitIterResultError</a> is returned, it is a program error
--   to call any further API on <i><tt>iter</tt></i> except for
--   <a>repoCommitTraverseIterClear</a>.
repoCommitTraverseIterNext :: (HasCallStack, MonadIO m, IsCancellable a) => RepoCommitTraverseIter -> Maybe a -> m RepoCommitIterResult

-- | Get the value of the “<tt>initialized</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCommitTraverseIter #initialized
--   </pre>
getRepoCommitTraverseIterInitialized :: MonadIO m => RepoCommitTraverseIter -> m Bool

-- | Set the value of the “<tt>initialized</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCommitTraverseIter [ #initialized <a>:=</a> value ]
--   </pre>
setRepoCommitTraverseIterInitialized :: MonadIO m => RepoCommitTraverseIter -> Bool -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.RepoCommitTraverseIter.RepoCommitTraverseIter
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.RepoCommitTraverseIter.RepoCommitTraverseIter
instance Data.GI.Base.BasicTypes.BoxedPtr GI.OSTree.Structs.RepoCommitTraverseIter.RepoCommitTraverseIter
instance Data.GI.Base.BasicTypes.CallocPtr GI.OSTree.Structs.RepoCommitTraverseIter.RepoCommitTraverseIter
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.RepoCommitTraverseIter.RepoCommitTraverseIter tag


-- | A structure allowing control over commits.
module GI.OSTree.Structs.RepoCommitModifier

-- | Memory-managed wrapper type.
newtype RepoCommitModifier
RepoCommitModifier :: ManagedPtr RepoCommitModifier -> RepoCommitModifier

-- | <i>No description available in the introspection data.</i>
repoCommitModifierNew :: (HasCallStack, MonadIO m) => [RepoCommitModifierFlags] -> Maybe RepoCommitFilter -> m RepoCommitModifier

-- | <i>No description available in the introspection data.</i>
repoCommitModifierRef :: (HasCallStack, MonadIO m) => RepoCommitModifier -> m RepoCommitModifier

-- | See the documentation for <tt>ostree_repo_devino_cache_new()</tt>.
--   This function can then be used for later calls to
--   <tt>ostree_repo_write_directory_to_mtree()</tt> to optimize commits.
--   
--   Note if your process has multiple writers, you should use separate
--   <tt>OSTreeRepo</tt> instances if you want to also use this API.
--   
--   This function will add a reference to <i><tt>cache</tt></i> without
--   copying - you should avoid further mutation of the cache.
--   
--   <i>Since: 2017.13</i>
repoCommitModifierSetDevinoCache :: (HasCallStack, MonadIO m) => RepoCommitModifier -> RepoDevInoCache -> m ()

-- | If <i><tt>policy</tt></i> is non-<a>Nothing</a>, use it to look up
--   labels to use for "security.selinux" extended attributes.
--   
--   Note that any policy specified this way operates in addition to any
--   extended attributes provided via
--   <a>repoCommitModifierSetXattrCallback</a>. However if both specify a
--   value for "security.selinux", then the one from the policy wins.
repoCommitModifierSetSepolicy :: (HasCallStack, MonadIO m, IsSePolicy a) => RepoCommitModifier -> Maybe a -> m ()

-- | In many cases, one wants to create a "derived" commit from base
--   commit. SELinux policy labels are part of that base commit. This API
--   allows one to easily set up SELinux labeling from a base commit.
--   
--   <i>Since: 2020.4</i>
repoCommitModifierSetSepolicyFromCommit :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => RepoCommitModifier -> a -> Text -> Maybe b -> m ()

-- | If set, this function should return extended attributes to use for the
--   given path. This is useful for things like ACLs and SELinux, where a
--   build system can label the files as it's committing to the repository.
repoCommitModifierSetXattrCallback :: (HasCallStack, MonadIO m) => RepoCommitModifier -> RepoCommitModifierXattrCallback -> m ()

-- | <i>No description available in the introspection data.</i>
repoCommitModifierUnref :: (HasCallStack, MonadIO m) => RepoCommitModifier -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.RepoCommitModifier.RepoCommitModifier
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.RepoCommitModifier.RepoCommitModifier
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Structs.RepoCommitModifier.RepoCommitModifier
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Structs.RepoCommitModifier.RepoCommitModifier
instance Data.GI.Base.BasicTypes.GBoxed GI.OSTree.Structs.RepoCommitModifier.RepoCommitModifier
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Structs.RepoCommitModifier.RepoCommitModifier)


-- | An extensible options structure controlling checkout. Ensure that you
--   have entirely zeroed the structure, then set just the desired options.
--   This is used by <a>repoCheckoutAt</a> which supercedes previous
--   separate enumeration usage in <a>repoCheckoutTree</a> and
--   <tt><i>ostree_repo_checkout_tree_at()</i></tt>.
module GI.OSTree.Structs.RepoCheckoutAtOptions

-- | Memory-managed wrapper type.
newtype RepoCheckoutAtOptions
RepoCheckoutAtOptions :: ManagedPtr RepoCheckoutAtOptions -> RepoCheckoutAtOptions

-- | Construct a <a>RepoCheckoutAtOptions</a> struct initialized to zero.
newZeroRepoCheckoutAtOptions :: MonadIO m => m RepoCheckoutAtOptions

-- | This function simply assigns <i><tt>cache</tt></i> to the
--   <tt>devino_to_csum_cache</tt> member of <i><tt>opts</tt></i>; it's
--   only useful for introspection.
--   
--   Note that cache does *not* have its refcount incremented - the
--   lifetime of <i><tt>cache</tt></i> must be equal to or greater than
--   that of <i><tt>opts</tt></i>.
--   
--   <i>Since: 2017.13</i>
repoCheckoutAtOptionsSetDevino :: (HasCallStack, MonadIO m) => RepoCheckoutAtOptions -> Maybe RepoDevInoCache -> m ()

-- | Get the value of the “<tt>bareuseronly_dirs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #bareuseronlyDirs
--   </pre>
getRepoCheckoutAtOptionsBareuseronlyDirs :: MonadIO m => RepoCheckoutAtOptions -> m Bool

-- | Set the value of the “<tt>bareuseronly_dirs</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #bareuseronlyDirs <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsBareuseronlyDirs :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m ()

-- | Set the value of the “<tt>devino_to_csum_cache</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #devinoToCsumCache
--   </pre>
clearRepoCheckoutAtOptionsDevinoToCsumCache :: MonadIO m => RepoCheckoutAtOptions -> m ()

-- | Get the value of the “<tt>devino_to_csum_cache</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #devinoToCsumCache
--   </pre>
getRepoCheckoutAtOptionsDevinoToCsumCache :: MonadIO m => RepoCheckoutAtOptions -> m (Maybe RepoDevInoCache)

-- | Set the value of the “<tt>devino_to_csum_cache</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #devinoToCsumCache <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsDevinoToCsumCache :: MonadIO m => RepoCheckoutAtOptions -> Ptr RepoDevInoCache -> m ()

-- | Get the value of the “<tt>enable_fsync</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #enableFsync
--   </pre>
getRepoCheckoutAtOptionsEnableFsync :: MonadIO m => RepoCheckoutAtOptions -> m Bool

-- | Set the value of the “<tt>enable_fsync</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #enableFsync <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsEnableFsync :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m ()

-- | Get the value of the “<tt>enable_uncompressed_cache</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #enableUncompressedCache
--   </pre>
getRepoCheckoutAtOptionsEnableUncompressedCache :: MonadIO m => RepoCheckoutAtOptions -> m Bool

-- | Set the value of the “<tt>enable_uncompressed_cache</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #enableUncompressedCache <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsEnableUncompressedCache :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m ()

-- | Set the value of the “<tt>filter</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #filter
--   </pre>
clearRepoCheckoutAtOptionsFilter :: MonadIO m => RepoCheckoutAtOptions -> m ()

-- | Get the value of the “<tt>filter</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #filter
--   </pre>
getRepoCheckoutAtOptionsFilter :: MonadIO m => RepoCheckoutAtOptions -> m (Maybe RepoCheckoutFilter_WithClosures)

-- | Set the value of the “<tt>filter</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #filter <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsFilter :: MonadIO m => RepoCheckoutAtOptions -> FunPtr C_RepoCheckoutFilter -> m ()

-- | Set the value of the “<tt>filter_user_data</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #filterUserData
--   </pre>
clearRepoCheckoutAtOptionsFilterUserData :: MonadIO m => RepoCheckoutAtOptions -> m ()

-- | Get the value of the “<tt>filter_user_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #filterUserData
--   </pre>
getRepoCheckoutAtOptionsFilterUserData :: MonadIO m => RepoCheckoutAtOptions -> m (Ptr ())

-- | Set the value of the “<tt>filter_user_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #filterUserData <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsFilterUserData :: MonadIO m => RepoCheckoutAtOptions -> Ptr () -> m ()

-- | Get the value of the “<tt>force_copy</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #forceCopy
--   </pre>
getRepoCheckoutAtOptionsForceCopy :: MonadIO m => RepoCheckoutAtOptions -> m Bool

-- | Set the value of the “<tt>force_copy</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #forceCopy <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsForceCopy :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m ()

-- | Get the value of the “<tt>force_copy_zerosized</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #forceCopyZerosized
--   </pre>
getRepoCheckoutAtOptionsForceCopyZerosized :: MonadIO m => RepoCheckoutAtOptions -> m Bool

-- | Set the value of the “<tt>force_copy_zerosized</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #forceCopyZerosized <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsForceCopyZerosized :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m ()

-- | Get the value of the “<tt>mode</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #mode
--   </pre>
getRepoCheckoutAtOptionsMode :: MonadIO m => RepoCheckoutAtOptions -> m RepoCheckoutMode

-- | Set the value of the “<tt>mode</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #mode <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsMode :: MonadIO m => RepoCheckoutAtOptions -> RepoCheckoutMode -> m ()

-- | Get the value of the “<tt>no_copy_fallback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #noCopyFallback
--   </pre>
getRepoCheckoutAtOptionsNoCopyFallback :: MonadIO m => RepoCheckoutAtOptions -> m Bool

-- | Set the value of the “<tt>no_copy_fallback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #noCopyFallback <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsNoCopyFallback :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m ()

-- | Get the value of the “<tt>overwrite_mode</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #overwriteMode
--   </pre>
getRepoCheckoutAtOptionsOverwriteMode :: MonadIO m => RepoCheckoutAtOptions -> m RepoCheckoutOverwriteMode

-- | Set the value of the “<tt>overwrite_mode</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #overwriteMode <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsOverwriteMode :: MonadIO m => RepoCheckoutAtOptions -> RepoCheckoutOverwriteMode -> m ()

-- | Get the value of the “<tt>process_passthrough_whiteouts</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #processPassthroughWhiteouts
--   </pre>
getRepoCheckoutAtOptionsProcessPassthroughWhiteouts :: MonadIO m => RepoCheckoutAtOptions -> m Bool

-- | Set the value of the “<tt>process_passthrough_whiteouts</tt>” field.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #processPassthroughWhiteouts <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsProcessPassthroughWhiteouts :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m ()

-- | Get the value of the “<tt>process_whiteouts</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #processWhiteouts
--   </pre>
getRepoCheckoutAtOptionsProcessWhiteouts :: MonadIO m => RepoCheckoutAtOptions -> m Bool

-- | Set the value of the “<tt>process_whiteouts</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #processWhiteouts <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsProcessWhiteouts :: MonadIO m => RepoCheckoutAtOptions -> Bool -> m ()

-- | Set the value of the “<tt>sepolicy</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #sepolicy
--   </pre>
clearRepoCheckoutAtOptionsSepolicy :: MonadIO m => RepoCheckoutAtOptions -> m ()

-- | Get the value of the “<tt>sepolicy</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #sepolicy
--   </pre>
getRepoCheckoutAtOptionsSepolicy :: MonadIO m => RepoCheckoutAtOptions -> m (Maybe SePolicy)

-- | Set the value of the “<tt>sepolicy</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #sepolicy <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsSepolicy :: MonadIO m => RepoCheckoutAtOptions -> Ptr SePolicy -> m ()

-- | Set the value of the “<tt>sepolicy_prefix</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #sepolicyPrefix
--   </pre>
clearRepoCheckoutAtOptionsSepolicyPrefix :: MonadIO m => RepoCheckoutAtOptions -> m ()

-- | Get the value of the “<tt>sepolicy_prefix</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #sepolicyPrefix
--   </pre>
getRepoCheckoutAtOptionsSepolicyPrefix :: MonadIO m => RepoCheckoutAtOptions -> m (Maybe Text)

-- | Set the value of the “<tt>sepolicy_prefix</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #sepolicyPrefix <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsSepolicyPrefix :: MonadIO m => RepoCheckoutAtOptions -> CString -> m ()

-- | Set the value of the “<tt>subpath</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #subpath
--   </pre>
clearRepoCheckoutAtOptionsSubpath :: MonadIO m => RepoCheckoutAtOptions -> m ()

-- | Get the value of the “<tt>subpath</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoCheckoutAtOptions #subpath
--   </pre>
getRepoCheckoutAtOptionsSubpath :: MonadIO m => RepoCheckoutAtOptions -> m (Maybe Text)

-- | Set the value of the “<tt>subpath</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> repoCheckoutAtOptions [ #subpath <a>:=</a> value ]
--   </pre>
setRepoCheckoutAtOptionsSubpath :: MonadIO m => RepoCheckoutAtOptions -> CString -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.RepoCheckoutAtOptions.RepoCheckoutAtOptions
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.RepoCheckoutAtOptions.RepoCheckoutAtOptions
instance Data.GI.Base.BasicTypes.BoxedPtr GI.OSTree.Structs.RepoCheckoutAtOptions.RepoCheckoutAtOptions
instance Data.GI.Base.BasicTypes.CallocPtr GI.OSTree.Structs.RepoCheckoutAtOptions.RepoCheckoutAtOptions
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.RepoCheckoutAtOptions.RepoCheckoutAtOptions tag


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.SePolicy

-- | Memory-managed wrapper type.
newtype SePolicy
SePolicy :: ManagedPtr SePolicy -> SePolicy

-- | Type class for types which can be safely cast to <a>SePolicy</a>, for
--   instance with <a>toSePolicy</a>.
class (GObject o, IsDescendantOf SePolicy o) => IsSePolicy o

-- | Cast to <a>SePolicy</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toSePolicy :: (MonadIO m, IsSePolicy o) => o -> m SePolicy

-- | Cleanup function for <a>sePolicySetfscreatecon</a>.
sePolicyFscreateconCleanup :: (HasCallStack, MonadIO m) => Ptr () -> m ()

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2016.5</i>
sePolicyGetCsum :: (HasCallStack, MonadIO m, IsSePolicy a) => a -> m (Maybe Text)

-- | Store in <i><tt>outLabel</tt></i> the security context for the given
--   <i><tt>relpath</tt></i> and mode <i><tt>unixMode</tt></i>. If the
--   policy does not specify a label, <a>Nothing</a> will be returned.
sePolicyGetLabel :: (HasCallStack, MonadIO m, IsSePolicy a, IsCancellable b) => a -> Text -> Word32 -> Maybe b -> m (Maybe Text)

-- | <i>No description available in the introspection data.</i>
sePolicyGetName :: (HasCallStack, MonadIO m, IsSePolicy a) => a -> m (Maybe Text)

-- | This API should be considered deprecated, because it's supported for
--   policy objects to be created from file-descriptor relative paths,
--   which may not be globally accessible.
sePolicyGetPath :: (HasCallStack, MonadIO m, IsSePolicy a) => a -> m (Maybe File)

-- | <i>No description available in the introspection data.</i>
sePolicyNew :: (HasCallStack, MonadIO m, IsFile a, IsCancellable b) => a -> Maybe b -> m SePolicy

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2017.4</i>
sePolicyNewAt :: (HasCallStack, MonadIO m, IsCancellable a) => Int32 -> Maybe a -> m SePolicy

-- | Extract the SELinux policy from a commit object via a partial
--   checkout. This is useful for labeling derived content as separate
--   commits.
--   
--   This function is the backend of
--   <tt>ostree_repo_commit_modifier_set_sepolicy_from_commit()</tt>.
sePolicyNewFromCommit :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Maybe b -> m SePolicy

-- | Reset the security context of <i><tt>target</tt></i> based on the
--   SELinux policy.
sePolicyRestorecon :: (HasCallStack, MonadIO m, IsSePolicy a, IsFileInfo b, IsFile c, IsCancellable d) => a -> Text -> Maybe b -> c -> [SePolicyRestoreconFlags] -> Maybe d -> m (Maybe Text)

-- | <i>No description available in the introspection data.</i>
sePolicySetfscreatecon :: (HasCallStack, MonadIO m, IsSePolicy a) => a -> Text -> Word32 -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>path</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSePolicyPath :: (IsSePolicy o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>path</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sePolicy #path
--   </pre>
getSePolicyPath :: (MonadIO m, IsSePolicy o) => o -> m (Maybe File)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>rootfs-dfd</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructSePolicyRootfsDfd :: (IsSePolicy o, MonadIO m) => Int32 -> m (GValueConstruct o)

-- | Get the value of the “<tt>rootfs-dfd</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sePolicy #rootfsDfd
--   </pre>
getSePolicyRootfsDfd :: (MonadIO m, IsSePolicy o) => o -> m Int32
instance GHC.Classes.Eq GI.OSTree.Objects.SePolicy.SePolicy
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.SePolicy.SePolicy o) => GI.OSTree.Objects.SePolicy.IsSePolicy o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.SePolicy.SePolicy
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.SePolicy.SePolicy
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.SePolicy.SePolicy
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.SePolicy.SePolicy
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.SePolicy.SePolicy)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.RepoFinderOverride

-- | Memory-managed wrapper type.
newtype RepoFinderOverride
RepoFinderOverride :: ManagedPtr RepoFinderOverride -> RepoFinderOverride

-- | Type class for types which can be safely cast to
--   <a>RepoFinderOverride</a>, for instance with
--   <a>toRepoFinderOverride</a>.
class (GObject o, IsDescendantOf RepoFinderOverride o) => IsRepoFinderOverride o

-- | Cast to <a>RepoFinderOverride</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toRepoFinderOverride :: (MonadIO m, IsRepoFinderOverride o) => o -> m RepoFinderOverride

-- | Add the given <i><tt>uri</tt></i> to the set of URIs which the repo
--   finder will search for matching refs when
--   <a>repoFinderResolveAsync</a> is called on it.
--   
--   <i>Since: 2018.6</i>
repoFinderOverrideAddUri :: (HasCallStack, MonadIO m, IsRepoFinderOverride a) => a -> Text -> m ()

-- | Create a new <a>RepoFinderOverride</a>.
--   
--   <i>Since: 2018.6</i>
repoFinderOverrideNew :: (HasCallStack, MonadIO m) => m RepoFinderOverride
instance GHC.Classes.Eq GI.OSTree.Objects.RepoFinderOverride.RepoFinderOverride
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.RepoFinderOverride.RepoFinderOverride o) => GI.OSTree.Objects.RepoFinderOverride.IsRepoFinderOverride o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.RepoFinderOverride.RepoFinderOverride
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.RepoFinderOverride.RepoFinderOverride
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.RepoFinderOverride.RepoFinderOverride
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.RepoFinderOverride.RepoFinderOverride
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.RepoFinderOverride.RepoFinderOverride)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.RepoFinderMount

-- | Memory-managed wrapper type.
newtype RepoFinderMount
RepoFinderMount :: ManagedPtr RepoFinderMount -> RepoFinderMount

-- | Type class for types which can be safely cast to
--   <a>RepoFinderMount</a>, for instance with <a>toRepoFinderMount</a>.
class (GObject o, IsDescendantOf RepoFinderMount o) => IsRepoFinderMount o

-- | Cast to <a>RepoFinderMount</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toRepoFinderMount :: (MonadIO m, IsRepoFinderMount o) => o -> m RepoFinderMount

-- | Create a new <a>RepoFinderMount</a>, using the given
--   <i><tt>monitor</tt></i> to look up volumes. If <i><tt>monitor</tt></i>
--   is <a>Nothing</a>, the monitor from <a>volumeMonitorGet</a> will be
--   used.
--   
--   <i>Since: 2018.6</i>
repoFinderMountNew :: (HasCallStack, MonadIO m, IsVolumeMonitor a) => Maybe a -> m RepoFinderMount

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>monitor</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRepoFinderMountMonitor :: (IsRepoFinderMount o, MonadIO m, IsVolumeMonitor a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>monitor</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repoFinderMount #monitor
--   </pre>
getRepoFinderMountMonitor :: (MonadIO m, IsRepoFinderMount o) => o -> m (Maybe VolumeMonitor)
instance GHC.Classes.Eq GI.OSTree.Objects.RepoFinderMount.RepoFinderMount
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.RepoFinderMount.RepoFinderMount o) => GI.OSTree.Objects.RepoFinderMount.IsRepoFinderMount o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.RepoFinderMount.RepoFinderMount
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.RepoFinderMount.RepoFinderMount
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.RepoFinderMount.RepoFinderMount
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.RepoFinderMount.RepoFinderMount
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.RepoFinderMount.RepoFinderMount)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.RepoFinderConfig

-- | Memory-managed wrapper type.
newtype RepoFinderConfig
RepoFinderConfig :: ManagedPtr RepoFinderConfig -> RepoFinderConfig

-- | Type class for types which can be safely cast to
--   <a>RepoFinderConfig</a>, for instance with <a>toRepoFinderConfig</a>.
class (GObject o, IsDescendantOf RepoFinderConfig o) => IsRepoFinderConfig o

-- | Cast to <a>RepoFinderConfig</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toRepoFinderConfig :: (MonadIO m, IsRepoFinderConfig o) => o -> m RepoFinderConfig

-- | Create a new <a>RepoFinderConfig</a>.
--   
--   <i>Since: 2018.6</i>
repoFinderConfigNew :: (HasCallStack, MonadIO m) => m RepoFinderConfig
instance GHC.Classes.Eq GI.OSTree.Objects.RepoFinderConfig.RepoFinderConfig
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.RepoFinderConfig.RepoFinderConfig o) => GI.OSTree.Objects.RepoFinderConfig.IsRepoFinderConfig o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.RepoFinderConfig.RepoFinderConfig
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.RepoFinderConfig.RepoFinderConfig
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.RepoFinderConfig.RepoFinderConfig
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.RepoFinderConfig.RepoFinderConfig
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.RepoFinderConfig.RepoFinderConfig)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.RepoFinderAvahi

-- | Memory-managed wrapper type.
newtype RepoFinderAvahi
RepoFinderAvahi :: ManagedPtr RepoFinderAvahi -> RepoFinderAvahi

-- | Type class for types which can be safely cast to
--   <a>RepoFinderAvahi</a>, for instance with <a>toRepoFinderAvahi</a>.
class (GObject o, IsDescendantOf RepoFinderAvahi o) => IsRepoFinderAvahi o

-- | Cast to <a>RepoFinderAvahi</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toRepoFinderAvahi :: (MonadIO m, IsRepoFinderAvahi o) => o -> m RepoFinderAvahi

-- | Create a new <a>RepoFinderAvahi</a> instance. It is intended that one
--   such instance be created per process, and it be used to answer all
--   resolution requests from <tt><i>OstreeRepos</i></tt>.
--   
--   The calling code is responsible for ensuring that
--   <i><tt>context</tt></i> is iterated while the <a>RepoFinderAvahi</a>
--   is running (after <a>repoFinderAvahiStart</a> is called). This may be
--   done from any thread.
--   
--   If <i><tt>context</tt></i> is <a>Nothing</a>, the current
--   thread-default <a>MainContext</a> is used.
--   
--   <i>Since: 2018.6</i>
repoFinderAvahiNew :: (HasCallStack, MonadIO m) => Maybe MainContext -> m RepoFinderAvahi

-- | Start monitoring the local network for peers who are advertising
--   OSTree repositories, using Avahi. In order for this to work, the
--   <a>MainContext</a> passed to <i><tt>self</tt></i> at construction time
--   must be iterated (so it will typically be the global
--   <a>MainContext</a>, or be a separate <a>MainContext</a> in a worker
--   thread).
--   
--   This will return an error (<a>IOErrorEnumFailed</a>) if initialisation
--   fails, or if Avahi support is not available
--   (<a>IOErrorEnumNotSupported</a>). In either case, the
--   <a>RepoFinderAvahi</a> instance is useless afterwards and should be
--   destroyed.
--   
--   Call <a>repoFinderAvahiStop</a> to stop the repo finder.
--   
--   It is an error to call this function multiple times on the same
--   <a>RepoFinderAvahi</a> instance, or to call it after
--   <a>repoFinderAvahiStop</a>.
--   
--   <i>Since: 2018.6</i>
repoFinderAvahiStart :: (HasCallStack, MonadIO m, IsRepoFinderAvahi a) => a -> m ()

-- | Stop monitoring the local network for peers who are advertising OSTree
--   repositories. If any resolve tasks (from
--   <a>repoFinderResolveAsync</a>) are in progress, they will be cancelled
--   and will return <a>IOErrorEnumCancelled</a>.
--   
--   Call <a>repoFinderAvahiStart</a> to start the repo finder.
--   
--   It is an error to call this function multiple times on the same
--   <a>RepoFinderAvahi</a> instance, or to call it before
--   <a>repoFinderAvahiStart</a>.
--   
--   <i>Since: 2018.6</i>
repoFinderAvahiStop :: (HasCallStack, MonadIO m, IsRepoFinderAvahi a) => a -> m ()
instance GHC.Classes.Eq GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi o) => GI.OSTree.Objects.RepoFinderAvahi.IsRepoFinderAvahi o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.RepoFinderAvahi.RepoFinderAvahi)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.RepoFile

-- | Memory-managed wrapper type.
newtype RepoFile
RepoFile :: ManagedPtr RepoFile -> RepoFile

-- | Type class for types which can be safely cast to <a>RepoFile</a>, for
--   instance with <a>toRepoFile</a>.
class (GObject o, IsDescendantOf RepoFile o) => IsRepoFile o

-- | Cast to <a>RepoFile</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toRepoFile :: (MonadIO m, IsRepoFile o) => o -> m RepoFile

-- | Ensure that the backing metadata is loaded.
repoFileEnsureResolved :: (HasCallStack, MonadIO m, IsRepoFile a) => a -> m ()

-- | <i>No description available in the introspection data.</i>
repoFileGetChecksum :: (HasCallStack, MonadIO m, IsRepoFile a) => a -> m Text

-- | <i>No description available in the introspection data.</i>
repoFileGetRepo :: (HasCallStack, MonadIO m, IsRepoFile a) => a -> m Repo

-- | <i>No description available in the introspection data.</i>
repoFileGetRoot :: (HasCallStack, MonadIO m, IsRepoFile a) => a -> m RepoFile

-- | <i>No description available in the introspection data.</i>
repoFileGetXattrs :: (HasCallStack, MonadIO m, IsRepoFile a, IsCancellable b) => a -> Maybe b -> m GVariant

-- | This API will return <a>Nothing</a> if the file is not "resolved" i.e.
--   in a loaded state. It will also return <a>Nothing</a> if this path is
--   not a directory tree.
repoFileTreeGetContents :: (HasCallStack, MonadIO m, IsRepoFile a) => a -> m (Maybe GVariant)

-- | <i>No description available in the introspection data.</i>
repoFileTreeGetContentsChecksum :: (HasCallStack, MonadIO m, IsRepoFile a) => a -> m (Maybe Text)

-- | This API will return <a>Nothing</a> if the file is not "resolved" i.e.
--   in a loaded state. It will also return <a>Nothing</a> if this path is
--   not a directory tree.
repoFileTreeGetMetadata :: (HasCallStack, MonadIO m, IsRepoFile a) => a -> m (Maybe GVariant)

-- | <i>No description available in the introspection data.</i>
repoFileTreeGetMetadataChecksum :: (HasCallStack, MonadIO m, IsRepoFile a) => a -> m (Maybe Text)

-- | <i>No description available in the introspection data.</i>
repoFileTreeQueryChild :: (HasCallStack, MonadIO m, IsRepoFile a, IsCancellable b) => a -> Int32 -> Text -> [FileQueryInfoFlags] -> Maybe b -> m FileInfo

-- | Replace the metadata checksum and metadata object.
repoFileTreeSetMetadata :: (HasCallStack, MonadIO m, IsRepoFile a) => a -> Text -> GVariant -> m ()
instance GHC.Classes.Eq GI.OSTree.Objects.RepoFile.RepoFile
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.RepoFile.RepoFile o) => GI.OSTree.Objects.RepoFile.IsRepoFile o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.RepoFile.RepoFile
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.RepoFile.RepoFile
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.RepoFile.RepoFile
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.RepoFile.RepoFile
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.RepoFile.RepoFile)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.Repo

-- | Memory-managed wrapper type.
newtype Repo
Repo :: ManagedPtr Repo -> Repo

-- | Type class for types which can be safely cast to <a>Repo</a>, for
--   instance with <a>toRepo</a>.
class (GObject o, IsDescendantOf Repo o) => IsRepo o

-- | Cast to <a>Repo</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toRepo :: (MonadIO m, IsRepo o) => o -> m Repo

-- | Abort the active transaction; any staged objects and ref changes will
--   be discarded. You *must* invoke this if you have chosen not to invoke
--   <a>repoCommitTransaction</a>. Calling this function when not in a
--   transaction will do nothing and return successfully.
repoAbortTransaction :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe b -> m ()

-- | Add a GPG signature to a summary file.
repoAddGpgSignatureSummary :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> [Text] -> Maybe Text -> Maybe b -> m ()

-- | Append a GPG signature to a commit.
repoAppendGpgSignature :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Bytes -> Maybe b -> m ()

-- | Similar to <a>repoCheckoutTree</a>, but uses directory-relative paths
--   for the destination, uses a new <tt>OstreeRepoCheckoutAtOptions</tt>,
--   and takes a commit checksum and optional subpath pair, rather than
--   requiring use of <tt>GFile</tt> APIs for the caller.
--   
--   It also replaces <a>repoCheckoutAt</a> which was not safe to use with
--   GObject introspection.
--   
--   Note in addition that unlike <a>repoCheckoutTree</a>, the default is
--   not to use the repository-internal uncompressed objects cache.
--   
--   <i>Since: 2016.8</i>
repoCheckoutAt :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe RepoCheckoutAtOptions -> Int32 -> Text -> Text -> Maybe b -> m ()

-- | Create a composefs filesystem metadata blob from an OSTree commit.
--   Supported options:
--   
--   <ul>
--   <li>verity: <tt>u</tt>: 0 = disabled, 1 = set if present on file, 2 =
--   enabled; any other value is a fatal error</li>
--   </ul>
repoCheckoutComposefs :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe GVariant -> Int32 -> Text -> Text -> Maybe b -> m ()

-- | Call this after finishing a succession of checkout operations; it will
--   delete any currently-unused uncompressed objects from the cache.
repoCheckoutGc :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe b -> m ()

-- | Check out <i><tt>source</tt></i> into <i><tt>destination</tt></i>,
--   which must live on the physical filesystem. <i><tt>source</tt></i> may
--   be any subdirectory of a given commit. The <i><tt>mode</tt></i> and
--   <i><tt>overwriteMode</tt></i> allow control over how the files are
--   checked out.
repoCheckoutTree :: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsRepoFile c, IsFileInfo d, IsCancellable e) => a -> RepoCheckoutMode -> RepoCheckoutOverwriteMode -> b -> c -> d -> Maybe e -> m ()

-- | Compute the composefs digest for a filesystem tree and insert it into
--   metadata for a commit object. The composefs digest covers the entire
--   filesystem tree and can be verified by the composefs mount tooling.
repoCommitAddComposefsMetadata :: (HasCallStack, MonadIO m, IsRepo a, IsRepoFile b, IsCancellable c) => a -> Word32 -> VariantDict -> b -> Maybe c -> m ()

-- | Complete the transaction. Any refs set with
--   <a>repoTransactionSetRef</a> or <a>repoTransactionSetRefspec</a> will
--   be written out.
--   
--   Note that if multiple threads are performing writes, all such threads
--   must have terminated before this function is invoked.
--   
--   Locking: Releases <tt>shared</tt> lock acquired by
--   <tt>ostree_repo_prepare_transaction()</tt> Multithreading: This
--   function is *not* MT safe; only one transaction can be active at a
--   time.
repoCommitTransaction :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe b -> m RepoTransactionStats

-- | <i>No description available in the introspection data.</i>
repoCopyConfig :: (HasCallStack, MonadIO m, IsRepo a) => a -> m KeyFile

-- | Create the underlying structure on disk for the repository, and call
--   <a>repoOpen</a> on the result, preparing it for use.
--   
--   Since version 2016.8, this function will succeed on an existing
--   repository, and finish creating any necessary files in a partially
--   created repository. However, this function cannot change the mode of
--   an existing repository, and will silently ignore an attempt to do so.
--   
--   Since 2017.9, "existing repository" is defined by the existence of an
--   <tt>objects</tt> subdirectory.
--   
--   This function predates <a>repoCreateAt</a>. It is an error to call
--   this function on a repository initialized via <a>repoOpenAt</a>.
repoCreate :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> RepoMode -> Maybe b -> m ()

-- | This is a file-descriptor relative version of <a>repoCreate</a>.
--   Create the underlying structure on disk for the repository, and call
--   <a>repoOpenAt</a> on the result, preparing it for use.
--   
--   If a repository already exists at <i><tt>dfd</tt></i> +
--   <i><tt>path</tt></i> (defined by an <tt>objects/</tt> subdirectory
--   existing), then this function will simply call <a>repoOpenAt</a>. In
--   other words, this function cannot be used to change the mode or
--   configuration (<tt>repo/config</tt>) of an existing repo.
--   
--   The <i><tt>options</tt></i> dict may contain:
--   
--   <ul>
--   <li>collection-id: s: Set as collection ID in repo/config (Since
--   2017.9)</li>
--   </ul>
--   
--   <i>Since: 2017.10</i>
repoCreateAt :: (HasCallStack, MonadIO m, IsCancellable a) => Int32 -> Text -> RepoMode -> Maybe GVariant -> Maybe a -> m Repo

-- | Remove the object of type <i><tt>objtype</tt></i> with checksum
--   <i><tt>sha256</tt></i> from the repository. An error of type
--   <a>IOErrorEnumNotFound</a> is thrown if the object does not exist.
repoDeleteObject :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> ObjectType -> Text -> Maybe b -> m ()

-- | Check whether two opened repositories are the same on disk: if their
--   root directories are the same inode. If <i><tt>a</tt></i> or
--   <i><tt>b</tt></i> are not open yet (due to <a>repoOpen</a> not being
--   called on them yet), <a>False</a> will be returned.
--   
--   <i>Since: 2017.12</i>
repoEqual :: (HasCallStack, MonadIO m, IsRepo a, IsRepo b) => a -> b -> m Bool

-- | Find reachable remote URIs which claim to provide any of the given
--   named <i><tt>refs</tt></i>. This will search for configured remotes
--   (t<a>RepoFinderConfig</a>), mounted volumes (t<a>RepoFinderMount</a>)
--   and (if enabled at compile time) local network peers
--   (t<a>RepoFinderAvahi</a>). In order to use a custom configuration of
--   <a>RepoFinder</a> instances, call <a>repoFinderResolveAllAsync</a> on
--   them individually.
--   
--   Any remote which is found and which claims to support any of the given
--   <i><tt>refs</tt></i> will be returned in the results. It is possible
--   that a remote claims to support a given ref, but turns out not to — it
--   is not possible to verify this until <a>repoPullFromRemotesAsync</a>
--   is called.
--   
--   The returned results will be sorted with the most useful first — this
--   is typically the remote which claims to provide the most of
--   <i><tt>refs</tt></i>, at the lowest latency.
--   
--   Each result contains a list of the subset of <i><tt>refs</tt></i> it
--   claims to provide. It is possible for a non-empty list of results to
--   be returned, but for some of <i><tt>refs</tt></i> to not be listed in
--   any of the results. Callers must check for this.
--   
--   Pass the results to <a>repoPullFromRemotesAsync</a> to pull the given
--   <i><tt>refs</tt></i> from those remotes.
--   
--   The following <i><tt>options</tt></i> are currently defined:
--   
--   <ul>
--   <li><tt>override-commit-ids</tt> (<tt>as</tt>): Array of specific
--   commit IDs to fetch. The nth commit ID applies to the nth ref, so this
--   must be the same length as <i><tt>refs</tt></i>, if provided.</li>
--   <li><tt>n-network-retries</tt> (<tt>u</tt>): Number of times to retry
--   each download on receiving a transient network error, such as a socket
--   timeout; default is 5, 0 means return errors without retrying. Since:
--   2018.6</li>
--   </ul>
--   
--   <i><tt>finders</tt></i> must be a non-empty <a>Nothing</a>-terminated
--   array of the <a>RepoFinder</a> instances to use, or <a>Nothing</a> to
--   use the system default set of finders, which will typically be all
--   available finders using their default options (but this is not
--   guaranteed).
--   
--   GPG verification of commits will be used unconditionally.
--   
--   This will use the thread-default <a>MainContext</a>, but will not
--   iterate it.
--   
--   <i>Since: 2018.6</i>
repoFindRemotesAsync :: (HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b, IsCancellable c) => a -> [CollectionRef] -> Maybe GVariant -> [RepoFinder] -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finish an asynchronous pull operation started with
--   <a>repoFindRemotesAsync</a>.
--   
--   <i>Since: 2018.6</i>
repoFindRemotesFinish :: (HasCallStack, MonadIO m, IsRepo a, IsAsyncResult b) => a -> b -> m [RepoFinderResult]

-- | Verify consistency of the object; this performs checks only relevant
--   to the immediate object itself, such as checksumming. This API call
--   will not itself traverse metadata objects for example.
--   
--   <i>Since: 2017.15</i>
repoFsckObject :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> ObjectType -> Text -> Maybe b -> m ()

-- | Get the bootloader configured. See the documentation for the
--   "sysroot.bootloader" config key.
--   
--   <i>Since: 2019.2</i>
repoGetBootloader :: (HasCallStack, MonadIO m, IsRepo a) => a -> m Text

-- | Get the collection ID of this repository. See [collection
--   IDs][collection-ids].
--   
--   <i>Since: 2018.6</i>
repoGetCollectionId :: (HasCallStack, MonadIO m, IsRepo a) => a -> m (Maybe Text)

-- | <i>No description available in the introspection data.</i>
repoGetConfig :: (HasCallStack, MonadIO m, IsRepo a) => a -> m KeyFile

-- | Get the set of default repo finders configured. See the documentation
--   for the "core.default-repo-finders" config key.
--   
--   <i>Since: 2018.9</i>
repoGetDefaultRepoFinders :: (HasCallStack, MonadIO m, IsRepo a) => a -> m [Text]

-- | In some cases it's useful for applications to access the repository
--   directly; for example, writing content into <tt>repo/tmp</tt> ensures
--   it's on the same filesystem. Another case is detecting the mtime on
--   the repository (to see whether a ref was written).
--   
--   <i>Since: 2016.4</i>
repoGetDfd :: (HasCallStack, MonadIO m, IsRepo a) => a -> m Int32

-- | For more information see <a>repoSetDisableFsync</a>.
repoGetDisableFsync :: (HasCallStack, MonadIO m, IsRepo a) => a -> m Bool

-- | Determine the number of bytes of free disk space that are reserved
--   according to the repo config and return that number in
--   <i><tt>outReservedBytes</tt></i>. See the documentation for the
--   core.min-free-space-size and core.min-free-space-percent repo config
--   options.
--   
--   <i>Since: 2018.9</i>
repoGetMinFreeSpaceBytes :: (HasCallStack, MonadIO m, IsRepo a) => a -> m Word64

-- | <i>No description available in the introspection data.</i>
repoGetMode :: (HasCallStack, MonadIO m, IsRepo a) => a -> m RepoMode

-- | Before this function can be used, <tt><i>ostree_repo_init()</i></tt>
--   must have been called.
repoGetParent :: (HasCallStack, MonadIO m, IsRepo a) => a -> m (Maybe Repo)

-- | Note that since the introduction of <a>repoOpenAt</a>, this function
--   may return a process-specific path in <tt>/proc</tt> if the repository
--   was created using that API. In general, you should avoid use of this
--   API.
repoGetPath :: (HasCallStack, MonadIO m, IsRepo a) => a -> m File

-- | OSTree remotes are represented by keyfile groups, formatted like:
--   <tt>[remote "remotename"]</tt>. This function returns a value named
--   <i><tt>optionName</tt></i> underneath that group, and returns it as a
--   boolean. If the option is not set, <i><tt>outValue</tt></i> will be
--   set to <i><tt>defaultValue</tt></i>. If an error is returned,
--   <i><tt>outValue</tt></i> will be set to <a>False</a>.
--   
--   <i>Since: 2016.5</i>
repoGetRemoteBooleanOption :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> Text -> Bool -> m Bool

-- | OSTree remotes are represented by keyfile groups, formatted like:
--   <tt>[remote "remotename"]</tt>. This function returns a value named
--   <i><tt>optionName</tt></i> underneath that group, and returns it as a
--   zero terminated array of strings. If the option is not set, or if an
--   error is returned, <i><tt>outValue</tt></i> will be set to
--   <a>Nothing</a>.
--   
--   <i>Since: 2016.5</i>
repoGetRemoteListOption :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> Text -> m [Text]

-- | OSTree remotes are represented by keyfile groups, formatted like:
--   <tt>[remote "remotename"]</tt>. This function returns a value named
--   <i><tt>optionName</tt></i> underneath that group, or
--   <i><tt>defaultValue</tt></i> if the remote exists but not the option
--   name. If an error is returned, <i><tt>outValue</tt></i> will be set to
--   <a>Nothing</a>.
--   
--   <i>Since: 2016.5</i>
repoGetRemoteOption :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> Text -> Maybe Text -> m (Maybe Text)

-- | Sign the given <i><tt>data</tt></i> with the specified keys in
--   <i><tt>keyId</tt></i>. Similar to <a>repoAddGpgSignatureSummary</a>
--   but can be used on any data.
--   
--   You can use <a>repoGpgVerifyData</a> to verify the signatures.
--   
--   <i>Since: 2020.8</i>
repoGpgSignData :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Bytes -> Maybe Bytes -> [Text] -> Maybe Text -> Maybe b -> m Bytes

-- | Verify <i><tt>signatures</tt></i> for <i><tt>data</tt></i> using GPG
--   keys in the keyring for <i><tt>remoteName</tt></i>, and return an
--   <a>GpgVerifyResult</a>.
--   
--   The <i><tt>remoteName</tt></i> parameter can be <a>Nothing</a>. In
--   that case it will do the verifications using GPG keys in the keyrings
--   of all remotes.
--   
--   <i>Since: 2016.6</i>
repoGpgVerifyData :: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsFile c, IsCancellable d) => a -> Maybe Text -> Bytes -> Bytes -> Maybe b -> Maybe c -> Maybe d -> m GpgVerifyResult

-- | Set <i><tt>outHaveObject</tt></i> to <a>True</a> if
--   <i><tt>self</tt></i> contains the given object; <a>False</a>
--   otherwise.
repoHasObject :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> ObjectType -> Text -> Maybe b -> m Bool

-- | Calculate a hash value for the given open repository, suitable for use
--   when putting it into a hash table. It is an error to call this on an
--   <a>Repo</a> which is not yet open, as a persistent hash value cannot
--   be calculated until the repository is open and the inode of its root
--   directory has been loaded.
--   
--   This function does no I/O.
--   
--   <i>Since: 2017.12</i>
repoHash :: (HasCallStack, MonadIO m, IsRepo a) => a -> m Word32

-- | Copy object named by <i><tt>objtype</tt></i> and
--   <i><tt>checksum</tt></i> into <i><tt>self</tt></i> from the source
--   repository <i><tt>source</tt></i>. If both repositories are of the
--   same type and on the same filesystem, this will simply be a fast Unix
--   hard link operation.
--   
--   Otherwise, a copy will be performed.
repoImportObjectFrom :: (HasCallStack, MonadIO m, IsRepo a, IsRepo b, IsCancellable c) => a -> b -> ObjectType -> Text -> Maybe c -> m ()

-- | Copy object named by <i><tt>objtype</tt></i> and
--   <i><tt>checksum</tt></i> into <i><tt>self</tt></i> from the source
--   repository <i><tt>source</tt></i>. If <i><tt>trusted</tt></i> is
--   <a>True</a> and both repositories are of the same type and on the same
--   filesystem, this will simply be a fast Unix hard link operation.
--   
--   Otherwise, a copy will be performed.
--   
--   <i>Since: 2016.5</i>
repoImportObjectFromWithTrust :: (HasCallStack, MonadIO m, IsRepo a, IsRepo b, IsCancellable c) => a -> b -> ObjectType -> Text -> Bool -> Maybe c -> m ()

-- | <i>No description available in the introspection data.</i>
repoIsSystem :: (HasCallStack, MonadIO m, IsRepo a) => a -> m Bool

-- | Returns whether the repository is writable by the current user. If the
--   repository is not writable, the <i><tt>error</tt></i> indicates why.
repoIsWritable :: (HasCallStack, MonadIO m, IsRepo a) => a -> m ()

-- | This function synchronously enumerates all static delta indexes in the
--   repository, returning its result in <i><tt>outIndexes</tt></i>.
--   
--   <i>Since: 2020.8</i>
repoListStaticDeltaIndexes :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe b -> m [Text]

-- | This function synchronously enumerates all static deltas in the
--   repository, returning its result in <i><tt>outDeltas</tt></i>.
repoListStaticDeltaNames :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe b -> m [Text]

-- | A version of <a>repoLoadVariant</a> specialized to commits, capable of
--   returning extended state information. Currently the only extended
--   state is <a>RepoCommitStatePartial</a>, which means that only a
--   sub-path of the commit is available.
repoLoadCommit :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> m (GVariant, [RepoCommitState])

-- | Load content object, decomposing it into three parts: the actual
--   content (for regular files), the metadata, and extended attributes.
repoLoadFile :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Maybe b -> m (Maybe InputStream, Maybe FileInfo, Maybe GVariant)

-- | Load object as a stream; useful when copying objects between
--   repositories.
repoLoadObjectStream :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> ObjectType -> Text -> Maybe b -> m (InputStream, Word64)

-- | Load the metadata object <i><tt>sha256</tt></i> of type
--   <i><tt>objtype</tt></i>, storing the result in
--   <i><tt>outVariant</tt></i>.
repoLoadVariant :: (HasCallStack, MonadIO m, IsRepo a) => a -> ObjectType -> Text -> m GVariant

-- | Attempt to load the metadata object <i><tt>sha256</tt></i> of type
--   <i><tt>objtype</tt></i> if it exists, storing the result in
--   <i><tt>outVariant</tt></i>. If it doesn't exist,
--   <i><tt>outVariant</tt></i> will be set to <a>Nothing</a> and the
--   function will still return TRUE.
repoLoadVariantIfExists :: (HasCallStack, MonadIO m, IsRepo a) => a -> ObjectType -> Text -> m (Maybe GVariant)

-- | Release a lock of type <i><tt>lockType</tt></i> from the lock state.
--   If the lock state becomes empty, the repository is unlocked.
--   Otherwise, the lock state only changes when transitioning from an
--   exclusive lock back to a shared lock. The requested
--   <i><tt>lockType</tt></i> must be the same type that was requested in
--   the call to <a>repoLockPush</a>. It is a programmer error if these do
--   not match and the program may abort if the lock would reach an invalid
--   state.
--   
--   <a>repoLockPop</a> waits for the lock depending on the repository's
--   lock-timeout-secs configuration. When lock-timeout-secs is -1, a
--   blocking lock is attempted. Otherwise, the lock is removed
--   non-blocking and <a>repoLockPop</a> will sleep synchronously up to
--   lock-timeout-secs seconds attempting to remove the lock. If the lock
--   cannot be removed within the timeout, a <a>IOErrorEnumWouldBlock</a>
--   error is returned.
--   
--   If <i><tt>self</tt></i> is not writable by the user, then no unlocking
--   is attempted and <a>True</a> is returned.
--   
--   <i>Since: 2021.3</i>
repoLockPop :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> RepoLockType -> Maybe b -> m ()

-- | Takes a lock on the repository and adds it to the lock state. If
--   <i><tt>lockType</tt></i> is <a>RepoLockTypeShared</a>, a shared lock
--   is taken. If <i><tt>lockType</tt></i> is <a>RepoLockTypeExclusive</a>,
--   an exclusive lock is taken. The actual lock state is only changed when
--   locking a previously unlocked repository or upgrading the lock from
--   shared to exclusive. If the requested lock type is unchanged or would
--   represent a downgrade (exclusive to shared), the lock state is not
--   changed.
--   
--   <a>repoLockPush</a> waits for the lock depending on the repository's
--   lock-timeout-secs configuration. When lock-timeout-secs is -1, a
--   blocking lock is attempted. Otherwise, the lock is taken non-blocking
--   and <a>repoLockPush</a> will sleep synchronously up to
--   lock-timeout-secs seconds attempting to acquire the lock. If the lock
--   cannot be acquired within the timeout, a <a>IOErrorEnumWouldBlock</a>
--   error is returned.
--   
--   If <i><tt>self</tt></i> is not writable by the user, then no locking
--   is attempted and <a>True</a> is returned.
--   
--   <i>Since: 2021.3</i>
repoLockPush :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> RepoLockType -> Maybe b -> m ()

-- | Commits in the "partial" state do not have all their child objects
--   written. This occurs in various situations, such as during a pull, but
--   also if a "subpath" pull is used, as well as "commit only" pulls.
--   
--   This function is used by <a>repoPullWithOptions</a>; you should use
--   this if you are implementing a different type of transport.
--   
--   <i>Since: 2017.15</i>
repoMarkCommitPartial :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> Bool -> m ()

-- | Allows the setting of a reason code for a partial commit. Presently it
--   only supports setting reason bitmask to
--   OSTREE_REPO_COMMIT_STATE_FSCK_PARTIAL, or
--   OSTREE_REPO_COMMIT_STATE_NORMAL. This will allow successive ostree
--   fsck operations to exit properly with an error code if the repository
--   has been truncated as a result of fsck trying to repair it.
--   
--   <i>Since: 2019.4</i>
repoMarkCommitPartialReason :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> Bool -> [RepoCommitState] -> m ()

-- | <i>No description available in the introspection data.</i>
repoModeFromString :: (HasCallStack, MonadIO m) => Text -> m RepoMode

-- | <i>No description available in the introspection data.</i>
repoNew :: (HasCallStack, MonadIO m, IsFile a) => a -> m Repo

-- | If the current working directory appears to be an OSTree repository,
--   create a new <a>Repo</a> object for accessing it. Otherwise use the
--   path in the OSTREE_REPO environment variable (if defined) or else the
--   default system repository located at /ostree/repo.
repoNewDefault :: (HasCallStack, MonadIO m) => m Repo

-- | Creates a new <a>Repo</a> instance, taking the system root path
--   explicitly instead of assuming "/".
repoNewForSysrootPath :: (HasCallStack, MonadIO m, IsFile a, IsFile b) => a -> b -> m Repo

-- | <i>No description available in the introspection data.</i>
repoOpen :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe b -> m ()

-- | This combines <a>repoNew</a> (but using fd-relative access) with
--   <a>repoOpen</a>. Use this when you know you should be operating on an
--   already extant repository. If you want to create one, use
--   <a>repoCreateAt</a>.
--   
--   <i>Since: 2017.10</i>
repoOpenAt :: (HasCallStack, MonadIO m, IsCancellable a) => Int32 -> Text -> Maybe a -> m Repo

-- | Starts or resumes a transaction. In order to write to a repo, you need
--   to start a transaction. You can complete the transaction with
--   <a>repoCommitTransaction</a>, or abort the transaction with
--   <a>repoAbortTransaction</a>.
--   
--   Currently, transactions may result in partial commits or data in the
--   target repository if interrupted during <a>repoCommitTransaction</a>,
--   and further writing refs is also not currently atomic.
--   
--   There can be at most one transaction active on a repo at a time per
--   instance of <tt>OstreeRepo</tt>; however, it is safe to have multiple
--   threads writing objects on a single <tt>OstreeRepo</tt> instance as
--   long as their lifetime is bounded by the transaction.
--   
--   Locking: Acquires a <tt>shared</tt> lock; release via commit or abort
--   Multithreading: This function is *not* MT safe; only one transaction
--   can be active at a time.
repoPrepareTransaction :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe b -> m Bool

-- | Delete content from the repository. By default, this function will
--   only delete "orphaned" objects not referred to by any commit. This can
--   happen during a local commit operation, when we have written content
--   objects but not saved the commit referencing them.
--   
--   However, if <a>RepoPruneFlagsRefsOnly</a> is provided, instead of
--   traversing all commits, only refs will be used. Particularly when
--   combined with <i><tt>depth</tt></i>, this is a convenient way to
--   delete history from the repository.
--   
--   Use the <a>RepoPruneFlagsNoPrune</a> to just determine statistics on
--   objects that would be deleted, without actually deleting them.
--   
--   Locking: exclusive
repoPrune :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> [RepoPruneFlags] -> Int32 -> Maybe b -> m (Int32, Int32, Word64)

-- | Delete content from the repository. This function is the "backend"
--   half of the higher level <a>repoPrune</a>. To use this function, you
--   determine the root set yourself, and this function finds all other
--   unreferenced objects and deletes them.
--   
--   Use this API when you want to perform more selective pruning - for
--   example, retain all commits from a production branch, but just GC some
--   history from your dev branch.
--   
--   The <a>RepoPruneFlagsNoPrune</a> flag may be specified to just
--   determine statistics on objects that would be deleted, without
--   actually deleting them.
--   
--   Locking: exclusive
--   
--   <i>Since: 2017.1</i>
repoPruneFromReachable :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> RepoPruneOptions -> Maybe b -> m (Int32, Int32, Word64)

-- | Prune static deltas, if COMMIT is specified then delete static delta
--   files only targeting that commit; otherwise any static delta of non
--   existing commits are deleted.
--   
--   Locking: exclusive
repoPruneStaticDeltas :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe Text -> Maybe b -> m ()

-- | Connect to the remote repository, fetching the specified set of refs
--   <i><tt>refsToFetch</tt></i>. For each ref that is changed, download
--   the commit, all metadata, and all content objects, storing them safely
--   on disk in <i><tt>self</tt></i>.
--   
--   If <i><tt>flags</tt></i> contains <a>RepoPullFlagsMirror</a>, and the
--   <i><tt>refsToFetch</tt></i> is <a>Nothing</a>, and the remote
--   repository contains a summary file, then all refs will be fetched.
--   
--   If <i><tt>flags</tt></i> contains <a>RepoPullFlagsCommitOnly</a>, then
--   only the metadata for the commits in <i><tt>refsToFetch</tt></i> is
--   pulled.
--   
--   Warning: This API will iterate the thread default main context, which
--   is a bug, but kept for compatibility reasons. If you want to avoid
--   this, use <a>mainContextPushThreadDefault</a> to push a new one around
--   this call.
repoPull :: (HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b, IsCancellable c) => a -> Text -> Maybe [Text] -> [RepoPullFlags] -> Maybe b -> Maybe c -> m ()

-- | Convenient "changed" callback for use with
--   <tt><i>ostree_async_progress_new_and_connect()</i></tt> when pulling
--   from a remote repository.
--   
--   Depending on the state of the <a>AsyncProgress</a>, either displays a
--   custom status message, or else outstanding fetch progress in
--   bytes/sec, or else outstanding content or metadata writes to the
--   repository in number of objects.
--   
--   Compatibility note: this function previously assumed that
--   <i><tt>userData</tt></i> was a pointer to a <tt><i>GSConsole</i></tt>
--   instance. This is no longer the case, and <i><tt>userData</tt></i> is
--   ignored.
repoPullDefaultConsoleProgressChanged :: (HasCallStack, MonadIO m, IsAsyncProgress a) => a -> Ptr () -> m ()

-- | Pull refs from multiple remotes which have been found using
--   <a>repoFindRemotesAsync</a>.
--   
--   <i><tt>results</tt></i> are expected to be in priority order, with the
--   best remotes to pull from listed first.
--   <a>repoPullFromRemotesAsync</a> will generally pull from the remotes
--   in order, but may parallelise its downloads.
--   
--   If an error is encountered when pulling from a given remote, that
--   remote will be ignored and another will be tried instead. If any refs
--   have not been downloaded successfully after all remotes have been
--   tried, <a>IOErrorEnumFailed</a> will be returned. The results of any
--   successful downloads will remain cached in the local repository.
--   
--   If <i><tt>cancellable</tt></i> is cancelled,
--   <a>IOErrorEnumCancelled</a> will be returned immediately. The results
--   of any successfully completed downloads at that point will remain
--   cached in the local repository.
--   
--   GPG verification of commits will be used unconditionally.
--   
--   The following <i><tt>options</tt></i> are currently defined:
--   
--   <ul>
--   <li><tt>flags</tt> (<tt>i</tt>): <a>RepoPullFlags</a> to apply to the
--   pull operation</li>
--   <li><tt>inherit-transaction</tt> (<tt>b</tt>): <a>True</a> to inherit
--   an ongoing transaction on the <a>Repo</a>, rather than encapsulating
--   the pull in a new one</li>
--   <li><tt>depth</tt> (<tt>i</tt>): How far in the history to traverse;
--   default is 0, -1 means infinite</li>
--   <li><tt>disable-static-deltas</tt> (<tt>b</tt>): Do not use static
--   deltas</li>
--   <li><tt>http-headers</tt> (<tt>a(ss)</tt>): Additional headers to add
--   to all HTTP requests</li>
--   <li><tt>subdirs</tt> (<tt>as</tt>): Pull just these
--   subdirectories</li>
--   <li><tt>update-frequency</tt> (<tt>u</tt>): Frequency to call the
--   async progress callback in milliseconds, if any; only values higher
--   than 0 are valid</li>
--   <li><tt>append-user-agent</tt> (<tt>s</tt>): Additional string to
--   append to the user agent</li>
--   <li><tt>n-network-retries</tt> (<tt>u</tt>): Number of times to retry
--   each download on receiving a transient network error, such as a socket
--   timeout; default is 5, 0 means return errors without retrying. Since:
--   2018.6</li>
--   <li><tt>ref-keyring-map</tt> (<tt>a(sss)</tt>): Array of (collection
--   ID, ref name, keyring remote name) tuples specifying which remote's
--   keyring should be used when doing GPG verification of each
--   collection-ref. This is useful to prevent a remote from serving
--   malicious updates to refs which did not originate from it. This can be
--   a subset or superset of the refs being pulled; any ref not being
--   pulled will be ignored and any ref without a keyring remote will be
--   verified with the keyring of the remote being pulled from. Since:
--   2019.2</li>
--   </ul>
--   
--   <i>Since: 2018.6</i>
repoPullFromRemotesAsync :: (HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b, IsCancellable c) => a -> [RepoFinderResult] -> Maybe GVariant -> Maybe b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Finish an asynchronous pull operation started with
--   <a>repoPullFromRemotesAsync</a>.
--   
--   <i>Since: 2018.6</i>
repoPullFromRemotesFinish :: (HasCallStack, MonadIO m, IsRepo a, IsAsyncResult b) => a -> b -> m ()

-- | This is similar to <a>repoPull</a>, but only fetches a single subpath.
repoPullOneDir :: (HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b, IsCancellable c) => a -> Text -> Text -> Maybe [Text] -> [RepoPullFlags] -> Maybe b -> Maybe c -> m ()

-- | Like <a>repoPull</a>, but supports an extensible set of flags. The
--   following are currently defined:
--   
--   <ul>
--   <li><tt>refs</tt> (<tt>as</tt>): Array of string refs</li>
--   <li><tt>collection-refs</tt> (<tt>a(sss)</tt>): Array of (collection
--   ID, ref name, checksum) tuples to pull; mutually exclusive with
--   <tt>refs</tt> and <tt>override-commit-ids</tt>. Checksums may be the
--   empty string to pull the latest commit for that ref</li>
--   <li><tt>flags</tt> (<tt>i</tt>): An instance of
--   <a>RepoPullFlags</a></li>
--   <li><tt>subdir</tt> (<tt>s</tt>): Pull just this subdirectory</li>
--   <li><tt>subdirs</tt> (<tt>as</tt>): Pull just these
--   subdirectories</li>
--   <li><tt>override-remote-name</tt> (<tt>s</tt>): If local, add this
--   remote to refspec</li>
--   <li><tt>gpg-verify</tt> (<tt>b</tt>): GPG verify commits</li>
--   <li><tt>gpg-verify-summary</tt> (<tt>b</tt>): GPG verify summary</li>
--   <li><tt>disable-sign-verify</tt> (<tt>b</tt>): Disable signapi
--   verification of commits</li>
--   <li><tt>disable-sign-verify-summary</tt> (<tt>b</tt>): Disable signapi
--   verification of the summary</li>
--   <li><tt>depth</tt> (<tt>i</tt>): How far in the history to traverse;
--   default is 0, -1 means infinite</li>
--   <li><tt>per-object-fsync</tt> (<tt>b</tt>): Perform disk writes more
--   slowly, avoiding a single large I/O sync</li>
--   <li><tt>disable-static-deltas</tt> (<tt>b</tt>): Do not use static
--   deltas</li>
--   <li><tt>require-static-deltas</tt> (<tt>b</tt>): Require static
--   deltas</li>
--   <li><tt>override-commit-ids</tt> (<tt>as</tt>): Array of specific
--   commit IDs to fetch for refs</li>
--   <li><tt>timestamp-check</tt> (<tt>b</tt>): Verify commit timestamps
--   are newer than current (when pulling via ref); Since: 2017.11</li>
--   <li><tt>timestamp-check-from-rev</tt> (<tt>s</tt>): Verify that all
--   fetched commit timestamps are newer than timestamp of given rev;
--   Since: 2020.4</li>
--   <li><tt>max-metadata-size</tt> (<tt>t</tt>): Restrict metadata objects
--   to a maximum number of bytes; 0 to disable. Since: 2018.9</li>
--   <li><tt>dry-run</tt> (<tt>b</tt>): Only print information on what will
--   be downloaded (requires static deltas)</li>
--   <li><tt>override-url</tt> (<tt>s</tt>): Fetch objects from this URL if
--   remote specifies no metalink in options</li>
--   <li><tt>inherit-transaction</tt> (<tt>b</tt>): Don't initiate, finish
--   or abort a transaction, useful to do multiple pulls in one
--   transaction.</li>
--   <li><tt>http-headers</tt> (<tt>a(ss)</tt>): Additional headers to add
--   to all HTTP requests</li>
--   <li><tt>update-frequency</tt> (<tt>u</tt>): Frequency to call the
--   async progress callback in milliseconds, if any; only values higher
--   than 0 are valid</li>
--   <li><tt>localcache-repos</tt> (<tt>as</tt>): File paths for local
--   repos to use as caches when doing remote fetches</li>
--   <li><tt>append-user-agent</tt> (<tt>s</tt>): Additional string to
--   append to the user agent</li>
--   <li><tt>n-network-retries</tt> (<tt>u</tt>): Number of times to retry
--   each download on receiving a transient network error, such as a socket
--   timeout; default is 5, 0 means return errors without retrying. Since:
--   2018.6</li>
--   <li><tt>low-speed-limit-bytes</tt> (<tt>u</tt>): The average transfer
--   speed per second of a transfer during the time set via
--   "low-speed-time-seconds" for libcurl to abort.</li>
--   <li><tt>low-speed-time-seconds</tt> (<tt>u</tt>): The time in number
--   seconds that the transfer speed should be below the
--   "low-speed-limit-bytes" setting for libcurl to abort.</li>
--   <li><tt>retry-all-network-errors</tt> (<tt>b</tt>): Retry when network
--   issues happen, instead of failing automatically. Currently only
--   affects libcurl. (Default set to true)</li>
--   <li><tt>max-outstanding-fetcher-requests</tt> (<tt>u</tt>): The max
--   amount of concurrent connections allowed.</li>
--   <li><tt>ref-keyring-map</tt> (<tt>a(sss)</tt>): Array of (collection
--   ID, ref name, keyring remote name) tuples specifying which remote's
--   keyring should be used when doing GPG verification of each
--   collection-ref. This is useful to prevent a remote from serving
--   malicious updates to refs which did not originate from it. This can be
--   a subset or superset of the refs being pulled; any ref not being
--   pulled will be ignored and any ref without a keyring remote will be
--   verified with the keyring of the remote being pulled from. Since:
--   2019.2</li>
--   <li><tt>summary-bytes</tt> (<tt>ay'): Contents of the </tt>summary<tt>
--   file to use. If this is specified, </tt>summary-sig-bytes<tt> must
--   also be specified. This is useful if doing multiple pull operations in
--   a transaction, using ostree_repo_remote_fetch_summary_with_options()
--   beforehand to download the </tt>summary<tt> and </tt>summary.sig<tt>
--   once for the entire transaction. If not specified, the </tt>summary@
--   will be downloaded from the remote. Since: 2020.5</li>
--   <li><tt>summary-sig-bytes</tt> (<tt>ay</tt>): Contents of the
--   <tt>summary.sig</tt> file. If this is specified,
--   <tt>summary-bytes</tt> must also be specified. Since: 2020.5</li>
--   <li><tt>disable-verify-bindings</tt> (@b`): Disable verification of
--   commit bindings. Since: 2020.9</li>
--   </ul>
repoPullWithOptions :: (HasCallStack, MonadIO m, IsRepo a, IsAsyncProgress b, IsCancellable c) => a -> Text -> GVariant -> Maybe b -> Maybe c -> m ()

-- | Return the size in bytes of object with checksum
--   <i><tt>sha256</tt></i>, after any compression has been applied.
repoQueryObjectStorageSize :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> ObjectType -> Text -> Maybe b -> m Word64

-- | Load the content for <i><tt>rev</tt></i> into <i><tt>outRoot</tt></i>.
repoReadCommit :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Maybe b -> m (File, Text)

-- | OSTree commits can have arbitrary metadata associated; this function
--   retrieves them. If none exists, <i><tt>outMetadata</tt></i> will be
--   set to <a>Nothing</a>.
repoReadCommitDetachedMetadata :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Maybe b -> m (Maybe GVariant)

-- | Regenerate the OSTree repository metadata used by clients to describe
--   available branches and other metadata.
--   
--   The repository metadata currently consists of the <tt>summary</tt>
--   file. See <a>repoRegenerateSummary</a> and
--   <tt><i>OSTREE_SUMMARY_GVARIANT_FORMAT</i></tt> for additional details
--   on its contents.
--   
--   Additionally, if the <tt>core/collection-id</tt> key is set in the
--   configuration, a <a>REPO_METADATA_REF</a> commit will be created.
--   
--   The following <i><tt>options</tt></i> are currently defined:
--   
--   <ul>
--   <li><tt>gpg-key-ids</tt> (<tt>as</tt>): Array of GPG key IDs to sign
--   the metadata with.</li>
--   <li><tt>gpg-homedir</tt> (<tt>s</tt>): GPG home directory.</li>
--   <li><tt>sign-keys</tt> (<tt>av</tt>): Array of keys to sign the
--   metadata with. The key type is specific to the sign engine used.</li>
--   <li><tt>sign-type</tt> (<tt>s</tt>): Sign engine type to use. If not
--   specified, <a>SIGN_NAME_ED25519</a> is used.</li>
--   </ul>
--   
--   Locking: shared
--   
--   <i>Since: 2023.1</i>
repoRegenerateMetadata :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe GVariant -> Maybe GVariant -> Maybe b -> m ()

-- | An OSTree repository can contain a high level "summary" file that
--   describes the available branches and other metadata.
--   
--   If the timetable for making commits and updating the summary file is
--   fairly regular, setting the <tt>ostree.summary.expires</tt> key in
--   <i><tt>additionalMetadata</tt></i> will aid clients in working out
--   when to check for updates.
--   
--   It is regenerated automatically after any ref is added, removed, or
--   updated if <tt>core/auto-update-summary</tt> is set.
--   
--   If the <tt>core/collection-id</tt> key is set in the configuration, it
--   will be included as <tt><i>OSTREE_SUMMARY_COLLECTION_ID</i></tt> in
--   the summary file. Refs that have associated collection IDs will be
--   included in the generated summary file, listed under the
--   <tt><i>OSTREE_SUMMARY_COLLECTION_MAP</i></tt> key. Collection IDs and
--   refs in <tt><i>OSTREE_SUMMARY_COLLECTION_MAP</i></tt> are guaranteed
--   to be in lexicographic order.
--   
--   Locking: shared (Prior to 2021.7, this was exclusive)
repoRegenerateSummary :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe GVariant -> Maybe b -> m ()

-- | By default, an <a>Repo</a> will cache the remote configuration and its
--   own repo/config data. This API can be used to reload it.
--   
--   <i>Since: 2017.2</i>
repoReloadConfig :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe b -> m ()

-- | Create a new remote named <i><tt>name</tt></i> pointing to
--   <i><tt>url</tt></i>. If <i><tt>options</tt></i> is provided, then it
--   will be mapped to <a>KeyFile</a> entries, where the GVariant
--   dictionary key is an option string, and the value is mapped as
--   follows: * s: <a>keyFileSetString</a> * b: <a>keyFileSetBoolean</a> *
--   as: <a>keyFileSetStringList</a>
repoRemoteAdd :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Maybe Text -> Maybe GVariant -> Maybe b -> m ()

-- | A combined function handling the equivalent of <a>repoRemoteAdd</a>,
--   <a>repoRemoteDelete</a>, with more options.
repoRemoteChange :: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsCancellable c) => a -> Maybe b -> RepoRemoteChange -> Text -> Maybe Text -> Maybe GVariant -> Maybe c -> m ()

-- | Delete the remote named <i><tt>name</tt></i>. It is an error if the
--   provided remote does not exist.
repoRemoteDelete :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Maybe b -> m ()

-- | Tries to fetch the summary file and any GPG signatures on the summary
--   file over HTTP, and returns the binary data in
--   <i><tt>outSummary</tt></i> and <i><tt>outSignatures</tt></i>
--   respectively.
--   
--   If no summary file exists on the remote server,
--   <i><tt>outSummary</tt></i> is set to <i><tt>nULL</tt></i>. Likewise if
--   the summary file is not signed, <i><tt>outSignatures</tt></i> is set
--   to <i><tt>nULL</tt></i>. In either case the function still returns
--   <a>True</a>.
--   
--   This method does not verify the signature of the downloaded summary
--   file. Use <a>repoVerifySummary</a> for that.
--   
--   Parse the summary data into a <a>GVariant</a> using
--   <a>variantNewFromBytes</a> with
--   <tt><i>OSTREE_SUMMARY_GVARIANT_FORMAT</i></tt> as the format string.
repoRemoteFetchSummary :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Maybe b -> m (Bytes, Bytes)

-- | Like <a>repoRemoteFetchSummary</a>, but supports an extensible set of
--   flags. The following are currently defined:
--   
--   <ul>
--   <li>override-url (s): Fetch summary from this URL if remote specifies
--   no metalink in options</li>
--   <li>http-headers (a(ss)): Additional headers to add to all HTTP
--   requests</li>
--   <li>append-user-agent (s): Additional string to append to the user
--   agent</li>
--   <li>n-network-retries (u): Number of times to retry each download on
--   receiving a transient network error, such as a socket timeout; default
--   is 5, 0 means return errors without retrying</li>
--   </ul>
--   
--   <i>Since: 2016.6</i>
repoRemoteFetchSummaryWithOptions :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Maybe GVariant -> Maybe b -> m (Bytes, Bytes)

-- | Enumerate the trusted GPG keys for the remote <i><tt>name</tt></i>. If
--   <i><tt>name</tt></i> is <a>Nothing</a>, the global GPG keys will be
--   returned. The keys will be returned in the <i><tt>outKeys</tt></i>
--   <a>PtrArray</a>. Each element in the array is a <a>GVariant</a> of
--   format <tt><i>OSTREE_GPG_KEY_GVARIANT_FORMAT</i></tt>. The
--   <i><tt>keyIds</tt></i> array can be used to limit which keys are
--   included. If <i><tt>keyIds</tt></i> is <a>Nothing</a>, then all keys
--   are included.
--   
--   <i>Since: 2021.4</i>
repoRemoteGetGpgKeys :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe Text -> Maybe [Text] -> Maybe b -> m [GVariant]

-- | Return whether GPG verification is enabled for the remote named
--   <i><tt>name</tt></i> through <i><tt>outGpgVerify</tt></i>. It is an
--   error if the provided remote does not exist.
repoRemoteGetGpgVerify :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> m Bool

-- | Return whether GPG verification of the summary is enabled for the
--   remote named <i><tt>name</tt></i> through
--   <i><tt>outGpgVerifySummary</tt></i>. It is an error if the provided
--   remote does not exist.
repoRemoteGetGpgVerifySummary :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> m Bool

-- | Return the URL of the remote named <i><tt>name</tt></i> through
--   <i><tt>outUrl</tt></i>. It is an error if the provided remote does not
--   exist.
repoRemoteGetUrl :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> m Text

-- | Imports one or more GPG keys from the open
--   <i><tt>sourceStream</tt></i>, or from the user's personal keyring if
--   <i><tt>sourceStream</tt></i> is <a>Nothing</a>. The
--   <i><tt>keyIds</tt></i> array can optionally restrict which keys are
--   imported. If <i><tt>keyIds</tt></i> is <a>Nothing</a>, then all keys
--   are imported.
--   
--   The imported keys will be used to conduct GPG verification when
--   pulling from the remote named <i><tt>name</tt></i>.
repoRemoteGpgImport :: (HasCallStack, MonadIO m, IsRepo a, IsInputStream b, IsCancellable c) => a -> Text -> Maybe b -> Maybe [Text] -> Maybe c -> m Word32

-- | List available remote names in an <a>Repo</a>. Remote names are sorted
--   alphabetically. If no remotes are available the function returns
--   <a>Nothing</a>.
repoRemoteList :: (HasCallStack, MonadIO m, IsRepo a) => a -> m [Text]

-- | Look up the checksum for the given collection–ref, returning it in
--   <i><tt>outRev</tt></i>. This will search through the mirrors and
--   remote refs.
--   
--   If <i><tt>allowNoent</tt></i> is <a>True</a> and the given
--   <i><tt>ref</tt></i> cannot be found, <a>True</a> will be returned and
--   <i><tt>outRev</tt></i> will be set to <a>Nothing</a>. If
--   <i><tt>allowNoent</tt></i> is <a>False</a> and the given
--   <i><tt>ref</tt></i> cannot be found, a <a>IOErrorEnumNotFound</a>
--   error will be returned.
--   
--   If you want to check only local refs, not remote or mirrored ones, use
--   the flag <a>RepoResolveRevExtFlagsLocalOnly</a>. This is analogous to
--   using <a>repoResolveRevExt</a> but for collection-refs.
--   
--   <i>Since: 2018.6</i>
repoResolveCollectionRef :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> CollectionRef -> Bool -> [RepoResolveRevExtFlags] -> Maybe b -> m (Maybe Text)

-- | Find the GPG keyring for the given <i><tt>collectionId</tt></i>, using
--   the local configuration from the given <a>Repo</a>. This will search
--   the configured remotes for ones whose <tt>collection-id</tt> key
--   matches <i><tt>collectionId</tt></i>, and will return the first
--   matching remote.
--   
--   If multiple remotes match and have different keyrings, a debug message
--   will be emitted, and the first result will be returned. It is expected
--   that the keyrings should match.
--   
--   If no match can be found, a <a>IOErrorEnumNotFound</a> error will be
--   returned.
--   
--   <i>Since: 2018.6</i>
repoResolveKeyringForCollection :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Maybe b -> m Remote

-- | Look up the given refspec, returning the checksum it references in the
--   parameter <i><tt>outRev</tt></i>. Will fall back on remote directory
--   if cannot find the given refspec in local.
repoResolveRev :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> Bool -> m (Maybe Text)

-- | Look up the given refspec, returning the checksum it references in the
--   parameter <i><tt>outRev</tt></i>. Differently from
--   <a>repoResolveRev</a>, this will not fall back to searching through
--   remote repos if a local ref is specified but not found.
--   
--   The flag <a>RepoResolveRevExtFlagsLocalOnly</a> is implied so using it
--   has no effect.
--   
--   <i>Since: 2016.7</i>
repoResolveRevExt :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> Bool -> [RepoResolveRevExtFlags] -> m (Maybe Text)

-- | This function is deprecated in favor of using
--   <a>repoDevInoCacheNew</a>, which allows a precise mapping to be built
--   up between hardlink checkout files and their checksums between
--   <tt>ostree_repo_checkout_at()</tt> and
--   <tt>ostree_repo_write_directory_to_mtree()</tt>.
--   
--   When invoking <a>repoWriteDirectoryToMtree</a>, it has to compute the
--   checksum of all files. If your commit contains hardlinks from a
--   checkout, this functions builds a mapping of device numbers and inodes
--   to their checksum.
--   
--   There is an upfront cost to creating this mapping, as this will scan
--   the entire objects directory. If your commit is composed of mostly
--   hardlinks to existing ostree objects, then this will speed up
--   considerably, so call it before you call
--   <a>repoWriteDirectoryToMtree</a> or similar. However,
--   <a>repoDevInoCacheNew</a> is better as it avoids scanning all objects.
--   
--   Multithreading: This function is *not* MT safe.
repoScanHardlinks :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe b -> m ()

-- | Like <a>repoSetRefImmediate</a>, but creates an alias.
--   
--   <i>Since: 2017.10</i>
repoSetAliasRefImmediate :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe Text -> Text -> Maybe Text -> Maybe b -> m ()

-- | Set a custom location for the cache directory used for e.g. per-remote
--   summary caches. Setting this manually is useful when doing operations
--   on a system repo as a user because you don't have write permissions in
--   the repo, where the cache is normally stored.
--   
--   <i>Since: 2016.5</i>
repoSetCacheDir :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Int32 -> Text -> Maybe b -> m ()

-- | Set or clear the collection ID of this repository. See [collection
--   IDs][collection-ids]. The update will be made in memory, but must be
--   written out to the repository configuration on disk using
--   <a>repoWriteConfig</a>.
--   
--   <i>Since: 2018.6</i>
repoSetCollectionId :: (HasCallStack, MonadIO m, IsRepo a) => a -> Maybe Text -> m ()

-- | This is like <a>repoTransactionSetCollectionRef</a>, except it may be
--   invoked outside of a transaction. This is presently safe for the case
--   where we're creating or overwriting an existing ref.
--   
--   <i>Since: 2018.6</i>
repoSetCollectionRefImmediate :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> CollectionRef -> Maybe Text -> Maybe b -> m ()

-- | Disable requests to <tt><i>fsync()</i></tt> to stable storage during
--   commits. This option should only be used by build system tools which
--   are creating disposable virtual machines, or have higher level
--   mechanisms for ensuring data consistency.
repoSetDisableFsync :: (HasCallStack, MonadIO m, IsRepo a) => a -> Bool -> m ()

-- | This is like <a>repoTransactionSetRef</a>, except it may be invoked
--   outside of a transaction. This is presently safe for the case where
--   we're creating or overwriting an existing ref.
--   
--   Multithreading: This function is MT safe.
repoSetRefImmediate :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe Text -> Text -> Maybe Text -> Maybe b -> m ()

-- | Add a GPG signature to a commit.
repoSignCommit :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Text -> Maybe Text -> Maybe b -> m ()

-- | This function is deprecated, sign the summary file instead. Add a GPG
--   signature to a static delta.
repoSignDelta :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Text -> Text -> Text -> Maybe b -> m ()

-- | Validate the commit data using the commit metadata which must contain
--   at least one valid signature. If GPG and signapi are both enabled,
--   then both must find at least one valid signature.
repoSignatureVerifyCommitData :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> Bytes -> Bytes -> [RepoVerifyFlags] -> m Text

-- | Given a directory representing an already-downloaded static delta on
--   disk, apply it, generating a new commit. The directory must be named
--   with the form "FROM-TO", where both are checksums, and it must contain
--   a file named "superblock", along with at least one part.
repoStaticDeltaExecuteOffline :: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsCancellable c) => a -> b -> Bool -> Maybe c -> m ()

-- | Given a directory representing an already-downloaded static delta on
--   disk, apply it, generating a new commit. If sign is passed, the static
--   delta signature is verified. If sign-verify-deltas configuration
--   option is set and static delta is signed, signature verification will
--   be mandatory before apply the static delta. The directory must be
--   named with the form "FROM-TO", where both are checksums, and it must
--   contain a file named "superblock", along with at least one part.
--   
--   <i>Since: 2020.7</i>
repoStaticDeltaExecuteOfflineWithSignature :: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsSign c, IsCancellable d) => a -> b -> c -> Bool -> Maybe d -> m ()

-- | Generate a lookaside "static delta" from <i><tt>from</tt></i>
--   (<a>Nothing</a> means from-empty) which can generate the objects in
--   <i><tt>to</tt></i>. This delta is an optimization over fetching
--   individual objects, and can be conveniently stored and applied
--   offline.
--   
--   The <i><tt>params</tt></i> argument should be an a{sv}. The following
--   attributes are known: - min-fallback-size: u: Minimum uncompressed
--   size in megabytes to use fallback, 0 to disable fallbacks -
--   max-chunk-size: u: Maximum size in megabytes of a delta part -
--   max-bsdiff-size: u: Maximum size in megabytes to consider bsdiff
--   compression for input files - compression: y: Compression type:
--   0=none, x=lzma, g=gzip - bsdiff-enabled: b: Enable bsdiff compression.
--   Default TRUE. - inline-parts: b: Put part data in header, to get a
--   single file delta. Default FALSE. - verbose: b: Print diagnostic
--   messages. Default FALSE. - endianness: b: Deltas use host byte order
--   by default; this option allows choosing (G_BIG_ENDIAN or
--   G_LITTLE_ENDIAN) - filename: ^ay: Save delta superblock to this
--   filename (bytestring), and parts in the same directory. Default saves
--   to repository. - sign-name: ^ay: Signature type to use (bytestring). -
--   sign-key-ids: ^as: NULL-terminated array of keys used to sign delta
--   superblock.
repoStaticDeltaGenerate :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> StaticDeltaGenerateOpt -> Maybe Text -> Text -> Maybe GVariant -> Maybe GVariant -> Maybe b -> m ()

-- | The delta index for a particular commit lists all the existing deltas
--   that can be used when downloading that commit. This operation
--   regenerates these indexes, either for a particular commit (if
--   <i><tt>optToCommit</tt></i> is non-<a>Nothing</a>), or for all commits
--   that are reachable by an existing delta (if
--   <i><tt>optToCommit</tt></i> is <a>Nothing</a>).
--   
--   This is normally called automatically when the summary is updated in
--   <a>repoRegenerateSummary</a>.
--   
--   Locking: shared
--   
--   <i>Since: 2020.8</i>
repoStaticDeltaReindex :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> StaticDeltaIndexFlags -> Text -> Maybe b -> m ()

-- | Verify static delta file signature.
--   
--   <i>Since: 2020.7</i>
repoStaticDeltaVerifySignature :: (HasCallStack, MonadIO m, IsRepo a, IsSign b) => a -> Text -> b -> m (Maybe Text)

-- | If <i><tt>checksum</tt></i> is not <a>Nothing</a>, then record it as
--   the target of local ref named <i><tt>ref</tt></i>.
--   
--   Otherwise, if <i><tt>checksum</tt></i> is <a>Nothing</a>, then record
--   that the ref should be deleted.
--   
--   The change will not be written out immediately, but when the
--   transaction is completed with <a>repoCommitTransaction</a>. If the
--   transaction is instead aborted with <a>repoAbortTransaction</a>, no
--   changes will be made to the repository.
--   
--   Multithreading: Since v2017.15 this function is MT safe.
--   
--   <i>Since: 2018.6</i>
repoTransactionSetCollectionRef :: (HasCallStack, MonadIO m, IsRepo a) => a -> CollectionRef -> Maybe Text -> m ()

-- | If <i><tt>checksum</tt></i> is not <a>Nothing</a>, then record it as
--   the target of ref named <i><tt>ref</tt></i>; if <i><tt>remote</tt></i>
--   is provided, the ref will appear to originate from that remote.
--   
--   Otherwise, if <i><tt>checksum</tt></i> is <a>Nothing</a>, then record
--   that the ref should be deleted.
--   
--   The change will be written when the transaction is completed with
--   <a>repoCommitTransaction</a>; that function takes care of writing all
--   of the objects (such as the commit referred to by
--   <i><tt>checksum</tt></i>) before updating the refs. If the transaction
--   is instead aborted with <a>repoAbortTransaction</a>, no changes to the
--   ref will be made to the repository.
--   
--   Note however that currently writing *multiple* refs is not truly
--   atomic; if the process or system is terminated during
--   <a>repoCommitTransaction</a>, it is possible that just some of the
--   refs will have been updated. Your application should take care to
--   handle this case.
--   
--   Multithreading: Since v2017.15 this function is MT safe.
repoTransactionSetRef :: (HasCallStack, MonadIO m, IsRepo a) => a -> Maybe Text -> Text -> Maybe Text -> m ()

-- | Like <a>repoTransactionSetRef</a>, but takes concatenated
--   <i><tt>refspec</tt></i> format as input instead of separate remote and
--   name arguments.
--   
--   Multithreading: Since v2017.15 this function is MT safe.
repoTransactionSetRefspec :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> Maybe Text -> m ()

-- | Gets all the commits that a certain object belongs to, as recorded by
--   a parents table gotten from
--   ostree_repo_traverse_commit_union_with_parents.
--   
--   <i>Since: 2018.5</i>
repoTraverseParentsGetCommits :: (HasCallStack, MonadIO m) => Map (Ptr ()) (Ptr ()) -> GVariant -> m [Text]

-- | Check for a valid GPG signature on commit named by the ASCII checksum
--   <i><tt>commitChecksum</tt></i>.
repoVerifyCommit :: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsFile c, IsCancellable d) => a -> Text -> Maybe b -> Maybe c -> Maybe d -> m ()

-- | Read GPG signature(s) on the commit named by the ASCII checksum
--   <i><tt>commitChecksum</tt></i> and return detailed results.
repoVerifyCommitExt :: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsFile c, IsCancellable d) => a -> Text -> Maybe b -> Maybe c -> Maybe d -> m GpgVerifyResult

-- | Read GPG signature(s) on the commit named by the ASCII checksum
--   <i><tt>commitChecksum</tt></i> and return detailed results, based on
--   the keyring configured for <i><tt>remote</tt></i>.
--   
--   <i>Since: 2016.14</i>
repoVerifyCommitForRemote :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Text -> Maybe b -> m GpgVerifyResult

-- | Verify <i><tt>signatures</tt></i> for <i><tt>summary</tt></i> data
--   using GPG keys in the keyring for <i><tt>remoteName</tt></i>, and
--   return an <a>GpgVerifyResult</a>.
repoVerifySummary :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Bytes -> Bytes -> Maybe b -> m GpgVerifyResult

-- | Import an archive file <i><tt>archive</tt></i> into the repository,
--   and write its file structure to <i><tt>mtree</tt></i>.
repoWriteArchiveToMtree :: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsMutableTree c, IsCancellable d) => a -> b -> c -> Maybe RepoCommitModifier -> Bool -> Maybe d -> m ()

-- | Read an archive from <i><tt>fd</tt></i> and import it into the
--   repository, writing its file structure to <i><tt>mtree</tt></i>.
repoWriteArchiveToMtreeFromFd :: (HasCallStack, MonadIO m, IsRepo a, IsMutableTree b, IsCancellable c) => a -> Int32 -> b -> Maybe RepoCommitModifier -> Bool -> Maybe c -> m ()

-- | Write a commit metadata object, referencing
--   <i><tt>rootContentsChecksum</tt></i> and
--   <i><tt>rootMetadataChecksum</tt></i>. This uses the current time as
--   the commit timestamp, but it can be overridden with an explicit
--   timestamp via the <a>standard</a> <tt>SOURCE_DATE_EPOCH</tt>
--   environment flag.
repoWriteCommit :: (HasCallStack, MonadIO m, IsRepo a, IsRepoFile b, IsCancellable c) => a -> Maybe Text -> Maybe Text -> Maybe Text -> Maybe GVariant -> b -> Maybe c -> m Text

-- | Replace any existing metadata associated with commit referred to by
--   <i><tt>checksum</tt></i> with <i><tt>metadata</tt></i>. If
--   <i><tt>metadata</tt></i> is <a>Nothing</a>, then existing data will be
--   deleted.
repoWriteCommitDetachedMetadata :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Text -> Maybe GVariant -> Maybe b -> m ()

-- | Write a commit metadata object, referencing
--   <i><tt>rootContentsChecksum</tt></i> and
--   <i><tt>rootMetadataChecksum</tt></i>.
repoWriteCommitWithTime :: (HasCallStack, MonadIO m, IsRepo a, IsRepoFile b, IsCancellable c) => a -> Maybe Text -> Maybe Text -> Maybe Text -> Maybe GVariant -> b -> Word64 -> Maybe c -> m Text

-- | Save <i><tt>newConfig</tt></i> in place of this repository's config
--   file.
repoWriteConfig :: (HasCallStack, MonadIO m, IsRepo a) => a -> KeyFile -> m ()

-- | Store the content object streamed as <i><tt>objectInput</tt></i>, with
--   total length <i><tt>length</tt></i>. The actual checksum will be
--   returned as <i><tt>outCsum</tt></i>.
repoWriteContent :: (HasCallStack, MonadIO m, IsRepo a, IsInputStream b, IsCancellable c) => a -> Maybe Text -> b -> Word64 -> Maybe c -> m (Maybe ByteString)

-- | Asynchronously store the content object <i><tt>object</tt></i>. If
--   provided, the checksum <i><tt>expectedChecksum</tt></i> will be
--   verified.
repoWriteContentAsync :: (HasCallStack, MonadIO m, IsRepo a, IsInputStream b, IsCancellable c) => a -> Maybe Text -> b -> Word64 -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Completes an invocation of <a>repoWriteContentAsync</a>.
repoWriteContentFinish :: (HasCallStack, MonadIO m, IsRepo a, IsAsyncResult b) => a -> b -> m Word8

-- | Store the content object streamed as <i><tt>objectInput</tt></i>, with
--   total length <i><tt>length</tt></i>. The given
--   <i><tt>checksum</tt></i> will be treated as trusted.
--   
--   This function should be used when importing file objects from local
--   disk, for example.
repoWriteContentTrusted :: (HasCallStack, MonadIO m, IsRepo a, IsInputStream b, IsCancellable c) => a -> Text -> b -> Word64 -> Maybe c -> m ()

-- | Store as objects all contents of the directory referred to by
--   <i><tt>dfd</tt></i> and <i><tt>path</tt></i> all children into the
--   repository <i><tt>self</tt></i>, overlaying the resulting filesystem
--   hierarchy into <i><tt>mtree</tt></i>.
repoWriteDfdToMtree :: (HasCallStack, MonadIO m, IsRepo a, IsMutableTree b, IsCancellable c) => a -> Int32 -> Text -> b -> Maybe RepoCommitModifier -> Maybe c -> m ()

-- | Store objects for <i><tt>dir</tt></i> and all children into the
--   repository <i><tt>self</tt></i>, overlaying the resulting filesystem
--   hierarchy into <i><tt>mtree</tt></i>.
repoWriteDirectoryToMtree :: (HasCallStack, MonadIO m, IsRepo a, IsFile b, IsMutableTree c, IsCancellable d) => a -> b -> c -> Maybe RepoCommitModifier -> Maybe d -> m ()

-- | Store the metadata object <i><tt>object</tt></i>. Return the checksum
--   as <i><tt>outCsum</tt></i>.
--   
--   If <i><tt>expectedChecksum</tt></i> is not <a>Nothing</a>, verify it
--   against the computed checksum.
repoWriteMetadata :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> ObjectType -> Maybe Text -> GVariant -> Maybe b -> m ByteString

-- | Asynchronously store the metadata object <i><tt>variant</tt></i>. If
--   provided, the checksum <i><tt>expectedChecksum</tt></i> will be
--   verified.
repoWriteMetadataAsync :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> ObjectType -> Maybe Text -> GVariant -> Maybe b -> Maybe AsyncReadyCallback -> m ()

-- | Complete a call to <a>repoWriteMetadataAsync</a>.
repoWriteMetadataFinish :: (HasCallStack, MonadIO m, IsRepo a, IsAsyncResult b) => a -> b -> m ByteString

-- | Store the metadata object <i><tt>variant</tt></i>; the provided
--   <i><tt>checksum</tt></i> is trusted.
repoWriteMetadataStreamTrusted :: (HasCallStack, MonadIO m, IsRepo a, IsInputStream b, IsCancellable c) => a -> ObjectType -> Text -> b -> Word64 -> Maybe c -> m ()

-- | Store the metadata object <i><tt>variant</tt></i>; the provided
--   <i><tt>checksum</tt></i> is trusted.
repoWriteMetadataTrusted :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> ObjectType -> Text -> GVariant -> Maybe b -> m ()

-- | Write all metadata objects for <i><tt>mtree</tt></i> to repo; the
--   resulting <i><tt>outFile</tt></i> points to the
--   <a>ObjectTypeDirTree</a> object that the <i><tt>mtree</tt></i>
--   represented.
repoWriteMtree :: (HasCallStack, MonadIO m, IsRepo a, IsMutableTree b, IsCancellable c) => a -> b -> Maybe c -> m File

-- | Create an <tt>OstreeContentWriter</tt> that allows streaming output
--   into the repository.
--   
--   <i>Since: 2021.2</i>
repoWriteRegfile :: (HasCallStack, MonadIO m, IsRepo a) => a -> Maybe Text -> Word32 -> Word32 -> Word32 -> Word64 -> Maybe GVariant -> m ContentWriter

-- | Synchronously create a file object from the provided content. This API
--   is intended for small files where it is reasonable to buffer the
--   entire content in memory.
--   
--   Unlike <tt>ostree_repo_write_content()</tt>, if
--   <i><tt>expectedChecksum</tt></i> is provided, this function will not
--   check for the presence of the object beforehand.
--   
--   <i>Since: 2021.2</i>
repoWriteRegfileInline :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe Text -> Word32 -> Word32 -> Word32 -> Maybe GVariant -> ByteString -> Maybe b -> m Text

-- | Synchronously create a symlink object.
--   
--   Unlike <tt>ostree_repo_write_content()</tt>, if
--   <i><tt>expectedChecksum</tt></i> is provided, this function will not
--   check for the presence of the object beforehand.
--   
--   <i>Since: 2021.2</i>
repoWriteSymlink :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => a -> Maybe Text -> Word32 -> Word32 -> Maybe GVariant -> Text -> Maybe b -> m Text

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>path</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructRepoPath :: (IsRepo o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>path</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repo #path
--   </pre>
getRepoPath :: (MonadIO m, IsRepo o) => o -> m File

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>remotes-config-dir</tt>” property. This is rarely needed
--   directly, but it is used by <a>new</a>.
constructRepoRemotesConfigDir :: (IsRepo o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>remotes-config-dir</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repo #remotesConfigDir
--   </pre>
getRepoRemotesConfigDir :: (MonadIO m, IsRepo o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sysroot-path</tt>” property. This is rarely needed directly, but
--   it is used by <a>new</a>.
constructRepoSysrootPath :: (IsRepo o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>sysroot-path</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> repo #sysrootPath
--   </pre>
getRepoSysrootPath :: (MonadIO m, IsRepo o) => o -> m (Maybe File)

-- | Emitted during a pull operation upon GPG verification (if enabled).
--   Applications can connect to this signal to output the verification
--   results if desired.
--   
--   The signal will be emitted from whichever <a>MainContext</a> is the
--   thread-default at the point when <a>repoPullWithOptions</a> is called.
type RepoGpgVerifyResultCallback = -- | /@checksum@/: checksum of the signed object Text -> -- | /@result@/: an t'GI.OSTree.Objects.GpgVerifyResult.GpgVerifyResult' GpgVerifyResult -> IO ()

-- | Connect a signal handler for the <a>gpgVerifyResult</a> signal, to be
--   run after the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>after</a> repo #gpgVerifyResult callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterRepoGpgVerifyResult :: (IsRepo a, MonadIO m) => a -> ((?self :: a) => RepoGpgVerifyResultCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>gpgVerifyResult</a> signal, to be
--   run before the default handler. When <a>overloading</a> is enabled,
--   this is equivalent to
--   
--   <pre>
--   <a>on</a> repo #gpgVerifyResult callback
--   </pre>
onRepoGpgVerifyResult :: (IsRepo a, MonadIO m) => a -> ((?self :: a) => RepoGpgVerifyResultCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.OSTree.Objects.Repo.Repo
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.Repo.Repo o) => GI.OSTree.Objects.Repo.IsRepo o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.Repo.Repo
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.Repo.Repo
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.Repo.Repo
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.Repo.Repo
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.Repo.Repo)


-- | Private instance structure.
module GI.OSTree.Objects.MutableTree

-- | Memory-managed wrapper type.
newtype MutableTree
MutableTree :: ManagedPtr MutableTree -> MutableTree

-- | Type class for types which can be safely cast to <a>MutableTree</a>,
--   for instance with <a>toMutableTree</a>.
class (GObject o, IsDescendantOf MutableTree o) => IsMutableTree o

-- | Cast to <a>MutableTree</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toMutableTree :: (MonadIO m, IsMutableTree o) => o -> m MutableTree

-- | In some cases, a tree may be in a "lazy" state that loads data in the
--   background; if an error occurred during a non-throwing API call, it
--   will have been cached. This function checks for a cached error. The
--   tree remains in error state.
--   
--   <i>Since: 2018.7</i>
mutableTreeCheckError :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> m ()

-- | Returns the subdirectory of self with filename <i><tt>name</tt></i>,
--   creating an empty one it if it doesn't exist.
mutableTreeEnsureDir :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> Text -> m MutableTree

-- | Create all parent trees necessary for the given
--   <i><tt>splitPath</tt></i> to exist.
mutableTreeEnsureParentDirs :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> [Text] -> Text -> m MutableTree

-- | Merges <i><tt>self</tt></i> with the tree given by
--   <i><tt>contentsChecksum</tt></i> and <i><tt>metadataChecksum</tt></i>,
--   but only if it's possible without writing new objects to the
--   <i><tt>repo</tt></i>. We can do this if either <i><tt>self</tt></i> is
--   empty, the tree given by <i><tt>contentsChecksum</tt></i> is empty or
--   if both trees already have the same <i><tt>contentsChecksum</tt></i>.
--   
--   <i>Since: 2018.7</i>
mutableTreeFillEmptyFromDirtree :: (HasCallStack, MonadIO m, IsMutableTree a, IsRepo b) => a -> b -> Text -> Text -> m Bool

-- | <i>No description available in the introspection data.</i>
mutableTreeGetContentsChecksum :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> m Text

-- | <i>No description available in the introspection data.</i>
mutableTreeGetFiles :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> m (Map Text Text)

-- | <i>No description available in the introspection data.</i>
mutableTreeGetMetadataChecksum :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> m Text

-- | Lookup <i><tt>name</tt></i> and returns
--   <i><tt>outFileChecksum</tt></i> or <i><tt>outSubdir</tt></i> depending
--   on its file type.
mutableTreeLookup :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> Text -> m (Maybe Text, Maybe MutableTree)

-- | <i>No description available in the introspection data.</i>
mutableTreeNew :: (HasCallStack, MonadIO m) => m MutableTree

-- | Creates a new OstreeMutableTree with the contents taken from the given
--   repo and checksums. The data will be loaded from the repo lazily as
--   needed.
--   
--   <i>Since: 2018.7</i>
mutableTreeNewFromChecksum :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> Text -> m MutableTree

-- | Creates a new OstreeMutableTree with the contents taken from the given
--   commit. The data will be loaded from the repo lazily as needed.
--   
--   <i>Since: 2021.5</i>
mutableTreeNewFromCommit :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> m MutableTree

-- | Remove the file or subdirectory named <i><tt>name</tt></i> from the
--   mutable tree <i><tt>self</tt></i>.
--   
--   <i>Since: 2018.9</i>
mutableTreeRemove :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> Text -> Bool -> m ()

-- | <i>No description available in the introspection data.</i>
mutableTreeReplaceFile :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> Text -> Text -> m ()

-- | <i>No description available in the introspection data.</i>
mutableTreeSetContentsChecksum :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> Text -> m ()

-- | <i>No description available in the introspection data.</i>
mutableTreeSetMetadataChecksum :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> Text -> m ()

-- | Traverse <i><tt>start</tt></i> number of elements starting from
--   <i><tt>splitPath</tt></i>; the child will be returned in
--   <i><tt>outSubdir</tt></i>.
mutableTreeWalk :: (HasCallStack, MonadIO m, IsMutableTree a) => a -> [Text] -> Word32 -> m MutableTree
instance GHC.Classes.Eq GI.OSTree.Objects.MutableTree.MutableTree
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.MutableTree.MutableTree o) => GI.OSTree.Objects.MutableTree.IsMutableTree o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.MutableTree.MutableTree
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.MutableTree.MutableTree
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.MutableTree.MutableTree
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.MutableTree.MutableTree
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.MutableTree.MutableTree)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Interfaces.Sign

-- | Memory-managed wrapper type.
newtype Sign
Sign :: ManagedPtr Sign -> Sign

-- | Type class for types which can be safely cast to <a>Sign</a>, for
--   instance with <a>toSign</a>.
class (GObject o, IsDescendantOf Sign o) => IsSign o

-- | Cast to <a>Sign</a>, for types for which this is known to be safe. For
--   general casts, use <a>castTo</a>.
toSign :: (MonadIO m, IsSign o) => o -> m Sign

-- | Add the public key for verification. Could be called multiple times
--   for adding all needed keys to be used for verification.
--   
--   The <i><tt>publicKey</tt></i> argument depends of the particular
--   engine implementation.
--   
--   <i>Since: 2020.2</i>
signAddPk :: (HasCallStack, MonadIO m, IsSign a) => a -> GVariant -> m ()

-- | Clear all previously preloaded secret and public keys.
--   
--   <i>Since: 2020.2</i>
signClearKeys :: (HasCallStack, MonadIO m, IsSign a) => a -> m ()

-- | Add a signature to a commit.
--   
--   Depending of the signing engine used you will need to load the secret
--   key with <tt><i>ostree_sign_set_sk</i></tt>.
--   
--   <i>Since: 2020.2</i>
signCommit :: (HasCallStack, MonadIO m, IsSign a, IsRepo b, IsCancellable c) => a -> b -> Text -> Maybe c -> m ()

-- | Verify if commit is signed with known key.
--   
--   Depending of the signing engine used you will need to load the public
--   key(s) for verification with <tt><i>ostree_sign_set_pk</i></tt>,
--   <tt><i>ostree_sign_add_pk</i></tt> and/or
--   <tt><i>ostree_sign_load_pk</i></tt>.
--   
--   <i>Since: 2020.2</i>
signCommitVerify :: (HasCallStack, MonadIO m, IsSign a, IsRepo b, IsCancellable c) => a -> b -> Text -> Maybe c -> m (Maybe Text)

-- | Sign the given <i><tt>data</tt></i> with pre-loaded secret key.
--   
--   Depending of the signing engine used you will need to load the secret
--   key with <tt><i>ostree_sign_set_sk</i></tt>.
--   
--   <i>Since: 2020.2</i>
signData :: (HasCallStack, MonadIO m, IsSign a, IsCancellable b) => a -> Bytes -> Maybe b -> m Bytes

-- | Verify given data against signatures with pre-loaded public keys.
--   
--   Depending of the signing engine used you will need to load the public
--   key(s) with <tt><i>ostree_sign_set_pk</i></tt>,
--   <tt><i>ostree_sign_add_pk</i></tt> or
--   <tt><i>ostree_sign_load_pk</i></tt>.
--   
--   <i>Since: 2020.2</i>
signDataVerify :: (HasCallStack, MonadIO m, IsSign a) => a -> Bytes -> GVariant -> m (Maybe Text)

-- | Return an array with newly allocated instances of all available
--   signing engines; they will not be initialized.
--   
--   <i>Since: 2020.2</i>
signGetAll :: (HasCallStack, MonadIO m) => m [Sign]

-- | Create a new instance of a signing engine.
--   
--   <i>Since: 2020.2</i>
signGetByName :: (HasCallStack, MonadIO m) => Text -> m Sign

-- | Return the pointer to the name of currently used/selected signing
--   engine.
--   
--   <i>Since: 2020.2</i>
signGetName :: (HasCallStack, MonadIO m, IsSign a) => a -> m Text

-- | Load public keys for verification from anywhere. It is expected that
--   all keys would be added to already pre-loaded keys.
--   
--   The <i><tt>options</tt></i> argument depends of the particular engine
--   implementation.
--   
--   For example, <i><tt>ed25515</tt></i> engine could use following
--   string-formatted options:
--   
--   <ul>
--   <li><i><tt>filename</tt></i> -- single file to use to load keys
--   from</li>
--   <li><i><tt>basedir</tt></i> -- directory containing subdirectories
--   'trusted.ed25519.d' and 'revoked.ed25519.d' with appropriate public
--   keys. Used for testing and re-definition of system-wide directories if
--   defaults are not suitable for any reason.</li>
--   </ul>
--   
--   <i>Since: 2020.2</i>
signLoadPk :: (HasCallStack, MonadIO m, IsSign a) => a -> GVariant -> m ()

-- | Return the pointer to the string with format used in (detached)
--   metadata for current signing engine.
--   
--   <i>Since: 2020.2</i>
signMetadataFormat :: (HasCallStack, MonadIO m, IsSign a) => a -> m Text

-- | Return the pointer to the name of the key used in (detached) metadata
--   for current signing engine.
--   
--   <i>Since: 2020.2</i>
signMetadataKey :: (HasCallStack, MonadIO m, IsSign a) => a -> m Text

-- | Set the public key for verification. It is expected what all
--   previously pre-loaded public keys will be dropped.
--   
--   The <i><tt>publicKey</tt></i> argument depends of the particular
--   engine implementation.
--   
--   <i>Since: 2020.2</i>
signSetPk :: (HasCallStack, MonadIO m, IsSign a) => a -> GVariant -> m ()

-- | Set the secret key to be used for signing data, commits and summary.
--   
--   The <i><tt>secretKey</tt></i> argument depends of the particular
--   engine implementation.
--   
--   <i>Since: 2020.2</i>
signSetSk :: (HasCallStack, MonadIO m, IsSign a) => a -> GVariant -> m ()

-- | Add a signature to a summary file. Based on
--   ostree_repo_add_gpg_signature_summary implementation.
--   
--   <i>Since: 2020.2</i>
signSummary :: (HasCallStack, MonadIO m, IsSign a, IsRepo b, IsCancellable c) => a -> b -> GVariant -> Maybe c -> m ()
instance GHC.Classes.Eq GI.OSTree.Interfaces.Sign.Sign
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Interfaces.Sign.Sign o) => GI.OSTree.Interfaces.Sign.IsSign o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Interfaces.Sign.Sign
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Interfaces.Sign.Sign
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Interfaces.Sign.Sign
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Interfaces.Sign.Sign
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Interfaces.Sign.Sign)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Interfaces.RepoFinder

-- | Memory-managed wrapper type.
newtype RepoFinder
RepoFinder :: ManagedPtr RepoFinder -> RepoFinder

-- | Type class for types which can be safely cast to <a>RepoFinder</a>,
--   for instance with <a>toRepoFinder</a>.
class (GObject o, IsDescendantOf RepoFinder o) => IsRepoFinder o

-- | Cast to <a>RepoFinder</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRepoFinder :: (MonadIO m, IsRepoFinder o) => o -> m RepoFinder

-- | A version of <a>repoFinderResolveAsync</a> which queries one or more
--   <i><tt>finders</tt></i> in parallel and combines the results.
--   
--   <i>Since: 2018.6</i>
repoFinderResolveAllAsync :: (HasCallStack, MonadIO m, IsRepo a, IsCancellable b) => [RepoFinder] -> [CollectionRef] -> a -> Maybe b -> Maybe AsyncReadyCallback -> m ()

-- | Get the results from a <a>repoFinderResolveAllAsync</a> operation.
--   
--   <i>Since: 2018.6</i>
repoFinderResolveAllFinish :: (HasCallStack, MonadIO m, IsAsyncResult a) => a -> m [RepoFinderResult]

-- | Find reachable remote URIs which claim to provide any of the given
--   <i><tt>refs</tt></i>. The specific method for finding the remotes
--   depends on the <a>RepoFinder</a> implementation.
--   
--   Any remote which is found and which claims to support any of the given
--   <i><tt>refs</tt></i> will be returned in the results. It is possible
--   that a remote claims to support a given ref, but turns out not to — it
--   is not possible to verify this until <a>repoPullFromRemotesAsync</a>
--   is called.
--   
--   The returned results will be sorted with the most useful first — this
--   is typically the remote which claims to provide the most
--   <i><tt>refs</tt></i>, at the lowest latency.
--   
--   Each result contains a mapping of <i><tt>refs</tt></i> to the
--   checksums of the commits which the result provides. If the result
--   provides the latest commit for a ref across all of the results, the
--   checksum will be set. Otherwise, if the result provides an outdated
--   commit, or doesn’t provide a given ref at all, the checksum will not
--   be set. Results which provide none of the requested
--   <i><tt>refs</tt></i> may be listed with an empty refs map.
--   
--   Pass the results to <a>repoPullFromRemotesAsync</a> to pull the given
--   <i><tt>refs</tt></i> from those remotes.
--   
--   <i>Since: 2018.6</i>
repoFinderResolveAsync :: (HasCallStack, MonadIO m, IsRepoFinder a, IsRepo b, IsCancellable c) => a -> [CollectionRef] -> b -> Maybe c -> Maybe AsyncReadyCallback -> m ()

-- | Get the results from a <a>repoFinderResolveAsync</a> operation.
--   
--   <i>Since: 2018.6</i>
repoFinderResolveFinish :: (HasCallStack, MonadIO m, IsRepoFinder a, IsAsyncResult b) => a -> b -> m [RepoFinderResult]
instance GHC.Classes.Eq GI.OSTree.Interfaces.RepoFinder.RepoFinder
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Interfaces.RepoFinder.RepoFinder o) => GI.OSTree.Interfaces.RepoFinder.IsRepoFinder o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Interfaces.RepoFinder.RepoFinder
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Interfaces.RepoFinder.RepoFinder
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Interfaces.RepoFinder.RepoFinder
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Interfaces.RepoFinder.RepoFinder
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Interfaces.RepoFinder.RepoFinder)


module GI.OSTree.Interfaces


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Structs.SignEd25519

-- | Memory-managed wrapper type.
newtype SignEd25519
SignEd25519 :: ManagedPtr SignEd25519 -> SignEd25519
instance GHC.Classes.Eq GI.OSTree.Structs.SignEd25519.SignEd25519
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.SignEd25519.SignEd25519
instance Data.GI.Base.BasicTypes.BoxedPtr GI.OSTree.Structs.SignEd25519.SignEd25519


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Structs.SignEd25519Class

-- | Memory-managed wrapper type.
newtype SignEd25519Class
SignEd25519Class :: ManagedPtr SignEd25519Class -> SignEd25519Class

-- | Construct a <a>SignEd25519Class</a> struct initialized to zero.
newZeroSignEd25519Class :: MonadIO m => m SignEd25519Class

-- | Get the value of the “<tt>parent_class</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> signEd25519Class #parentClass
--   </pre>
getSignEd25519ClassParentClass :: MonadIO m => SignEd25519Class -> m ObjectClass
instance GHC.Classes.Eq GI.OSTree.Structs.SignEd25519Class.SignEd25519Class
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.SignEd25519Class.SignEd25519Class
instance Data.GI.Base.BasicTypes.BoxedPtr GI.OSTree.Structs.SignEd25519Class.SignEd25519Class
instance Data.GI.Base.BasicTypes.CallocPtr GI.OSTree.Structs.SignEd25519Class.SignEd25519Class
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.SignEd25519Class.SignEd25519Class tag


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Structs.SysrootDeployTreeOpts

-- | Memory-managed wrapper type.
newtype SysrootDeployTreeOpts
SysrootDeployTreeOpts :: ManagedPtr SysrootDeployTreeOpts -> SysrootDeployTreeOpts

-- | Construct a <a>SysrootDeployTreeOpts</a> struct initialized to zero.
newZeroSysrootDeployTreeOpts :: MonadIO m => m SysrootDeployTreeOpts

-- | Get the value of the “<tt>locked</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sysrootDeployTreeOpts #locked
--   </pre>
getSysrootDeployTreeOptsLocked :: MonadIO m => SysrootDeployTreeOpts -> m Bool

-- | Set the value of the “<tt>locked</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sysrootDeployTreeOpts [ #locked <a>:=</a> value ]
--   </pre>
setSysrootDeployTreeOptsLocked :: MonadIO m => SysrootDeployTreeOpts -> Bool -> m ()

-- | Set the value of the “<tt>overlay_initrds</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #overlayInitrds
--   </pre>
clearSysrootDeployTreeOptsOverlayInitrds :: MonadIO m => SysrootDeployTreeOpts -> m ()

-- | Get the value of the “<tt>overlay_initrds</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sysrootDeployTreeOpts #overlayInitrds
--   </pre>
getSysrootDeployTreeOptsOverlayInitrds :: MonadIO m => SysrootDeployTreeOpts -> m (Maybe Text)

-- | Set the value of the “<tt>overlay_initrds</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sysrootDeployTreeOpts [ #overlayInitrds <a>:=</a> value ]
--   </pre>
setSysrootDeployTreeOptsOverlayInitrds :: MonadIO m => SysrootDeployTreeOpts -> CString -> m ()

-- | Set the value of the “<tt>override_kernel_argv</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #overrideKernelArgv
--   </pre>
clearSysrootDeployTreeOptsOverrideKernelArgv :: MonadIO m => SysrootDeployTreeOpts -> m ()

-- | Get the value of the “<tt>override_kernel_argv</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sysrootDeployTreeOpts #overrideKernelArgv
--   </pre>
getSysrootDeployTreeOptsOverrideKernelArgv :: MonadIO m => SysrootDeployTreeOpts -> m (Maybe Text)

-- | Set the value of the “<tt>override_kernel_argv</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sysrootDeployTreeOpts [ #overrideKernelArgv <a>:=</a> value ]
--   </pre>
setSysrootDeployTreeOptsOverrideKernelArgv :: MonadIO m => SysrootDeployTreeOpts -> CString -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.SysrootDeployTreeOpts.SysrootDeployTreeOpts
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.SysrootDeployTreeOpts.SysrootDeployTreeOpts
instance Data.GI.Base.BasicTypes.BoxedPtr GI.OSTree.Structs.SysrootDeployTreeOpts.SysrootDeployTreeOpts
instance Data.GI.Base.BasicTypes.CallocPtr GI.OSTree.Structs.SysrootDeployTreeOpts.SysrootDeployTreeOpts
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.SysrootDeployTreeOpts.SysrootDeployTreeOpts tag


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Structs.SysrootWriteDeploymentsOpts

-- | Memory-managed wrapper type.
newtype SysrootWriteDeploymentsOpts
SysrootWriteDeploymentsOpts :: ManagedPtr SysrootWriteDeploymentsOpts -> SysrootWriteDeploymentsOpts

-- | Construct a <a>SysrootWriteDeploymentsOpts</a> struct initialized to
--   zero.
newZeroSysrootWriteDeploymentsOpts :: MonadIO m => m SysrootWriteDeploymentsOpts

-- | Get the value of the “<tt>disable_auto_early_prune</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sysrootWriteDeploymentsOpts #disableAutoEarlyPrune
--   </pre>
getSysrootWriteDeploymentsOptsDisableAutoEarlyPrune :: MonadIO m => SysrootWriteDeploymentsOpts -> m Bool

-- | Set the value of the “<tt>disable_auto_early_prune</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sysrootWriteDeploymentsOpts [ #disableAutoEarlyPrune <a>:=</a> value ]
--   </pre>
setSysrootWriteDeploymentsOptsDisableAutoEarlyPrune :: MonadIO m => SysrootWriteDeploymentsOpts -> Bool -> m ()

-- | Get the value of the “<tt>do_postclean</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sysrootWriteDeploymentsOpts #doPostclean
--   </pre>
getSysrootWriteDeploymentsOptsDoPostclean :: MonadIO m => SysrootWriteDeploymentsOpts -> m Bool

-- | Set the value of the “<tt>do_postclean</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> sysrootWriteDeploymentsOpts [ #doPostclean <a>:=</a> value ]
--   </pre>
setSysrootWriteDeploymentsOptsDoPostclean :: MonadIO m => SysrootWriteDeploymentsOpts -> Bool -> m ()
instance GHC.Classes.Eq GI.OSTree.Structs.SysrootWriteDeploymentsOpts.SysrootWriteDeploymentsOpts
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Structs.SysrootWriteDeploymentsOpts.SysrootWriteDeploymentsOpts
instance Data.GI.Base.BasicTypes.BoxedPtr GI.OSTree.Structs.SysrootWriteDeploymentsOpts.SysrootWriteDeploymentsOpts
instance Data.GI.Base.BasicTypes.CallocPtr GI.OSTree.Structs.SysrootWriteDeploymentsOpts.SysrootWriteDeploymentsOpts
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.OSTree.Structs.SysrootWriteDeploymentsOpts.SysrootWriteDeploymentsOpts tag


module GI.OSTree.Structs


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.SysrootUpgrader

-- | Memory-managed wrapper type.
newtype SysrootUpgrader
SysrootUpgrader :: ManagedPtr SysrootUpgrader -> SysrootUpgrader

-- | Type class for types which can be safely cast to
--   <a>SysrootUpgrader</a>, for instance with <a>toSysrootUpgrader</a>.
class (GObject o, IsDescendantOf SysrootUpgrader o) => IsSysrootUpgrader o

-- | Cast to <a>SysrootUpgrader</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toSysrootUpgrader :: (MonadIO m, IsSysrootUpgrader o) => o -> m SysrootUpgrader

-- | Check that the timestamp on <i><tt>toRev</tt></i> is equal to or newer
--   than <i><tt>fromRev</tt></i>. This protects systems against
--   man-in-the-middle attackers which provide a client with an older
--   commit.
sysrootUpgraderCheckTimestamps :: (HasCallStack, MonadIO m, IsRepo a) => a -> Text -> Text -> m ()

-- | Write the new deployment to disk, perform a configuration merge with
--   /etc, and update the bootloader configuration.
sysrootUpgraderDeploy :: (HasCallStack, MonadIO m, IsSysrootUpgrader a, IsCancellable b) => a -> Maybe b -> m ()

-- | <i>No description available in the introspection data.</i>
sysrootUpgraderDupOrigin :: (HasCallStack, MonadIO m, IsSysrootUpgrader a) => a -> m (Maybe KeyFile)

-- | <i>No description available in the introspection data.</i>
sysrootUpgraderGetOrigin :: (HasCallStack, MonadIO m, IsSysrootUpgrader a) => a -> m (Maybe KeyFile)

-- | <i>No description available in the introspection data.</i>
sysrootUpgraderGetOriginDescription :: (HasCallStack, MonadIO m, IsSysrootUpgrader a) => a -> m (Maybe Text)

-- | <i>No description available in the introspection data.</i>
sysrootUpgraderNew :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Maybe b -> m SysrootUpgrader

-- | <i>No description available in the introspection data.</i>
sysrootUpgraderNewForOs :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Maybe Text -> Maybe b -> m SysrootUpgrader

-- | <i>No description available in the introspection data.</i>
sysrootUpgraderNewForOsWithFlags :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Maybe Text -> [SysrootUpgraderFlags] -> Maybe b -> m SysrootUpgrader

-- | Perform a pull from the origin. First check if the ref has changed, if
--   so download the linked objects, and store the updated ref locally.
--   Then <i><tt>outChanged</tt></i> will be <a>True</a>.
--   
--   If the origin remote is unchanged, <i><tt>outChanged</tt></i> will be
--   set to <a>False</a>.
sysrootUpgraderPull :: (HasCallStack, MonadIO m, IsSysrootUpgrader a, IsAsyncProgress b, IsCancellable c) => a -> [RepoPullFlags] -> [SysrootUpgraderPullFlags] -> Maybe b -> Maybe c -> m Bool

-- | Like <a>sysrootUpgraderPull</a>, but allows retrieving just a subpath
--   of the tree. This can be used to download metadata files from inside
--   the tree such as package databases.
sysrootUpgraderPullOneDir :: (HasCallStack, MonadIO m, IsSysrootUpgrader a, IsAsyncProgress b, IsCancellable c) => a -> Text -> [RepoPullFlags] -> [SysrootUpgraderPullFlags] -> Maybe b -> Maybe c -> m Bool

-- | Replace the origin with <i><tt>origin</tt></i>.
sysrootUpgraderSetOrigin :: (HasCallStack, MonadIO m, IsSysrootUpgrader a, IsCancellable b) => a -> Maybe KeyFile -> Maybe b -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>flags</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSysrootUpgraderFlags :: (IsSysrootUpgrader o, MonadIO m) => [SysrootUpgraderFlags] -> m (GValueConstruct o)

-- | Get the value of the “<tt>flags</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sysrootUpgrader #flags
--   </pre>
getSysrootUpgraderFlags :: (MonadIO m, IsSysrootUpgrader o) => o -> m [SysrootUpgraderFlags]

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>osname</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSysrootUpgraderOsname :: (IsSysrootUpgrader o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>osname</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sysrootUpgrader #osname
--   </pre>
getSysrootUpgraderOsname :: (MonadIO m, IsSysrootUpgrader o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>sysroot</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSysrootUpgraderSysroot :: (IsSysrootUpgrader o, MonadIO m, IsSysroot a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>sysroot</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sysrootUpgrader #sysroot
--   </pre>
getSysrootUpgraderSysroot :: (MonadIO m, IsSysrootUpgrader o) => o -> m (Maybe Sysroot)
instance GHC.Classes.Eq GI.OSTree.Objects.SysrootUpgrader.SysrootUpgrader
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.SysrootUpgrader.SysrootUpgrader o) => GI.OSTree.Objects.SysrootUpgrader.IsSysrootUpgrader o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.SysrootUpgrader.SysrootUpgrader
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.SysrootUpgrader.SysrootUpgrader
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.SysrootUpgrader.SysrootUpgrader
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.SysrootUpgrader.SysrootUpgrader
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.SysrootUpgrader.SysrootUpgrader)


-- | <i>No description available in the introspection data.</i>
module GI.OSTree.Objects.Sysroot

-- | Memory-managed wrapper type.
newtype Sysroot
Sysroot :: ManagedPtr Sysroot -> Sysroot

-- | Type class for types which can be safely cast to <a>Sysroot</a>, for
--   instance with <a>toSysroot</a>.
class (GObject o, IsDescendantOf Sysroot o) => IsSysroot o

-- | Cast to <a>Sysroot</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toSysroot :: (MonadIO m, IsSysroot o) => o -> m Sysroot

-- | Given the target deployment (which must be the staged deployment) this
--   API will toggle its "finalization locking" state. If it is currently
--   locked, it will be unlocked (and hence queued to apply on shutdown).
--   
--   <i>Since: 2023.8</i>
sysrootChangeFinalization :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b) => a -> b -> m ()

-- | Delete any state that resulted from a partially completed transaction,
--   such as incomplete deployments.
sysrootCleanup :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Maybe b -> m ()

-- | Prune the system repository. This is a thin wrapper around
--   <a>repoPruneFromReachable</a>; the primary addition is that this
--   function automatically gathers all deployed commits into the reachable
--   set.
--   
--   You generally want to at least set the
--   <tt>OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY</tt> flag in
--   <i><tt>options</tt></i>. A commit traversal depth of <tt>0</tt> is
--   assumed.
--   
--   Locking: exclusive
--   
--   <i>Since: 2018.6</i>
sysrootCleanupPruneRepo :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> RepoPruneOptions -> Maybe b -> m (Int32, Int32, Word64)

-- | Older version of <a>sysrootStageTreeWithOptions</a>.
--   
--   <i>Since: 2018.5</i>
sysrootDeployTree :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b, IsCancellable c) => a -> Maybe Text -> Text -> Maybe KeyFile -> Maybe b -> Maybe [Text] -> Maybe c -> m Deployment

-- | Check out deployment tree with revision <i><tt>revision</tt></i>,
--   performing a 3 way merge with <i><tt>providedMergeDeployment</tt></i>
--   for configuration.
--   
--   When booted into the sysroot, you should use the
--   <a>sysrootStageTree</a> API instead.
--   
--   <i>Since: 2020.7</i>
sysrootDeployTreeWithOptions :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b, IsCancellable c) => a -> Maybe Text -> Text -> Maybe KeyFile -> Maybe b -> Maybe SysrootDeployTreeOpts -> Maybe c -> m Deployment

-- | Prepare the specified deployment for a kexec.
sysrootDeploymentKexecLoad :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b, IsCancellable c) => a -> b -> Maybe c -> m ()

-- | Entirely replace the kernel arguments of <i><tt>deployment</tt></i>
--   with the values in <i><tt>newKargs</tt></i>.
sysrootDeploymentSetKargs :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b, IsCancellable c) => a -> b -> [Text] -> Maybe c -> m ()

-- | Replace the kernel arguments of <i><tt>deployment</tt></i> with the
--   values in <i><tt>kargsStr</tt></i>.
sysrootDeploymentSetKargsInPlace :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b, IsCancellable c) => a -> b -> Maybe Text -> Maybe c -> m ()

-- | By default, deployment directories are not mutable. This function will
--   allow making them temporarily mutable, for example to allow layering
--   additional non-OSTree content.
sysrootDeploymentSetMutable :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b, IsCancellable c) => a -> b -> Bool -> Maybe c -> m ()

-- | By default, deployments may be subject to garbage collection. Typical
--   uses of libostree only retain at most 2 deployments. If
--   <i><tt>isPinned</tt></i> is <tt>TRUE</tt>, a metadata bit will be set
--   causing libostree to avoid automatic GC of the deployment. However,
--   this is really an "advisory" note; it's still possible for e.g. older
--   versions of libostree unaware of pinning to GC the deployment.
--   
--   This function does nothing and returns successfully if the deployment
--   is already in the desired pinning state. It is an error to try to pin
--   the staged deployment (as it's not in the bootloader entries).
--   
--   <i>Since: 2018.3</i>
sysrootDeploymentSetPinned :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b) => a -> b -> Bool -> m ()

-- | Configure the target deployment <i><tt>deployment</tt></i> such that
--   it is writable. There are multiple modes, essentially differing in
--   whether or not any changes persist across reboot.
--   
--   The <tt>OSTREE_DEPLOYMENT_UNLOCKED_HOTFIX</tt> state is persistent
--   across reboots.
--   
--   <i>Since: 2016.4</i>
sysrootDeploymentUnlock :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b, IsCancellable c) => a -> b -> DeploymentUnlockedState -> Maybe c -> m ()

-- | Ensure that <i><tt>self</tt></i> is set up as a valid rootfs, by
--   creating /ostree/repo, among other things.
sysrootEnsureInitialized :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Maybe b -> m ()

-- | This function may only be called if the sysroot is loaded.
sysrootGetBootedDeployment :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m (Maybe Deployment)

-- | <i>No description available in the introspection data.</i>
sysrootGetBootversion :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m Int32

-- | <i>No description available in the introspection data.</i>
sysrootGetDeploymentDirectory :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b) => a -> b -> m File

-- | Note this function only returns a *relative* path - if you want to
--   access, it, you must either use fd-relative api such as
--   <tt><i>openat()</i></tt>, or concatenate it with the full
--   <a>sysrootGetPath</a>.
sysrootGetDeploymentDirpath :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b) => a -> b -> m Text

-- | <i>No description available in the introspection data.</i>
sysrootGetDeploymentOriginPath :: (HasCallStack, MonadIO m, IsFile a) => a -> m File

-- | <i>No description available in the introspection data.</i>
sysrootGetDeployments :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m [Deployment]

-- | Access a file descriptor that refers to the root directory of this
--   sysroot. <a>sysrootInitialize</a> (or <a>sysrootLoad</a>) must have
--   been invoked prior to calling this function.
sysrootGetFd :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m Int32

-- | Find the deployment to use as a configuration merge source; this is
--   the first one in the current deployment list which matches osname.
sysrootGetMergeDeployment :: (HasCallStack, MonadIO m, IsSysroot a) => a -> Maybe Text -> m (Maybe Deployment)

-- | <i>No description available in the introspection data.</i>
sysrootGetPath :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m File

-- | Retrieve the OSTree repository in sysroot <i><tt>self</tt></i>. The
--   repo is guaranteed to be open (see <a>repoOpen</a>).
sysrootGetRepo :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Maybe b -> m Repo

-- | <i>No description available in the introspection data.</i>
--   
--   <i>Since: 2018.5</i>
sysrootGetStagedDeployment :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m (Maybe Deployment)

-- | <i>No description available in the introspection data.</i>
sysrootGetSubbootversion :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m Int32

-- | Initialize the directory structure for an "osname", which is a group
--   of operating system deployments, with a shared <tt>/var</tt>. One is
--   required for generating a deployment.
--   
--   <i>Since: 2016.4</i>
sysrootInitOsname :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Text -> Maybe b -> m ()

-- | Subset of <a>sysrootLoad</a>; performs basic initialization. Notably,
--   one can invoke <tt>ostree_sysroot_get_fd()</tt> after calling this
--   function.
--   
--   It is not necessary to call this function if <a>sysrootLoad</a> is
--   invoked.
--   
--   <i>Since: 2020.1</i>
sysrootInitialize :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m ()

-- | Prepare the current process for modifying a booted sysroot, if
--   applicable. This function subsumes the functionality of
--   <tt>ostree_sysroot_initialize</tt> and may be invoked wherever that
--   function is.
--   
--   If the sysroot does not appear to be booted, or where the current
--   process is not uid 0, this function returns successfully.
--   
--   Otherwise, if the process is in the same mount namespace as pid 1,
--   create a new namespace.
--   
--   If you invoke this function, it must be before <a>sysrootLoad</a>; it
--   may be invoked before or after <a>sysrootInitialize</a>.
--   
--   <i>Since: 2022.7</i>
sysrootInitializeWithMountNamespace :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Maybe b -> m ()

-- | Can only be invoked after <tt>ostree_sysroot_initialize()</tt>.
--   
--   <i>Since: 2020.1</i>
sysrootIsBooted :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m Bool

-- | Load deployment list, bootversion, and subbootversion from the rootfs
--   <i><tt>self</tt></i>.
sysrootLoad :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Maybe b -> m ()

-- | Acquire an exclusive multi-process write lock for
--   <i><tt>self</tt></i>. This call blocks until the lock has been
--   acquired. The lock is not reentrant.
--   
--   Release the lock with <a>sysrootUnlock</a>. The lock will also be
--   released if <i><tt>self</tt></i> is deallocated.
sysrootLock :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m ()

-- | An asynchronous version of <a>sysrootLock</a>.
sysrootLockAsync :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Maybe b -> Maybe AsyncReadyCallback -> m ()

-- | Call when <a>sysrootLockAsync</a> is ready.
sysrootLockFinish :: (HasCallStack, MonadIO m, IsSysroot a, IsAsyncResult b) => a -> b -> m ()

-- | Create a new <a>Sysroot</a> object for the sysroot at
--   <i><tt>path</tt></i>. If <i><tt>path</tt></i> is <a>Nothing</a>, the
--   current visible root file system is used, equivalent to
--   <a>sysrootNewDefault</a>.
sysrootNew :: (HasCallStack, MonadIO m, IsFile a) => Maybe a -> m Sysroot

-- | <i>No description available in the introspection data.</i>
sysrootNewDefault :: (HasCallStack, MonadIO m) => m Sysroot

-- | <i>No description available in the introspection data.</i>
sysrootOriginNewFromRefspec :: (HasCallStack, MonadIO m, IsSysroot a) => a -> Text -> m KeyFile

-- | Like <a>sysrootCleanup</a> in that it cleans up incomplete deployments
--   and old boot versions, but does NOT prune the repository.
sysrootPrepareCleanup :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Maybe b -> m ()

-- | Find the pending and rollback deployments for <i><tt>osname</tt></i>.
--   Pass <a>Nothing</a> for <i><tt>osname</tt></i> to use the booted
--   deployment's osname. By default, pending deployment is the first
--   deployment in the order that matches <i><tt>osname</tt></i>, and
--   <i><tt>rollback</tt></i> will be the next one after the booted
--   deployment, or the deployment after the pending if we're not looking
--   at the booted deployment.
--   
--   <i>Since: 2017.7</i>
sysrootQueryDeploymentsFor :: (HasCallStack, MonadIO m, IsSysroot a) => a -> Maybe Text -> m (Maybe Deployment, Maybe Deployment)

-- | This function is a variant of <a>sysrootGetRepo</a> that cannot fail,
--   and returns a cached repository. Can only be called after
--   <a>sysrootInitialize</a> or <a>sysrootLoad</a> has been invoked
--   successfully.
--   
--   <i>Since: 2017.7</i>
sysrootRepo :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m Repo

-- | Find the booted deployment, or return an error if not booted via
--   OSTree.
--   
--   <i>Since: 2021.1</i>
sysrootRequireBootedDeployment :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m Deployment

-- | If this function is invoked, then libostree will assume that a private
--   Linux mount namespace has been created by the process. The primary use
--   case for this is to have e.g. /sysroot mounted read-only by default.
--   
--   If this function has been called, then when a function which requires
--   writable access is invoked, libostree will automatically remount as
--   writable any mount points on which it operates. This currently is just
--   <tt>/sysroot</tt> and <tt>/boot</tt>.
--   
--   If you invoke this function, it must be before <a>sysrootLoad</a>; it
--   may be invoked before or after <a>sysrootInitialize</a>.
--   
--   <i>Since: 2020.1</i>
sysrootSetMountNamespaceInUse :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m ()

-- | Prepend <i><tt>newDeployment</tt></i> to the list of deployments,
--   commit, and cleanup. By default, all other deployments for the given
--   <i><tt>osname</tt></i> except the merge deployment and the booted
--   deployment will be garbage collected.
--   
--   If <a>SysrootSimpleWriteDeploymentFlagsRetain</a> is specified, then
--   all current deployments will be kept.
--   
--   If <a>SysrootSimpleWriteDeploymentFlagsRetainPending</a> is specified,
--   then pending deployments will be kept.
--   
--   If <a>SysrootSimpleWriteDeploymentFlagsRetainRollback</a> is
--   specified, then rollback deployments will be kept.
--   
--   If <a>SysrootSimpleWriteDeploymentFlagsNotDefault</a> is specified,
--   then instead of prepending, the new deployment will be added right
--   after the booted or merge deployment, instead of first.
--   
--   If <a>SysrootSimpleWriteDeploymentFlagsNoClean</a> is specified, then
--   no cleanup will be performed after adding the deployment. Make sure to
--   call <a>sysrootCleanup</a> sometime later, instead.
sysrootSimpleWriteDeployment :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b, IsDeployment c, IsCancellable d) => a -> Maybe Text -> b -> Maybe c -> [SysrootSimpleWriteDeploymentFlags] -> Maybe d -> m ()

-- | Stage an overlay initrd to be used in an upcoming deployment. Returns
--   a checksum which can be passed to <a>sysrootDeployTreeWithOptions</a>
--   or <a>sysrootStageTreeWithOptions</a> via the <tt>overlay_initrds</tt>
--   array option.
--   
--   <i>Since: 2020.7</i>
sysrootStageOverlayInitrd :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Int32 -> Maybe b -> m Text

-- | Older version of <a>sysrootStageTreeWithOptions</a>.
--   
--   <i>Since: 2018.5</i>
sysrootStageTree :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b, IsCancellable c) => a -> Maybe Text -> Text -> Maybe KeyFile -> Maybe b -> Maybe [Text] -> Maybe c -> m Deployment

-- | Like <a>sysrootDeployTree</a>, but "finalization" only occurs at OS
--   shutdown time.
--   
--   <i>Since: 2020.7</i>
sysrootStageTreeWithOptions :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b, IsCancellable c) => a -> Maybe Text -> Text -> Maybe KeyFile -> Maybe b -> SysrootDeployTreeOpts -> Maybe c -> m Deployment

-- | Try to acquire an exclusive multi-process write lock for
--   <i><tt>self</tt></i>. If another process holds the lock, this function
--   will return immediately, setting <i><tt>outAcquired</tt></i> to
--   <a>False</a>, and returning <a>True</a> (and no error).
--   
--   Release the lock with <a>sysrootUnlock</a>. The lock will also be
--   released if <i><tt>self</tt></i> is deallocated.
sysrootTryLock :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m Bool

-- | Release any resources such as file descriptors referring to the root
--   directory of this sysroot. Normally, those resources are cleared by
--   finalization, but in garbage collected languages that may not be
--   predictable.
--   
--   This undoes the effect of <tt>ostree_sysroot_load()</tt>.
sysrootUnload :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m ()

-- | Clear the lock previously acquired with <a>sysrootLock</a>. It is safe
--   to call this function if the lock has not been previously acquired.
sysrootUnlock :: (HasCallStack, MonadIO m, IsSysroot a) => a -> m ()

-- | Update a sysroot as needed after having copied it into place using
--   file-level operations. This enables options like fs-verity on the
--   required files that may have been lost during the copy.
--   
--   <i>Since: 2023.11</i>
sysrootUpdatePostCopy :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> Maybe b -> m ()

-- | Older version of <a>sysrootWriteDeploymentsWithOptions</a>. This
--   version will perform post-deployment cleanup by default.
sysrootWriteDeployments :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> [Deployment] -> Maybe b -> m ()

-- | Assuming <i><tt>newDeployments</tt></i> have already been deployed in
--   place on disk via <a>sysrootDeployTree</a>, atomically update
--   bootloader configuration. By default, no post-transaction cleanup will
--   be performed. You should invoke <a>sysrootCleanup</a> at some point
--   after the transaction, or specify <tt>do_postclean</tt> in
--   <i><tt>opts</tt></i>. Skipping the post-transaction cleanup is useful
--   if for example you want to control pruning of the repository.
--   
--   <i>Since: 2017.4</i>
sysrootWriteDeploymentsWithOptions :: (HasCallStack, MonadIO m, IsSysroot a, IsCancellable b) => a -> [Deployment] -> SysrootWriteDeploymentsOpts -> Maybe b -> m ()

-- | Immediately replace the origin file of the referenced
--   <i><tt>deployment</tt></i> with the contents of
--   <i><tt>newOrigin</tt></i>. If <i><tt>newOrigin</tt></i> is
--   <a>Nothing</a>, this function will write the current origin of
--   <i><tt>deployment</tt></i>.
sysrootWriteOriginFile :: (HasCallStack, MonadIO m, IsSysroot a, IsDeployment b, IsCancellable c) => a -> b -> Maybe KeyFile -> Maybe c -> m ()

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>path</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructSysrootPath :: (IsSysroot o, MonadIO m, IsFile a) => a -> m (GValueConstruct o)

-- | Get the value of the “<tt>path</tt>” property. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> sysroot #path
--   </pre>
getSysrootPath :: (MonadIO m, IsSysroot o) => o -> m File

-- | libostree will log to the journal various events, such as the /etc
--   merge status, and transaction completion. Connect to this signal to
--   also synchronously receive the text for those messages. This is
--   intended to be used by command line tools which link to libostree as a
--   library.
--   
--   Currently, the structured data is only available via the systemd
--   journal.
--   
--   <i>Since: 2017.10</i>
type SysrootJournalMsgCallback = -- | /@msg@/: Human-readable string (should not contain newlines) Text -> IO ()

-- | Connect a signal handler for the <a>journalMsg</a> signal, to be run
--   after the default handler. When <a>overloading</a> is enabled, this is
--   equivalent to
--   
--   <pre>
--   <a>after</a> sysroot #journalMsg callback
--   </pre>
--   
--   By default the object invoking the signal is not passed to the
--   callback. If you need to access it, you can use the implit
--   <tt>?self</tt> parameter. Note that this requires activating the
--   <tt>ImplicitParams</tt> GHC extension.
afterSysrootJournalMsg :: (IsSysroot a, MonadIO m) => a -> ((?self :: a) => SysrootJournalMsgCallback) -> m SignalHandlerId

-- | Connect a signal handler for the <a>journalMsg</a> signal, to be run
--   before the default handler. When <a>overloading</a> is enabled, this
--   is equivalent to
--   
--   <pre>
--   <a>on</a> sysroot #journalMsg callback
--   </pre>
onSysrootJournalMsg :: (IsSysroot a, MonadIO m) => a -> ((?self :: a) => SysrootJournalMsgCallback) -> m SignalHandlerId
instance GHC.Classes.Eq GI.OSTree.Objects.Sysroot.Sysroot
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.OSTree.Objects.Sysroot.Sysroot o) => GI.OSTree.Objects.Sysroot.IsSysroot o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.OSTree.Objects.Sysroot.Sysroot
instance Data.GI.Base.BasicTypes.TypedObject GI.OSTree.Objects.Sysroot.Sysroot
instance Data.GI.Base.BasicTypes.GObject GI.OSTree.Objects.Sysroot.Sysroot
instance Data.GI.Base.Overloading.HasParentTypes GI.OSTree.Objects.Sysroot.Sysroot
instance Data.GI.Base.GValue.IsGValue (GHC.Maybe.Maybe GI.OSTree.Objects.Sysroot.Sysroot)


module GI.OSTree.Objects


module GI.OSTree
