## pk-client-sync pk-client-sync |

## Synopsis

    PkResults *         pk_client_accept_eula               (PkClient *client,
                                                             const gchar *eula_id,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_adopt                     (PkClient *client,
                                                             const gchar *transaction_id,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_download_packages         (PkClient *client,
                                                             gchar **package_ids,
                                                             const gchar *directory,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_get_categories            (PkClient *client,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_get_depends               (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **package_ids,
                                                             gboolean recursive,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_get_details               (PkClient *client,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_get_distro_upgrades       (PkClient *client,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_get_files                 (PkClient *client,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_get_old_transactions      (PkClient *client,
                                                             guint number,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_get_packages              (PkClient *client,
                                                             PkBitfield filters,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkProgress *        pk_client_get_progress              (PkClient *client,
                                                             const gchar *transaction_id,
                                                             GCancellable *cancellable,
                                                             GError **error);
    PkResults *         pk_client_get_repo_list             (PkClient *client,
                                                             PkBitfield filters,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_get_requires              (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **package_ids,
                                                             gboolean recursive,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_get_update_detail         (PkClient *client,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_get_updates               (PkClient *client,
                                                             PkBitfield filters,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_install_files             (PkClient *client,
                                                             gboolean only_trusted,
                                                             gchar **files,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_install_packages          (PkClient *client,
                                                             gboolean only_trusted,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_install_signature         (PkClient *client,
                                                             PkSigTypeEnum type,
                                                             const gchar *key_id,
                                                             const gchar *package_id,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_refresh_cache             (PkClient *client,
                                                             gboolean force,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_remove_packages           (PkClient *client,
                                                             gchar **package_ids,
                                                             gboolean allow_deps,
                                                             gboolean autoremove,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_repair_system             (PkClient *client,
                                                             gboolean only_trusted,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_repo_enable               (PkClient *client,
                                                             const gchar *repo_id,
                                                             gboolean enabled,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_repo_set_data             (PkClient *client,
                                                             const gchar *repo_id,
                                                             const gchar *parameter,
                                                             const gchar *value,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_resolve                   (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **packages,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_rollback                  (PkClient *client,
                                                             const gchar *transaction_id,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_search_details            (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **values,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_search_files              (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **values,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_search_groups             (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **values,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_search_names              (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **values,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_simulate_install_files    (PkClient *client,
                                                             gchar **files,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_simulate_install_packages (PkClient *client,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_simulate_remove_packages  (PkClient *client,
                                                             gchar **package_ids,
                                                             gboolean autoremove,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_simulate_repair_system    (PkClient *client,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_simulate_update_packages  (PkClient *client,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_update_packages           (PkClient *client,
                                                             gboolean only_trusted,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_update_system             (PkClient *client,
                                                             gboolean only_trusted,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_upgrade_system            (PkClient *client,
                                                             const gchar *distro_id,
                                                             PkUpgradeKindEnum upgrade_kind,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);
    PkResults *         pk_client_what_provides             (PkClient *client,
                                                             PkBitfield filters,
                                                             PkProvidesEnum provides,
                                                             gchar **values,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

## Description

## Details

### pk_client_accept_eula ()

    PkResults *         pk_client_accept_eula               (PkClient *client,
                                                             const gchar *eula_id,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

We may want to agree to a EULA dialog if one is presented.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`eula_id` : | the `eula_id` we are agreeing to
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_adopt ()

    PkResults *         pk_client_adopt                     (PkClient *client,
                                                             const gchar *transaction_id,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Adopt a transaction.

Warning: this function is synchronous, and will block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`transaction_id` : | a transaction ID such as "/21_ebcbdaae_data"
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_download_packages ()

    PkResults *         pk_client_download_packages         (PkClient *client,
                                                             gchar **package_ids,
                                                             const gchar *directory,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Downloads package files to a specified location.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`directory` : | the location where packages are to be downloaded
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_categories ()

    PkResults *         pk_client_get_categories            (PkClient *client,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Get a list of all categories supported.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_depends ()

    PkResults *         pk_client_get_depends               (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **package_ids,
                                                             gboolean recursive,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Get the packages that depend this one, i.e. child->parent.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`filters` : | a `PkBitfield` such as `PK_FILTER_ENUM_GUI` | `PK_FILTER_ENUM_FREE` or `PK_FILTER_ENUM_NONE`
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`recursive` : | If we should search recursively for depends
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_details ()

    PkResults *         pk_client_get_details               (PkClient *client,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Get details of a package, so more information can be obtained for GUI or command line tools.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_distro_upgrades ()

    PkResults *         pk_client_get_distro_upgrades       (PkClient *client,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

This method should return a list of distribution upgrades that are available. It should not return updates, only major upgrades.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_files ()

    PkResults *         pk_client_get_files                 (PkClient *client,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Get the file list (i.e. a list of files installed) for the specified package.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_old_transactions ()

    PkResults *         pk_client_get_old_transactions      (PkClient *client,
                                                             guint number,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Get the old transaction list, mainly used for the rollback viewer.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`number` : | the number of past transactions to return, or 0 for all
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_packages ()

    PkResults *         pk_client_get_packages              (PkClient *client,
                                                             PkBitfield filters,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Get the list of packages from the backend

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`filters` : | a `PkBitfield` such as `PK_FILTER_ENUM_GUI` | `PK_FILTER_ENUM_FREE` or `PK_FILTER_ENUM_NONE`
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_progress ()

    PkProgress *        pk_client_get_progress              (PkClient *client,
                                                             const gchar *transaction_id,
                                                             GCancellable *cancellable,
                                                             GError **error);

Get the progress of a transaction.

Warning: this function is synchronous, and will block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`transaction_id` : | The transaction id
`cancellable` : | a GCancellable or `NULL`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_repo_list ()

    PkResults *         pk_client_get_repo_list             (PkClient *client,
                                                             PkBitfield filters,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Get the list of repositories installed on the system.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`filters` : | a `PkBitfield` such as `PK_FILTER_ENUM_DEVEL` or `PK_FILTER_ENUM_NONE`
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_requires ()

    PkResults *         pk_client_get_requires              (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **package_ids,
                                                             gboolean recursive,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Get the packages that require this one, i.e. parent->child.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`filters` : | a `PkBitfield` such as `PK_FILTER_ENUM_GUI` | `PK_FILTER_ENUM_FREE` or `PK_FILTER_ENUM_NONE`
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`recursive` : | If we should search recursively for requires
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_update_detail ()

    PkResults *         pk_client_get_update_detail         (PkClient *client,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Get details about the specific update, for instance any CVE urls and severity information.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_get_updates ()

    PkResults *         pk_client_get_updates               (PkClient *client,
                                                             PkBitfield filters,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Get a list of all the packages that can be updated for all repositories.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`filters` : | a `PkBitfield` such as `PK_FILTER_ENUM_DEVEL` or `PK_FILTER_ENUM_NONE`
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_install_files ()

    PkResults *         pk_client_install_files             (PkClient *client,
                                                             gboolean only_trusted,
                                                             gchar **files,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Install a file locally, and get the deps from the repositories. This is useful for double clicking on a .rpm or .deb file.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`only_trusted` : | only trusted packages should be installed
`files` : | a file such as "/home/hughsie/Desktop/hal-devel-0.10.0.rpm". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_install_packages ()

    PkResults *         pk_client_install_packages          (PkClient *client,
                                                             gboolean only_trusted,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Install a package of the newest and most correct version.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`only_trusted` : | only trusted packages should be installed
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_install_signature ()

    PkResults *         pk_client_install_signature         (PkClient *client,
                                                             PkSigTypeEnum type,
                                                             const gchar *key_id,
                                                             const gchar *package_id,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Install a software source signature of the newest and most correct version.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`type` : | the signature type, e.g. `PK_SIGTYPE_ENUM_GPG`
`key_id` : | a key ID such as "0df23df"
`package_id` : | a signature_id structure such as "hal;0.0.1;i386;fedora"
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_refresh_cache ()

    PkResults *         pk_client_refresh_cache             (PkClient *client,
                                                             gboolean force,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Refresh the cache, i.e. download new metadata from a remote URL so that package lists are up to date. This action may take a few minutes and should be done when the session and system are idle.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`force` : | if we should aggressively drop caches
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_remove_packages ()

    PkResults *         pk_client_remove_packages           (PkClient *client,
                                                             gchar **package_ids,
                                                             gboolean allow_deps,
                                                             gboolean autoremove,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Remove a package (optionally with dependancies) from the system. If `allow_deps` is set to `FALSE`, and other packages would have to be removed, then the transaction would fail.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`allow_deps` : | if other dependent packages are allowed to be removed from the computer
`autoremove` : | if other packages installed at the same time should be tried to remove
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_repair_system ()

    PkResults *         pk_client_repair_system             (PkClient *client,
                                                             gboolean only_trusted,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

This transaction will try to recover from a broken package management system: e.g. the installation of a package with unsatisfied dependencies has been forced by using a low level tool (rpm or dpkg) or the system was shutdown during processing an installation.

The backend will decide what is best to do.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`only_trusted` : | if only trusted packages should be installed
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.7.2

### pk_client_repo_enable ()

    PkResults *         pk_client_repo_enable               (PkClient *client,
                                                             const gchar *repo_id,
                                                             gboolean enabled,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Enable or disable the repository.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`repo_id` : | a repo_id structure such as "livna-devel"
`enabled` : | if we should enable the repository
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_repo_set_data ()

    PkResults *         pk_client_repo_set_data             (PkClient *client,
                                                             const gchar *repo_id,
                                                             const gchar *parameter,
                                                             const gchar *value,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

We may want to set a repository parameter. NOTE: this is free text, and is left to the backend to define a format.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`repo_id` : | a repo_id structure such as "livna-devel"
`parameter` : | the parameter to change
`value` : | what we should change it to
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_resolve ()

    PkResults *         pk_client_resolve                   (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **packages,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Resolve a package name into a `package_id`. This can return installed and available packages and allows you find out if a package is installed locally or is available in a repository.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`filters` : | a `PkBitfield` such as `PK_FILTER_ENUM_GUI` | `PK_FILTER_ENUM_FREE` or `PK_FILTER_ENUM_NONE`
`packages` : | an array of package names to resolve, e.g. "gnome-system-tools". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_rollback ()

    PkResults *         pk_client_rollback                  (PkClient *client,
                                                             const gchar *transaction_id,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

We may want to agree to a EULA dialog if one is presented.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`transaction_id` : | the `transaction_id` we want to return to
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_search_details ()

    PkResults *         pk_client_search_details            (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **values,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Search all detailed summary information to try and find a keyword. Think of this as `pk_client_search_names()`, but trying much harder and taking longer.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`filters` : | a `PkBitfield` such as `PK_FILTER_ENUM_GUI` | `PK_FILTER_ENUM_FREE` or `PK_FILTER_ENUM_NONE`
`values` : | free text to search for, for instance, "power". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.5

### pk_client_search_files ()

    PkResults *         pk_client_search_files              (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **values,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Search for packages that provide a specific file.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`filters` : | a `PkBitfield` such as `PK_FILTER_ENUM_GUI` | `PK_FILTER_ENUM_FREE` or `PK_FILTER_ENUM_NONE`
`values` : | file to search for, for instance, "/sbin/service". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.5

### pk_client_search_groups ()

    PkResults *         pk_client_search_groups             (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **values,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Return all packages in a specific group.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`filters` : | a `PkBitfield` such as `PK_FILTER_ENUM_GUI` | `PK_FILTER_ENUM_FREE` or `PK_FILTER_ENUM_NONE`
`values` : | a group enum to search for, for instance, "system-tools". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.5

### pk_client_search_names ()

    PkResults *         pk_client_search_names              (PkClient *client,
                                                             PkBitfield filters,
                                                             gchar **values,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Search all the locally installed files and remote repositories for a package that matches a specific name.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`filters` : | a `PkBitfield` such as `PK_FILTER_ENUM_GUI` | `PK_FILTER_ENUM_FREE` or `PK_FILTER_ENUM_NONE`
`values` : | free text to search for, for instance, "power". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.5

### pk_client_simulate_install_files ()

    PkResults *         pk_client_simulate_install_files    (PkClient *client,
                                                             gchar **files,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Simulate an installation of files.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`files` : | a file such as "/home/hughsie/Desktop/hal-devel-0.10.0.rpm". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_simulate_install_packages ()

    PkResults *         pk_client_simulate_install_packages (PkClient *client,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Simulate an installation of packages.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_simulate_remove_packages ()

    PkResults *         pk_client_simulate_remove_packages  (PkClient *client,
                                                             gchar **package_ids,
                                                             gboolean autoremove,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Simulate a removal of packages.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`autoremove` : | if other packages installed at the same time should be tried to remove
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_simulate_repair_system ()

    PkResults *         pk_client_simulate_repair_system    (PkClient *client,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

This transaction simultes the recovery from a broken package management system: e.g. the installation of a package with unsatisfied dependencies has been forced by using a low level tool (rpm or dpkg) or the system was shutdown during processing an installation.

The backend will decide what is best to do.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.7.2

### pk_client_simulate_update_packages ()

    PkResults *         pk_client_simulate_update_packages  (PkClient *client,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Simulate an update of packages.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_update_packages ()

    PkResults *         pk_client_update_packages           (PkClient *client,
                                                             gboolean only_trusted,
                                                             gchar **package_ids,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Update specific packages to the newest available versions.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`only_trusted` : | only trusted packages should be installed
`package_ids` : | a null terminated array of package_id structures such as "hal;0.0.1;i386;fedora". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_update_system ()

    PkResults *         pk_client_update_system             (PkClient *client,
                                                             gboolean only_trusted,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

Update all the packages on the system with the highest versions found in all repositories. NOTE: you can't choose what repositories to update from, but you can do:

- `pk_client_repo_disable()`

- `pk_client_update_system()`

- `pk_client_repo_enable()`

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`only_trusted` : | only trusted packages should be installed
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3

### pk_client_upgrade_system ()

    PkResults *         pk_client_upgrade_system            (PkClient *client,
                                                             const gchar *distro_id,
                                                             PkUpgradeKindEnum upgrade_kind,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

This transaction will upgrade the distro to the next version, which may involve just downloading the installer and setting up the boot device, or may involve doing an on-line upgrade.

The backend will decide what is best to do.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`distro_id` : | a distro ID such as "fedora-14"
`upgrade_kind` : | a PkUpgradeKindEnum such as `PK_UPGRADE_KIND_ENUM_COMPLETE`
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.6.11

### pk_client_what_provides ()

    PkResults *         pk_client_what_provides             (PkClient *client,
                                                             PkBitfield filters,
                                                             PkProvidesEnum provides,
                                                             gchar **values,
                                                             GCancellable *cancellable,
                                                             PkProgressCallback progress_callback,
                                                             gpointer progress_user_data,
                                                             GError **error);

This should return packages that provide the supplied attributes. This method is useful for finding out what package(s) provide a modalias or GStreamer codec string.

Warning: this function is synchronous, and may block. Do not use it in GUI applications.

`client` : | a valid PkClient instance
`filters` : | a `PkBitfield` such as `PK_FILTER_ENUM_GUI` | `PK_FILTER_ENUM_FREE` or `PK_FILTER_ENUM_NONE`
`provides` : | a PkProvidesEnum value such as PK_PROVIDES_ENUM_CODEC
`values` : | a search term such as "sound/mp3". [array zero-terminated=1]
`cancellable` : | a GCancellable or `NULL`
`progress_callback` : | the function to run when the progress changes. [scope call]
`progress_user_data` : | data to pass to `progress_callback`
`error` : | the GError to store any failure, or `NULL`
Returns : | a `PkResults` object, or NULL for error. [transfer full]

Since 0.5.3