<MACRO>
<NAME>OSTREE_TYPE_ASYNC_PROGRESS</NAME>
#define OSTREE_TYPE_ASYNC_PROGRESS         (ostree_async_progress_get_type ())
</MACRO>
<MACRO>
<NAME>OSTREE_ASYNC_PROGRESS</NAME>
#define OSTREE_ASYNC_PROGRESS(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), OSTREE_TYPE_ASYNC_PROGRESS, OstreeAsyncProgress))
</MACRO>
<MACRO>
<NAME>OSTREE_ASYNC_PROGRESS_CLASS</NAME>
#define OSTREE_ASYNC_PROGRESS_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), OSTREE_TYPE_ASYNC_PROGRESS, OstreeAsyncProgressClass))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_ASYNC_PROGRESS</NAME>
#define OSTREE_IS_ASYNC_PROGRESS(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), OSTREE_TYPE_ASYNC_PROGRESS))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_ASYNC_PROGRESS_CLASS</NAME>
#define OSTREE_IS_ASYNC_PROGRESS_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), OSTREE_TYPE_ASYNC_PROGRESS))
</MACRO>
<MACRO>
<NAME>OSTREE_ASYNC_PROGRESS_GET_CLASS</NAME>
#define OSTREE_ASYNC_PROGRESS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), OSTREE_TYPE_ASYNC_PROGRESS, OstreeAsyncProgressClass))
</MACRO>
<TYPEDEF>
<NAME>OstreeAsyncProgress</NAME>
typedef struct OstreeAsyncProgress   OstreeAsyncProgress;
</TYPEDEF>
<TYPEDEF>
<NAME>OstreeAsyncProgressClass</NAME>
typedef struct OstreeAsyncProgressClass   OstreeAsyncProgressClass;
</TYPEDEF>
<FUNCTION>
<NAME>ostree_async_progress_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_new</NAME>
<RETURNS>OstreeAsyncProgress *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_new_and_connect</NAME>
<RETURNS>OstreeAsyncProgress *</RETURNS>
void (*changed) (OstreeAsyncProgress *self, gpointer user_data), gpointer user_data
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_get_status</NAME>
<RETURNS>char *</RETURNS>
OstreeAsyncProgress       *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_get</NAME>
<RETURNS>void</RETURNS>
OstreeAsyncProgress *self, ...
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_get_uint</NAME>
<RETURNS>guint</RETURNS>
OstreeAsyncProgress       *self, const char                *key
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_get_uint64</NAME>
<RETURNS>guint64</RETURNS>
OstreeAsyncProgress       *self, const char                *key
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_get_variant</NAME>
<RETURNS>GVariant *</RETURNS>
OstreeAsyncProgress *self, const char          *key
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_set_status</NAME>
<RETURNS>void</RETURNS>
OstreeAsyncProgress       *self, const char                *status
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_set</NAME>
<RETURNS>void</RETURNS>
OstreeAsyncProgress *self, ...
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_set_uint</NAME>
<RETURNS>void</RETURNS>
OstreeAsyncProgress       *self, const char                *key, guint                      value
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_set_uint64</NAME>
<RETURNS>void</RETURNS>
OstreeAsyncProgress       *self, const char                *key, guint64                    value
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_set_variant</NAME>
<RETURNS>void</RETURNS>
OstreeAsyncProgress *self, const char          *key, GVariant            *value
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_finish</NAME>
<RETURNS>void</RETURNS>
OstreeAsyncProgress *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_async_progress_copy_state</NAME>
<RETURNS>void</RETURNS>
OstreeAsyncProgress *self, OstreeAsyncProgress *dest
</FUNCTION>
<USER_FUNCTION>
<NAME>OstreeBloomHashFunc</NAME>
<RETURNS>guint64</RETURNS>
gconstpointer element, guint8        k
</USER_FUNCTION>
<MACRO>
<NAME>OSTREE_TYPE_BLOOM</NAME>
#define OSTREE_TYPE_BLOOM (ostree_bloom_get_type ())
</MACRO>
<FUNCTION>
<NAME>ostree_bloom_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_bloom_new</NAME>
<RETURNS>OstreeBloom *</RETURNS>
gsize               n_bytes, guint8              k, OstreeBloomHashFunc hash_func
</FUNCTION>
<FUNCTION>
<NAME>ostree_bloom_new_from_bytes</NAME>
<RETURNS>OstreeBloom *</RETURNS>
GBytes              *bytes, guint8               k, OstreeBloomHashFunc  hash_func
</FUNCTION>
<FUNCTION>
<NAME>ostree_bloom_ref</NAME>
<RETURNS>OstreeBloom *</RETURNS>
OstreeBloom *bloom
</FUNCTION>
<FUNCTION>
<NAME>ostree_bloom_unref</NAME>
<RETURNS>void</RETURNS>
OstreeBloom *bloom
</FUNCTION>
<FUNCTION>
<NAME>ostree_bloom_maybe_contains</NAME>
<RETURNS>gboolean</RETURNS>
OstreeBloom   *bloom, gconstpointer  element
</FUNCTION>
<FUNCTION>
<NAME>ostree_bloom_seal</NAME>
<RETURNS>GBytes *</RETURNS>
OstreeBloom *bloom
</FUNCTION>
<FUNCTION>
<NAME>ostree_bloom_add_element</NAME>
<RETURNS>void</RETURNS>
OstreeBloom   *bloom, gconstpointer  element
</FUNCTION>
<FUNCTION>
<NAME>ostree_bloom_get_size</NAME>
<RETURNS>gsize</RETURNS>
OstreeBloom *bloom
</FUNCTION>
<FUNCTION>
<NAME>ostree_bloom_get_k</NAME>
<RETURNS>guint8</RETURNS>
OstreeBloom *bloom
</FUNCTION>
<FUNCTION>
<NAME>ostree_bloom_get_hash_func</NAME>
<RETURNS>OstreeBloomHashFunc</RETURNS>
OstreeBloom *bloom
</FUNCTION>
<FUNCTION>
<NAME>ostree_str_bloom_hash</NAME>
<RETURNS>guint64</RETURNS>
gconstpointer element, guint8        k
</FUNCTION>
<STRUCT>
<NAME>OstreeBloom</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_BOOTCONFIG_PARSER</NAME>
#define OSTREE_TYPE_BOOTCONFIG_PARSER (ostree_bootconfig_parser_get_type ())
</MACRO>
<MACRO>
<NAME>OSTREE_BOOTCONFIG_PARSER</NAME>
#define OSTREE_BOOTCONFIG_PARSER(inst) (G_TYPE_CHECK_INSTANCE_CAST ((inst), OSTREE_TYPE_BOOTCONFIG_PARSER, OstreeBootconfigParser))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_BOOTCONFIG_PARSER</NAME>
#define OSTREE_IS_BOOTCONFIG_PARSER(inst) (G_TYPE_CHECK_INSTANCE_TYPE ((inst), OSTREE_TYPE_BOOTCONFIG_PARSER))
</MACRO>
<FUNCTION>
<NAME>ostree_bootconfig_parser_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_bootconfig_parser_new</NAME>
<RETURNS>OstreeBootconfigParser *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_bootconfig_parser_clone</NAME>
<RETURNS>OstreeBootconfigParser *</RETURNS>
OstreeBootconfigParser *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_bootconfig_parser_parse</NAME>
<RETURNS>gboolean</RETURNS>
OstreeBootconfigParser  *self, GFile           *path, GCancellable    *cancellable, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_bootconfig_parser_parse_at</NAME>
<RETURNS>gboolean</RETURNS>
OstreeBootconfigParser  *self, int                      dfd, const char              *path, GCancellable    *cancellable, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_bootconfig_parser_write</NAME>
<RETURNS>gboolean</RETURNS>
OstreeBootconfigParser   *self, GFile            *output, GCancellable     *cancellable, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_bootconfig_parser_write_at</NAME>
<RETURNS>gboolean</RETURNS>
OstreeBootconfigParser   *self, int                       dfd, const char               *path, GCancellable             *cancellable, GError                  **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_bootconfig_parser_set</NAME>
<RETURNS>void</RETURNS>
OstreeBootconfigParser  *self, const char      *key, const char      *value
</FUNCTION>
<FUNCTION>
<NAME>ostree_bootconfig_parser_get</NAME>
<RETURNS>const char *</RETURNS>
OstreeBootconfigParser  *self, const char      *key
</FUNCTION>
<FUNCTION>
<NAME>ostree_bootconfig_parser_set_overlay_initrds</NAME>
<RETURNS>void</RETURNS>
OstreeBootconfigParser  *self, char                   **initrds
</FUNCTION>
<FUNCTION>
<NAME>ostree_bootconfig_parser_get_overlay_initrds</NAME>
<RETURNS>char **</RETURNS>
OstreeBootconfigParser  *self
</FUNCTION>
<STRUCT>
<NAME>OstreeBootconfigParser</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_BOOTLOADER_ZIPL</NAME>
#define OSTREE_TYPE_BOOTLOADER_ZIPL (_ostree_bootloader_zipl_get_type ())
</MACRO>
<MACRO>
<NAME>OSTREE_BOOTLOADER_ZIPL</NAME>
#define OSTREE_BOOTLOADER_ZIPL(inst) (G_TYPE_CHECK_INSTANCE_CAST ((inst), OSTREE_TYPE_BOOTLOADER_ZIPL, OstreeBootloaderZipl))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_BOOTLOADER_ZIPL</NAME>
#define OSTREE_IS_BOOTLOADER_ZIPL(inst) (G_TYPE_CHECK_INSTANCE_TYPE ((inst), OSTREE_TYPE_BOOTLOADER_ZIPL))
</MACRO>
<STRUCT>
<NAME>OstreeBootloaderZipl</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_CHAIN_INPUT_STREAM</NAME>
#define OSTREE_TYPE_CHAIN_INPUT_STREAM         (ostree_chain_input_stream_get_type ())
</MACRO>
<MACRO>
<NAME>OSTREE_CHAIN_INPUT_STREAM</NAME>
#define OSTREE_CHAIN_INPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), OSTREE_TYPE_CHAIN_INPUT_STREAM, OstreeChainInputStream))
</MACRO>
<MACRO>
<NAME>OSTREE_CHAIN_INPUT_STREAM_CLASS</NAME>
#define OSTREE_CHAIN_INPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), OSTREE_TYPE_CHAIN_INPUT_STREAM, OstreeChainInputStreamClass))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_CHAIN_INPUT_STREAM</NAME>
#define OSTREE_IS_CHAIN_INPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), OSTREE_TYPE_CHAIN_INPUT_STREAM))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_CHAIN_INPUT_STREAM_CLASS</NAME>
#define OSTREE_IS_CHAIN_INPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), OSTREE_TYPE_CHAIN_INPUT_STREAM))
</MACRO>
<MACRO>
<NAME>OSTREE_CHAIN_INPUT_STREAM_GET_CLASS</NAME>
#define OSTREE_CHAIN_INPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), OSTREE_TYPE_CHAIN_INPUT_STREAM, OstreeChainInputStreamClass))
</MACRO>
<STRUCT>
<NAME>OstreeChainInputStream</NAME>
struct _OstreeChainInputStream
{
  GInputStream parent_instance;

  /*< private >*/
  OstreeChainInputStreamPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>OstreeChainInputStreamClass</NAME>
struct _OstreeChainInputStreamClass
{
  GInputStreamClass parent_class;

  /*< private >*/
  /* Padding for future expansion */
  void (*_g_reserved1) (void);
  void (*_g_reserved2) (void);
  void (*_g_reserved3) (void);
  void (*_g_reserved4) (void);
  void (*_g_reserved5) (void);
};
</STRUCT>
<FUNCTION>
<NAME>ostree_chain_input_stream_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_chain_input_stream_new</NAME>
<RETURNS>OstreeChainInputStream *</RETURNS>
GPtrArray *streams
</FUNCTION>
<STRUCT>
<NAME>OstreeChainInputStreamPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_CHECKSUM_INPUT_STREAM</NAME>
#define OSTREE_TYPE_CHECKSUM_INPUT_STREAM         (ostree_checksum_input_stream_get_type ())
</MACRO>
<MACRO>
<NAME>OSTREE_CHECKSUM_INPUT_STREAM</NAME>
#define OSTREE_CHECKSUM_INPUT_STREAM(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), OSTREE_TYPE_CHECKSUM_INPUT_STREAM, OstreeChecksumInputStream))
</MACRO>
<MACRO>
<NAME>OSTREE_CHECKSUM_INPUT_STREAM_CLASS</NAME>
#define OSTREE_CHECKSUM_INPUT_STREAM_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), OSTREE_TYPE_CHECKSUM_INPUT_STREAM, OstreeChecksumInputStreamClass))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_CHECKSUM_INPUT_STREAM</NAME>
#define OSTREE_IS_CHECKSUM_INPUT_STREAM(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), OSTREE_TYPE_CHECKSUM_INPUT_STREAM))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_CHECKSUM_INPUT_STREAM_CLASS</NAME>
#define OSTREE_IS_CHECKSUM_INPUT_STREAM_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), OSTREE_TYPE_CHECKSUM_INPUT_STREAM))
</MACRO>
<MACRO>
<NAME>OSTREE_CHECKSUM_INPUT_STREAM_GET_CLASS</NAME>
#define OSTREE_CHECKSUM_INPUT_STREAM_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), OSTREE_TYPE_CHECKSUM_INPUT_STREAM, OstreeChecksumInputStreamClass))
</MACRO>
<STRUCT>
<NAME>OstreeChecksumInputStream</NAME>
struct _OstreeChecksumInputStream
{
  GFilterInputStream parent_instance;

  /*< private >*/
  OstreeChecksumInputStreamPrivate *priv;
};
</STRUCT>
<STRUCT>
<NAME>OstreeChecksumInputStreamClass</NAME>
struct _OstreeChecksumInputStreamClass
{
  GFilterInputStreamClass parent_class;

  /*< private >*/
  /* Padding for future expansion */
  void (*_g_reserved1) (void);
  void (*_g_reserved2) (void);
  void (*_g_reserved3) (void);
  void (*_g_reserved4) (void);
  void (*_g_reserved5) (void);
};
</STRUCT>
<FUNCTION>
<NAME>ostree_checksum_input_stream_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_input_stream_new</NAME>
<RETURNS>OstreeChecksumInputStream *</RETURNS>
GInputStream   *stream, GChecksum      *checksum
</FUNCTION>
<STRUCT>
<NAME>OstreeChecksumInputStreamPrivate</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_MAX_METADATA_SIZE</NAME>
#define OSTREE_MAX_METADATA_SIZE (10 * 1024 * 1024)
</MACRO>
<MACRO>
<NAME>OSTREE_MAX_METADATA_WARN_SIZE</NAME>
#define OSTREE_MAX_METADATA_WARN_SIZE (7 * 1024 * 1024)
</MACRO>
<MACRO>
<NAME>OSTREE_SHA256_DIGEST_LEN</NAME>
#define OSTREE_SHA256_DIGEST_LEN (32)
</MACRO>
<MACRO>
<NAME>OSTREE_SHA256_STRING_LEN</NAME>
#define OSTREE_SHA256_STRING_LEN (64)
</MACRO>
<ENUM>
<NAME>OstreeObjectType</NAME>
typedef enum {
  OSTREE_OBJECT_TYPE_FILE = 1,                /* .file */
  OSTREE_OBJECT_TYPE_DIR_TREE = 2,            /* .dirtree */
  OSTREE_OBJECT_TYPE_DIR_META = 3,            /* .dirmeta */
  OSTREE_OBJECT_TYPE_COMMIT = 4,              /* .commit */
  OSTREE_OBJECT_TYPE_TOMBSTONE_COMMIT = 5,    /* .commit-tombstone */
  OSTREE_OBJECT_TYPE_COMMIT_META = 6,         /* .commitmeta */
  OSTREE_OBJECT_TYPE_PAYLOAD_LINK = 7,         /* .payload-link */
} OstreeObjectType;
</ENUM>
<MACRO>
<NAME>OSTREE_OBJECT_TYPE_IS_META</NAME>
#define OSTREE_OBJECT_TYPE_IS_META(t) (t >= 2 && t <= 6)
</MACRO>
<MACRO>
<NAME>OSTREE_OBJECT_TYPE_LAST</NAME>
#define OSTREE_OBJECT_TYPE_LAST OSTREE_OBJECT_TYPE_PAYLOAD_LINK
</MACRO>
<MACRO>
<NAME>OSTREE_DIRMETA_GVARIANT_STRING</NAME>
#define OSTREE_DIRMETA_GVARIANT_STRING "(uuua(ayay))"
</MACRO>
<MACRO>
<NAME>OSTREE_DIRMETA_GVARIANT_FORMAT</NAME>
#define OSTREE_DIRMETA_GVARIANT_FORMAT G_VARIANT_TYPE (OSTREE_DIRMETA_GVARIANT_STRING)
</MACRO>
<MACRO>
<NAME>OSTREE_FILEMETA_GVARIANT_STRING</NAME>
#define OSTREE_FILEMETA_GVARIANT_STRING "(uuua(ayay))"
</MACRO>
<MACRO>
<NAME>OSTREE_FILEMETA_GVARIANT_FORMAT</NAME>
#define OSTREE_FILEMETA_GVARIANT_FORMAT G_VARIANT_TYPE (OSTREE_FILEMETA_GVARIANT_STRING)
</MACRO>
<MACRO>
<NAME>OSTREE_TREE_GVARIANT_STRING</NAME>
#define OSTREE_TREE_GVARIANT_STRING "(a(say)a(sayay))"
</MACRO>
<MACRO>
<NAME>OSTREE_TREE_GVARIANT_FORMAT</NAME>
#define OSTREE_TREE_GVARIANT_FORMAT G_VARIANT_TYPE (OSTREE_TREE_GVARIANT_STRING)
</MACRO>
<MACRO>
<NAME>OSTREE_COMMIT_GVARIANT_STRING</NAME>
#define OSTREE_COMMIT_GVARIANT_STRING "(a{sv}aya(say)sstayay)"
</MACRO>
<MACRO>
<NAME>OSTREE_COMMIT_GVARIANT_FORMAT</NAME>
#define OSTREE_COMMIT_GVARIANT_FORMAT G_VARIANT_TYPE (OSTREE_COMMIT_GVARIANT_STRING)
</MACRO>
<MACRO>
<NAME>OSTREE_SUMMARY_GVARIANT_STRING</NAME>
#define OSTREE_SUMMARY_GVARIANT_STRING "(a(s(taya{sv}))a{sv})"
</MACRO>
<MACRO>
<NAME>OSTREE_SUMMARY_GVARIANT_FORMAT</NAME>
#define OSTREE_SUMMARY_GVARIANT_FORMAT G_VARIANT_TYPE (OSTREE_SUMMARY_GVARIANT_STRING)
</MACRO>
<MACRO>
<NAME>OSTREE_SUMMARY_SIG_GVARIANT_STRING</NAME>
#define OSTREE_SUMMARY_SIG_GVARIANT_STRING "a{sv}"
</MACRO>
<MACRO>
<NAME>OSTREE_SUMMARY_SIG_GVARIANT_FORMAT</NAME>
#define OSTREE_SUMMARY_SIG_GVARIANT_FORMAT G_VARIANT_TYPE (OSTREE_SUMMARY_SIG_GVARIANT_STRING)
</MACRO>
<MACRO>
<NAME>OSTREE_TIMESTAMP</NAME>
#define OSTREE_TIMESTAMP (0)
</MACRO>
<ENUM>
<NAME>OstreeRepoMode</NAME>
typedef enum {
  OSTREE_REPO_MODE_BARE,
  OSTREE_REPO_MODE_ARCHIVE,
  OSTREE_REPO_MODE_ARCHIVE_Z2 = OSTREE_REPO_MODE_ARCHIVE,
  OSTREE_REPO_MODE_BARE_USER,
  OSTREE_REPO_MODE_BARE_USER_ONLY,
} OstreeRepoMode;
</ENUM>
<MACRO>
<NAME>OSTREE_COMMIT_META_KEY_VERSION</NAME>
#define OSTREE_COMMIT_META_KEY_VERSION "version"
</MACRO>
<MACRO>
<NAME>OSTREE_COMMIT_META_KEY_ARCHITECTURE</NAME>
#define OSTREE_COMMIT_META_KEY_ARCHITECTURE "ostree.architecture"
</MACRO>
<MACRO>
<NAME>OSTREE_COMMIT_META_KEY_ENDOFLIFE_REBASE</NAME>
#define OSTREE_COMMIT_META_KEY_ENDOFLIFE_REBASE "ostree.endoflife-rebase"
</MACRO>
<MACRO>
<NAME>OSTREE_COMMIT_META_KEY_ENDOFLIFE</NAME>
#define OSTREE_COMMIT_META_KEY_ENDOFLIFE "ostree.endoflife"
</MACRO>
<MACRO>
<NAME>OSTREE_COMMIT_META_KEY_SOURCE_TITLE</NAME>
#define OSTREE_COMMIT_META_KEY_SOURCE_TITLE "ostree.source-title"
</MACRO>
<MACRO>
<NAME>OSTREE_COMMIT_META_KEY_REF_BINDING</NAME>
#define OSTREE_COMMIT_META_KEY_REF_BINDING "ostree.ref-binding"
</MACRO>
<MACRO>
<NAME>OSTREE_COMMIT_META_KEY_COLLECTION_BINDING</NAME>
#define OSTREE_COMMIT_META_KEY_COLLECTION_BINDING "ostree.collection-binding"
</MACRO>
<FUNCTION>
<NAME>ostree_metadata_variant_type</NAME>
<RETURNS>const GVariantType *</RETURNS>
OstreeObjectType objtype
</FUNCTION>
<FUNCTION>
<NAME>ostree_validate_checksum_string</NAME>
<RETURNS>gboolean</RETURNS>
const char *sha256, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_to_bytes</NAME>
<RETURNS>guchar *</RETURNS>
const char *checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_to_bytes_v</NAME>
<RETURNS>GVariant *</RETURNS>
const char *checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_b64_to_bytes</NAME>
<RETURNS>guchar *</RETURNS>
const char *checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_b64_inplace_to_bytes</NAME>
<RETURNS>void</RETURNS>
const char *checksum, guint8     *buf
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_from_bytes</NAME>
<RETURNS>char *</RETURNS>
const guchar *csum
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_from_bytes_v</NAME>
<RETURNS>char *</RETURNS>
GVariant *csum_v
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_b64_from_bytes</NAME>
<RETURNS>char *</RETURNS>
const guchar *csum
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_inplace_from_bytes</NAME>
<RETURNS>void</RETURNS>
const guchar *csum, char         *buf
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_b64_inplace_from_bytes</NAME>
<RETURNS>void</RETURNS>
const guchar *csum, char         *buf
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_inplace_to_bytes</NAME>
<RETURNS>void</RETURNS>
const char *checksum, guchar     *buf
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_bytes_peek</NAME>
<RETURNS>const guchar *</RETURNS>
GVariant *bytes
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_bytes_peek_validate</NAME>
<RETURNS>const guchar *</RETURNS>
GVariant *bytes, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_cmp_checksum_bytes</NAME>
<RETURNS>int</RETURNS>
const guchar *a, const guchar *b
</FUNCTION>
<FUNCTION>
<NAME>ostree_validate_rev</NAME>
<RETURNS>gboolean</RETURNS>
const char *rev, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_validate_collection_id</NAME>
<RETURNS>gboolean</RETURNS>
const char *collection_id, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_validate_remote_name</NAME>
<RETURNS>gboolean</RETURNS>
const char *remote_name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_parse_refspec</NAME>
<RETURNS>gboolean</RETURNS>
const char *refspec, char      **out_remote, char      **out_ref, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_object_type_to_string</NAME>
<RETURNS>const char *</RETURNS>
OstreeObjectType objtype
</FUNCTION>
<FUNCTION>
<NAME>ostree_object_type_from_string</NAME>
<RETURNS>OstreeObjectType</RETURNS>
const char *str
</FUNCTION>
<FUNCTION>
<NAME>ostree_hash_object_name</NAME>
<RETURNS>guint</RETURNS>
gconstpointer a
</FUNCTION>
<FUNCTION>
<NAME>ostree_object_name_serialize</NAME>
<RETURNS>GVariant *</RETURNS>
const char *checksum, OstreeObjectType objtype
</FUNCTION>
<FUNCTION>
<NAME>ostree_object_name_deserialize</NAME>
<RETURNS>void</RETURNS>
GVariant         *variant, const char      **out_checksum, OstreeObjectType *out_objtype
</FUNCTION>
<FUNCTION>
<NAME>ostree_object_to_string</NAME>
<RETURNS>char *</RETURNS>
const char *checksum, OstreeObjectType objtype
</FUNCTION>
<FUNCTION>
<NAME>ostree_object_from_string</NAME>
<RETURNS>void</RETURNS>
const char *str, gchar     **out_checksum, OstreeObjectType *out_objtype
</FUNCTION>
<FUNCTION>
<NAME>ostree_content_stream_parse</NAME>
<RETURNS>gboolean</RETURNS>
gboolean                compressed, GInputStream           *input, guint64                 input_length, gboolean                trusted, GInputStream          **out_input, GFileInfo             **out_file_info, GVariant              **out_xattrs, GCancellable           *cancellable, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_content_file_parse</NAME>
<RETURNS>gboolean</RETURNS>
gboolean                compressed, GFile                  *content_path, gboolean                trusted, GInputStream          **out_input, GFileInfo             **out_file_info, GVariant              **out_xattrs, GCancellable           *cancellable, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_content_file_parse_at</NAME>
<RETURNS>gboolean</RETURNS>
gboolean                compressed, int                     parent_dfd, const char             *path, gboolean                trusted, GInputStream          **out_input, GFileInfo             **out_file_info, GVariant              **out_xattrs, GCancellable           *cancellable, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_raw_file_to_archive_z2_stream</NAME>
<RETURNS>gboolean</RETURNS>
GInputStream       *input, GFileInfo          *file_info, GVariant           *xattrs, GInputStream      **out_input, GCancellable       *cancellable, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_raw_file_to_archive_z2_stream_with_options</NAME>
<RETURNS>gboolean</RETURNS>
GInputStream       *input, GFileInfo          *file_info, GVariant           *xattrs, GVariant           *options, GInputStream      **out_input, GCancellable       *cancellable, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_raw_file_to_content_stream</NAME>
<RETURNS>gboolean</RETURNS>
GInputStream       *input, GFileInfo          *file_info, GVariant           *xattrs, GInputStream      **out_input, guint64            *out_length, GCancellable       *cancellable, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_file_from_input</NAME>
<RETURNS>gboolean</RETURNS>
GFileInfo        *file_info, GVariant         *xattrs, GInputStream     *in, OstreeObjectType  objtype, guchar          **out_csum, GCancellable     *cancellable, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_file</NAME>
<RETURNS>gboolean</RETURNS>
GFile             *f, OstreeObjectType   objtype, guchar           **out_csum, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_break_hardlink</NAME>
<RETURNS>gboolean</RETURNS>
int               dfd, const char       *path, gboolean          skip_xattrs, GCancellable     *cancellable, GError          **error
</FUNCTION>
<ENUM>
<NAME>OstreeChecksumFlags</NAME>
typedef enum {
  OSTREE_CHECKSUM_FLAGS_NONE = 0,
  OSTREE_CHECKSUM_FLAGS_IGNORE_XATTRS = (1 << 0),
} OstreeChecksumFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_checksum_file_at</NAME>
<RETURNS>gboolean</RETURNS>
int               dfd, const char       *path, struct stat      *stbuf, OstreeObjectType  objtype, OstreeChecksumFlags flags, char            **out_checksum, GCancellable     *cancellable, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_file_async</NAME>
<RETURNS>void</RETURNS>
GFile                 *f, OstreeObjectType       objtype, int                    io_priority, GCancellable          *cancellable, GAsyncReadyCallback    callback, gpointer               user_data
</FUNCTION>
<FUNCTION>
<NAME>ostree_checksum_file_async_finish</NAME>
<RETURNS>gboolean</RETURNS>
GFile          *f, GAsyncResult   *result, guchar        **out_csum, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_create_directory_metadata</NAME>
<RETURNS>GVariant *</RETURNS>
GFileInfo *dir_info, GVariant  *xattrs
</FUNCTION>
<FUNCTION>
<NAME>ostree_validate_structureof_objtype</NAME>
<RETURNS>gboolean</RETURNS>
guchar    objtype, GError   **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_validate_structureof_csum_v</NAME>
<RETURNS>gboolean</RETURNS>
GVariant  *checksum, GError   **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_validate_structureof_checksum_string</NAME>
<RETURNS>gboolean</RETURNS>
const char *checksum, GError   **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_validate_structureof_file_mode</NAME>
<RETURNS>gboolean</RETURNS>
guint32            mode, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_validate_structureof_commit</NAME>
<RETURNS>gboolean</RETURNS>
GVariant      *commit, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_validate_structureof_dirtree</NAME>
<RETURNS>gboolean</RETURNS>
GVariant      *dirtree, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_validate_structureof_dirmeta</NAME>
<RETURNS>gboolean</RETURNS>
GVariant      *dirmeta, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_commit_get_parent</NAME>
<RETURNS>gchar *</RETURNS>
GVariant  *commit_variant
</FUNCTION>
<FUNCTION>
<NAME>ostree_commit_get_timestamp</NAME>
<RETURNS>guint64</RETURNS>
GVariant  *commit_variant
</FUNCTION>
<FUNCTION>
<NAME>ostree_commit_get_content_checksum</NAME>
<RETURNS>gchar *</RETURNS>
GVariant  *commit_variant
</FUNCTION>
<STRUCT>
<NAME>OstreeCommitSizesEntry</NAME>
typedef struct {
  gchar *checksum;
  OstreeObjectType objtype;
  guint64 unpacked;
  guint64 archived;
} OstreeCommitSizesEntry;
</STRUCT>
<FUNCTION>
<NAME>ostree_commit_sizes_entry_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_commit_sizes_entry_new</NAME>
<RETURNS>OstreeCommitSizesEntry *</RETURNS>
const gchar      *checksum, OstreeObjectType  objtype, guint64           unpacked, guint64           archived
</FUNCTION>
<FUNCTION>
<NAME>ostree_commit_sizes_entry_copy</NAME>
<RETURNS>OstreeCommitSizesEntry *</RETURNS>
const OstreeCommitSizesEntry *entry
</FUNCTION>
<FUNCTION>
<NAME>ostree_commit_sizes_entry_free</NAME>
<RETURNS>void</RETURNS>
OstreeCommitSizesEntry *entry
</FUNCTION>
<FUNCTION>
<NAME>ostree_commit_get_object_sizes</NAME>
<RETURNS>gboolean</RETURNS>
GVariant   *commit_variant, GPtrArray **out_sizes_entries, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_check_version</NAME>
<RETURNS>gboolean</RETURNS>
guint required_year, guint required_release
</FUNCTION>
<STRUCT>
<NAME>OstreeDeployment</NAME>
struct _OstreeDeployment
{
  GObject       parent_instance;

  int index;
  char *osname;
  char *csum;
  int deployserial;
  char *bootcsum;
  int bootserial;
  OstreeBootconfigParser *bootconfig;
  GKeyFile *origin;
  OstreeDeploymentUnlockedState unlocked;
  gboolean staged;
  char **overlay_initrds;
  char *overlay_initrds_id;
};
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_DEPLOYMENT</NAME>
#define OSTREE_TYPE_DEPLOYMENT (ostree_deployment_get_type ())
</MACRO>
<MACRO>
<NAME>OSTREE_DEPLOYMENT</NAME>
#define OSTREE_DEPLOYMENT(inst) (G_TYPE_CHECK_INSTANCE_CAST ((inst), OSTREE_TYPE_DEPLOYMENT, OstreeDeployment))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_DEPLOYMENT</NAME>
#define OSTREE_IS_DEPLOYMENT(inst) (G_TYPE_CHECK_INSTANCE_TYPE ((inst), OSTREE_TYPE_DEPLOYMENT))
</MACRO>
<MACRO>
<NAME>OSTREE_ORIGIN_TRANSIENT_GROUP</NAME>
#define OSTREE_ORIGIN_TRANSIENT_GROUP "libostree-transient"
</MACRO>
<FUNCTION>
<NAME>ostree_deployment_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_hash</NAME>
<RETURNS>guint</RETURNS>
gconstpointer v
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_equal</NAME>
<RETURNS>gboolean</RETURNS>
gconstpointer ap, gconstpointer bp
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_new</NAME>
<RETURNS>OstreeDeployment *</RETURNS>
int    index, const char  *osname, const char  *csum, int    deployserial, const char  *bootcsum, int    bootserial
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_get_index</NAME>
<RETURNS>int</RETURNS>
OstreeDeployment *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_get_osname</NAME>
<RETURNS>const char *</RETURNS>
OstreeDeployment *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_get_deployserial</NAME>
<RETURNS>int</RETURNS>
OstreeDeployment *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_get_csum</NAME>
<RETURNS>const char *</RETURNS>
OstreeDeployment *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_get_bootcsum</NAME>
<RETURNS>const char *</RETURNS>
OstreeDeployment *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_get_bootserial</NAME>
<RETURNS>int</RETURNS>
OstreeDeployment *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_get_bootconfig</NAME>
<RETURNS>OstreeBootconfigParser *</RETURNS>
OstreeDeployment *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_get_origin</NAME>
<RETURNS>GKeyFile *</RETURNS>
OstreeDeployment *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_is_staged</NAME>
<RETURNS>gboolean</RETURNS>
OstreeDeployment *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_is_pinned</NAME>
<RETURNS>gboolean</RETURNS>
OstreeDeployment *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_set_index</NAME>
<RETURNS>void</RETURNS>
OstreeDeployment *self, int index
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_set_bootserial</NAME>
<RETURNS>void</RETURNS>
OstreeDeployment *self, int index
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_set_bootconfig</NAME>
<RETURNS>void</RETURNS>
OstreeDeployment *self, OstreeBootconfigParser *bootconfig
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_set_origin</NAME>
<RETURNS>void</RETURNS>
OstreeDeployment *self, GKeyFile *origin
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_origin_remove_transient_state</NAME>
<RETURNS>void</RETURNS>
GKeyFile *origin
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_clone</NAME>
<RETURNS>OstreeDeployment *</RETURNS>
OstreeDeployment *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_get_origin_relpath</NAME>
<RETURNS>char *</RETURNS>
OstreeDeployment *self
</FUNCTION>
<ENUM>
<NAME>OstreeDeploymentUnlockedState</NAME>
typedef enum {
  OSTREE_DEPLOYMENT_UNLOCKED_NONE,
  OSTREE_DEPLOYMENT_UNLOCKED_DEVELOPMENT,
  OSTREE_DEPLOYMENT_UNLOCKED_HOTFIX,
  OSTREE_DEPLOYMENT_UNLOCKED_TRANSIENT,
} OstreeDeploymentUnlockedState;
</ENUM>
<FUNCTION>
<NAME>ostree_deployment_unlocked_state_to_string</NAME>
<RETURNS>const char *</RETURNS>
OstreeDeploymentUnlockedState state
</FUNCTION>
<FUNCTION>
<NAME>ostree_deployment_get_unlocked</NAME>
<RETURNS>OstreeDeploymentUnlockedState</RETURNS>
OstreeDeployment *self
</FUNCTION>
<STRUCT>
<NAME>OstreeDeployment</NAME>
</STRUCT>
<ENUM>
<NAME>OstreeDiffFlags</NAME>
typedef enum {
  OSTREE_DIFF_FLAGS_NONE = 0,
  OSTREE_DIFF_FLAGS_IGNORE_XATTRS = (1 << 0)
} OstreeDiffFlags;
</ENUM>
<STRUCT>
<NAME>OstreeDiffItem</NAME>
struct _OstreeDiffItem
{
  gint refcount;  /* atomic */

  GFile *src;
  GFile *target;

  GFileInfo *src_info;
  GFileInfo *target_info;

  char *src_checksum;
  char *target_checksum;
};
</STRUCT>
<FUNCTION>
<NAME>ostree_diff_item_ref</NAME>
<RETURNS>OstreeDiffItem *</RETURNS>
OstreeDiffItem *diffitem
</FUNCTION>
<FUNCTION>
<NAME>ostree_diff_item_unref</NAME>
<RETURNS>void</RETURNS>
OstreeDiffItem *diffitem
</FUNCTION>
<FUNCTION>
<NAME>ostree_diff_item_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_diff_dirs</NAME>
<RETURNS>gboolean</RETURNS>
OstreeDiffFlags flags, GFile          *a, GFile          *b, GPtrArray      *modified, GPtrArray      *removed, GPtrArray      *added, GCancellable   *cancellable, GError        **error
</FUNCTION>
<STRUCT>
<NAME>OstreeDiffDirsOptions</NAME>
typedef struct {
  gint owner_uid;
  gint owner_gid;

  OstreeRepoDevInoCache *devino_to_csum_cache;

  gboolean unused_bools[7];
  int unused_ints[6];
  /* 4 byte hole on 64 bit */
  gpointer unused_ptrs[7];
} OstreeDiffDirsOptions;
</STRUCT>
<MACRO>
<NAME>OSTREE_DIFF_DIRS_OPTIONS_INIT</NAME>
#define OSTREE_DIFF_DIRS_OPTIONS_INIT { .owner_uid = -1, .owner_gid = -1, }
</MACRO>
<FUNCTION>
<NAME>ostree_diff_dirs_with_options</NAME>
<RETURNS>gboolean</RETURNS>
OstreeDiffFlags       flags, GFile                 *a, GFile                 *b, GPtrArray             *modified, GPtrArray             *removed, GPtrArray             *added, OstreeDiffDirsOptions *options, GCancellable          *cancellable, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_diff_print</NAME>
<RETURNS>void</RETURNS>
GFile          *a, GFile          *b, GPtrArray      *modified, GPtrArray      *removed, GPtrArray      *added
</FUNCTION>
<MACRO>
<NAME>OSTREE_TYPE_FETCHER_CONFIG_FLAGS</NAME>
#define OSTREE_TYPE_FETCHER_CONFIG_FLAGS (_ostree_fetcher_config_flags_get_type ())
</MACRO>
<MACRO>
<NAME>OSTREE_TYPE_FETCHER_REQUEST_FLAGS</NAME>
#define OSTREE_TYPE_FETCHER_REQUEST_FLAGS (_ostree_fetcher_request_flags_get_type ())
</MACRO>
<MACRO>
<NAME>OSTREE_FETCHER_USERAGENT_STRING</NAME>
#define OSTREE_FETCHER_USERAGENT_STRING (PACKAGE_NAME "/" PACKAGE_VERSION)
</MACRO>
<FUNCTION>
<NAME>if</NAME>
<RETURNS>else</RETURNS>
!glnx_open_anonymous_tmpfile (O_RDWR | O_CLOEXEC, tmpf, error)) return FALSE; if (!glnx_fchmod (tmpf->fd, 0644, error)) return FALSE; return TRUE; } gboolean _ostree_fetcher_mirrored_request_to_membuf (OstreeFetcher *fetcher, GPtrArray     *mirrorlist, const char    *filename, OstreeFetcherRequestFlags flags, const char    *if_none_match, guint64        if_modified_since, guint          n_network_retries, GBytes         **out_contents, gboolean      *out_not_modified, char         **out_etag, guint64       *out_last_modified, guint64        max_size, GCancellable   *cancellable, GError         **error
</FUNCTION>
<MACRO>
<NAME>OSTREE_TYPE_GPG_VERIFY_RESULT</NAME>
#define OSTREE_TYPE_GPG_VERIFY_RESULT \
  (ostree_gpg_verify_result_get_type ())
</MACRO>
<MACRO>
<NAME>OSTREE_GPG_VERIFY_RESULT</NAME>
#define OSTREE_GPG_VERIFY_RESULT(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), OSTREE_TYPE_GPG_VERIFY_RESULT, OstreeGpgVerifyResult))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_GPG_VERIFY_RESULT</NAME>
#define OSTREE_IS_GPG_VERIFY_RESULT(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), OSTREE_TYPE_GPG_VERIFY_RESULT))
</MACRO>
<TYPEDEF>
<NAME>OstreeGpgVerifyResult</NAME>
typedef struct OstreeGpgVerifyResult OstreeGpgVerifyResult;
</TYPEDEF>
<ENUM>
<NAME>OstreeGpgSignatureAttr</NAME>
typedef enum {
  OSTREE_GPG_SIGNATURE_ATTR_VALID,
  OSTREE_GPG_SIGNATURE_ATTR_SIG_EXPIRED,
  OSTREE_GPG_SIGNATURE_ATTR_KEY_EXPIRED,
  OSTREE_GPG_SIGNATURE_ATTR_KEY_REVOKED,
  OSTREE_GPG_SIGNATURE_ATTR_KEY_MISSING,
  OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT,
  OSTREE_GPG_SIGNATURE_ATTR_TIMESTAMP,
  OSTREE_GPG_SIGNATURE_ATTR_EXP_TIMESTAMP,
  OSTREE_GPG_SIGNATURE_ATTR_PUBKEY_ALGO_NAME,
  OSTREE_GPG_SIGNATURE_ATTR_HASH_ALGO_NAME,
  OSTREE_GPG_SIGNATURE_ATTR_USER_NAME,
  OSTREE_GPG_SIGNATURE_ATTR_USER_EMAIL,
  OSTREE_GPG_SIGNATURE_ATTR_FINGERPRINT_PRIMARY,
  OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP,
  OSTREE_GPG_SIGNATURE_ATTR_KEY_EXP_TIMESTAMP_PRIMARY,
} OstreeGpgSignatureAttr;
</ENUM>
<FUNCTION>
<NAME>ostree_gpg_verify_result_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_gpg_verify_result_count_all</NAME>
<RETURNS>guint</RETURNS>
OstreeGpgVerifyResult *result
</FUNCTION>
<FUNCTION>
<NAME>ostree_gpg_verify_result_count_valid</NAME>
<RETURNS>guint</RETURNS>
OstreeGpgVerifyResult *result
</FUNCTION>
<FUNCTION>
<NAME>ostree_gpg_verify_result_lookup</NAME>
<RETURNS>gboolean</RETURNS>
OstreeGpgVerifyResult *result, const gchar *key_id, guint *out_signature_index
</FUNCTION>
<FUNCTION>
<NAME>ostree_gpg_verify_result_get</NAME>
<RETURNS>GVariant *</RETURNS>
OstreeGpgVerifyResult *result, guint signature_index, OstreeGpgSignatureAttr *attrs, guint n_attrs
</FUNCTION>
<FUNCTION>
<NAME>ostree_gpg_verify_result_get_all</NAME>
<RETURNS>GVariant *</RETURNS>
OstreeGpgVerifyResult *result, guint signature_index
</FUNCTION>
<ENUM>
<NAME>OstreeGpgSignatureFormatFlags</NAME>
typedef enum {
  OSTREE_GPG_SIGNATURE_FORMAT_DEFAULT = (0 << 0),
} OstreeGpgSignatureFormatFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_gpg_verify_result_describe</NAME>
<RETURNS>void</RETURNS>
OstreeGpgVerifyResult *result, guint signature_index, GString *output_buffer, const gchar *line_prefix, OstreeGpgSignatureFormatFlags flags
</FUNCTION>
<FUNCTION>
<NAME>ostree_gpg_verify_result_describe_variant</NAME>
<RETURNS>void</RETURNS>
GVariant *variant, GString *output_buffer, const gchar *line_prefix, OstreeGpgSignatureFormatFlags flags
</FUNCTION>
<FUNCTION>
<NAME>ostree_gpg_verify_result_require_valid_signature</NAME>
<RETURNS>gboolean</RETURNS>
OstreeGpgVerifyResult *result, GError **error
</FUNCTION>
<ENUM>
<NAME>OstreeGpgError</NAME>
typedef enum {
  OSTREE_GPG_ERROR_NO_SIGNATURE = 0,
  OSTREE_GPG_ERROR_INVALID_SIGNATURE,
  OSTREE_GPG_ERROR_MISSING_KEY,
  OSTREE_GPG_ERROR_EXPIRED_SIGNATURE,
  OSTREE_GPG_ERROR_EXPIRED_KEY,
  OSTREE_GPG_ERROR_REVOKED_KEY,
} OstreeGpgError;
</ENUM>
<FUNCTION>
<NAME>ostree_gpg_error_quark</NAME>
<RETURNS>GQuark</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>OSTREE_GPG_ERROR</NAME>
#define OSTREE_GPG_ERROR (ostree_gpg_error_quark ())
</MACRO>
<FUNCTION>
<NAME>ostree_kernel_args_free</NAME>
<RETURNS>void</RETURNS>
OstreeKernelArgs *kargs
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_new</NAME>
<RETURNS>OstreeKernelArgs *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_cleanup</NAME>
<RETURNS>void</RETURNS>
void *loc
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_replace_take</NAME>
<RETURNS>void</RETURNS>
OstreeKernelArgs  *kargs, char              *arg
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_replace</NAME>
<RETURNS>void</RETURNS>
OstreeKernelArgs  *kargs, const char        *arg
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_replace_argv</NAME>
<RETURNS>void</RETURNS>
OstreeKernelArgs  *kargs, char             **argv
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_append</NAME>
<RETURNS>void</RETURNS>
OstreeKernelArgs  *kargs, const char     *arg
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_append_argv</NAME>
<RETURNS>void</RETURNS>
OstreeKernelArgs  *kargs, char **argv
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_append_argv_filtered</NAME>
<RETURNS>void</RETURNS>
OstreeKernelArgs  *kargs, char **argv, char **prefixes
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_new_replace</NAME>
<RETURNS>gboolean</RETURNS>
OstreeKernelArgs *kargs, const char       *arg, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_delete</NAME>
<RETURNS>gboolean</RETURNS>
OstreeKernelArgs *kargs, const char       *arg, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_delete_key_entry</NAME>
<RETURNS>gboolean</RETURNS>
OstreeKernelArgs *kargs, const char       *key, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_append_proc_cmdline</NAME>
<RETURNS>gboolean</RETURNS>
OstreeKernelArgs *kargs, GCancellable     *cancellable, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_parse_append</NAME>
<RETURNS>void</RETURNS>
OstreeKernelArgs *kargs, const char *options
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_get_last_value</NAME>
<RETURNS>const char *</RETURNS>
OstreeKernelArgs *kargs, const char *key
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_from_string</NAME>
<RETURNS>OstreeKernelArgs *</RETURNS>
const char *options
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_to_strv</NAME>
<RETURNS>char **</RETURNS>
OstreeKernelArgs *kargs
</FUNCTION>
<FUNCTION>
<NAME>ostree_kernel_args_to_string</NAME>
<RETURNS>char *</RETURNS>
OstreeKernelArgs *kargs
</FUNCTION>
<STRUCT>
<NAME>OstreeKernelArgs</NAME>
</STRUCT>
<STRUCT>
<NAME>OstreeKernelArgsEntry</NAME>
</STRUCT>
<TYPEDEF>
<NAME>OtAutoArchiveWrite</NAME>
typedef struct archive OtAutoArchiveWrite;
</TYPEDEF>
<TYPEDEF>
<NAME>OtAutoArchiveRead</NAME>
typedef struct archive OtAutoArchiveRead;
</TYPEDEF>
<FUNCTION>
<NAME>ot_archive_read_new</NAME>
<RETURNS>OtAutoArchiveRead *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ot_open_archive_read</NAME>
<RETURNS>OtAutoArchiveRead *</RETURNS>
const char *path, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ot_open_archive_read_fd</NAME>
<RETURNS>OtAutoArchiveRead *</RETURNS>
int fd, GError **error
</FUNCTION>
<MACRO>
<NAME>OSTREE_TYPE_MUTABLE_TREE</NAME>
#define OSTREE_TYPE_MUTABLE_TREE         (ostree_mutable_tree_get_type ())
</MACRO>
<MACRO>
<NAME>OSTREE_MUTABLE_TREE</NAME>
#define OSTREE_MUTABLE_TREE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), OSTREE_TYPE_MUTABLE_TREE, OstreeMutableTree))
</MACRO>
<MACRO>
<NAME>OSTREE_MUTABLE_TREE_CLASS</NAME>
#define OSTREE_MUTABLE_TREE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), OSTREE_TYPE_MUTABLE_TREE, OstreeMutableTreeClass))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_MUTABLE_TREE</NAME>
#define OSTREE_IS_MUTABLE_TREE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), OSTREE_TYPE_MUTABLE_TREE))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_MUTABLE_TREE_CLASS</NAME>
#define OSTREE_IS_MUTABLE_TREE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), OSTREE_TYPE_MUTABLE_TREE))
</MACRO>
<MACRO>
<NAME>OSTREE_MUTABLE_TREE_GET_CLASS</NAME>
#define OSTREE_MUTABLE_TREE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), OSTREE_TYPE_MUTABLE_TREE, OstreeMutableTreeClass))
</MACRO>
<TYPEDEF>
<NAME>OstreeMutableTreeClass</NAME>
typedef struct OstreeMutableTreeClass   OstreeMutableTreeClass;
</TYPEDEF>
<STRUCT>
<NAME>OstreeMutableTreeIter</NAME>
typedef struct {
  gboolean        in_files;
  GHashTableIter  iter;
} OstreeMutableTreeIter;
</STRUCT>
<FUNCTION>
<NAME>ostree_mutable_tree_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_new</NAME>
<RETURNS>OstreeMutableTree *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_new_from_checksum</NAME>
<RETURNS>OstreeMutableTree *</RETURNS>
OstreeRepo *repo, const char *contents_checksum, const char *metadata_checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_set_metadata_checksum</NAME>
<RETURNS>void</RETURNS>
OstreeMutableTree *self, const char        *checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_get_metadata_checksum</NAME>
<RETURNS>const char *</RETURNS>
OstreeMutableTree *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_set_contents_checksum</NAME>
<RETURNS>void</RETURNS>
OstreeMutableTree *self, const char        *checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_get_contents_checksum</NAME>
<RETURNS>const char *</RETURNS>
OstreeMutableTree *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_replace_file</NAME>
<RETURNS>gboolean</RETURNS>
OstreeMutableTree *self, const char        *name, const char        *checksum, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_remove</NAME>
<RETURNS>gboolean</RETURNS>
OstreeMutableTree *self, const char        *name, gboolean           allow_noent, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_ensure_dir</NAME>
<RETURNS>gboolean</RETURNS>
OstreeMutableTree *self, const char        *name, OstreeMutableTree **out_subdir, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_lookup</NAME>
<RETURNS>gboolean</RETURNS>
OstreeMutableTree   *self, const char          *name, char               **out_file_checksum, OstreeMutableTree  **out_subdir, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_ensure_parent_dirs</NAME>
<RETURNS>gboolean</RETURNS>
OstreeMutableTree  *self, GPtrArray          *split_path, const char         *metadata_checksum, OstreeMutableTree **out_parent, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_walk</NAME>
<RETURNS>gboolean</RETURNS>
OstreeMutableTree   *self, GPtrArray           *split_path, guint                start, OstreeMutableTree  **out_subdir, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_fill_empty_from_dirtree</NAME>
<RETURNS>gboolean</RETURNS>
OstreeMutableTree *self, OstreeRepo        *repo, const char        *contents_checksum, const char        *metadata_checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_check_error</NAME>
<RETURNS>gboolean</RETURNS>
OstreeMutableTree     *self, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_get_subdirs</NAME>
<RETURNS>GHashTable *</RETURNS>
OstreeMutableTree *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_mutable_tree_get_files</NAME>
<RETURNS>GHashTable *</RETURNS>
OstreeMutableTree *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_collection_ref_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_collection_ref_new</NAME>
<RETURNS>OstreeCollectionRef *</RETURNS>
const gchar *collection_id, const gchar *ref_name
</FUNCTION>
<FUNCTION>
<NAME>ostree_collection_ref_dup</NAME>
<RETURNS>OstreeCollectionRef *</RETURNS>
const OstreeCollectionRef *ref
</FUNCTION>
<FUNCTION>
<NAME>ostree_collection_ref_free</NAME>
<RETURNS>void</RETURNS>
OstreeCollectionRef *ref
</FUNCTION>
<FUNCTION>
<NAME>ostree_collection_ref_hash</NAME>
<RETURNS>guint</RETURNS>
gconstpointer ref
</FUNCTION>
<FUNCTION>
<NAME>ostree_collection_ref_equal</NAME>
<RETURNS>gboolean</RETURNS>
gconstpointer ref1, gconstpointer ref2
</FUNCTION>
<FUNCTION>
<NAME>ostree_collection_ref_dupv</NAME>
<RETURNS>OstreeCollectionRef **</RETURNS>
const OstreeCollectionRef * const *refs
</FUNCTION>
<FUNCTION>
<NAME>ostree_collection_ref_freev</NAME>
<RETURNS>void</RETURNS>
OstreeCollectionRef **refs
</FUNCTION>
<TYPEDEF>
<NAME>OstreeCollectionRefv</NAME>
typedef OstreeCollectionRef** OstreeCollectionRefv;
</TYPEDEF>
<STRUCT>
<NAME>OstreeRemote</NAME>
struct OstreeRemote {
  int ref_count;  /* atomic */
  char *name;  /* (not nullable) */
  char *refspec_name;  /* (nullable) */
  char *group;   /* group name in options (not nullable) */
  char *keyring; /* keyring name ($refspec_name.trustedkeys.gpg) (not nullable) */
  GFile *file;   /* NULL if remote defined in repo/config */
  GKeyFile *options;
};
</STRUCT>
<FUNCTION>
<NAME>ostree_remote_new</NAME>
<RETURNS>OstreeRemote *</RETURNS>
const gchar *name
</FUNCTION>
<FUNCTION>
<NAME>ostree_remote_new_dynamic</NAME>
<RETURNS>OstreeRemote *</RETURNS>
const gchar *name, const gchar *refspec_name
</FUNCTION>
<FUNCTION>
<NAME>ostree_remote_new_from_keyfile</NAME>
<RETURNS>OstreeRemote *</RETURNS>
GKeyFile    *keyfile, const gchar *group
</FUNCTION>
<FUNCTION>
<NAME>ostree_remote_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_remote_ref</NAME>
<RETURNS>OstreeRemote *</RETURNS>
OstreeRemote *remote
</FUNCTION>
<FUNCTION>
<NAME>ostree_remote_unref</NAME>
<RETURNS>void</RETURNS>
OstreeRemote *remote
</FUNCTION>
<FUNCTION>
<NAME>ostree_remote_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
OstreeRemote *remote
</FUNCTION>
<FUNCTION>
<NAME>ostree_remote_get_url</NAME>
<RETURNS>gchar *</RETURNS>
OstreeRemote *remote
</FUNCTION>
<STRUCT>
<NAME>OstreeRepoCheckoutOptions</NAME>
typedef struct {
  OstreeRepoCheckoutMode mode;
  OstreeRepoCheckoutOverwriteMode overwrite_mode;

  guint enable_uncompressed_cache : 1;
  guint disable_fsync : 1;
  guint process_whiteouts : 1;
  guint no_copy_fallback : 1;
  guint reserved : 28;

  const char *subpath;

  OstreeRepoDevInoCache *devino_to_csum_cache;

  guint unused_uints[6];
  gpointer unused_ptrs[7];
} OstreeRepoCheckoutOptions;
</STRUCT>
<FUNCTION>
<NAME>ostree_repo_checkout_tree_at</NAME>
<DEPRECATED/>
<RETURNS>gboolean</RETURNS>
OstreeRepo                         *self, OstreeRepoCheckoutOptions          *options, int                                 destination_dfd, const char                         *destination_path, const char                         *commit, GCancellable                       *cancellable, GError                            **error
</FUNCTION>
<MACRO>
<NAME>OSTREE_TYPE_REPO_FILE</NAME>
#define OSTREE_TYPE_REPO_FILE         (ostree_repo_file_get_type ())
</MACRO>
<MACRO>
<NAME>OSTREE_REPO_FILE</NAME>
#define OSTREE_REPO_FILE(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), OSTREE_TYPE_REPO_FILE, OstreeRepoFile))
</MACRO>
<MACRO>
<NAME>OSTREE_REPO_FILE_CLASS</NAME>
#define OSTREE_REPO_FILE_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), OSTREE_TYPE_REPO_FILE, OstreeRepoFileClass))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_REPO_FILE</NAME>
#define OSTREE_IS_REPO_FILE(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), OSTREE_TYPE_REPO_FILE))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_REPO_FILE_CLASS</NAME>
#define OSTREE_IS_REPO_FILE_CLASS(k)  (G_TYPE_CHECK_CLASS_TYPE ((k), OSTREE_TYPE_REPO_FILE))
</MACRO>
<MACRO>
<NAME>OSTREE_REPO_FILE_GET_CLASS</NAME>
#define OSTREE_REPO_FILE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), OSTREE_TYPE_REPO_FILE, OstreeRepoFileClass))
</MACRO>
<STRUCT>
<NAME>OstreeRepoFileClass</NAME>
struct _OstreeRepoFileClass
{
  GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>ostree_repo_file_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_ensure_resolved</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepoFile  *self, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_get_xattrs</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepoFile  *self, GVariant       **out_xattrs, GCancellable    *cancellable, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_get_repo</NAME>
<RETURNS>OstreeRepo *</RETURNS>
OstreeRepoFile  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_get_root</NAME>
<RETURNS>OstreeRepoFile *</RETURNS>
OstreeRepoFile  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_tree_set_metadata</NAME>
<RETURNS>void</RETURNS>
OstreeRepoFile *self, const char     *checksum, GVariant       *metadata
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_tree_get_contents_checksum</NAME>
<RETURNS>const char *</RETURNS>
OstreeRepoFile  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_tree_get_metadata_checksum</NAME>
<RETURNS>const char *</RETURNS>
OstreeRepoFile  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_tree_get_contents</NAME>
<RETURNS>GVariant *</RETURNS>
OstreeRepoFile *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_tree_get_metadata</NAME>
<RETURNS>GVariant *</RETURNS>
OstreeRepoFile *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_get_checksum</NAME>
<RETURNS>const char *</RETURNS>
OstreeRepoFile  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_tree_find_child</NAME>
<RETURNS>int</RETURNS>
OstreeRepoFile  *self, const char      *name, gboolean        *is_dir, GVariant       **out_container
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_file_tree_query_child</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepoFile  *self, int              n, const char      *attributes, GFileQueryInfoFlags flags, GFileInfo      **out_info, GCancellable    *cancellable, GError         **error
</FUNCTION>
<MACRO>
<NAME>OSTREE_TYPE_REPO_FINDER_AVAHI</NAME>
#define OSTREE_TYPE_REPO_FINDER_AVAHI (ostree_repo_finder_avahi_get_type ())
</MACRO>
<FUNCTION>
<NAME>ostree_repo_finder_avahi_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>OstreeRepoFinderAvahi</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_REPO_FINDER_CONFIG</NAME>
#define OSTREE_TYPE_REPO_FINDER_CONFIG (ostree_repo_finder_config_get_type ())
</MACRO>
<FUNCTION>
<NAME>ostree_repo_finder_config_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>OstreeRepoFinderConfig</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_REPO_FINDER_MOUNT</NAME>
#define OSTREE_TYPE_REPO_FINDER_MOUNT (ostree_repo_finder_mount_get_type ())
</MACRO>
<FUNCTION>
<NAME>ostree_repo_finder_mount_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>OstreeRepoFinderMount</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_REPO_FINDER_OVERRIDE</NAME>
#define OSTREE_TYPE_REPO_FINDER_OVERRIDE (ostree_repo_finder_override_get_type ())
</MACRO>
<FUNCTION>
<NAME>ostree_repo_finder_override_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>OstreeRepoFinderOverride</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_REPO_FINDER</NAME>
#define OSTREE_TYPE_REPO_FINDER (ostree_repo_finder_get_type ())
</MACRO>
<FUNCTION>
<NAME>ostree_repo_finder_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>OSTREE_REPO_FINDER</NAME>
<RETURNS>OstreeRepoFinder *</RETURNS>
gpointer ptr) static inline gboolean OSTREE_IS_REPO_FINDER (gpointer ptr
</FUNCTION>
<FUNCTION>
<NAME>OSTREE_REPO_FINDER_GET_IFACE</NAME>
<RETURNS>OstreeRepoFinderInterface *</RETURNS>
gpointer ptr
</FUNCTION>
<STRUCT>
<NAME>OstreeRepoFinderInterface</NAME>
struct _OstreeRepoFinderInterface
{
  GTypeInterface g_iface;

  void (*resolve_async) (OstreeRepoFinder                  *self,
                         const OstreeCollectionRef * const *refs,
                         OstreeRepo                        *parent_repo,
                         GCancellable                      *cancellable,
                         GAsyncReadyCallback                callback,
                         gpointer                           user_data);
  GPtrArray *(*resolve_finish) (OstreeRepoFinder  *self,
                                GAsyncResult      *result,
                                GError           **error);
};
</STRUCT>
<FUNCTION>
<NAME>ostree_repo_finder_resolve_async</NAME>
<RETURNS>void</RETURNS>
OstreeRepoFinder                  *self, const OstreeCollectionRef * const *refs, OstreeRepo                        *parent_repo, GCancellable                      *cancellable, GAsyncReadyCallback                callback, gpointer                           user_data
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_finder_resolve_finish</NAME>
<RETURNS>GPtrArray *</RETURNS>
OstreeRepoFinder  *self, GAsyncResult      *result, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_finder_resolve_all_async</NAME>
<RETURNS>void</RETURNS>
OstreeRepoFinder * const          *finders, const OstreeCollectionRef * const *refs, OstreeRepo                        *parent_repo, GCancellable                      *cancellable, GAsyncReadyCallback                callback, gpointer                           user_data
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_finder_resolve_all_finish</NAME>
<RETURNS>GPtrArray *</RETURNS>
GAsyncResult  *result, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_finder_result_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_finder_result_new</NAME>
<RETURNS>OstreeRepoFinderResult *</RETURNS>
OstreeRemote     *remote, OstreeRepoFinder *finder, gint              priority, GHashTable       *ref_to_checksum, GHashTable       *ref_to_timestamp, guint64           summary_last_modified
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_finder_result_dup</NAME>
<RETURNS>OstreeRepoFinderResult *</RETURNS>
OstreeRepoFinderResult *result
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_finder_result_compare</NAME>
<RETURNS>gint</RETURNS>
const OstreeRepoFinderResult *a, const OstreeRepoFinderResult *b
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_finder_result_free</NAME>
<RETURNS>void</RETURNS>
OstreeRepoFinderResult *result
</FUNCTION>
<TYPEDEF>
<NAME>OstreeRepoFinderResultv</NAME>
typedef OstreeRepoFinderResult** OstreeRepoFinderResultv;
</TYPEDEF>
<FUNCTION>
<NAME>ostree_repo_finder_result_freev</NAME>
<RETURNS>void</RETURNS>
OstreeRepoFinderResult **results
</FUNCTION>
<STRUCT>
<NAME>OstreeRepoFinder</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_REPO</NAME>
#define OSTREE_TYPE_REPO ostree_repo_get_type()
</MACRO>
<MACRO>
<NAME>OSTREE_REPO</NAME>
#define OSTREE_REPO(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), OSTREE_TYPE_REPO, OstreeRepo))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_REPO</NAME>
#define OSTREE_IS_REPO(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), OSTREE_TYPE_REPO))
</MACRO>
<FUNCTION>
<NAME>ostree_repo_mode_from_string</NAME>
<RETURNS>gboolean</RETURNS>
const char      *mode, OstreeRepoMode  *out_mode, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_new</NAME>
<RETURNS>OstreeRepo *</RETURNS>
GFile *path
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_new_for_sysroot_path</NAME>
<RETURNS>OstreeRepo *</RETURNS>
GFile *repo_path, GFile *sysroot_path
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_new_default</NAME>
<RETURNS>OstreeRepo *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_open</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_open_at</NAME>
<RETURNS>OstreeRepo *</RETURNS>
int           dfd, const char   *path, GCancellable *cancellable, GError      **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_set_disable_fsync</NAME>
<RETURNS>void</RETURNS>
OstreeRepo    *self, gboolean       disable_fsync
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_set_cache_dir</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo    *self, int            dfd, const char    *path, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_disable_fsync</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo    *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_is_system</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo   *repo
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_is_writable</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo  *self, GError     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_create</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, OstreeRepoMode  mode, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_create_at</NAME>
<RETURNS>OstreeRepo *</RETURNS>
int             dfd, const char     *path, OstreeRepoMode  mode, GVariant       *options, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_collection_id</NAME>
<RETURNS>const gchar *</RETURNS>
OstreeRepo   *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_set_collection_id</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo   *self, const gchar  *collection_id, GError      **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_default_repo_finders</NAME>
<RETURNS>const gchar * const *</RETURNS>
OstreeRepo   *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_bootloader</NAME>
<RETURNS>const gchar *</RETURNS>
OstreeRepo   *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_path</NAME>
<RETURNS>GFile *</RETURNS>
OstreeRepo  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_dfd</NAME>
<RETURNS>int</RETURNS>
OstreeRepo  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_hash</NAME>
<RETURNS>guint</RETURNS>
OstreeRepo *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_equal</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo *a, OstreeRepo *b
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_mode</NAME>
<RETURNS>OstreeRepoMode</RETURNS>
OstreeRepo  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_min_free_space_bytes</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo *self, guint64 *out_reserved_bytes, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_config</NAME>
<RETURNS>GKeyFile *</RETURNS>
OstreeRepo *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_copy_config</NAME>
<RETURNS>GKeyFile *</RETURNS>
OstreeRepo *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_reload_config</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo *self, GCancellable *cancellable, GError    **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_remote_add</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, const char     *name, const char     *url, GVariant       *options, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_remote_delete</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, const char     *name, GCancellable   *cancellable, GError        **error
</FUNCTION>
<ENUM>
<NAME>OstreeRepoRemoteChange</NAME>
typedef enum {
  OSTREE_REPO_REMOTE_CHANGE_ADD,
  OSTREE_REPO_REMOTE_CHANGE_ADD_IF_NOT_EXISTS,
  OSTREE_REPO_REMOTE_CHANGE_DELETE,
  OSTREE_REPO_REMOTE_CHANGE_DELETE_IF_EXISTS,
  OSTREE_REPO_REMOTE_CHANGE_REPLACE,
} OstreeRepoRemoteChange;
</ENUM>
<FUNCTION>
<NAME>ostree_repo_remote_change</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, GFile          *sysroot, OstreeRepoRemoteChange changeop, const char     *name, const char     *url, GVariant       *options, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_remote_list</NAME>
<RETURNS>char **</RETURNS>
OstreeRepo *self, guint      *out_n_remotes
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_remote_get_url</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo   *self, const char   *name, char        **out_url, GError      **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_remote_option</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo  *self, const char  *remote_name, const char  *option_name, const char  *default_value, char       **out_value, GError     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_remote_list_option</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo   *self, const char   *remote_name, const char   *option_name, char       ***out_value, GError      **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_remote_boolean_option</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo  *self, const char  *remote_name, const char  *option_name, gboolean     default_value, gboolean    *out_value, GError     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_remote_fetch_summary</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo    *self, const char    *name, GBytes       **out_summary, GBytes       **out_signatures, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_remote_fetch_summary_with_options</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo    *self, const char    *name, GVariant      *options, GBytes       **out_summary, GBytes       **out_signatures, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_get_parent</NAME>
<RETURNS>OstreeRepo *</RETURNS>
OstreeRepo  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_config</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo *self, GKeyFile   *new_config, GError    **error
</FUNCTION>
<ENUM>
<NAME>OstreeRepoCommitState</NAME>
typedef enum {
  OSTREE_REPO_COMMIT_STATE_NORMAL = 0,
  OSTREE_REPO_COMMIT_STATE_PARTIAL = (1 << 0),
  OSTREE_REPO_COMMIT_STATE_FSCK_PARTIAL = (1 << 1),
} OstreeRepoCommitState;
</ENUM>
<STRUCT>
<NAME>OstreeRepoTransactionStats</NAME>
struct _OstreeRepoTransactionStats {
  guint metadata_objects_total;
  guint metadata_objects_written;
  guint content_objects_total;
  guint content_objects_written;
  guint64 content_bytes_written;
  guint devino_cache_hits;

  guint   padding1;
  guint64 padding2;
  guint64 padding3;
  guint64 padding4;
};
</STRUCT>
<FUNCTION>
<NAME>ostree_repo_transaction_stats_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_scan_hardlinks</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_prepare_transaction</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, gboolean       *out_transaction_resume, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_transaction</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                  *self, OstreeRepoTransactionStats  *out_stats, GCancellable                *cancellable, GError                     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_abort_transaction</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_mark_commit_partial</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, const char     *checksum, gboolean        is_partial, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_mark_commit_partial_reason</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, const char     *checksum, gboolean        is_partial, OstreeRepoCommitState in_state, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_transaction_set_refspec</NAME>
<RETURNS>void</RETURNS>
OstreeRepo *self, const char *refspec, const char *checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_transaction_set_ref</NAME>
<RETURNS>void</RETURNS>
OstreeRepo *self, const char *remote, const char *ref, const char *checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_transaction_set_collection_ref</NAME>
<RETURNS>void</RETURNS>
OstreeRepo                *self, const OstreeCollectionRef *ref, const char                *checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_set_ref_immediate</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo *self, const char *remote, const char *ref, const char *checksum, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_set_alias_ref_immediate</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo *self, const char *remote, const char *ref, const char *target, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_set_collection_ref_immediate</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                 *self, const OstreeCollectionRef  *ref, const char                 *checksum, GCancellable               *cancellable, GError                    **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_has_object</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo           *self, OstreeObjectType      objtype, const char           *checksum, gboolean             *out_have_object, GCancellable         *cancellable, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_metadata</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo        *self, OstreeObjectType   objtype, const char        *expected_checksum, GVariant          *object, guchar           **out_csum, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_metadata_async</NAME>
<RETURNS>void</RETURNS>
OstreeRepo              *self, OstreeObjectType         objtype, const char              *expected_checksum, GVariant                *object, GCancellable            *cancellable, GAsyncReadyCallback      callback, gpointer                 user_data
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_metadata_finish</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo        *self, GAsyncResult      *result, guchar           **out_csum, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_content</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo       *self, const char       *expected_checksum, GInputStream     *object_input, guint64           length, guchar          **out_csum, GCancellable     *cancellable, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_metadata_trusted</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo        *self, OstreeObjectType   objtype, const char        *checksum, GVariant          *variant, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_metadata_stream_trusted</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo        *self, OstreeObjectType   objtype, const char        *checksum, GInputStream      *object_input, guint64            length, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_content_trusted</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo       *self, const char       *checksum, GInputStream     *object_input, guint64           length, GCancellable     *cancellable, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_content_async</NAME>
<RETURNS>void</RETURNS>
OstreeRepo              *self, const char              *expected_checksum, GInputStream            *object, guint64                  length, GCancellable            *cancellable, GAsyncReadyCallback      callback, gpointer                 user_data
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_content_finish</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo        *self, GAsyncResult      *result, guchar           **out_csum, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_resolve_rev</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo  *self, const char  *refspec, gboolean     allow_noent, char       **out_rev, GError     **error
</FUNCTION>
<ENUM>
<NAME>OstreeRepoResolveRevExtFlags</NAME>
typedef enum {
  OSTREE_REPO_RESOLVE_REV_EXT_NONE = 0,
  OSTREE_REPO_RESOLVE_REV_EXT_LOCAL_ONLY = (1 << 0),
} OstreeRepoResolveRevExtFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_repo_resolve_rev_ext</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                    *self, const char                    *refspec, gboolean                       allow_noent, OstreeRepoResolveRevExtFlags   flags, char                         **out_rev, GError                       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_resolve_collection_ref</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                    *self, const OstreeCollectionRef     *ref, gboolean                       allow_noent, OstreeRepoResolveRevExtFlags   flags, char                         **out_rev, GCancellable                  *cancellable, GError                       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_list_refs</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo       *self, const char       *refspec_prefix, GHashTable      **out_all_refs, GCancellable     *cancellable, GError          **error
</FUNCTION>
<ENUM>
<NAME>OstreeRepoListRefsExtFlags</NAME>
typedef enum {
  OSTREE_REPO_LIST_REFS_EXT_NONE = 0,
  OSTREE_REPO_LIST_REFS_EXT_ALIASES = (1 << 0),
  OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_REMOTES = (1 << 1),
  OSTREE_REPO_LIST_REFS_EXT_EXCLUDE_MIRRORS = (1 << 2),
} OstreeRepoListRefsExtFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_repo_list_refs_ext</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                 *self, const char                 *refspec_prefix, GHashTable                 **out_all_refs, OstreeRepoListRefsExtFlags flags, GCancellable               *cancellable, GError                     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_remote_list_refs</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo       *self, const char       *remote_name, GHashTable      **out_all_refs, GCancellable     *cancellable, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_remote_list_collection_refs</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo    *self, const char    *remote_name, GHashTable   **out_all_refs, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_load_variant</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo  *self, OstreeObjectType objtype, const char    *sha256, GVariant     **out_variant, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_load_variant_if_exists</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo  *self, OstreeObjectType objtype, const char    *sha256, GVariant     **out_variant, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_load_commit</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo            *self, const char            *checksum, GVariant             **out_commit, OstreeRepoCommitState *out_state, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_load_file</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo         *self, const char         *checksum, GInputStream      **out_input, GFileInfo         **out_file_info, GVariant          **out_xattrs, GCancellable       *cancellable, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_load_object_stream</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo         *self, OstreeObjectType    objtype, const char         *checksum, GInputStream      **out_input, guint64            *out_size, GCancellable       *cancellable, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_query_object_storage_size</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo           *self, OstreeObjectType      objtype, const char           *sha256, guint64              *out_size, GCancellable         *cancellable, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_import_object_from</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo           *self, OstreeRepo           *source, OstreeObjectType      objtype, const char           *checksum, GCancellable         *cancellable, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_import_object_from_with_trust</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo           *self, OstreeRepo           *source, OstreeObjectType      objtype, const char           *checksum, gboolean              trusted, GCancellable         *cancellable, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_delete_object</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo           *self, OstreeObjectType      objtype, const char           *sha256, GCancellable         *cancellable, GError              **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_fsck_object</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo           *self, OstreeObjectType      objtype, const char           *sha256, GCancellable         *cancellable, GError              **error
</FUNCTION>
<ENUM>
<NAME>OstreeRepoCommitFilterResult</NAME>
typedef enum {
  OSTREE_REPO_COMMIT_FILTER_ALLOW,
  OSTREE_REPO_COMMIT_FILTER_SKIP
} OstreeRepoCommitFilterResult;
</ENUM>
<USER_FUNCTION>
<NAME>OstreeRepoCommitFilter</NAME>
<RETURNS>OstreeRepoCommitFilterResult</RETURNS>
OstreeRepo    *repo, const char    *path, GFileInfo     *file_info, gpointer       user_data
</USER_FUNCTION>
<ENUM>
<NAME>OstreeRepoCommitModifierFlags</NAME>
typedef enum {
  OSTREE_REPO_COMMIT_MODIFIER_FLAGS_NONE = 0,
  OSTREE_REPO_COMMIT_MODIFIER_FLAGS_SKIP_XATTRS = (1 << 0),
  OSTREE_REPO_COMMIT_MODIFIER_FLAGS_GENERATE_SIZES = (1 << 1),
  OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CANONICAL_PERMISSIONS = (1 << 2),
  OSTREE_REPO_COMMIT_MODIFIER_FLAGS_ERROR_ON_UNLABELED = (1 << 3),
  OSTREE_REPO_COMMIT_MODIFIER_FLAGS_CONSUME = (1 << 4),
  OSTREE_REPO_COMMIT_MODIFIER_FLAGS_DEVINO_CANONICAL = (1 << 5),
} OstreeRepoCommitModifierFlags;
</ENUM>
<TYPEDEF>
<NAME>OstreeRepoCommitModifier</NAME>
typedef struct OstreeRepoCommitModifier OstreeRepoCommitModifier;
</TYPEDEF>
<FUNCTION>
<NAME>ostree_repo_commit_modifier_new</NAME>
<RETURNS>OstreeRepoCommitModifier *</RETURNS>
OstreeRepoCommitModifierFlags  flags, OstreeRepoCommitFilter         commit_filter, gpointer                       user_data, GDestroyNotify                 destroy_notify
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_modifier_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<USER_FUNCTION>
<NAME>OstreeRepoCommitModifierXattrCallback</NAME>
<RETURNS>GVariant *</RETURNS>
OstreeRepo     *repo, const char     *path, GFileInfo      *file_info, gpointer        user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_modifier_set_xattr_callback</NAME>
<RETURNS>void</RETURNS>
OstreeRepoCommitModifier              *modifier, OstreeRepoCommitModifierXattrCallback  callback, GDestroyNotify                         destroy, gpointer                               user_data
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_modifier_set_sepolicy</NAME>
<RETURNS>void</RETURNS>
OstreeRepoCommitModifier              *modifier, OstreeSePolicy                        *sepolicy
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_modifier_set_sepolicy_from_commit</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepoCommitModifier              *modifier, OstreeRepo                            *repo, const char                            *rev, GCancellable                          *cancellable, GError                               **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_modifier_set_devino_cache</NAME>
<RETURNS>void</RETURNS>
OstreeRepoCommitModifier              *modifier, OstreeRepoDevInoCache                 *cache
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_modifier_ref</NAME>
<RETURNS>OstreeRepoCommitModifier *</RETURNS>
OstreeRepoCommitModifier *modifier
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_modifier_unref</NAME>
<RETURNS>void</RETURNS>
OstreeRepoCommitModifier *modifier
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_directory_to_mtree</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                 *self, GFile                      *dir, OstreeMutableTree          *mtree, OstreeRepoCommitModifier   *modifier, GCancellable               *cancellable, GError                    **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_dfd_to_mtree</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                 *self, int                         dfd, const char                 *path, OstreeMutableTree          *mtree, OstreeRepoCommitModifier   *modifier, GCancellable               *cancellable, GError                    **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_archive_to_mtree</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                   *self, GFile                        *archive, OstreeMutableTree            *mtree, OstreeRepoCommitModifier     *modifier, gboolean                      autocreate_parents, GCancellable                 *cancellable, GError                      **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_archive_to_mtree_from_fd</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                *self, int                        fd, OstreeMutableTree         *mtree, OstreeRepoCommitModifier  *modifier, gboolean                   autocreate_parents, GCancellable              *cancellable, GError                   **error
</FUNCTION>
<USER_FUNCTION>
<NAME>OstreeRepoImportArchiveTranslatePathname</NAME>
<RETURNS>char *</RETURNS>
OstreeRepo     *repo, const struct stat *stbuf, const char     *src_path, gpointer        user_data
</USER_FUNCTION>
<STRUCT>
<NAME>OstreeRepoImportArchiveOptions</NAME>
typedef struct {
  guint ignore_unsupported_content : 1;
  guint autocreate_parents : 1;
  guint use_ostree_convention : 1;
  guint callback_with_entry_pathname : 1;
  guint reserved : 28;

  guint unused_uint[8];
  OstreeRepoImportArchiveTranslatePathname translate_pathname;
  gpointer translate_pathname_user_data;
  gpointer unused_ptrs[6];
} OstreeRepoImportArchiveOptions;
</STRUCT>
<FUNCTION>
<NAME>ostree_repo_import_archive_to_mtree</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                      *self, OstreeRepoImportArchiveOptions  *opts, void                            *archive, OstreeMutableTree               *mtree, OstreeRepoCommitModifier        *modifier, GCancellable                   *cancellable, GError                        **error
</FUNCTION>
<STRUCT>
<NAME>OstreeRepoExportArchiveOptions</NAME>
typedef struct {
  guint disable_xattrs : 1;
  guint reserved : 31;

  /* 4 byte hole on 64 bit arches */
  guint64 timestamp_secs;

  guint unused_uint[8];

  char *path_prefix;

  gpointer unused_ptrs[7];
} OstreeRepoExportArchiveOptions;
</STRUCT>
<FUNCTION>
<NAME>ostree_repo_export_tree_to_archive</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                *self, OstreeRepoExportArchiveOptions  *opts, OstreeRepoFile            *root, void                      *archive, GCancellable             *cancellable, GError                  **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_mtree</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo         *self, OstreeMutableTree  *mtree, GFile             **out_file, GCancellable       *cancellable, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_commit</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo      *self, const char      *parent, const char      *subject, const char      *body, GVariant        *metadata, OstreeRepoFile  *root, char           **out_commit, GCancellable    *cancellable, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_commit_with_time</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo      *self, const char      *parent, const char      *subject, const char      *body, GVariant        *metadata, OstreeRepoFile  *root, guint64         time, char           **out_commit, GCancellable    *cancellable, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_read_commit_detached_metadata</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo      *self, const char      *checksum, GVariant       **out_metadata, GCancellable    *cancellable, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_write_commit_detached_metadata</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo      *self, const char      *checksum, GVariant        *metadata, GCancellable    *cancellable, GError         **error
</FUNCTION>
<ENUM>
<NAME>OstreeRepoCheckoutMode</NAME>
typedef enum {
  OSTREE_REPO_CHECKOUT_MODE_NONE = 0,
  OSTREE_REPO_CHECKOUT_MODE_USER = 1
} OstreeRepoCheckoutMode;
</ENUM>
<ENUM>
<NAME>OstreeRepoCheckoutOverwriteMode</NAME>
typedef enum {
  OSTREE_REPO_CHECKOUT_OVERWRITE_NONE = 0,
  OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_FILES = 1,
  OSTREE_REPO_CHECKOUT_OVERWRITE_ADD_FILES = 2, /* Since: 2017.3 */
  OSTREE_REPO_CHECKOUT_OVERWRITE_UNION_IDENTICAL = 3, /* Since: 2017.11 */
} OstreeRepoCheckoutOverwriteMode;
</ENUM>
<FUNCTION>
<NAME>ostree_repo_checkout_tree</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo               *self, OstreeRepoCheckoutMode    mode, OstreeRepoCheckoutOverwriteMode    overwrite_mode, GFile                    *destination, OstreeRepoFile           *source, GFileInfo                *source_info, GCancellable             *cancellable, GError                  **error
</FUNCTION>
<ENUM>
<NAME>OstreeRepoCheckoutFilterResult</NAME>
typedef enum {
  OSTREE_REPO_CHECKOUT_FILTER_ALLOW,
  OSTREE_REPO_CHECKOUT_FILTER_SKIP
} OstreeRepoCheckoutFilterResult;
</ENUM>
<USER_FUNCTION>
<NAME>OstreeRepoCheckoutFilter</NAME>
<RETURNS>OstreeRepoCheckoutFilterResult</RETURNS>
OstreeRepo    *repo, const char    *path, struct stat   *stbuf, gpointer       user_data
</USER_FUNCTION>
<STRUCT>
<NAME>OstreeRepoCheckoutAtOptions</NAME>
typedef struct {
  OstreeRepoCheckoutMode mode;
  OstreeRepoCheckoutOverwriteMode overwrite_mode;

  gboolean enable_uncompressed_cache;  /* Deprecated */
  gboolean enable_fsync;  /* Deprecated */
  gboolean process_whiteouts;
  gboolean no_copy_fallback;
  gboolean force_copy; /* Since: 2017.6 */
  gboolean bareuseronly_dirs; /* Since: 2017.7 */
  gboolean force_copy_zerosized; /* Since: 2018.9 */
  gboolean unused_bools[4];
  /* 4 byte hole on 64 bit */

  const char *subpath;

  OstreeRepoDevInoCache *devino_to_csum_cache;

  int unused_ints[6];
  gpointer unused_ptrs[3];
  OstreeRepoCheckoutFilter filter; /* Since: 2018.2 */
  gpointer filter_user_data; /* Since: 2018.2 */
  OstreeSePolicy *sepolicy; /* Since: 2017.6 */
  const char *sepolicy_prefix;
} OstreeRepoCheckoutAtOptions;
</STRUCT>
<FUNCTION>
<NAME>ostree_repo_devino_cache_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_devino_cache_new</NAME>
<RETURNS>OstreeRepoDevInoCache *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_devino_cache_ref</NAME>
<RETURNS>OstreeRepoDevInoCache *</RETURNS>
OstreeRepoDevInoCache *cache
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_devino_cache_unref</NAME>
<RETURNS>void</RETURNS>
OstreeRepoDevInoCache *cache
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_checkout_at_options_set_devino</NAME>
<RETURNS>void</RETURNS>
OstreeRepoCheckoutAtOptions *opts, OstreeRepoDevInoCache *cache
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_checkout_at</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                         *self, OstreeRepoCheckoutAtOptions        *options, int                                 destination_dfd, const char                         *destination_path, const char                         *commit, GCancellable                       *cancellable, GError                            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_checkout_gc</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo        *self, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_read_commit</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo    *self, const char    *ref, GFile        **out_root, char         **out_commit, GCancellable  *cancellable, GError        **error
</FUNCTION>
<ENUM>
<NAME>OstreeRepoListObjectsFlags</NAME>
typedef enum {
  OSTREE_REPO_LIST_OBJECTS_LOOSE = (1 << 0),
  OSTREE_REPO_LIST_OBJECTS_PACKED = (1 << 1),
  OSTREE_REPO_LIST_OBJECTS_ALL = (1 << 2),
  OSTREE_REPO_LIST_OBJECTS_NO_PARENTS = (1 << 3),
} OstreeRepoListObjectsFlags;
</ENUM>
<MACRO>
<NAME>OSTREE_REPO_LIST_OBJECTS_VARIANT_TYPE</NAME>
#define OSTREE_REPO_LIST_OBJECTS_VARIANT_TYPE (G_VARIANT_TYPE ("(bas)")
</MACRO>
<FUNCTION>
<NAME>ostree_repo_list_objects</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                  *self, OstreeRepoListObjectsFlags   flags, GHashTable                 **out_objects, GCancellable                *cancellable, GError                     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_list_commit_objects_starting_with</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                  *self, const char                  *start, GHashTable                 **out_commits, GCancellable                *cancellable, GError                     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_list_static_delta_names</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                  *self, GPtrArray                  **out_deltas, GCancellable                *cancellable, GError                     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_list_static_delta_indexes</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                  *self, GPtrArray                  **out_indexes, GCancellable                *cancellable, GError                     **error
</FUNCTION>
<ENUM>
<NAME>OstreeStaticDeltaGenerateOpt</NAME>
typedef enum {
  OSTREE_STATIC_DELTA_GENERATE_OPT_LOWLATENCY,
  OSTREE_STATIC_DELTA_GENERATE_OPT_MAJOR
} OstreeStaticDeltaGenerateOpt;
</ENUM>
<FUNCTION>
<NAME>ostree_repo_static_delta_generate</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                   *self, OstreeStaticDeltaGenerateOpt  opt, const char                   *from, const char                   *to, GVariant                     *metadata, GVariant                     *params, GCancellable                 *cancellable, GError                      **error
</FUNCTION>
<ENUM>
<NAME>OstreeStaticDeltaIndexFlags</NAME>
typedef enum {
  OSTREE_STATIC_DELTA_INDEX_FLAGS_NONE = 0,
} OstreeStaticDeltaIndexFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_repo_static_delta_reindex</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                  *repo, OstreeStaticDeltaIndexFlags flags, const char                  *opt_to_commit, GCancellable                *cancellable, GError                     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_static_delta_execute_offline_with_signature</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo   *self, GFile        *dir_or_file, OstreeSign   *sign, gboolean     skip_validation, GCancellable *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_static_delta_execute_offline</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                    *self, GFile                         *dir_or_file, gboolean                       skip_validation, GCancellable                  *cancellable, GError                      **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_static_delta_verify_signature</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo       *self, const char       *delta_id, OstreeSign       *sign, char            **out_success_message, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_traverse_new_reachable</NAME>
<RETURNS>GHashTable *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_traverse_new_parents</NAME>
<RETURNS>GHashTable *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_traverse_parents_get_commits</NAME>
<RETURNS>char **</RETURNS>
GHashTable *parents, GVariant *object
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_traverse_commit</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo         *repo, const char         *commit_checksum, int                 maxdepth, GHashTable        **out_reachable, GCancellable       *cancellable, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_traverse_commit_union</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo         *repo, const char         *commit_checksum, int                 maxdepth, GHashTable         *inout_reachable, GCancellable       *cancellable, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_traverse_commit_union_with_parents</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo         *repo, const char         *commit_checksum, int                 maxdepth, GHashTable         *inout_reachable, GHashTable         *inout_parents, GCancellable       *cancellable, GError            **error
</FUNCTION>
<STRUCT>
<NAME>OstreeRepoCommitTraverseIter</NAME>
struct _OstreeRepoCommitTraverseIter {
  gboolean initialized;
  /* 4 byte hole on 64 bit */
  gpointer dummy[10];
  char dummy_checksum_data[(OSTREE_SHA256_STRING_LEN+1)*2];
};
</STRUCT>
<ENUM>
<NAME>OstreeRepoCommitTraverseFlags</NAME>
typedef enum {
  OSTREE_REPO_COMMIT_TRAVERSE_FLAG_NONE = (1 << 0)
} OstreeRepoCommitTraverseFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_repo_commit_traverse_iter_init_commit</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepoCommitTraverseIter    *iter, OstreeRepo                      *repo, GVariant                        *commit, OstreeRepoCommitTraverseFlags    flags, GError                         **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_traverse_iter_init_dirtree</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepoCommitTraverseIter    *iter, OstreeRepo                      *repo, GVariant                        *dirtree, OstreeRepoCommitTraverseFlags    flags, GError                         **error
</FUNCTION>
<ENUM>
<NAME>OstreeRepoCommitIterResult</NAME>
typedef enum {
  OSTREE_REPO_COMMIT_ITER_RESULT_ERROR,
  OSTREE_REPO_COMMIT_ITER_RESULT_END,
  OSTREE_REPO_COMMIT_ITER_RESULT_FILE,
  OSTREE_REPO_COMMIT_ITER_RESULT_DIR
} OstreeRepoCommitIterResult;
</ENUM>
<FUNCTION>
<NAME>ostree_repo_commit_traverse_iter_next</NAME>
<RETURNS>OstreeRepoCommitIterResult</RETURNS>
OstreeRepoCommitTraverseIter *iter, GCancellable       *cancellable, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_traverse_iter_get_file</NAME>
<RETURNS>void</RETURNS>
OstreeRepoCommitTraverseIter *iter, char                        **out_name, char                        **out_checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_traverse_iter_get_dir</NAME>
<RETURNS>void</RETURNS>
OstreeRepoCommitTraverseIter *iter, char                        **out_name, char                        **out_content_checksum, char                        **out_meta_checksum
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_traverse_iter_clear</NAME>
<RETURNS>void</RETURNS>
OstreeRepoCommitTraverseIter *iter
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_commit_traverse_iter_cleanup</NAME>
<RETURNS>void</RETURNS>
void *p
</FUNCTION>
<MACRO>
<NAME>ostree_cleanup_repo_commit_traverse_iter</NAME>
#define ostree_cleanup_repo_commit_traverse_iter __attribute__ ((cleanup(ostree_repo_commit_traverse_iter_cleanup)))
</MACRO>
<ENUM>
<NAME>OstreeRepoPruneFlags</NAME>
typedef enum {
  OSTREE_REPO_PRUNE_FLAGS_NONE = 0,
  OSTREE_REPO_PRUNE_FLAGS_NO_PRUNE = (1 << 0),
  OSTREE_REPO_PRUNE_FLAGS_REFS_ONLY = (1 << 1),
} OstreeRepoPruneFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_repo_prune_static_deltas</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo *self, const char *commit, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_prune</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo        *self, OstreeRepoPruneFlags   flags, gint               depth, gint              *out_objects_total, gint              *out_objects_pruned, guint64           *out_pruned_object_size_total, GCancellable      *cancellable, GError           **error
</FUNCTION>
<STRUCT>
<NAME>OstreeRepoPruneOptions</NAME>
struct _OstreeRepoPruneOptions {
  OstreeRepoPruneFlags flags;

  /* 4 byte hole on 64 bit */

  GHashTable *reachable; /* Set<GVariant> (object names) */

  gboolean unused_bools[6];
  int unused_ints[6];
  gpointer unused_ptrs[7];
};
</STRUCT>
<FUNCTION>
<NAME>ostree_repo_traverse_reachable_refs</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo *self, guint       depth, GHashTable *reachable, GCancellable *cancellable, GError      **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_prune_from_reachable</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo             *self, OstreeRepoPruneOptions *options, gint              *out_objects_total, gint              *out_objects_pruned, guint64           *out_pruned_object_size_total, GCancellable           *cancellable, GError              **error
</FUNCTION>
<ENUM>
<NAME>OstreeRepoPullFlags</NAME>
typedef enum {
  OSTREE_REPO_PULL_FLAGS_NONE,
  OSTREE_REPO_PULL_FLAGS_MIRROR = (1 << 0),
  OSTREE_REPO_PULL_FLAGS_COMMIT_ONLY = (1 << 1),
  OSTREE_REPO_PULL_FLAGS_UNTRUSTED = (1 << 2),
  OSTREE_REPO_PULL_FLAGS_BAREUSERONLY_FILES = (1 << 3),
  OSTREE_REPO_PULL_FLAGS_TRUSTED_HTTP = (1 << 4),
} OstreeRepoPullFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_repo_pull</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo             *self, const char             *remote_name, char                  **refs_to_fetch, OstreeRepoPullFlags     flags, OstreeAsyncProgress    *progress, GCancellable           *cancellable, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_pull_one_dir</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo               *self, const char               *remote_name, const char               *dir_to_pull, char                    **refs_to_fetch, OstreeRepoPullFlags       flags, OstreeAsyncProgress      *progress, GCancellable             *cancellable, GError                  **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_pull_with_options</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo             *self, const char             *remote_name_or_baseurl, GVariant               *options, OstreeAsyncProgress    *progress, GCancellable           *cancellable, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_find_remotes_async</NAME>
<RETURNS>void</RETURNS>
OstreeRepo                         *self, const OstreeCollectionRef * const  *refs, GVariant                           *options, OstreeRepoFinder                  **finders, OstreeAsyncProgress                *progress, GCancellable                       *cancellable, GAsyncReadyCallback                 callback, gpointer                            user_data
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_find_remotes_finish</NAME>
<RETURNS>OstreeRepoFinderResult **</RETURNS>
OstreeRepo    *self, GAsyncResult  *result, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_pull_from_remotes_async</NAME>
<RETURNS>void</RETURNS>
OstreeRepo                           *self, const OstreeRepoFinderResult * const *results, GVariant                             *options, OstreeAsyncProgress                  *progress, GCancellable                         *cancellable, GAsyncReadyCallback                   callback, gpointer                              user_data
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_pull_from_remotes_finish</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo    *self, GAsyncResult  *result, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_resolve_keyring_for_collection</NAME>
<RETURNS>OstreeRemote *</RETURNS>
OstreeRepo    *self, const gchar   *collection_id, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_list_collection_refs</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo                 *self, const char                 *match_collection_id, GHashTable                 **out_all_refs, OstreeRepoListRefsExtFlags flags, GCancellable               *cancellable, GError                     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_pull_default_console_progress_changed</NAME>
<RETURNS>void</RETURNS>
OstreeAsyncProgress *progress, gpointer             user_data
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_sign_commit</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, const gchar    *commit_checksum, const gchar    *key_id, const gchar    *homedir, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_sign_delta</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, const gchar    *from_commit, const gchar    *to_commit, const gchar    *key_id, const gchar    *homedir, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_verify_commit</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo   *self, const gchar  *commit_checksum, GFile        *keyringdir, GFile        *extra_keyring, GCancellable *cancellable, GError      **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_remote_get_gpg_verify</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo  *self, const char  *name, gboolean    *out_gpg_verify, GError     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_remote_get_gpg_verify_summary</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo  *self, const char  *name, gboolean    *out_gpg_verify_summary, GError     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_remote_gpg_import</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo         *self, const char         *name, GInputStream       *source_stream, const char * const *key_ids, guint              *out_imported, GCancellable       *cancellable, GError            **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_add_gpg_signature_summary</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, const gchar    **key_id, const gchar    *homedir, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_append_gpg_signature</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, const gchar    *commit_checksum, GBytes         *signature_bytes, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_gpg_sign_data</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, GBytes         *data, GBytes         *old_signatures, const gchar   **key_id, const gchar    *homedir, GBytes        **out_signatures, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_verify_commit_ext</NAME>
<RETURNS>OstreeGpgVerifyResult *</RETURNS>
OstreeRepo    *self, const gchar   *commit_checksum, GFile         *keyringdir, GFile         *extra_keyring, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_verify_commit_for_remote</NAME>
<RETURNS>OstreeGpgVerifyResult *</RETURNS>
OstreeRepo    *self, const gchar   *commit_checksum, const gchar   *remote_name, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_gpg_verify_data</NAME>
<RETURNS>OstreeGpgVerifyResult *</RETURNS>
OstreeRepo    *self, const gchar   *remote_name, GBytes        *data, GBytes        *signatures, GFile         *keyringdir, GFile         *extra_keyring, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_verify_summary</NAME>
<RETURNS>OstreeGpgVerifyResult *</RETURNS>
OstreeRepo    *self, const char    *remote_name, GBytes        *summary, GBytes        *signatures, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_repo_regenerate_summary</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *self, GVariant       *additional_metadata, GCancellable   *cancellable, GError        **error
</FUNCTION>
<MACRO>
<NAME>OSTREE_REPO_METADATA_REF</NAME>
#define OSTREE_REPO_METADATA_REF "ostree-metadata"
</MACRO>
<MACRO>
<NAME>OSTREE_META_KEY_DEPLOY_COLLECTION_ID</NAME>
#define OSTREE_META_KEY_DEPLOY_COLLECTION_ID "ostree.deploy-collection-id"
</MACRO>
<STRUCT>
<NAME>OstreeRepoCommitTraverseIter</NAME>
</STRUCT>
<STRUCT>
<NAME>OstreeRepoPruneOptions</NAME>
</STRUCT>
<STRUCT>
<NAME>OstreeRollsumMatches</NAME>
typedef struct {
  GHashTable *from_rollsums;
  GHashTable *to_rollsums;
  guint crcmatches;
  guint bufmatches;
  guint total;
  guint64 match_size;
  GPtrArray *matches;
} OstreeRollsumMatches;
</STRUCT>
<STRUCT>
<NAME>OstreeSepolicyFsCreatecon</NAME>
typedef struct {
  gboolean initialized;
} OstreeSepolicyFsCreatecon;
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_SEPOLICY</NAME>
#define OSTREE_TYPE_SEPOLICY ostree_sepolicy_get_type()
</MACRO>
<MACRO>
<NAME>OSTREE_SEPOLICY</NAME>
#define OSTREE_SEPOLICY(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), OSTREE_TYPE_SEPOLICY, OstreeSePolicy))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_SEPOLICY</NAME>
#define OSTREE_IS_SEPOLICY(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), OSTREE_TYPE_SEPOLICY))
</MACRO>
<FUNCTION>
<NAME>ostree_sepolicy_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_sepolicy_new</NAME>
<RETURNS>OstreeSePolicy *</RETURNS>
GFile         *path, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sepolicy_new_at</NAME>
<RETURNS>OstreeSePolicy *</RETURNS>
int            rootfs_dfd, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sepolicy_get_path</NAME>
<RETURNS>GFile *</RETURNS>
OstreeSePolicy  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sepolicy_get_name</NAME>
<RETURNS>const char *</RETURNS>
OstreeSePolicy *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sepolicy_get_csum</NAME>
<RETURNS>const char *</RETURNS>
OstreeSePolicy *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sepolicy_get_label</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSePolicy    *self, const char       *relpath, guint32           unix_mode, char            **out_label, GCancellable     *cancellable, GError          **error
</FUNCTION>
<ENUM>
<NAME>OstreeSePolicyRestoreconFlags</NAME>
typedef enum {
  OSTREE_SEPOLICY_RESTORECON_FLAGS_NONE,
  OSTREE_SEPOLICY_RESTORECON_FLAGS_ALLOW_NOLABEL = (1 << 0),
  OSTREE_SEPOLICY_RESTORECON_FLAGS_KEEP_EXISTING = (1 << 1)
} OstreeSePolicyRestoreconFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_sepolicy_restorecon</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSePolicy   *self, const char       *path, GFileInfo        *info, GFile            *target, OstreeSePolicyRestoreconFlags  flags, char            **out_new_label, GCancellable     *cancellable, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sepolicy_setfscreatecon</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSePolicy   *self, const char       *path, guint32           mode, GError          **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sepolicy_fscreatecon_cleanup</NAME>
<RETURNS>void</RETURNS>
void **unused
</FUNCTION>
<MACRO>
<NAME>ostree_cleanup_sepolicy_fscreatecon</NAME>
#define ostree_cleanup_sepolicy_fscreatecon __attribute__ ((cleanup(ostree_sepolicy_fscreatecon_cleanup)))
</MACRO>
<MACRO>
<NAME>OSTREE_TYPE_SIGN_DUMMY</NAME>
#define OSTREE_TYPE_SIGN_DUMMY (_ostree_sign_dummy_get_type ())
</MACRO>
<STRUCT>
<NAME>OstreeSignDummy</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_SIGN_ED25519</NAME>
#define OSTREE_TYPE_SIGN_ED25519 (_ostree_sign_ed25519_get_type ())
</MACRO>
<STRUCT>
<NAME>OstreeSignEd25519</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_SIGN</NAME>
#define OSTREE_TYPE_SIGN (ostree_sign_get_type ())
</MACRO>
<FUNCTION>
<NAME>ostree_sign_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>OSTREE_SIGN</NAME>
<RETURNS>OstreeSign *</RETURNS>
gpointer ptr) static inline gboolean OSTREE_IS_SIGN (gpointer ptr
</FUNCTION>
<FUNCTION>
<NAME>OSTREE_SIGN_GET_IFACE</NAME>
<RETURNS>OstreeSignInterface *</RETURNS>
gpointer ptr
</FUNCTION>
<MACRO>
<NAME>OSTREE_SIGN_NAME_ED25519</NAME>
#define OSTREE_SIGN_NAME_ED25519 "ed25519"
</MACRO>
<STRUCT>
<NAME>OstreeSignInterface</NAME>
struct _OstreeSignInterface
{
  GTypeInterface g_iface;
  const gchar *(* get_name) (OstreeSign *self);
  gboolean (* data)   (OstreeSign *self,
                       GBytes *data,
                       GBytes **signature,
                       GCancellable *cancellable,
                       GError **error);
  gboolean (* data_verify) (OstreeSign *self,
                            GBytes *data,
                            GVariant   *signatures,
                            char      **out_success_message,
                            GError **error);
  const gchar *(* metadata_key) (OstreeSign *self);
  const gchar *(* metadata_format) (OstreeSign *self);
  gboolean (* clear_keys) (OstreeSign *self,
                           GError **error);
  gboolean (* set_sk) (OstreeSign *self,
                       GVariant *secret_key,
                       GError **error);
  gboolean (* set_pk) (OstreeSign *self,
                       GVariant *public_key,
                       GError **error);
  gboolean (* add_pk) (OstreeSign *self,
                       GVariant *public_key,
                       GError **error);
  gboolean (* load_pk) (OstreeSign *self,
                        GVariant *options,
                        GError **error);
};
</STRUCT>
<FUNCTION>
<NAME>ostree_sign_get_name</NAME>
<RETURNS>const gchar *</RETURNS>
OstreeSign *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_data</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSign *self, GBytes *data, GBytes **signature, GCancellable *cancellable, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_data_verify</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSign *self, GBytes     *data, GVariant   *signatures, char      **out_success_message, GError     **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_metadata_key</NAME>
<RETURNS>const gchar *</RETURNS>
OstreeSign *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_metadata_format</NAME>
<RETURNS>const gchar *</RETURNS>
OstreeSign *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_commit</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSign     *self, OstreeRepo     *repo, const gchar    *commit_checksum, GCancellable   *cancellable, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_commit_verify</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSign *self, OstreeRepo     *repo, const gchar    *commit_checksum, char          **out_success_message, GCancellable   *cancellable, GError         **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_clear_keys</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSign *self, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_set_sk</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSign *self, GVariant *secret_key, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_set_pk</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSign *self, GVariant *public_key, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_add_pk</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSign *self, GVariant *public_key, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_load_pk</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSign *self, GVariant *options, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_get_all</NAME>
<RETURNS>GPtrArray *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_get_by_name</NAME>
<RETURNS>OstreeSign *</RETURNS>
const gchar *name, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sign_summary</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSign    *self, OstreeRepo    *repo, GVariant      *keys, GCancellable  *cancellable, GError       **error
</FUNCTION>
<STRUCT>
<NAME>OstreeSign</NAME>
</STRUCT>
<MACRO>
<NAME>SOUP_AVAILABLE_IN_2_4</NAME>
#define SOUP_AVAILABLE_IN_2_4
</MACRO>
<MACRO>
<NAME>SOUP_AVAILABLE_IN_2_28</NAME>
#define SOUP_AVAILABLE_IN_2_28
</MACRO>
<MACRO>
<NAME>SOUP_AVAILABLE_IN_2_32</NAME>
#define SOUP_AVAILABLE_IN_2_32
</MACRO>
<MACRO>
<NAME>SOUP_VAR</NAME>
#define SOUP_VAR extern
</MACRO>
<MACRO>
<NAME>SOUP_URI_SCHEME_HTTP</NAME>
#define SOUP_URI_SCHEME_HTTP     _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_HTTP, "http")
</MACRO>
<MACRO>
<NAME>SOUP_URI_SCHEME_HTTPS</NAME>
#define SOUP_URI_SCHEME_HTTPS    _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_HTTPS, "https")
</MACRO>
<MACRO>
<NAME>SOUP_URI_SCHEME_FTP</NAME>
#define SOUP_URI_SCHEME_FTP      _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_FTP, "ftp")
</MACRO>
<MACRO>
<NAME>SOUP_URI_SCHEME_FILE</NAME>
#define SOUP_URI_SCHEME_FILE     _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_FILE, "file")
</MACRO>
<MACRO>
<NAME>SOUP_URI_SCHEME_DATA</NAME>
#define SOUP_URI_SCHEME_DATA     _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_DATA, "data")
</MACRO>
<MACRO>
<NAME>SOUP_URI_SCHEME_RESOURCE</NAME>
#define SOUP_URI_SCHEME_RESOURCE _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_RESOURCE, "resource")
</MACRO>
<MACRO>
<NAME>SOUP_URI_SCHEME_WS</NAME>
#define SOUP_URI_SCHEME_WS       _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_WS, "ws")
</MACRO>
<MACRO>
<NAME>SOUP_URI_SCHEME_WSS</NAME>
#define SOUP_URI_SCHEME_WSS      _SOUP_ATOMIC_INTERN_STRING (_SOUP_URI_SCHEME_WSS, "wss")
</MACRO>
<FUNCTION>
<NAME>soup_form_encode_hash</NAME>
<RETURNS>char *</RETURNS>
GHashTable   *form_data_set
</FUNCTION>
<FUNCTION>
<NAME>soup_form_encode_valist</NAME>
<RETURNS>char *</RETURNS>
const char   *first_field, va_list       args
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_new_with_base</NAME>
<RETURNS>SoupURI *</RETURNS>
SoupURI    *base, const char *uri_string
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_new</NAME>
<RETURNS>SoupURI *</RETURNS>
const char *uri_string
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_to_string</NAME>
<RETURNS>char *</RETURNS>
SoupURI    *uri, gboolean    just_path_and_query
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_copy</NAME>
<RETURNS>SoupURI *</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_equal</NAME>
<RETURNS>gboolean</RETURNS>
SoupURI    *uri1, SoupURI    *uri2
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_free</NAME>
<RETURNS>void</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_encode</NAME>
<RETURNS>char *</RETURNS>
const char *part, const char *escape_extra
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_decode</NAME>
<RETURNS>char *</RETURNS>
const char *part
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_normalize</NAME>
<RETURNS>char *</RETURNS>
const char *part, const char *unescape_extra
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_uses_default_port</NAME>
<RETURNS>gboolean</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_get_scheme</NAME>
<RETURNS>const char *</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_scheme</NAME>
<RETURNS>void</RETURNS>
SoupURI    *uri, const char *scheme
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_get_user</NAME>
<RETURNS>const char *</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_user</NAME>
<RETURNS>void</RETURNS>
SoupURI    *uri, const char *user
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_get_password</NAME>
<RETURNS>const char *</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_password</NAME>
<RETURNS>void</RETURNS>
SoupURI    *uri, const char *password
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_get_host</NAME>
<RETURNS>const char *</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_host</NAME>
<RETURNS>void</RETURNS>
SoupURI    *uri, const char *host
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_get_port</NAME>
<RETURNS>guint</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_port</NAME>
<RETURNS>void</RETURNS>
SoupURI    *uri, guint       port
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_get_path</NAME>
<RETURNS>const char *</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_path</NAME>
<RETURNS>void</RETURNS>
SoupURI    *uri, const char *path
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_get_query</NAME>
<RETURNS>const char *</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_query</NAME>
<RETURNS>void</RETURNS>
SoupURI    *uri, const char *query
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_query_from_form</NAME>
<RETURNS>void</RETURNS>
SoupURI    *uri, GHashTable *form
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_query_from_fields</NAME>
<RETURNS>void</RETURNS>
SoupURI    *uri, const char *first_field, ...
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_get_fragment</NAME>
<RETURNS>const char *</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_fragment</NAME>
<RETURNS>void</RETURNS>
SoupURI    *uri, const char *fragment
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_copy_host</NAME>
<RETURNS>SoupURI *</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_host_hash</NAME>
<RETURNS>guint</RETURNS>
gconstpointer key
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_host_equal</NAME>
<RETURNS>gboolean</RETURNS>
gconstpointer v1, gconstpointer v2
</FUNCTION>
<MACRO>
<NAME>SOUP_URI_IS_VALID</NAME>
#define   SOUP_URI_IS_VALID(uri)       ((uri) && (uri)->scheme && (uri)->path)
</MACRO>
<MACRO>
<NAME>SOUP_URI_VALID_FOR_HTTP</NAME>
#define   SOUP_URI_VALID_FOR_HTTP(uri) ((uri) && ((uri)->scheme == SOUP_URI_SCHEME_HTTP || (uri)->scheme == SOUP_URI_SCHEME_HTTPS) && (uri)->host && (uri)->path)
</MACRO>
<STRUCT>
<NAME>SoupURI</NAME>
</STRUCT>
<MACRO>
<NAME>OSTREE_TYPE_SYSROOT_UPGRADER</NAME>
#define OSTREE_TYPE_SYSROOT_UPGRADER ostree_sysroot_upgrader_get_type()
</MACRO>
<MACRO>
<NAME>OSTREE_SYSROOT_UPGRADER</NAME>
#define OSTREE_SYSROOT_UPGRADER(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), OSTREE_TYPE_SYSROOT_UPGRADER, OstreeSysrootUpgrader))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_SYSROOT_UPGRADER</NAME>
#define OSTREE_IS_SYSROOT_UPGRADER(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), OSTREE_TYPE_SYSROOT_UPGRADER))
</MACRO>
<ENUM>
<NAME>OstreeSysrootUpgraderFlags</NAME>
typedef enum {
  OSTREE_SYSROOT_UPGRADER_FLAGS_NONE = (1 << 0),
  OSTREE_SYSROOT_UPGRADER_FLAGS_IGNORE_UNCONFIGURED = (1 << 1),
} OstreeSysrootUpgraderFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_flags_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_new</NAME>
<RETURNS>OstreeSysrootUpgrader *</RETURNS>
OstreeSysroot *sysroot, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_new_for_os</NAME>
<RETURNS>OstreeSysrootUpgrader *</RETURNS>
OstreeSysroot *sysroot, const char    *osname, GCancellable  *cancellable, GError       **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_new_for_os_with_flags</NAME>
<RETURNS>OstreeSysrootUpgrader *</RETURNS>
OstreeSysroot              *sysroot, const char                 *osname, OstreeSysrootUpgraderFlags  flags, GCancellable               *cancellable, GError                    **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_get_origin</NAME>
<RETURNS>GKeyFile *</RETURNS>
OstreeSysrootUpgrader *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_dup_origin</NAME>
<RETURNS>GKeyFile *</RETURNS>
OstreeSysrootUpgrader *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_set_origin</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysrootUpgrader *self, GKeyFile *origin, GCancellable *cancellable, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_get_origin_description</NAME>
<RETURNS>char *</RETURNS>
OstreeSysrootUpgrader *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_check_timestamps</NAME>
<RETURNS>gboolean</RETURNS>
OstreeRepo     *repo, const char     *from_rev, const char     *to_rev, GError        **error
</FUNCTION>
<ENUM>
<NAME>OstreeSysrootUpgraderPullFlags</NAME>
typedef enum {
  OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_NONE = 0,
  OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_ALLOW_OLDER = (1 << 0),
  OSTREE_SYSROOT_UPGRADER_PULL_FLAGS_SYNTHETIC = (1 << 1) /* Don't actually do a pull, just check timestamps/changed */
} OstreeSysrootUpgraderPullFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_pull</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysrootUpgrader  *self, OstreeRepoPullFlags     flags, OstreeSysrootUpgraderPullFlags     upgrader_flags, OstreeAsyncProgress    *progress, gboolean               *out_changed, GCancellable           *cancellable, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_pull_one_dir</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysrootUpgrader  *self, const char                   *dir_to_pull, OstreeRepoPullFlags     flags, OstreeSysrootUpgraderPullFlags     upgrader_flags, OstreeAsyncProgress    *progress, gboolean               *out_changed, GCancellable           *cancellable, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_upgrader_deploy</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysrootUpgrader  *self, GCancellable           *cancellable, GError                **error
</FUNCTION>
<MACRO>
<NAME>OSTREE_TYPE_SYSROOT</NAME>
#define OSTREE_TYPE_SYSROOT ostree_sysroot_get_type()
</MACRO>
<MACRO>
<NAME>OSTREE_SYSROOT</NAME>
#define OSTREE_SYSROOT(obj) \
  (G_TYPE_CHECK_INSTANCE_CAST ((obj), OSTREE_TYPE_SYSROOT, OstreeSysroot))
</MACRO>
<MACRO>
<NAME>OSTREE_IS_SYSROOT</NAME>
#define OSTREE_IS_SYSROOT(obj) \
  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), OSTREE_TYPE_SYSROOT))
</MACRO>
<FUNCTION>
<NAME>ostree_sysroot_get_type</NAME>
<RETURNS>GType</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_new</NAME>
<RETURNS>OstreeSysroot *</RETURNS>
GFile *path
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_new_default</NAME>
<RETURNS>OstreeSysroot *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_set_mount_namespace_in_use</NAME>
<RETURNS>void</RETURNS>
OstreeSysroot  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_path</NAME>
<RETURNS>GFile *</RETURNS>
OstreeSysroot *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_is_booted</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_fd</NAME>
<RETURNS>int</RETURNS>
OstreeSysroot *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_initialize</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot  *self, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_load</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot  *self, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_load_if_changed</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot  *self, gboolean       *out_changed, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_unload</NAME>
<RETURNS>void</RETURNS>
OstreeSysroot  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_ensure_initialized</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot  *self, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_bootversion</NAME>
<RETURNS>int</RETURNS>
OstreeSysroot   *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_subbootversion</NAME>
<RETURNS>int</RETURNS>
OstreeSysroot   *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_deployments</NAME>
<RETURNS>GPtrArray *</RETURNS>
OstreeSysroot  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_booted_deployment</NAME>
<RETURNS>OstreeDeployment *</RETURNS>
OstreeSysroot *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_staged_deployment</NAME>
<RETURNS>OstreeDeployment *</RETURNS>
OstreeSysroot *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_deployment_directory</NAME>
<RETURNS>GFile *</RETURNS>
OstreeSysroot    *self, OstreeDeployment *deployment
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_deployment_dirpath</NAME>
<RETURNS>char *</RETURNS>
OstreeSysroot    *self, OstreeDeployment *deployment
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_deployment_origin_path</NAME>
<RETURNS>GFile *</RETURNS>
GFile   *deployment_path
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_lock</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot  *self, GError **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_try_lock</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot         *self, gboolean              *out_acquired, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_lock_async</NAME>
<RETURNS>void</RETURNS>
OstreeSysroot         *self, GCancellable          *cancellable, GAsyncReadyCallback    callback, gpointer               user_data
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_lock_finish</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot         *self, GAsyncResult          *result, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_unlock</NAME>
<RETURNS>void</RETURNS>
OstreeSysroot  *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_init_osname</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot       *self, const char          *osname, GCancellable        *cancellable, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_cleanup</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot       *self, GCancellable        *cancellable, GError             **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_prepare_cleanup</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot  *self, GCancellable   *cancellable, GError        **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_cleanup_prune_repo</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot          *sysroot, OstreeRepoPruneOptions *options, gint                   *out_objects_total, gint                   *out_objects_pruned, guint64                *out_pruned_object_size_total, GCancellable           *cancellable, GError                **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_write_origin_file</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot         *sysroot, OstreeDeployment      *deployment, GKeyFile              *new_origin, GCancellable          *cancellable, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_repo</NAME>
<RETURNS>OstreeRepo *</RETURNS>
OstreeSysroot *self
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_repo</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot         *self, OstreeRepo           **out_repo, GCancellable          *cancellable, GError               **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_deployment_set_kargs</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot     *self, OstreeDeployment  *deployment, char             **new_kargs, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_write_deployments</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot     *self, GPtrArray         *new_deployments, GCancellable      *cancellable, GError           **error
</FUNCTION>
<STRUCT>
<NAME>OstreeSysrootWriteDeploymentsOpts</NAME>
typedef struct {
  gboolean do_postclean;
  gboolean unused_bools[7];
  int unused_ints[7];
  gpointer unused_ptrs[7];
} OstreeSysrootWriteDeploymentsOpts;
</STRUCT>
<FUNCTION>
<NAME>ostree_sysroot_write_deployments_with_options</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot     *self, GPtrArray         *new_deployments, OstreeSysrootWriteDeploymentsOpts *opts, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_stage_overlay_initrd</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot  *self, int             fd, char          **out_checksum, GCancellable   *cancellable, GError        **error
</FUNCTION>
<STRUCT>
<NAME>OstreeSysrootDeployTreeOpts</NAME>
typedef struct {
  gboolean unused_bools[8];
  int unused_ints[8];
  char **override_kernel_argv;
  char **overlay_initrds;
  gpointer unused_ptrs[6];
} OstreeSysrootDeployTreeOpts;
</STRUCT>
<FUNCTION>
<NAME>ostree_sysroot_deploy_tree</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot     *self, const char        *osname, const char        *revision, GKeyFile          *origin, OstreeDeployment  *provided_merge_deployment, char             **override_kernel_argv, OstreeDeployment **out_new_deployment, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_deploy_tree_with_options</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot     *self, const char        *osname, const char        *revision, GKeyFile          *origin, OstreeDeployment  *provided_merge_deployment, OstreeSysrootDeployTreeOpts *opts, OstreeDeployment **out_new_deployment, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_stage_tree</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot     *self, const char        *osname, const char        *revision, GKeyFile          *origin, OstreeDeployment  *merge_deployment, char             **override_kernel_argv, OstreeDeployment **out_new_deployment, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_stage_tree_with_options</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot     *self, const char        *osname, const char        *revision, GKeyFile          *origin, OstreeDeployment  *merge_deployment, OstreeSysrootDeployTreeOpts *opts, OstreeDeployment **out_new_deployment, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_deployment_set_mutable</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot     *self, OstreeDeployment  *deployment, gboolean           is_mutable, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_deployment_set_pinned</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot     *self, OstreeDeployment  *deployment, gboolean           is_pinned, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_deployment_unlock</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot     *self, OstreeDeployment  *deployment, OstreeDeploymentUnlockedState unlocked_state, GCancellable      *cancellable, GError           **error
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_query_deployments_for</NAME>
<RETURNS>void</RETURNS>
OstreeSysroot     *self, const char        *osname, OstreeDeployment  **out_pending, OstreeDeployment  **out_rollback
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_get_merge_deployment</NAME>
<RETURNS>OstreeDeployment *</RETURNS>
OstreeSysroot     *self, const char        *osname
</FUNCTION>
<FUNCTION>
<NAME>ostree_sysroot_origin_new_from_refspec</NAME>
<RETURNS>GKeyFile *</RETURNS>
OstreeSysroot      *self, const char         *refspec
</FUNCTION>
<ENUM>
<NAME>OstreeSysrootSimpleWriteDeploymentFlags</NAME>
typedef enum {
  OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NONE = 0,
  OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN = (1 << 0),
  OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NOT_DEFAULT = (1 << 1),
  OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_NO_CLEAN = (1 << 2),
  OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_PENDING = (1 << 3),
  OSTREE_SYSROOT_SIMPLE_WRITE_DEPLOYMENT_FLAGS_RETAIN_ROLLBACK = (1 << 4),
} OstreeSysrootSimpleWriteDeploymentFlags;
</ENUM>
<FUNCTION>
<NAME>ostree_sysroot_simple_write_deployment</NAME>
<RETURNS>gboolean</RETURNS>
OstreeSysroot      *sysroot, const char         *osname, OstreeDeployment   *new_deployment, OstreeDeployment   *merge_deployment, OstreeSysrootSimpleWriteDeploymentFlags flags, GCancellable       *cancellable, GError            **error
</FUNCTION>
<TYPEDEF>
<NAME>OstreeRepo</NAME>
typedef struct OstreeRepo OstreeRepo;
</TYPEDEF>
<TYPEDEF>
<NAME>OstreeRepoDevInoCache</NAME>
typedef struct OstreeRepoDevInoCache OstreeRepoDevInoCache;
</TYPEDEF>
<TYPEDEF>
<NAME>OstreeSePolicy</NAME>
typedef struct OstreeSePolicy OstreeSePolicy;
</TYPEDEF>
<TYPEDEF>
<NAME>OstreeSysroot</NAME>
typedef struct OstreeSysroot OstreeSysroot;
</TYPEDEF>
<TYPEDEF>
<NAME>OstreeSysrootUpgrader</NAME>
typedef struct OstreeSysrootUpgrader OstreeSysrootUpgrader;
</TYPEDEF>
<TYPEDEF>
<NAME>OstreeMutableTree</NAME>
typedef struct OstreeMutableTree OstreeMutableTree;
</TYPEDEF>
<TYPEDEF>
<NAME>OstreeRepoFile</NAME>
typedef struct OstreeRepoFile OstreeRepoFile;
</TYPEDEF>
<TYPEDEF>
<NAME>OstreeRemote</NAME>
typedef struct OstreeRemote OstreeRemote;
</TYPEDEF>
<MACRO>
<NAME>OSTREE_YEAR_VERSION</NAME>
#define OSTREE_YEAR_VERSION (2020)
</MACRO>
<MACRO>
<NAME>OSTREE_RELEASE_VERSION</NAME>
#define OSTREE_RELEASE_VERSION (8)
</MACRO>
<MACRO>
<NAME>OSTREE_VERSION</NAME>
#define OSTREE_VERSION (2020.8)
</MACRO>
<MACRO>
<NAME>OSTREE_VERSION_S</NAME>
#define OSTREE_VERSION_S "2020.8"
</MACRO>
<MACRO>
<NAME>OSTREE_ENCODE_VERSION</NAME>
#define OSTREE_ENCODE_VERSION(year,release) \
        ((year) << 16 | (release))
</MACRO>
<MACRO>
<NAME>OSTREE_VERSION_HEX</NAME>
#define OSTREE_VERSION_HEX \
        (OSTREE_ENCODE_VERSION (OSTREE_YEAR_VERSION, OSTREE_RELEASE_VERSION))
</MACRO>
<MACRO>
<NAME>OSTREE_CHECK_VERSION</NAME>
#define OSTREE_CHECK_VERSION(year,release)   \
        (OSTREE_YEAR_VERSION > (year) || \
         (OSTREE_YEAR_VERSION == (year) && OSTREE_RELEASE_VERSION >= (release)))
</MACRO>
<MACRO>
<NAME>OSTREE_BUILT_FEATURES</NAME>
#define OSTREE_BUILT_FEATURES "gpgme ex-fsverity selinux libmount release p2p"
</MACRO>
