/* steam-restart-presentation.c generated by valac 0.56.19, the Vala compiler
 * generated from steam-restart-presentation.vala, do not modify */

#include "protonplus_core.h"
#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <gee.h>
#include <glib/gi18n-lib.h>
#include <libnotify/notify.h>

#if !defined(VALA_STRICT_C)
#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
#elif defined(__clang__) && (__clang_major__ >= 16)
#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
#endif
#endif

enum  {
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_0_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_TARGET_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_PENDING_COUNT_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_DOCUMENTED_REQUIREMENT_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_CONSERVATIVE_REQUIREMENT_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_main_steam_restart_target_summary_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_NUM_PROPERTIES];
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
enum  {
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_0_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_VISIBLE_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_TITLE_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_MULTIPLE_TARGETS_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_main_steam_restart_banner_state_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_NUM_PROPERTIES];
#define _g_free0(var) (var = (g_free (var), NULL))
enum  {
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_0_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_HEADING_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_BODY_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_TOAST_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_CAN_RETRY_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_main_steam_restart_message_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_NUM_PROPERTIES];
enum  {
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_PRESENTATION_0_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_PRESENTATION_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_main_steam_restart_presentation_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_PRESENTATION_NUM_PROPERTIES];
enum  {
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TOAST_POLICY_0_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TOAST_POLICY_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_main_steam_restart_toast_policy_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TOAST_POLICY_NUM_PROPERTIES];
enum  {
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_NOTIFICATION_POLICY_0_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_NOTIFICATION_POLICY_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_main_steam_restart_notification_policy_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_NOTIFICATION_POLICY_NUM_PROPERTIES];
enum  {
	PROTON_PLUS_WIDGETS_MAIN_LIBNOTIFY_STEAM_RESTART_NOTIFICATION_SENDER_0_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_LIBNOTIFY_STEAM_RESTART_NOTIFICATION_SENDER_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_main_libnotify_steam_restart_notification_sender_properties[PROTON_PLUS_WIDGETS_MAIN_LIBNOTIFY_STEAM_RESTART_NOTIFICATION_SENDER_NUM_PROPERTIES];
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
enum  {
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_NOTIFICATION_COORDINATOR_0_PROPERTY,
	PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_NOTIFICATION_COORDINATOR_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_main_steam_restart_notification_coordinator_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_NOTIFICATION_COORDINATOR_NUM_PROPERTIES];

struct _ProtonPlusWidgetsMainSteamRestartTargetSummaryPrivate {
	ProtonPlusModelsSteamRestartTarget* _target;
	guint _pending_count;
	gboolean _has_documented_requirement;
	gboolean _has_conservative_requirement;
};

struct _ProtonPlusWidgetsMainSteamRestartBannerStatePrivate {
	gboolean _visible;
	gchar* _title;
	gboolean _multiple_targets;
};

struct _ProtonPlusWidgetsMainSteamRestartMessagePrivate {
	gchar* _heading;
	gchar* _body;
	gchar* _toast;
	gboolean _can_retry;
};

struct _ProtonPlusWidgetsMainSteamRestartToastPolicyPrivate {
	gboolean initial_shown;
	gboolean multiple_shown;
};

struct _ProtonPlusWidgetsMainSteamRestartNotificationPolicyPrivate {
	gboolean initial_sent;
	gboolean aggregate_sent;
};

struct _ProtonPlusWidgetsMainSteamRestartNotificationCoordinatorPrivate {
	ProtonPlusWidgetsMainSteamRestartNotificationPolicy* policy;
	ProtonPlusWidgetsMainSteamRestartNotificationSender* sender;
};

static gint ProtonPlusWidgetsMainSteamRestartTargetSummary_private_offset;
static gpointer proton_plus_widgets_main_steam_restart_target_summary_parent_class = NULL;
static gint ProtonPlusWidgetsMainSteamRestartBannerState_private_offset;
static gpointer proton_plus_widgets_main_steam_restart_banner_state_parent_class = NULL;
static gint ProtonPlusWidgetsMainSteamRestartMessage_private_offset;
static gpointer proton_plus_widgets_main_steam_restart_message_parent_class = NULL;
static gpointer proton_plus_widgets_main_steam_restart_presentation_parent_class = NULL;
static gint ProtonPlusWidgetsMainSteamRestartToastPolicy_private_offset;
static gpointer proton_plus_widgets_main_steam_restart_toast_policy_parent_class = NULL;
static gint ProtonPlusWidgetsMainSteamRestartNotificationPolicy_private_offset;
static gpointer proton_plus_widgets_main_steam_restart_notification_policy_parent_class = NULL;
static gpointer proton_plus_widgets_main_libnotify_steam_restart_notification_sender_parent_class = NULL;
static ProtonPlusWidgetsMainSteamRestartNotificationSenderIface * proton_plus_widgets_main_libnotify_steam_restart_notification_sender_proton_plus_widgets_main_steam_restart_notification_sender_parent_iface = NULL;
static gint ProtonPlusWidgetsMainSteamRestartNotificationCoordinator_private_offset;
static gpointer proton_plus_widgets_main_steam_restart_notification_coordinator_parent_class = NULL;

static void proton_plus_widgets_main_steam_restart_target_summary_set_target (ProtonPlusWidgetsMainSteamRestartTargetSummary* self,
                                                                       ProtonPlusModelsSteamRestartTarget* value);
static void proton_plus_widgets_main_steam_restart_target_summary_set_pending_count (ProtonPlusWidgetsMainSteamRestartTargetSummary* self,
                                                                              guint value);
static void proton_plus_widgets_main_steam_restart_target_summary_set_has_documented_requirement (ProtonPlusWidgetsMainSteamRestartTargetSummary* self,
                                                                                           gboolean value);
static void proton_plus_widgets_main_steam_restart_target_summary_set_has_conservative_requirement (ProtonPlusWidgetsMainSteamRestartTargetSummary* self,
                                                                                             gboolean value);
static void proton_plus_widgets_main_steam_restart_target_summary_finalize (GObject * obj);
static GType proton_plus_widgets_main_steam_restart_target_summary_get_type_once (void);
static void _vala_proton_plus_widgets_main_steam_restart_target_summary_get_property (GObject * object,
                                                                               guint property_id,
                                                                               GValue * value,
                                                                               GParamSpec * pspec);
static void _vala_proton_plus_widgets_main_steam_restart_target_summary_set_property (GObject * object,
                                                                               guint property_id,
                                                                               const GValue * value,
                                                                               GParamSpec * pspec);
static void proton_plus_widgets_main_steam_restart_banner_state_set_visible (ProtonPlusWidgetsMainSteamRestartBannerState* self,
                                                                      gboolean value);
static void proton_plus_widgets_main_steam_restart_banner_state_set_title (ProtonPlusWidgetsMainSteamRestartBannerState* self,
                                                                    const gchar* value);
static void proton_plus_widgets_main_steam_restart_banner_state_set_multiple_targets (ProtonPlusWidgetsMainSteamRestartBannerState* self,
                                                                               gboolean value);
static void proton_plus_widgets_main_steam_restart_banner_state_finalize (GObject * obj);
static GType proton_plus_widgets_main_steam_restart_banner_state_get_type_once (void);
static void _vala_proton_plus_widgets_main_steam_restart_banner_state_get_property (GObject * object,
                                                                             guint property_id,
                                                                             GValue * value,
                                                                             GParamSpec * pspec);
static void _vala_proton_plus_widgets_main_steam_restart_banner_state_set_property (GObject * object,
                                                                             guint property_id,
                                                                             const GValue * value,
                                                                             GParamSpec * pspec);
static void proton_plus_widgets_main_steam_restart_message_set_heading (ProtonPlusWidgetsMainSteamRestartMessage* self,
                                                                 const gchar* value);
static void proton_plus_widgets_main_steam_restart_message_set_body (ProtonPlusWidgetsMainSteamRestartMessage* self,
                                                              const gchar* value);
static void proton_plus_widgets_main_steam_restart_message_set_toast (ProtonPlusWidgetsMainSteamRestartMessage* self,
                                                               const gchar* value);
static void proton_plus_widgets_main_steam_restart_message_set_can_retry (ProtonPlusWidgetsMainSteamRestartMessage* self,
                                                                   gboolean value);
static void proton_plus_widgets_main_steam_restart_message_finalize (GObject * obj);
static GType proton_plus_widgets_main_steam_restart_message_get_type_once (void);
static void _vala_proton_plus_widgets_main_steam_restart_message_get_property (GObject * object,
                                                                        guint property_id,
                                                                        GValue * value,
                                                                        GParamSpec * pspec);
static void _vala_proton_plus_widgets_main_steam_restart_message_set_property (GObject * object,
                                                                        guint property_id,
                                                                        const GValue * value,
                                                                        GParamSpec * pspec);
static gint __lambda348_ (ProtonPlusWidgetsMainSteamRestartTargetSummary* a,
                   ProtonPlusWidgetsMainSteamRestartTargetSummary* b);
static gint ___lambda348__gcompare_data_func (gconstpointer a,
                                       gconstpointer b,
                                       gpointer self);
static GType proton_plus_widgets_main_steam_restart_presentation_get_type_once (void);
static void proton_plus_widgets_main_steam_restart_toast_policy_finalize (GObject * obj);
static GType proton_plus_widgets_main_steam_restart_toast_policy_get_type_once (void);
static void proton_plus_widgets_main_steam_restart_notification_policy_finalize (GObject * obj);
static GType proton_plus_widgets_main_steam_restart_notification_policy_get_type_once (void);
static GType proton_plus_widgets_main_steam_restart_notification_sender_get_type_once (void);
static void proton_plus_widgets_main_libnotify_steam_restart_notification_sender_real_send_restart_required (ProtonPlusWidgetsMainSteamRestartNotificationSender* base,
                                                                                                      const gchar* message,
                                                                                                      GError** error);
static GType proton_plus_widgets_main_libnotify_steam_restart_notification_sender_get_type_once (void);
static void proton_plus_widgets_main_steam_restart_notification_coordinator_finalize (GObject * obj);
static GType proton_plus_widgets_main_steam_restart_notification_coordinator_get_type_once (void);

static inline gpointer
proton_plus_widgets_main_steam_restart_target_summary_get_instance_private (ProtonPlusWidgetsMainSteamRestartTargetSummary* self)
{
	return G_STRUCT_MEMBER_P (self, ProtonPlusWidgetsMainSteamRestartTargetSummary_private_offset);
}

ProtonPlusWidgetsMainSteamRestartTargetSummary*
proton_plus_widgets_main_steam_restart_target_summary_construct (GType object_type,
                                                                 ProtonPlusModelsSteamRestartTarget* target,
                                                                 guint pending_count,
                                                                 gboolean documented,
                                                                 gboolean conservative)
{
	ProtonPlusWidgetsMainSteamRestartTargetSummary * self = NULL;
	g_return_val_if_fail (target != NULL, NULL);
	self = (ProtonPlusWidgetsMainSteamRestartTargetSummary*) g_object_new (object_type, NULL);
	proton_plus_widgets_main_steam_restart_target_summary_set_target (self, target);
	proton_plus_widgets_main_steam_restart_target_summary_set_pending_count (self, pending_count);
	proton_plus_widgets_main_steam_restart_target_summary_set_has_documented_requirement (self, documented);
	proton_plus_widgets_main_steam_restart_target_summary_set_has_conservative_requirement (self, conservative);
	return self;
}

ProtonPlusWidgetsMainSteamRestartTargetSummary*
proton_plus_widgets_main_steam_restart_target_summary_new (ProtonPlusModelsSteamRestartTarget* target,
                                                           guint pending_count,
                                                           gboolean documented,
                                                           gboolean conservative)
{
	return proton_plus_widgets_main_steam_restart_target_summary_construct (PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_TARGET_SUMMARY, target, pending_count, documented, conservative);
}

ProtonPlusModelsSteamRestartTarget*
proton_plus_widgets_main_steam_restart_target_summary_get_target (ProtonPlusWidgetsMainSteamRestartTargetSummary* self)
{
	ProtonPlusModelsSteamRestartTarget* result;
	ProtonPlusModelsSteamRestartTarget* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_target;
	result = _tmp0_;
	return result;
}

static gpointer
_g_object_ref0 (gpointer self)
{
	return self ? g_object_ref (self) : NULL;
}

static void
proton_plus_widgets_main_steam_restart_target_summary_set_target (ProtonPlusWidgetsMainSteamRestartTargetSummary* self,
                                                                  ProtonPlusModelsSteamRestartTarget* value)
{
	ProtonPlusModelsSteamRestartTarget* old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_main_steam_restart_target_summary_get_target (self);
	if (old_value != value) {
		ProtonPlusModelsSteamRestartTarget* _tmp0_;
		_tmp0_ = _g_object_ref0 (value);
		_g_object_unref0 (self->priv->_target);
		self->priv->_target = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_main_steam_restart_target_summary_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_TARGET_PROPERTY]);
	}
}

guint
proton_plus_widgets_main_steam_restart_target_summary_get_pending_count (ProtonPlusWidgetsMainSteamRestartTargetSummary* self)
{
	guint result;
	g_return_val_if_fail (self != NULL, 0U);
	result = self->priv->_pending_count;
	return result;
}

static void
proton_plus_widgets_main_steam_restart_target_summary_set_pending_count (ProtonPlusWidgetsMainSteamRestartTargetSummary* self,
                                                                         guint value)
{
	guint old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_main_steam_restart_target_summary_get_pending_count (self);
	if (old_value != value) {
		self->priv->_pending_count = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_main_steam_restart_target_summary_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_PENDING_COUNT_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_main_steam_restart_target_summary_get_has_documented_requirement (ProtonPlusWidgetsMainSteamRestartTargetSummary* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_has_documented_requirement;
	return result;
}

static void
proton_plus_widgets_main_steam_restart_target_summary_set_has_documented_requirement (ProtonPlusWidgetsMainSteamRestartTargetSummary* self,
                                                                                      gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_main_steam_restart_target_summary_get_has_documented_requirement (self);
	if (old_value != value) {
		self->priv->_has_documented_requirement = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_main_steam_restart_target_summary_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_DOCUMENTED_REQUIREMENT_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_main_steam_restart_target_summary_get_has_conservative_requirement (ProtonPlusWidgetsMainSteamRestartTargetSummary* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_has_conservative_requirement;
	return result;
}

static void
proton_plus_widgets_main_steam_restart_target_summary_set_has_conservative_requirement (ProtonPlusWidgetsMainSteamRestartTargetSummary* self,
                                                                                        gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_main_steam_restart_target_summary_get_has_conservative_requirement (self);
	if (old_value != value) {
		self->priv->_has_conservative_requirement = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_main_steam_restart_target_summary_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_CONSERVATIVE_REQUIREMENT_PROPERTY]);
	}
}

static void
proton_plus_widgets_main_steam_restart_target_summary_class_init (ProtonPlusWidgetsMainSteamRestartTargetSummaryClass * klass,
                                                                  gpointer klass_data)
{
	proton_plus_widgets_main_steam_restart_target_summary_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &ProtonPlusWidgetsMainSteamRestartTargetSummary_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_proton_plus_widgets_main_steam_restart_target_summary_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_proton_plus_widgets_main_steam_restart_target_summary_set_property;
	G_OBJECT_CLASS (klass)->finalize = proton_plus_widgets_main_steam_restart_target_summary_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_TARGET_PROPERTY, proton_plus_widgets_main_steam_restart_target_summary_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_TARGET_PROPERTY] = g_param_spec_object ("target", "target", "target", PROTON_PLUS_MODELS_TYPE_STEAM_RESTART_TARGET, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_PENDING_COUNT_PROPERTY, proton_plus_widgets_main_steam_restart_target_summary_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_PENDING_COUNT_PROPERTY] = g_param_spec_uint ("pending-count", "pending-count", "pending-count", 0, G_MAXUINT, 0U, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_DOCUMENTED_REQUIREMENT_PROPERTY, proton_plus_widgets_main_steam_restart_target_summary_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_DOCUMENTED_REQUIREMENT_PROPERTY] = g_param_spec_boolean ("has-documented-requirement", "has-documented-requirement", "has-documented-requirement", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_CONSERVATIVE_REQUIREMENT_PROPERTY, proton_plus_widgets_main_steam_restart_target_summary_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_CONSERVATIVE_REQUIREMENT_PROPERTY] = g_param_spec_boolean ("has-conservative-requirement", "has-conservative-requirement", "has-conservative-requirement", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
}

static void
proton_plus_widgets_main_steam_restart_target_summary_instance_init (ProtonPlusWidgetsMainSteamRestartTargetSummary * self,
                                                                     gpointer klass)
{
	self->priv = proton_plus_widgets_main_steam_restart_target_summary_get_instance_private (self);
}

static void
proton_plus_widgets_main_steam_restart_target_summary_finalize (GObject * obj)
{
	ProtonPlusWidgetsMainSteamRestartTargetSummary * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_TARGET_SUMMARY, ProtonPlusWidgetsMainSteamRestartTargetSummary);
	_g_object_unref0 (self->priv->_target);
	G_OBJECT_CLASS (proton_plus_widgets_main_steam_restart_target_summary_parent_class)->finalize (obj);
}

static GType
proton_plus_widgets_main_steam_restart_target_summary_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsMainSteamRestartTargetSummaryClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_main_steam_restart_target_summary_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsMainSteamRestartTargetSummary), 0, (GInstanceInitFunc) proton_plus_widgets_main_steam_restart_target_summary_instance_init, NULL };
	GType proton_plus_widgets_main_steam_restart_target_summary_type_id;
	proton_plus_widgets_main_steam_restart_target_summary_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsMainSteamRestartTargetSummary", &g_define_type_info, 0);
	ProtonPlusWidgetsMainSteamRestartTargetSummary_private_offset = g_type_add_instance_private (proton_plus_widgets_main_steam_restart_target_summary_type_id, sizeof (ProtonPlusWidgetsMainSteamRestartTargetSummaryPrivate));
	return proton_plus_widgets_main_steam_restart_target_summary_type_id;
}

GType
proton_plus_widgets_main_steam_restart_target_summary_get_type (void)
{
	static volatile gsize proton_plus_widgets_main_steam_restart_target_summary_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_main_steam_restart_target_summary_type_id__once)) {
		GType proton_plus_widgets_main_steam_restart_target_summary_type_id;
		proton_plus_widgets_main_steam_restart_target_summary_type_id = proton_plus_widgets_main_steam_restart_target_summary_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_main_steam_restart_target_summary_type_id__once, proton_plus_widgets_main_steam_restart_target_summary_type_id);
	}
	return proton_plus_widgets_main_steam_restart_target_summary_type_id__once;
}

static void
_vala_proton_plus_widgets_main_steam_restart_target_summary_get_property (GObject * object,
                                                                          guint property_id,
                                                                          GValue * value,
                                                                          GParamSpec * pspec)
{
	ProtonPlusWidgetsMainSteamRestartTargetSummary * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_TARGET_SUMMARY, ProtonPlusWidgetsMainSteamRestartTargetSummary);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_TARGET_PROPERTY:
		g_value_set_object (value, proton_plus_widgets_main_steam_restart_target_summary_get_target (self));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_PENDING_COUNT_PROPERTY:
		g_value_set_uint (value, proton_plus_widgets_main_steam_restart_target_summary_get_pending_count (self));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_DOCUMENTED_REQUIREMENT_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_main_steam_restart_target_summary_get_has_documented_requirement (self));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_CONSERVATIVE_REQUIREMENT_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_main_steam_restart_target_summary_get_has_conservative_requirement (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_proton_plus_widgets_main_steam_restart_target_summary_set_property (GObject * object,
                                                                          guint property_id,
                                                                          const GValue * value,
                                                                          GParamSpec * pspec)
{
	ProtonPlusWidgetsMainSteamRestartTargetSummary * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_TARGET_SUMMARY, ProtonPlusWidgetsMainSteamRestartTargetSummary);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_TARGET_PROPERTY:
		proton_plus_widgets_main_steam_restart_target_summary_set_target (self, g_value_get_object (value));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_PENDING_COUNT_PROPERTY:
		proton_plus_widgets_main_steam_restart_target_summary_set_pending_count (self, g_value_get_uint (value));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_DOCUMENTED_REQUIREMENT_PROPERTY:
		proton_plus_widgets_main_steam_restart_target_summary_set_has_documented_requirement (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_TARGET_SUMMARY_HAS_CONSERVATIVE_REQUIREMENT_PROPERTY:
		proton_plus_widgets_main_steam_restart_target_summary_set_has_conservative_requirement (self, g_value_get_boolean (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
proton_plus_widgets_main_steam_restart_banner_state_get_instance_private (ProtonPlusWidgetsMainSteamRestartBannerState* self)
{
	return G_STRUCT_MEMBER_P (self, ProtonPlusWidgetsMainSteamRestartBannerState_private_offset);
}

ProtonPlusWidgetsMainSteamRestartBannerState*
proton_plus_widgets_main_steam_restart_banner_state_construct (GType object_type,
                                                               gboolean visible,
                                                               const gchar* title,
                                                               gboolean multiple_targets)
{
	ProtonPlusWidgetsMainSteamRestartBannerState * self = NULL;
	g_return_val_if_fail (title != NULL, NULL);
	self = (ProtonPlusWidgetsMainSteamRestartBannerState*) g_object_new (object_type, NULL);
	proton_plus_widgets_main_steam_restart_banner_state_set_visible (self, visible);
	proton_plus_widgets_main_steam_restart_banner_state_set_title (self, title);
	proton_plus_widgets_main_steam_restart_banner_state_set_multiple_targets (self, multiple_targets);
	return self;
}

ProtonPlusWidgetsMainSteamRestartBannerState*
proton_plus_widgets_main_steam_restart_banner_state_new (gboolean visible,
                                                         const gchar* title,
                                                         gboolean multiple_targets)
{
	return proton_plus_widgets_main_steam_restart_banner_state_construct (PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_BANNER_STATE, visible, title, multiple_targets);
}

gboolean
proton_plus_widgets_main_steam_restart_banner_state_get_visible (ProtonPlusWidgetsMainSteamRestartBannerState* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_visible;
	return result;
}

static void
proton_plus_widgets_main_steam_restart_banner_state_set_visible (ProtonPlusWidgetsMainSteamRestartBannerState* self,
                                                                 gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_main_steam_restart_banner_state_get_visible (self);
	if (old_value != value) {
		self->priv->_visible = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_main_steam_restart_banner_state_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_VISIBLE_PROPERTY]);
	}
}

const gchar*
proton_plus_widgets_main_steam_restart_banner_state_get_title (ProtonPlusWidgetsMainSteamRestartBannerState* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_title;
	result = _tmp0_;
	return result;
}

static void
proton_plus_widgets_main_steam_restart_banner_state_set_title (ProtonPlusWidgetsMainSteamRestartBannerState* self,
                                                               const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_main_steam_restart_banner_state_get_title (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_title);
		self->priv->_title = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_main_steam_restart_banner_state_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_TITLE_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_main_steam_restart_banner_state_get_multiple_targets (ProtonPlusWidgetsMainSteamRestartBannerState* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_multiple_targets;
	return result;
}

static void
proton_plus_widgets_main_steam_restart_banner_state_set_multiple_targets (ProtonPlusWidgetsMainSteamRestartBannerState* self,
                                                                          gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_main_steam_restart_banner_state_get_multiple_targets (self);
	if (old_value != value) {
		self->priv->_multiple_targets = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_main_steam_restart_banner_state_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_MULTIPLE_TARGETS_PROPERTY]);
	}
}

static void
proton_plus_widgets_main_steam_restart_banner_state_class_init (ProtonPlusWidgetsMainSteamRestartBannerStateClass * klass,
                                                                gpointer klass_data)
{
	proton_plus_widgets_main_steam_restart_banner_state_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &ProtonPlusWidgetsMainSteamRestartBannerState_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_proton_plus_widgets_main_steam_restart_banner_state_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_proton_plus_widgets_main_steam_restart_banner_state_set_property;
	G_OBJECT_CLASS (klass)->finalize = proton_plus_widgets_main_steam_restart_banner_state_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_VISIBLE_PROPERTY, proton_plus_widgets_main_steam_restart_banner_state_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_VISIBLE_PROPERTY] = g_param_spec_boolean ("visible", "visible", "visible", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_TITLE_PROPERTY, proton_plus_widgets_main_steam_restart_banner_state_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_TITLE_PROPERTY] = g_param_spec_string ("title", "title", "title", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_MULTIPLE_TARGETS_PROPERTY, proton_plus_widgets_main_steam_restart_banner_state_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_MULTIPLE_TARGETS_PROPERTY] = g_param_spec_boolean ("multiple-targets", "multiple-targets", "multiple-targets", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
}

static void
proton_plus_widgets_main_steam_restart_banner_state_instance_init (ProtonPlusWidgetsMainSteamRestartBannerState * self,
                                                                   gpointer klass)
{
	self->priv = proton_plus_widgets_main_steam_restart_banner_state_get_instance_private (self);
}

static void
proton_plus_widgets_main_steam_restart_banner_state_finalize (GObject * obj)
{
	ProtonPlusWidgetsMainSteamRestartBannerState * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_BANNER_STATE, ProtonPlusWidgetsMainSteamRestartBannerState);
	_g_free0 (self->priv->_title);
	G_OBJECT_CLASS (proton_plus_widgets_main_steam_restart_banner_state_parent_class)->finalize (obj);
}

static GType
proton_plus_widgets_main_steam_restart_banner_state_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsMainSteamRestartBannerStateClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_main_steam_restart_banner_state_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsMainSteamRestartBannerState), 0, (GInstanceInitFunc) proton_plus_widgets_main_steam_restart_banner_state_instance_init, NULL };
	GType proton_plus_widgets_main_steam_restart_banner_state_type_id;
	proton_plus_widgets_main_steam_restart_banner_state_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsMainSteamRestartBannerState", &g_define_type_info, 0);
	ProtonPlusWidgetsMainSteamRestartBannerState_private_offset = g_type_add_instance_private (proton_plus_widgets_main_steam_restart_banner_state_type_id, sizeof (ProtonPlusWidgetsMainSteamRestartBannerStatePrivate));
	return proton_plus_widgets_main_steam_restart_banner_state_type_id;
}

GType
proton_plus_widgets_main_steam_restart_banner_state_get_type (void)
{
	static volatile gsize proton_plus_widgets_main_steam_restart_banner_state_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_main_steam_restart_banner_state_type_id__once)) {
		GType proton_plus_widgets_main_steam_restart_banner_state_type_id;
		proton_plus_widgets_main_steam_restart_banner_state_type_id = proton_plus_widgets_main_steam_restart_banner_state_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_main_steam_restart_banner_state_type_id__once, proton_plus_widgets_main_steam_restart_banner_state_type_id);
	}
	return proton_plus_widgets_main_steam_restart_banner_state_type_id__once;
}

static void
_vala_proton_plus_widgets_main_steam_restart_banner_state_get_property (GObject * object,
                                                                        guint property_id,
                                                                        GValue * value,
                                                                        GParamSpec * pspec)
{
	ProtonPlusWidgetsMainSteamRestartBannerState * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_BANNER_STATE, ProtonPlusWidgetsMainSteamRestartBannerState);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_VISIBLE_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_main_steam_restart_banner_state_get_visible (self));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_TITLE_PROPERTY:
		g_value_set_string (value, proton_plus_widgets_main_steam_restart_banner_state_get_title (self));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_MULTIPLE_TARGETS_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_main_steam_restart_banner_state_get_multiple_targets (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_proton_plus_widgets_main_steam_restart_banner_state_set_property (GObject * object,
                                                                        guint property_id,
                                                                        const GValue * value,
                                                                        GParamSpec * pspec)
{
	ProtonPlusWidgetsMainSteamRestartBannerState * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_BANNER_STATE, ProtonPlusWidgetsMainSteamRestartBannerState);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_VISIBLE_PROPERTY:
		proton_plus_widgets_main_steam_restart_banner_state_set_visible (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_TITLE_PROPERTY:
		proton_plus_widgets_main_steam_restart_banner_state_set_title (self, g_value_get_string (value));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_BANNER_STATE_MULTIPLE_TARGETS_PROPERTY:
		proton_plus_widgets_main_steam_restart_banner_state_set_multiple_targets (self, g_value_get_boolean (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
proton_plus_widgets_main_steam_restart_message_get_instance_private (ProtonPlusWidgetsMainSteamRestartMessage* self)
{
	return G_STRUCT_MEMBER_P (self, ProtonPlusWidgetsMainSteamRestartMessage_private_offset);
}

ProtonPlusWidgetsMainSteamRestartMessage*
proton_plus_widgets_main_steam_restart_message_construct (GType object_type,
                                                          const gchar* heading,
                                                          const gchar* body,
                                                          const gchar* toast,
                                                          gboolean can_retry)
{
	ProtonPlusWidgetsMainSteamRestartMessage * self = NULL;
	self = (ProtonPlusWidgetsMainSteamRestartMessage*) g_object_new (object_type, NULL);
	proton_plus_widgets_main_steam_restart_message_set_heading (self, heading);
	proton_plus_widgets_main_steam_restart_message_set_body (self, body);
	proton_plus_widgets_main_steam_restart_message_set_toast (self, toast);
	proton_plus_widgets_main_steam_restart_message_set_can_retry (self, can_retry);
	return self;
}

ProtonPlusWidgetsMainSteamRestartMessage*
proton_plus_widgets_main_steam_restart_message_new (const gchar* heading,
                                                    const gchar* body,
                                                    const gchar* toast,
                                                    gboolean can_retry)
{
	return proton_plus_widgets_main_steam_restart_message_construct (PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_MESSAGE, heading, body, toast, can_retry);
}

const gchar*
proton_plus_widgets_main_steam_restart_message_get_heading (ProtonPlusWidgetsMainSteamRestartMessage* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_heading;
	result = _tmp0_;
	return result;
}

static void
proton_plus_widgets_main_steam_restart_message_set_heading (ProtonPlusWidgetsMainSteamRestartMessage* self,
                                                            const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_main_steam_restart_message_get_heading (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_heading);
		self->priv->_heading = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_main_steam_restart_message_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_HEADING_PROPERTY]);
	}
}

const gchar*
proton_plus_widgets_main_steam_restart_message_get_body (ProtonPlusWidgetsMainSteamRestartMessage* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_body;
	result = _tmp0_;
	return result;
}

static void
proton_plus_widgets_main_steam_restart_message_set_body (ProtonPlusWidgetsMainSteamRestartMessage* self,
                                                         const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_main_steam_restart_message_get_body (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_body);
		self->priv->_body = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_main_steam_restart_message_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_BODY_PROPERTY]);
	}
}

const gchar*
proton_plus_widgets_main_steam_restart_message_get_toast (ProtonPlusWidgetsMainSteamRestartMessage* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_toast;
	result = _tmp0_;
	return result;
}

static void
proton_plus_widgets_main_steam_restart_message_set_toast (ProtonPlusWidgetsMainSteamRestartMessage* self,
                                                          const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_main_steam_restart_message_get_toast (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_toast);
		self->priv->_toast = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_main_steam_restart_message_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_TOAST_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_main_steam_restart_message_get_can_retry (ProtonPlusWidgetsMainSteamRestartMessage* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_can_retry;
	return result;
}

static void
proton_plus_widgets_main_steam_restart_message_set_can_retry (ProtonPlusWidgetsMainSteamRestartMessage* self,
                                                              gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_main_steam_restart_message_get_can_retry (self);
	if (old_value != value) {
		self->priv->_can_retry = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_main_steam_restart_message_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_CAN_RETRY_PROPERTY]);
	}
}

static void
proton_plus_widgets_main_steam_restart_message_class_init (ProtonPlusWidgetsMainSteamRestartMessageClass * klass,
                                                           gpointer klass_data)
{
	proton_plus_widgets_main_steam_restart_message_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &ProtonPlusWidgetsMainSteamRestartMessage_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_proton_plus_widgets_main_steam_restart_message_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_proton_plus_widgets_main_steam_restart_message_set_property;
	G_OBJECT_CLASS (klass)->finalize = proton_plus_widgets_main_steam_restart_message_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_HEADING_PROPERTY, proton_plus_widgets_main_steam_restart_message_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_HEADING_PROPERTY] = g_param_spec_string ("heading", "heading", "heading", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_BODY_PROPERTY, proton_plus_widgets_main_steam_restart_message_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_BODY_PROPERTY] = g_param_spec_string ("body", "body", "body", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_TOAST_PROPERTY, proton_plus_widgets_main_steam_restart_message_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_TOAST_PROPERTY] = g_param_spec_string ("toast", "toast", "toast", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_CAN_RETRY_PROPERTY, proton_plus_widgets_main_steam_restart_message_properties[PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_CAN_RETRY_PROPERTY] = g_param_spec_boolean ("can-retry", "can-retry", "can-retry", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE));
}

static void
proton_plus_widgets_main_steam_restart_message_instance_init (ProtonPlusWidgetsMainSteamRestartMessage * self,
                                                              gpointer klass)
{
	self->priv = proton_plus_widgets_main_steam_restart_message_get_instance_private (self);
}

static void
proton_plus_widgets_main_steam_restart_message_finalize (GObject * obj)
{
	ProtonPlusWidgetsMainSteamRestartMessage * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_MESSAGE, ProtonPlusWidgetsMainSteamRestartMessage);
	_g_free0 (self->priv->_heading);
	_g_free0 (self->priv->_body);
	_g_free0 (self->priv->_toast);
	G_OBJECT_CLASS (proton_plus_widgets_main_steam_restart_message_parent_class)->finalize (obj);
}

static GType
proton_plus_widgets_main_steam_restart_message_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsMainSteamRestartMessageClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_main_steam_restart_message_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsMainSteamRestartMessage), 0, (GInstanceInitFunc) proton_plus_widgets_main_steam_restart_message_instance_init, NULL };
	GType proton_plus_widgets_main_steam_restart_message_type_id;
	proton_plus_widgets_main_steam_restart_message_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsMainSteamRestartMessage", &g_define_type_info, 0);
	ProtonPlusWidgetsMainSteamRestartMessage_private_offset = g_type_add_instance_private (proton_plus_widgets_main_steam_restart_message_type_id, sizeof (ProtonPlusWidgetsMainSteamRestartMessagePrivate));
	return proton_plus_widgets_main_steam_restart_message_type_id;
}

GType
proton_plus_widgets_main_steam_restart_message_get_type (void)
{
	static volatile gsize proton_plus_widgets_main_steam_restart_message_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_main_steam_restart_message_type_id__once)) {
		GType proton_plus_widgets_main_steam_restart_message_type_id;
		proton_plus_widgets_main_steam_restart_message_type_id = proton_plus_widgets_main_steam_restart_message_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_main_steam_restart_message_type_id__once, proton_plus_widgets_main_steam_restart_message_type_id);
	}
	return proton_plus_widgets_main_steam_restart_message_type_id__once;
}

static void
_vala_proton_plus_widgets_main_steam_restart_message_get_property (GObject * object,
                                                                   guint property_id,
                                                                   GValue * value,
                                                                   GParamSpec * pspec)
{
	ProtonPlusWidgetsMainSteamRestartMessage * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_MESSAGE, ProtonPlusWidgetsMainSteamRestartMessage);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_HEADING_PROPERTY:
		g_value_set_string (value, proton_plus_widgets_main_steam_restart_message_get_heading (self));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_BODY_PROPERTY:
		g_value_set_string (value, proton_plus_widgets_main_steam_restart_message_get_body (self));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_TOAST_PROPERTY:
		g_value_set_string (value, proton_plus_widgets_main_steam_restart_message_get_toast (self));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_CAN_RETRY_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_main_steam_restart_message_get_can_retry (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_proton_plus_widgets_main_steam_restart_message_set_property (GObject * object,
                                                                   guint property_id,
                                                                   const GValue * value,
                                                                   GParamSpec * pspec)
{
	ProtonPlusWidgetsMainSteamRestartMessage * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_MESSAGE, ProtonPlusWidgetsMainSteamRestartMessage);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_HEADING_PROPERTY:
		proton_plus_widgets_main_steam_restart_message_set_heading (self, g_value_get_string (value));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_BODY_PROPERTY:
		proton_plus_widgets_main_steam_restart_message_set_body (self, g_value_get_string (value));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_TOAST_PROPERTY:
		proton_plus_widgets_main_steam_restart_message_set_toast (self, g_value_get_string (value));
		break;
		case PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_MESSAGE_CAN_RETRY_PROPERTY:
		proton_plus_widgets_main_steam_restart_message_set_can_retry (self, g_value_get_boolean (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static gint
__lambda348_ (ProtonPlusWidgetsMainSteamRestartTargetSummary* a,
              ProtonPlusWidgetsMainSteamRestartTargetSummary* b)
{
	gint by_name = 0;
	GCompareFunc _tmp0_;
	ProtonPlusModelsSteamRestartTarget* _tmp1_;
	ProtonPlusModelsSteamRestartTarget* _tmp2_;
	const gchar* _tmp3_;
	const gchar* _tmp4_;
	ProtonPlusModelsSteamRestartTarget* _tmp5_;
	ProtonPlusModelsSteamRestartTarget* _tmp6_;
	const gchar* _tmp7_;
	const gchar* _tmp8_;
	gint _tmp9_ = 0;
	gint result;
	g_return_val_if_fail (a != NULL, -1);
	g_return_val_if_fail (b != NULL, -1);
	_tmp0_ = ((GCompareFunc) g_strcmp0);
	_tmp1_ = proton_plus_widgets_main_steam_restart_target_summary_get_target (a);
	_tmp2_ = _tmp1_;
	_tmp3_ = proton_plus_models_steam_restart_target_get_display_name (_tmp2_);
	_tmp4_ = _tmp3_;
	_tmp5_ = proton_plus_widgets_main_steam_restart_target_summary_get_target (b);
	_tmp6_ = _tmp5_;
	_tmp7_ = proton_plus_models_steam_restart_target_get_display_name (_tmp6_);
	_tmp8_ = _tmp7_;
	by_name = _tmp0_ (_tmp4_, _tmp8_);
	if (by_name != 0) {
		_tmp9_ = by_name;
	} else {
		GCompareFunc _tmp10_;
		ProtonPlusModelsSteamRestartTarget* _tmp11_;
		ProtonPlusModelsSteamRestartTarget* _tmp12_;
		const gchar* _tmp13_;
		const gchar* _tmp14_;
		ProtonPlusModelsSteamRestartTarget* _tmp15_;
		ProtonPlusModelsSteamRestartTarget* _tmp16_;
		const gchar* _tmp17_;
		const gchar* _tmp18_;
		_tmp10_ = ((GCompareFunc) g_strcmp0);
		_tmp11_ = proton_plus_widgets_main_steam_restart_target_summary_get_target (a);
		_tmp12_ = _tmp11_;
		_tmp13_ = proton_plus_models_steam_restart_target_get_id (_tmp12_);
		_tmp14_ = _tmp13_;
		_tmp15_ = proton_plus_widgets_main_steam_restart_target_summary_get_target (b);
		_tmp16_ = _tmp15_;
		_tmp17_ = proton_plus_models_steam_restart_target_get_id (_tmp16_);
		_tmp18_ = _tmp17_;
		_tmp9_ = _tmp10_ (_tmp14_, _tmp18_);
	}
	result = _tmp9_;
	return result;
}

static gint
___lambda348__gcompare_data_func (gconstpointer a,
                                  gconstpointer b,
                                  gpointer self)
{
	gint result;
	result = __lambda348_ ((ProtonPlusWidgetsMainSteamRestartTargetSummary*) a, (ProtonPlusWidgetsMainSteamRestartTargetSummary*) b);
	return result;
}

GeeList*
proton_plus_widgets_main_steam_restart_presentation_summarize (GeeList* records)
{
	GeeHashMap* counts = NULL;
	GeeHashMap* _tmp0_;
	GeeHashMap* targets = NULL;
	GeeHashMap* _tmp1_;
	GeeHashMap* documented = NULL;
	GeeHashMap* _tmp2_;
	GeeHashMap* conservative = NULL;
	GeeHashMap* _tmp3_;
	GeeArrayList* summaries = NULL;
	GeeArrayList* _tmp40_;
	GeeArrayList* _tmp66_;
	GeeList* result;
	g_return_val_if_fail (records != NULL, NULL);
	_tmp0_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, G_TYPE_UINT, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
	counts = _tmp0_;
	_tmp1_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, PROTON_PLUS_MODELS_TYPE_STEAM_RESTART_TARGET, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
	targets = _tmp1_;
	_tmp2_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, G_TYPE_BOOLEAN, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
	documented = _tmp2_;
	_tmp3_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, G_TYPE_BOOLEAN, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
	conservative = _tmp3_;
	{
		GeeList* _record_list = NULL;
		gint _record_size = 0;
		GeeList* _tmp4_;
		gint _tmp5_;
		gint _tmp6_;
		gint _record_index = 0;
		_record_list = records;
		_tmp4_ = _record_list;
		_tmp5_ = gee_collection_get_size ((GeeCollection*) _tmp4_);
		_tmp6_ = _tmp5_;
		_record_size = _tmp6_;
		_record_index = -1;
		while (TRUE) {
			gint _tmp7_;
			gint _tmp8_;
			ProtonPlusModelsSteamRestartPendingRecord* record = NULL;
			GeeList* _tmp9_;
			gpointer _tmp10_;
			gchar* id = NULL;
			ProtonPlusModelsSteamRestartPendingRecord* _tmp11_;
			ProtonPlusModelsSteamChangeReceipt* _tmp12_;
			ProtonPlusModelsSteamChangeReceipt* _tmp13_;
			ProtonPlusModelsSteamRestartTarget* _tmp14_;
			ProtonPlusModelsSteamRestartTarget* _tmp15_;
			const gchar* _tmp16_;
			const gchar* _tmp17_;
			gchar* _tmp18_;
			GeeHashMap* _tmp19_;
			const gchar* _tmp20_;
			GeeHashMap* _tmp21_;
			const gchar* _tmp22_;
			gpointer _tmp23_;
			GeeHashMap* _tmp24_;
			const gchar* _tmp25_;
			ProtonPlusModelsSteamRestartPendingRecord* _tmp26_;
			ProtonPlusModelsSteamChangeReceipt* _tmp27_;
			ProtonPlusModelsSteamChangeReceipt* _tmp28_;
			ProtonPlusModelsSteamRestartTarget* _tmp29_;
			ProtonPlusModelsSteamRestartTarget* _tmp30_;
			ProtonPlusModelsSteamRestartPendingRecord* _tmp31_;
			ProtonPlusModelsSteamChangeReceipt* _tmp32_;
			ProtonPlusModelsSteamChangeReceipt* _tmp33_;
			ProtonPlusModelsSteamRestartRequirement _tmp34_;
			ProtonPlusModelsSteamRestartRequirement _tmp35_;
			_record_index = _record_index + 1;
			_tmp7_ = _record_index;
			_tmp8_ = _record_size;
			if (!(_tmp7_ < _tmp8_)) {
				break;
			}
			_tmp9_ = _record_list;
			_tmp10_ = gee_list_get (_tmp9_, _record_index);
			record = (ProtonPlusModelsSteamRestartPendingRecord*) _tmp10_;
			_tmp11_ = record;
			_tmp12_ = proton_plus_models_steam_restart_pending_record_get_receipt (_tmp11_);
			_tmp13_ = _tmp12_;
			_tmp14_ = proton_plus_models_steam_change_receipt_get_target (_tmp13_);
			_tmp15_ = _tmp14_;
			_tmp16_ = proton_plus_models_steam_restart_target_get_id (_tmp15_);
			_tmp17_ = _tmp16_;
			_tmp18_ = g_strdup (_tmp17_);
			id = _tmp18_;
			_tmp19_ = counts;
			_tmp20_ = id;
			_tmp21_ = counts;
			_tmp22_ = id;
			_tmp23_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp21_, _tmp22_);
			gee_abstract_map_set ((GeeAbstractMap*) _tmp19_, _tmp20_, (gpointer) ((guintptr) (((guint) ((guintptr) _tmp23_)) + 1)));
			_tmp24_ = targets;
			_tmp25_ = id;
			_tmp26_ = record;
			_tmp27_ = proton_plus_models_steam_restart_pending_record_get_receipt (_tmp26_);
			_tmp28_ = _tmp27_;
			_tmp29_ = proton_plus_models_steam_change_receipt_get_target (_tmp28_);
			_tmp30_ = _tmp29_;
			gee_abstract_map_set ((GeeAbstractMap*) _tmp24_, _tmp25_, _tmp30_);
			_tmp31_ = record;
			_tmp32_ = proton_plus_models_steam_restart_pending_record_get_receipt (_tmp31_);
			_tmp33_ = _tmp32_;
			_tmp34_ = proton_plus_models_steam_change_receipt_get_restart_requirement (_tmp33_);
			_tmp35_ = _tmp34_;
			if (_tmp35_ == PROTON_PLUS_MODELS_STEAM_RESTART_REQUIREMENT_DOCUMENTED) {
				GeeHashMap* _tmp36_;
				const gchar* _tmp37_;
				_tmp36_ = documented;
				_tmp37_ = id;
				gee_abstract_map_set ((GeeAbstractMap*) _tmp36_, _tmp37_, (gpointer) ((gintptr) TRUE));
			} else {
				GeeHashMap* _tmp38_;
				const gchar* _tmp39_;
				_tmp38_ = conservative;
				_tmp39_ = id;
				gee_abstract_map_set ((GeeAbstractMap*) _tmp38_, _tmp39_, (gpointer) ((gintptr) TRUE));
			}
			_g_free0 (id);
			_g_object_unref0 (record);
		}
	}
	_tmp40_ = gee_array_list_new (PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_TARGET_SUMMARY, (GBoxedCopyFunc) g_object_ref, (GDestroyNotify) g_object_unref, NULL, NULL, NULL);
	summaries = _tmp40_;
	{
		GeeIterator* _id_it = NULL;
		GeeHashMap* _tmp41_;
		GeeSet* _tmp42_;
		GeeSet* _tmp43_;
		GeeSet* _tmp44_;
		GeeIterator* _tmp45_;
		GeeIterator* _tmp46_;
		_tmp41_ = targets;
		_tmp42_ = gee_abstract_map_get_keys ((GeeAbstractMap*) _tmp41_);
		_tmp43_ = _tmp42_;
		_tmp44_ = _tmp43_;
		_tmp45_ = gee_iterable_iterator ((GeeIterable*) _tmp44_);
		_tmp46_ = _tmp45_;
		_g_object_unref0 (_tmp44_);
		_id_it = _tmp46_;
		while (TRUE) {
			GeeIterator* _tmp47_;
			gchar* id = NULL;
			GeeIterator* _tmp48_;
			gpointer _tmp49_;
			GeeArrayList* _tmp50_;
			GeeHashMap* _tmp51_;
			const gchar* _tmp52_;
			gpointer _tmp53_;
			ProtonPlusModelsSteamRestartTarget* _tmp54_;
			GeeHashMap* _tmp55_;
			const gchar* _tmp56_;
			gpointer _tmp57_;
			GeeHashMap* _tmp58_;
			const gchar* _tmp59_;
			gpointer _tmp60_;
			GeeHashMap* _tmp61_;
			const gchar* _tmp62_;
			gpointer _tmp63_;
			ProtonPlusWidgetsMainSteamRestartTargetSummary* _tmp64_;
			ProtonPlusWidgetsMainSteamRestartTargetSummary* _tmp65_;
			_tmp47_ = _id_it;
			if (!gee_iterator_next (_tmp47_)) {
				break;
			}
			_tmp48_ = _id_it;
			_tmp49_ = gee_iterator_get (_tmp48_);
			id = (gchar*) _tmp49_;
			_tmp50_ = summaries;
			_tmp51_ = targets;
			_tmp52_ = id;
			_tmp53_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp51_, _tmp52_);
			_tmp54_ = (ProtonPlusModelsSteamRestartTarget*) _tmp53_;
			_tmp55_ = counts;
			_tmp56_ = id;
			_tmp57_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp55_, _tmp56_);
			_tmp58_ = documented;
			_tmp59_ = id;
			_tmp60_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp58_, _tmp59_);
			_tmp61_ = conservative;
			_tmp62_ = id;
			_tmp63_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp61_, _tmp62_);
			_tmp64_ = proton_plus_widgets_main_steam_restart_target_summary_new (_tmp54_, (guint) ((guintptr) _tmp57_), (gboolean) ((gintptr) _tmp60_), (gboolean) ((gintptr) _tmp63_));
			_tmp65_ = _tmp64_;
			gee_abstract_collection_add ((GeeAbstractCollection*) _tmp50_, _tmp65_);
			_g_object_unref0 (_tmp65_);
			_g_object_unref0 (_tmp54_);
			_g_free0 (id);
		}
		_g_object_unref0 (_id_it);
	}
	_tmp66_ = summaries;
	gee_list_sort ((GeeList*) _tmp66_, ___lambda348__gcompare_data_func, NULL, NULL);
	result = (GeeList*) summaries;
	_g_object_unref0 (conservative);
	_g_object_unref0 (documented);
	_g_object_unref0 (targets);
	_g_object_unref0 (counts);
	return result;
}

ProtonPlusWidgetsMainSteamRestartBannerState*
proton_plus_widgets_main_steam_restart_presentation_banner_state (GeeList* records)
{
	gint count = 0;
	gint _tmp0_;
	gint _tmp1_;
	GeeList* targets = NULL;
	GeeList* _tmp3_;
	GeeList* _tmp4_;
	gint _tmp5_;
	gint _tmp6_;
	gchar* _tmp11_;
	gchar* _tmp12_;
	ProtonPlusWidgetsMainSteamRestartBannerState* _tmp13_;
	ProtonPlusWidgetsMainSteamRestartBannerState* _tmp14_;
	ProtonPlusWidgetsMainSteamRestartBannerState* result;
	g_return_val_if_fail (records != NULL, NULL);
	_tmp0_ = gee_collection_get_size ((GeeCollection*) records);
	_tmp1_ = _tmp0_;
	count = _tmp1_;
	if (count == 0) {
		ProtonPlusWidgetsMainSteamRestartBannerState* _tmp2_;
		_tmp2_ = proton_plus_widgets_main_steam_restart_banner_state_new (FALSE, "", FALSE);
		result = _tmp2_;
		return result;
	}
	_tmp3_ = proton_plus_widgets_main_steam_restart_presentation_summarize (records);
	targets = _tmp3_;
	_tmp4_ = targets;
	_tmp5_ = gee_collection_get_size ((GeeCollection*) _tmp4_);
	_tmp6_ = _tmp5_;
	if (_tmp6_ > 1) {
		gchar* _tmp7_;
		gchar* _tmp8_;
		ProtonPlusWidgetsMainSteamRestartBannerState* _tmp9_;
		ProtonPlusWidgetsMainSteamRestartBannerState* _tmp10_;
		_tmp7_ = g_strdup_printf (ngettext ("Steam restarts are needed to apply %u change", "Steam restarts are needed to apply %u changes", (gulong) count), (guint) count);
		_tmp8_ = _tmp7_;
		_tmp9_ = proton_plus_widgets_main_steam_restart_banner_state_new (TRUE, _tmp8_, TRUE);
		_tmp10_ = _tmp9_;
		_g_free0 (_tmp8_);
		result = _tmp10_;
		_g_object_unref0 (targets);
		return result;
	}
	_tmp11_ = g_strdup_printf (ngettext ("Restart Steam to apply %u change", "Restart Steam to apply %u changes", (gulong) count), (guint) count);
	_tmp12_ = _tmp11_;
	_tmp13_ = proton_plus_widgets_main_steam_restart_banner_state_new (TRUE, _tmp12_, FALSE);
	_tmp14_ = _tmp13_;
	_g_free0 (_tmp12_);
	result = _tmp14_;
	_g_object_unref0 (targets);
	return result;
}

gchar*
proton_plus_widgets_main_steam_restart_presentation_requirement_explanation (ProtonPlusWidgetsMainSteamRestartTargetSummary* summary)
{
	gboolean _tmp0_;
	gboolean _tmp1_;
	gchar* _tmp6_;
	gchar* result;
	g_return_val_if_fail (summary != NULL, NULL);
	_tmp0_ = proton_plus_widgets_main_steam_restart_target_summary_get_has_documented_requirement (summary);
	_tmp1_ = _tmp0_;
	if (_tmp1_) {
		const gchar* _tmp2_ = NULL;
		gboolean _tmp3_;
		gboolean _tmp4_;
		gchar* _tmp5_;
		_tmp3_ = proton_plus_widgets_main_steam_restart_target_summary_get_has_conservative_requirement (summary);
		_tmp4_ = _tmp3_;
		if (_tmp4_) {
			_tmp2_ = _ ("Steam must restart to detect a newly installed compatibility tool. Oth" \
"er pending changes will be applied at the same time.");
		} else {
			_tmp2_ = _ ("Steam must restart to detect a newly installed compatibility tool.");
		}
		_tmp5_ = g_strdup (_tmp2_);
		result = _tmp5_;
		return result;
	}
	_tmp6_ = g_strdup (_ ("Restarting Steam lets it safely reload the changed configuration."));
	result = _tmp6_;
	return result;
}

gchar*
proton_plus_widgets_main_steam_restart_presentation_progress_title (ProtonPlusModelsSteamRestartOperationState state)
{
	gchar* result;
	switch (state) {
		case PROTON_PLUS_MODELS_STEAM_RESTART_OPERATION_STATE_PREFLIGHT:
		{
			gchar* _tmp0_;
			_tmp0_ = g_strdup (_ ("Checking Steam…"));
			result = _tmp0_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_OPERATION_STATE_REQUESTING_SHUTDOWN:
		{
			gchar* _tmp1_;
			_tmp1_ = g_strdup (_ ("Closing Steam…"));
			result = _tmp1_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_OPERATION_STATE_WAITING_FOR_EXIT:
		{
			gchar* _tmp2_;
			_tmp2_ = g_strdup (_ ("Waiting for Steam to close…"));
			result = _tmp2_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_OPERATION_STATE_APPLYING_CHANGES:
		{
			gchar* _tmp3_;
			_tmp3_ = g_strdup (_ ("Applying changes…"));
			result = _tmp3_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_OPERATION_STATE_LAUNCHING:
		{
			gchar* _tmp4_;
			_tmp4_ = g_strdup (_ ("Starting Steam…"));
			result = _tmp4_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_OPERATION_STATE_WAITING_FOR_START:
		{
			gchar* _tmp5_;
			_tmp5_ = g_strdup (_ ("Waiting for Steam to start…"));
			result = _tmp5_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_OPERATION_STATE_STEAMOS_HANDOFF_REQUESTED:
		{
			gchar* _tmp6_;
			_tmp6_ = g_strdup (_ ("SteamOS is restarting Steam"));
			result = _tmp6_;
			return result;
		}
		default:
		{
			gchar* _tmp7_;
			_tmp7_ = g_strdup ("");
			result = _tmp7_;
			return result;
		}
	}
}

ProtonPlusWidgetsMainSteamRestartMessage*
proton_plus_widgets_main_steam_restart_presentation_failure_message (ProtonPlusModelsSteamRestartFailureReason reason,
                                                                     gboolean steam_stopped)
{
	ProtonPlusWidgetsMainSteamRestartMessage* result;
	switch (reason) {
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_NO_PENDING_CHANGES:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp0_;
			_tmp0_ = proton_plus_widgets_main_steam_restart_message_new (NULL, NULL, _ ("Steam no longer needs to restart"), FALSE);
			result = _tmp0_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_ALREADY_IN_PROGRESS:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp1_;
			_tmp1_ = proton_plus_widgets_main_steam_restart_message_new (NULL, NULL, NULL, FALSE);
			result = _tmp1_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_TARGET_SNAPSHOT_MISMATCH:
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_STATE_UNKNOWN_OR_AMBIGUOUS:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp2_;
			_tmp2_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Steam status couldn’t be confirmed"), _ ("ProtonPlus did not restart Steam. Try again or restart it manually."), NULL, FALSE);
			result = _tmp2_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_STEAM_STARTING:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp3_;
			_tmp3_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Steam is still starting"), _ ("Wait for Steam to finish starting, then try again."), NULL, TRUE);
			result = _tmp3_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_STEAM_UPDATING:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp4_;
			_tmp4_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Steam is updating"), _ ("Wait until the update finishes, then try again."), NULL, TRUE);
			result = _tmp4_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_STEAMOS_GAMING_MODE:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp5_;
			_tmp5_ = proton_plus_widgets_main_steam_restart_message_new (_ ("SteamOS handoff isn’t available"), _ ("ProtonPlus can hand off only a confirmed running native Steam session." \
" Switch to Desktop Mode to apply this pending restart."), NULL, FALSE);
			result = _tmp5_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_STEAMOS_CONFIGURATION_REQUIRES_DESKTOP_MODE:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp6_;
			_tmp6_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Switch to Desktop Mode"), _ ("Steam-owned configuration is staged and must be applied while Steam is" \
" stopped. SteamOS Gaming Mode would close ProtonPlus before it can per" \
"form that step. Switch to Desktop Mode, open ProtonPlus, and restart S" \
"team there."), NULL, FALSE);
			result = _tmp6_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_GAME_OR_COMPATIBILITY_PROCESS:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp7_;
			_tmp7_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Close running games first"), _ ("ProtonPlus will not restart Steam while a game or compatibility proces" \
"s is running."), NULL, FALSE);
			result = _tmp7_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_SESSION_BLOCKER:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp8_;
			_tmp8_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Steam can’t restart right now"), _ ("Finish the current Steam activity, then try again."), NULL, TRUE);
			result = _tmp8_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_GRACEFUL_SHUTDOWN_UNSUPPORTED:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp9_;
			_tmp9_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Close Steam manually"), _ ("ProtonPlus cannot safely close this Steam installation automatically. " \
"The reminder will remain and ProtonPlus will detect when Steam closes." \
" After closing Steam, select Restart Steam again to reopen it."), NULL, FALSE);
			result = _tmp9_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_GRACEFUL_SHUTDOWN_FAILED:
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_EXIT_TIMEOUT:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp10_;
			_tmp10_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Steam didn’t close"), _ ("No force termination was attempted. Close Steam manually or try again."), NULL, TRUE);
			result = _tmp10_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_RELAUNCH_UNAVAILABLE:
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_RELAUNCH_FAILED:
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_START_TIMEOUT:
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_NEW_SESSION_UNCONFIRMED:
		{
			const gchar* _tmp11_ = NULL;
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp12_;
			if (steam_stopped) {
				_tmp11_ = _ ("Steam is currently closed. Start it manually. ProtonPlus will keep the" \
" reminder until it confirms a new session.");
			} else {
				_tmp11_ = _ ("Start Steam manually. ProtonPlus will keep the reminder until it confi" \
"rms a new session.");
			}
			_tmp12_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Steam couldn’t be reopened"), _tmp11_, NULL, FALSE);
			result = _tmp12_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_CONFIGURATION_RECONCILIATION_FAILED:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp13_;
			_tmp13_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Steam changes need attention"), _ ("Steam is closed. ProtonPlus could not safely apply every pending chang" \
"e; retry or start Steam manually after resolving the conflict."), NULL, TRUE);
			result = _tmp13_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_CANCELLED:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp14_;
			_tmp14_ = proton_plus_widgets_main_steam_restart_message_new (NULL, NULL, _ ("Steam restart was cancelled"), FALSE);
			result = _tmp14_;
			return result;
		}
		case PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_PENDING_STATE_PERSISTENCE_FAILED:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp15_;
			_tmp15_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Steam restarted"), _ ("Steam restarted successfully, but ProtonPlus could not save the cleare" \
"d reminder state."), NULL, FALSE);
			result = _tmp15_;
			return result;
		}
		default:
		{
			ProtonPlusWidgetsMainSteamRestartMessage* _tmp16_;
			_tmp16_ = proton_plus_widgets_main_steam_restart_message_new (_ ("Steam couldn’t restart"), _ ("Try again later or restart Steam manually."), NULL, FALSE);
			result = _tmp16_;
			return result;
		}
	}
}

ProtonPlusWidgetsMainSteamRestartMessage*
proton_plus_widgets_main_steam_restart_presentation_success_message (gboolean other_targets_pending,
                                                                     gboolean persistence_failed)
{
	const gchar* _tmp1_ = NULL;
	ProtonPlusWidgetsMainSteamRestartMessage* _tmp2_;
	ProtonPlusWidgetsMainSteamRestartMessage* result;
	if (persistence_failed) {
		ProtonPlusWidgetsMainSteamRestartMessage* _tmp0_;
		_tmp0_ = proton_plus_widgets_main_steam_restart_presentation_failure_message (PROTON_PLUS_MODELS_STEAM_RESTART_FAILURE_REASON_PENDING_STATE_PERSISTENCE_FAILED, FALSE);
		result = _tmp0_;
		return result;
	}
	if (other_targets_pending) {
		_tmp1_ = _ ("Steam restarted; other changes still need a restart");
	} else {
		_tmp1_ = _ ("Steam restarted");
	}
	_tmp2_ = proton_plus_widgets_main_steam_restart_message_new (NULL, NULL, _tmp1_, FALSE);
	result = _tmp2_;
	return result;
}

ProtonPlusWidgetsMainSteamRestartMessage*
proton_plus_widgets_main_steam_restart_presentation_steamos_handoff_message (void)
{
	ProtonPlusWidgetsMainSteamRestartMessage* _tmp0_;
	ProtonPlusWidgetsMainSteamRestartMessage* result;
	_tmp0_ = proton_plus_widgets_main_steam_restart_message_new (NULL, NULL, _ ("SteamOS is restarting Steam"), FALSE);
	result = _tmp0_;
	return result;
}

ProtonPlusWidgetsMainSteamRestartPresentation*
proton_plus_widgets_main_steam_restart_presentation_construct (GType object_type)
{
	ProtonPlusWidgetsMainSteamRestartPresentation * self = NULL;
	self = (ProtonPlusWidgetsMainSteamRestartPresentation*) g_object_new (object_type, NULL);
	return self;
}

ProtonPlusWidgetsMainSteamRestartPresentation*
proton_plus_widgets_main_steam_restart_presentation_new (void)
{
	return proton_plus_widgets_main_steam_restart_presentation_construct (PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_PRESENTATION);
}

static void
proton_plus_widgets_main_steam_restart_presentation_class_init (ProtonPlusWidgetsMainSteamRestartPresentationClass * klass,
                                                                gpointer klass_data)
{
	proton_plus_widgets_main_steam_restart_presentation_parent_class = g_type_class_peek_parent (klass);
}

static void
proton_plus_widgets_main_steam_restart_presentation_instance_init (ProtonPlusWidgetsMainSteamRestartPresentation * self,
                                                                   gpointer klass)
{
}

static GType
proton_plus_widgets_main_steam_restart_presentation_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsMainSteamRestartPresentationClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_main_steam_restart_presentation_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsMainSteamRestartPresentation), 0, (GInstanceInitFunc) proton_plus_widgets_main_steam_restart_presentation_instance_init, NULL };
	GType proton_plus_widgets_main_steam_restart_presentation_type_id;
	proton_plus_widgets_main_steam_restart_presentation_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsMainSteamRestartPresentation", &g_define_type_info, 0);
	return proton_plus_widgets_main_steam_restart_presentation_type_id;
}

GType
proton_plus_widgets_main_steam_restart_presentation_get_type (void)
{
	static volatile gsize proton_plus_widgets_main_steam_restart_presentation_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_main_steam_restart_presentation_type_id__once)) {
		GType proton_plus_widgets_main_steam_restart_presentation_type_id;
		proton_plus_widgets_main_steam_restart_presentation_type_id = proton_plus_widgets_main_steam_restart_presentation_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_main_steam_restart_presentation_type_id__once, proton_plus_widgets_main_steam_restart_presentation_type_id);
	}
	return proton_plus_widgets_main_steam_restart_presentation_type_id__once;
}

static inline gpointer
proton_plus_widgets_main_steam_restart_toast_policy_get_instance_private (ProtonPlusWidgetsMainSteamRestartToastPolicy* self)
{
	return G_STRUCT_MEMBER_P (self, ProtonPlusWidgetsMainSteamRestartToastPolicy_private_offset);
}

gchar*
proton_plus_widgets_main_steam_restart_toast_policy_update (ProtonPlusWidgetsMainSteamRestartToastPolicy* self,
                                                            guint previous_count,
                                                            guint current_count,
                                                            gboolean restored)
{
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	gboolean _tmp3_ = FALSE;
	gboolean _tmp4_ = FALSE;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	if (current_count == ((guint) 0)) {
		self->priv->initial_shown = FALSE;
		self->priv->multiple_shown = FALSE;
		result = NULL;
		return result;
	}
	if (restored) {
		result = NULL;
		return result;
	}
	if (previous_count == ((guint) 0)) {
		_tmp1_ = current_count > ((guint) 0);
	} else {
		_tmp1_ = FALSE;
	}
	if (_tmp1_) {
		_tmp0_ = !self->priv->initial_shown;
	} else {
		_tmp0_ = FALSE;
	}
	if (_tmp0_) {
		gchar* _tmp2_;
		self->priv->initial_shown = TRUE;
		_tmp2_ = g_strdup (_ ("Steam needs to restart to apply your changes"));
		result = _tmp2_;
		return result;
	}
	if (previous_count == ((guint) 1)) {
		_tmp4_ = current_count > ((guint) 1);
	} else {
		_tmp4_ = FALSE;
	}
	if (_tmp4_) {
		_tmp3_ = !self->priv->multiple_shown;
	} else {
		_tmp3_ = FALSE;
	}
	if (_tmp3_) {
		gchar* _tmp5_;
		self->priv->multiple_shown = TRUE;
		_tmp5_ = g_strdup (_ ("Multiple changes will be applied after Steam restarts"));
		result = _tmp5_;
		return result;
	}
	result = NULL;
	return result;
}

ProtonPlusWidgetsMainSteamRestartToastPolicy*
proton_plus_widgets_main_steam_restart_toast_policy_construct (GType object_type)
{
	ProtonPlusWidgetsMainSteamRestartToastPolicy * self = NULL;
	self = (ProtonPlusWidgetsMainSteamRestartToastPolicy*) g_object_new (object_type, NULL);
	return self;
}

ProtonPlusWidgetsMainSteamRestartToastPolicy*
proton_plus_widgets_main_steam_restart_toast_policy_new (void)
{
	return proton_plus_widgets_main_steam_restart_toast_policy_construct (PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_TOAST_POLICY);
}

static void
proton_plus_widgets_main_steam_restart_toast_policy_class_init (ProtonPlusWidgetsMainSteamRestartToastPolicyClass * klass,
                                                                gpointer klass_data)
{
	proton_plus_widgets_main_steam_restart_toast_policy_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &ProtonPlusWidgetsMainSteamRestartToastPolicy_private_offset);
	G_OBJECT_CLASS (klass)->finalize = proton_plus_widgets_main_steam_restart_toast_policy_finalize;
}

static void
proton_plus_widgets_main_steam_restart_toast_policy_instance_init (ProtonPlusWidgetsMainSteamRestartToastPolicy * self,
                                                                   gpointer klass)
{
	self->priv = proton_plus_widgets_main_steam_restart_toast_policy_get_instance_private (self);
	self->priv->initial_shown = FALSE;
	self->priv->multiple_shown = FALSE;
}

static void
proton_plus_widgets_main_steam_restart_toast_policy_finalize (GObject * obj)
{
	ProtonPlusWidgetsMainSteamRestartToastPolicy * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_TOAST_POLICY, ProtonPlusWidgetsMainSteamRestartToastPolicy);
	G_OBJECT_CLASS (proton_plus_widgets_main_steam_restart_toast_policy_parent_class)->finalize (obj);
}

static GType
proton_plus_widgets_main_steam_restart_toast_policy_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsMainSteamRestartToastPolicyClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_main_steam_restart_toast_policy_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsMainSteamRestartToastPolicy), 0, (GInstanceInitFunc) proton_plus_widgets_main_steam_restart_toast_policy_instance_init, NULL };
	GType proton_plus_widgets_main_steam_restart_toast_policy_type_id;
	proton_plus_widgets_main_steam_restart_toast_policy_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsMainSteamRestartToastPolicy", &g_define_type_info, 0);
	ProtonPlusWidgetsMainSteamRestartToastPolicy_private_offset = g_type_add_instance_private (proton_plus_widgets_main_steam_restart_toast_policy_type_id, sizeof (ProtonPlusWidgetsMainSteamRestartToastPolicyPrivate));
	return proton_plus_widgets_main_steam_restart_toast_policy_type_id;
}

GType
proton_plus_widgets_main_steam_restart_toast_policy_get_type (void)
{
	static volatile gsize proton_plus_widgets_main_steam_restart_toast_policy_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_main_steam_restart_toast_policy_type_id__once)) {
		GType proton_plus_widgets_main_steam_restart_toast_policy_type_id;
		proton_plus_widgets_main_steam_restart_toast_policy_type_id = proton_plus_widgets_main_steam_restart_toast_policy_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_main_steam_restart_toast_policy_type_id__once, proton_plus_widgets_main_steam_restart_toast_policy_type_id);
	}
	return proton_plus_widgets_main_steam_restart_toast_policy_type_id__once;
}

static inline gpointer
proton_plus_widgets_main_steam_restart_notification_policy_get_instance_private (ProtonPlusWidgetsMainSteamRestartNotificationPolicy* self)
{
	return G_STRUCT_MEMBER_P (self, ProtonPlusWidgetsMainSteamRestartNotificationPolicy_private_offset);
}

gchar*
proton_plus_widgets_main_steam_restart_notification_policy_update (ProtonPlusWidgetsMainSteamRestartNotificationPolicy* self,
                                                                   guint previous_count,
                                                                   guint current_count,
                                                                   gboolean active,
                                                                   gboolean restored)
{
	gboolean _tmp0_ = FALSE;
	gboolean _tmp1_ = FALSE;
	gboolean _tmp2_ = FALSE;
	gboolean _tmp4_ = FALSE;
	gboolean _tmp5_ = FALSE;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	if (current_count == ((guint) 0)) {
		self->priv->initial_sent = FALSE;
		self->priv->aggregate_sent = FALSE;
		result = NULL;
		return result;
	}
	if (active) {
		_tmp0_ = TRUE;
	} else {
		_tmp0_ = restored;
	}
	if (_tmp0_) {
		result = NULL;
		return result;
	}
	if (previous_count == ((guint) 0)) {
		_tmp2_ = current_count > ((guint) 0);
	} else {
		_tmp2_ = FALSE;
	}
	if (_tmp2_) {
		_tmp1_ = !self->priv->initial_sent;
	} else {
		_tmp1_ = FALSE;
	}
	if (_tmp1_) {
		gchar* _tmp3_;
		self->priv->initial_sent = TRUE;
		_tmp3_ = g_strdup (_ ("Steam needs to restart to apply your changes"));
		result = _tmp3_;
		return result;
	}
	if (previous_count == ((guint) 1)) {
		_tmp5_ = current_count > ((guint) 1);
	} else {
		_tmp5_ = FALSE;
	}
	if (_tmp5_) {
		_tmp4_ = !self->priv->aggregate_sent;
	} else {
		_tmp4_ = FALSE;
	}
	if (_tmp4_) {
		gchar* _tmp6_;
		self->priv->aggregate_sent = TRUE;
		_tmp6_ = g_strdup (_ ("Multiple changes will be applied after Steam restarts"));
		result = _tmp6_;
		return result;
	}
	result = NULL;
	return result;
}

ProtonPlusWidgetsMainSteamRestartNotificationPolicy*
proton_plus_widgets_main_steam_restart_notification_policy_construct (GType object_type)
{
	ProtonPlusWidgetsMainSteamRestartNotificationPolicy * self = NULL;
	self = (ProtonPlusWidgetsMainSteamRestartNotificationPolicy*) g_object_new (object_type, NULL);
	return self;
}

ProtonPlusWidgetsMainSteamRestartNotificationPolicy*
proton_plus_widgets_main_steam_restart_notification_policy_new (void)
{
	return proton_plus_widgets_main_steam_restart_notification_policy_construct (PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_NOTIFICATION_POLICY);
}

static void
proton_plus_widgets_main_steam_restart_notification_policy_class_init (ProtonPlusWidgetsMainSteamRestartNotificationPolicyClass * klass,
                                                                       gpointer klass_data)
{
	proton_plus_widgets_main_steam_restart_notification_policy_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &ProtonPlusWidgetsMainSteamRestartNotificationPolicy_private_offset);
	G_OBJECT_CLASS (klass)->finalize = proton_plus_widgets_main_steam_restart_notification_policy_finalize;
}

static void
proton_plus_widgets_main_steam_restart_notification_policy_instance_init (ProtonPlusWidgetsMainSteamRestartNotificationPolicy * self,
                                                                          gpointer klass)
{
	self->priv = proton_plus_widgets_main_steam_restart_notification_policy_get_instance_private (self);
	self->priv->initial_sent = FALSE;
	self->priv->aggregate_sent = FALSE;
}

static void
proton_plus_widgets_main_steam_restart_notification_policy_finalize (GObject * obj)
{
	ProtonPlusWidgetsMainSteamRestartNotificationPolicy * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_NOTIFICATION_POLICY, ProtonPlusWidgetsMainSteamRestartNotificationPolicy);
	G_OBJECT_CLASS (proton_plus_widgets_main_steam_restart_notification_policy_parent_class)->finalize (obj);
}

static GType
proton_plus_widgets_main_steam_restart_notification_policy_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsMainSteamRestartNotificationPolicyClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_main_steam_restart_notification_policy_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsMainSteamRestartNotificationPolicy), 0, (GInstanceInitFunc) proton_plus_widgets_main_steam_restart_notification_policy_instance_init, NULL };
	GType proton_plus_widgets_main_steam_restart_notification_policy_type_id;
	proton_plus_widgets_main_steam_restart_notification_policy_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsMainSteamRestartNotificationPolicy", &g_define_type_info, 0);
	ProtonPlusWidgetsMainSteamRestartNotificationPolicy_private_offset = g_type_add_instance_private (proton_plus_widgets_main_steam_restart_notification_policy_type_id, sizeof (ProtonPlusWidgetsMainSteamRestartNotificationPolicyPrivate));
	return proton_plus_widgets_main_steam_restart_notification_policy_type_id;
}

GType
proton_plus_widgets_main_steam_restart_notification_policy_get_type (void)
{
	static volatile gsize proton_plus_widgets_main_steam_restart_notification_policy_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_main_steam_restart_notification_policy_type_id__once)) {
		GType proton_plus_widgets_main_steam_restart_notification_policy_type_id;
		proton_plus_widgets_main_steam_restart_notification_policy_type_id = proton_plus_widgets_main_steam_restart_notification_policy_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_main_steam_restart_notification_policy_type_id__once, proton_plus_widgets_main_steam_restart_notification_policy_type_id);
	}
	return proton_plus_widgets_main_steam_restart_notification_policy_type_id__once;
}

GQuark
proton_plus_widgets_main_steam_restart_notification_error_quark (void)
{
	return g_quark_from_static_string ("proton-plus-widgets-main-steam-restart-notification-error-quark");
}

static GType
proton_plus_widgets_main_steam_restart_notification_error_get_type_once (void)
{
	static const GEnumValue values[] = {{PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_NOTIFICATION_ERROR_DELIVERY_FAILED, "PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_NOTIFICATION_ERROR_DELIVERY_FAILED", "delivery-failed"}, {0, NULL, NULL}};
	GType proton_plus_widgets_main_steam_restart_notification_error_type_id;
	proton_plus_widgets_main_steam_restart_notification_error_type_id = g_enum_register_static ("ProtonPlusWidgetsMainSteamRestartNotificationError", values);
	return proton_plus_widgets_main_steam_restart_notification_error_type_id;
}

GType
proton_plus_widgets_main_steam_restart_notification_error_get_type (void)
{
	static volatile gsize proton_plus_widgets_main_steam_restart_notification_error_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_main_steam_restart_notification_error_type_id__once)) {
		GType proton_plus_widgets_main_steam_restart_notification_error_type_id;
		proton_plus_widgets_main_steam_restart_notification_error_type_id = proton_plus_widgets_main_steam_restart_notification_error_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_main_steam_restart_notification_error_type_id__once, proton_plus_widgets_main_steam_restart_notification_error_type_id);
	}
	return proton_plus_widgets_main_steam_restart_notification_error_type_id__once;
}

void
proton_plus_widgets_main_steam_restart_notification_sender_send_restart_required (ProtonPlusWidgetsMainSteamRestartNotificationSender* self,
                                                                                  const gchar* message,
                                                                                  GError** error)
{
	ProtonPlusWidgetsMainSteamRestartNotificationSenderIface* _iface_;
	g_return_if_fail (self != NULL);
	_iface_ = PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_NOTIFICATION_SENDER_GET_INTERFACE (self);
	if (_iface_->send_restart_required) {
		_iface_->send_restart_required (self, message, error);
	}
}

static void
proton_plus_widgets_main_steam_restart_notification_sender_default_init (ProtonPlusWidgetsMainSteamRestartNotificationSenderIface * iface,
                                                                         gpointer iface_data)
{
}

static GType
proton_plus_widgets_main_steam_restart_notification_sender_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsMainSteamRestartNotificationSenderIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_main_steam_restart_notification_sender_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
	GType proton_plus_widgets_main_steam_restart_notification_sender_type_id;
	proton_plus_widgets_main_steam_restart_notification_sender_type_id = g_type_register_static (G_TYPE_INTERFACE, "ProtonPlusWidgetsMainSteamRestartNotificationSender", &g_define_type_info, 0);
	g_type_interface_add_prerequisite (proton_plus_widgets_main_steam_restart_notification_sender_type_id, G_TYPE_OBJECT);
	return proton_plus_widgets_main_steam_restart_notification_sender_type_id;
}

GType
proton_plus_widgets_main_steam_restart_notification_sender_get_type (void)
{
	static volatile gsize proton_plus_widgets_main_steam_restart_notification_sender_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_main_steam_restart_notification_sender_type_id__once)) {
		GType proton_plus_widgets_main_steam_restart_notification_sender_type_id;
		proton_plus_widgets_main_steam_restart_notification_sender_type_id = proton_plus_widgets_main_steam_restart_notification_sender_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_main_steam_restart_notification_sender_type_id__once, proton_plus_widgets_main_steam_restart_notification_sender_type_id);
	}
	return proton_plus_widgets_main_steam_restart_notification_sender_type_id__once;
}

static void
proton_plus_widgets_main_libnotify_steam_restart_notification_sender_real_send_restart_required (ProtonPlusWidgetsMainSteamRestartNotificationSender* base,
                                                                                                 const gchar* message,
                                                                                                 GError** error)
{
	ProtonPlusWidgetsMainLibnotifySteamRestartNotificationSender * self;
	NotifyNotification* notification = NULL;
	NotifyNotification* _tmp0_;
	GError* _inner_error0_ = NULL;
	self = (ProtonPlusWidgetsMainLibnotifySteamRestartNotificationSender*) base;
	g_return_if_fail (message != NULL);
	_tmp0_ = notify_notification_new (_ ("Steam restart needed"), message, "steam-symbolic");
	notification = _tmp0_;
	{
		NotifyNotification* _tmp1_;
		_tmp1_ = notification;
		notify_notification_show (_tmp1_, &_inner_error0_);
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
			goto __catch0_g_error;
		}
	}
	goto __finally0;
	__catch0_g_error:
	{
		GError* e = NULL;
		GError* _tmp2_;
		const gchar* _tmp3_;
		GError* _tmp4_;
		e = _inner_error0_;
		_inner_error0_ = NULL;
		_tmp2_ = e;
		_tmp3_ = _tmp2_->message;
		_tmp4_ = g_error_new (PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_NOTIFICATION_ERROR, PROTON_PLUS_WIDGETS_MAIN_STEAM_RESTART_NOTIFICATION_ERROR_DELIVERY_FAILED, "%s", _tmp3_);
		_inner_error0_ = _tmp4_;
		_g_error_free0 (e);
		goto __finally0;
	}
	__finally0:
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		g_propagate_error (error, _inner_error0_);
		_g_object_unref0 (notification);
		return;
	}
	_g_object_unref0 (notification);
}

ProtonPlusWidgetsMainLibnotifySteamRestartNotificationSender*
proton_plus_widgets_main_libnotify_steam_restart_notification_sender_construct (GType object_type)
{
	ProtonPlusWidgetsMainLibnotifySteamRestartNotificationSender * self = NULL;
	self = (ProtonPlusWidgetsMainLibnotifySteamRestartNotificationSender*) g_object_new (object_type, NULL);
	return self;
}

ProtonPlusWidgetsMainLibnotifySteamRestartNotificationSender*
proton_plus_widgets_main_libnotify_steam_restart_notification_sender_new (void)
{
	return proton_plus_widgets_main_libnotify_steam_restart_notification_sender_construct (PROTON_PLUS_WIDGETS_MAIN_TYPE_LIBNOTIFY_STEAM_RESTART_NOTIFICATION_SENDER);
}

static void
proton_plus_widgets_main_libnotify_steam_restart_notification_sender_class_init (ProtonPlusWidgetsMainLibnotifySteamRestartNotificationSenderClass * klass,
                                                                                 gpointer klass_data)
{
	proton_plus_widgets_main_libnotify_steam_restart_notification_sender_parent_class = g_type_class_peek_parent (klass);
}

static void
proton_plus_widgets_main_libnotify_steam_restart_notification_sender_proton_plus_widgets_main_steam_restart_notification_sender_interface_init (ProtonPlusWidgetsMainSteamRestartNotificationSenderIface * iface,
                                                                                                                                                gpointer iface_data)
{
	proton_plus_widgets_main_libnotify_steam_restart_notification_sender_proton_plus_widgets_main_steam_restart_notification_sender_parent_iface = g_type_interface_peek_parent (iface);
	iface->send_restart_required = (void (*) (ProtonPlusWidgetsMainSteamRestartNotificationSender*, const gchar*, GError**)) proton_plus_widgets_main_libnotify_steam_restart_notification_sender_real_send_restart_required;
}

static void
proton_plus_widgets_main_libnotify_steam_restart_notification_sender_instance_init (ProtonPlusWidgetsMainLibnotifySteamRestartNotificationSender * self,
                                                                                    gpointer klass)
{
}

static GType
proton_plus_widgets_main_libnotify_steam_restart_notification_sender_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsMainLibnotifySteamRestartNotificationSenderClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_main_libnotify_steam_restart_notification_sender_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsMainLibnotifySteamRestartNotificationSender), 0, (GInstanceInitFunc) proton_plus_widgets_main_libnotify_steam_restart_notification_sender_instance_init, NULL };
	static const GInterfaceInfo proton_plus_widgets_main_steam_restart_notification_sender_info = { (GInterfaceInitFunc) proton_plus_widgets_main_libnotify_steam_restart_notification_sender_proton_plus_widgets_main_steam_restart_notification_sender_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
	GType proton_plus_widgets_main_libnotify_steam_restart_notification_sender_type_id;
	proton_plus_widgets_main_libnotify_steam_restart_notification_sender_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsMainLibnotifySteamRestartNotificationSender", &g_define_type_info, 0);
	g_type_add_interface_static (proton_plus_widgets_main_libnotify_steam_restart_notification_sender_type_id, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_NOTIFICATION_SENDER, &proton_plus_widgets_main_steam_restart_notification_sender_info);
	return proton_plus_widgets_main_libnotify_steam_restart_notification_sender_type_id;
}

GType
proton_plus_widgets_main_libnotify_steam_restart_notification_sender_get_type (void)
{
	static volatile gsize proton_plus_widgets_main_libnotify_steam_restart_notification_sender_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_main_libnotify_steam_restart_notification_sender_type_id__once)) {
		GType proton_plus_widgets_main_libnotify_steam_restart_notification_sender_type_id;
		proton_plus_widgets_main_libnotify_steam_restart_notification_sender_type_id = proton_plus_widgets_main_libnotify_steam_restart_notification_sender_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_main_libnotify_steam_restart_notification_sender_type_id__once, proton_plus_widgets_main_libnotify_steam_restart_notification_sender_type_id);
	}
	return proton_plus_widgets_main_libnotify_steam_restart_notification_sender_type_id__once;
}

static inline gpointer
proton_plus_widgets_main_steam_restart_notification_coordinator_get_instance_private (ProtonPlusWidgetsMainSteamRestartNotificationCoordinator* self)
{
	return G_STRUCT_MEMBER_P (self, ProtonPlusWidgetsMainSteamRestartNotificationCoordinator_private_offset);
}

ProtonPlusWidgetsMainSteamRestartNotificationCoordinator*
proton_plus_widgets_main_steam_restart_notification_coordinator_construct (GType object_type,
                                                                           ProtonPlusWidgetsMainSteamRestartNotificationSender* sender,
                                                                           ProtonPlusWidgetsMainSteamRestartNotificationPolicy* policy)
{
	ProtonPlusWidgetsMainSteamRestartNotificationCoordinator * self = NULL;
	ProtonPlusWidgetsMainSteamRestartNotificationSender* _tmp0_;
	ProtonPlusWidgetsMainSteamRestartNotificationPolicy* _tmp1_ = NULL;
	ProtonPlusWidgetsMainSteamRestartNotificationPolicy* _tmp2_;
	ProtonPlusWidgetsMainSteamRestartNotificationPolicy* _tmp4_;
	g_return_val_if_fail (sender != NULL, NULL);
	self = (ProtonPlusWidgetsMainSteamRestartNotificationCoordinator*) g_object_new (object_type, NULL);
	_tmp0_ = _g_object_ref0 (sender);
	_g_object_unref0 (self->priv->sender);
	self->priv->sender = _tmp0_;
	_tmp2_ = _g_object_ref0 (policy);
	_tmp1_ = _tmp2_;
	if (_tmp1_ == NULL) {
		ProtonPlusWidgetsMainSteamRestartNotificationPolicy* _tmp3_;
		_tmp3_ = proton_plus_widgets_main_steam_restart_notification_policy_new ();
		_g_object_unref0 (_tmp1_);
		_tmp1_ = _tmp3_;
	}
	_tmp4_ = _tmp1_;
	_tmp1_ = NULL;
	_g_object_unref0 (self->priv->policy);
	self->priv->policy = _tmp4_;
	_g_object_unref0 (_tmp1_);
	return self;
}

ProtonPlusWidgetsMainSteamRestartNotificationCoordinator*
proton_plus_widgets_main_steam_restart_notification_coordinator_new (ProtonPlusWidgetsMainSteamRestartNotificationSender* sender,
                                                                     ProtonPlusWidgetsMainSteamRestartNotificationPolicy* policy)
{
	return proton_plus_widgets_main_steam_restart_notification_coordinator_construct (PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_NOTIFICATION_COORDINATOR, sender, policy);
}

void
proton_plus_widgets_main_steam_restart_notification_coordinator_update (ProtonPlusWidgetsMainSteamRestartNotificationCoordinator* self,
                                                                        guint previous_count,
                                                                        guint current_count,
                                                                        gboolean active,
                                                                        gboolean restored)
{
	gchar* message = NULL;
	ProtonPlusWidgetsMainSteamRestartNotificationPolicy* _tmp0_;
	gchar* _tmp1_;
	const gchar* _tmp2_;
	GError* _inner_error0_ = NULL;
	g_return_if_fail (self != NULL);
	_tmp0_ = self->priv->policy;
	_tmp1_ = proton_plus_widgets_main_steam_restart_notification_policy_update (_tmp0_, previous_count, current_count, active, restored);
	message = _tmp1_;
	_tmp2_ = message;
	if (_tmp2_ == NULL) {
		_g_free0 (message);
		return;
	}
	{
		ProtonPlusWidgetsMainSteamRestartNotificationSender* _tmp3_;
		const gchar* _tmp4_;
		_tmp3_ = self->priv->sender;
		_tmp4_ = message;
		proton_plus_widgets_main_steam_restart_notification_sender_send_restart_required (_tmp3_, (const gchar*) _tmp4_, &_inner_error0_);
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
			goto __catch0_g_error;
		}
	}
	goto __finally0;
	__catch0_g_error:
	{
		GError* e = NULL;
		GError* _tmp5_;
		const gchar* _tmp6_;
		e = _inner_error0_;
		_inner_error0_ = NULL;
		_tmp5_ = e;
		_tmp6_ = _tmp5_->message;
		g_warning ("steam-restart-presentation.vala:248: Failed to send Steam restart noti" \
"fication: %s", _tmp6_);
		_g_error_free0 (e);
	}
	__finally0:
	if (G_UNLIKELY (_inner_error0_ != NULL)) {
		_g_free0 (message);
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
		g_clear_error (&_inner_error0_);
		return;
	}
	_g_free0 (message);
}

static void
proton_plus_widgets_main_steam_restart_notification_coordinator_class_init (ProtonPlusWidgetsMainSteamRestartNotificationCoordinatorClass * klass,
                                                                            gpointer klass_data)
{
	proton_plus_widgets_main_steam_restart_notification_coordinator_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &ProtonPlusWidgetsMainSteamRestartNotificationCoordinator_private_offset);
	G_OBJECT_CLASS (klass)->finalize = proton_plus_widgets_main_steam_restart_notification_coordinator_finalize;
}

static void
proton_plus_widgets_main_steam_restart_notification_coordinator_instance_init (ProtonPlusWidgetsMainSteamRestartNotificationCoordinator * self,
                                                                               gpointer klass)
{
	self->priv = proton_plus_widgets_main_steam_restart_notification_coordinator_get_instance_private (self);
}

static void
proton_plus_widgets_main_steam_restart_notification_coordinator_finalize (GObject * obj)
{
	ProtonPlusWidgetsMainSteamRestartNotificationCoordinator * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PROTON_PLUS_WIDGETS_MAIN_TYPE_STEAM_RESTART_NOTIFICATION_COORDINATOR, ProtonPlusWidgetsMainSteamRestartNotificationCoordinator);
	_g_object_unref0 (self->priv->policy);
	_g_object_unref0 (self->priv->sender);
	G_OBJECT_CLASS (proton_plus_widgets_main_steam_restart_notification_coordinator_parent_class)->finalize (obj);
}

static GType
proton_plus_widgets_main_steam_restart_notification_coordinator_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsMainSteamRestartNotificationCoordinatorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_main_steam_restart_notification_coordinator_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsMainSteamRestartNotificationCoordinator), 0, (GInstanceInitFunc) proton_plus_widgets_main_steam_restart_notification_coordinator_instance_init, NULL };
	GType proton_plus_widgets_main_steam_restart_notification_coordinator_type_id;
	proton_plus_widgets_main_steam_restart_notification_coordinator_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsMainSteamRestartNotificationCoordinator", &g_define_type_info, 0);
	ProtonPlusWidgetsMainSteamRestartNotificationCoordinator_private_offset = g_type_add_instance_private (proton_plus_widgets_main_steam_restart_notification_coordinator_type_id, sizeof (ProtonPlusWidgetsMainSteamRestartNotificationCoordinatorPrivate));
	return proton_plus_widgets_main_steam_restart_notification_coordinator_type_id;
}

GType
proton_plus_widgets_main_steam_restart_notification_coordinator_get_type (void)
{
	static volatile gsize proton_plus_widgets_main_steam_restart_notification_coordinator_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_main_steam_restart_notification_coordinator_type_id__once)) {
		GType proton_plus_widgets_main_steam_restart_notification_coordinator_type_id;
		proton_plus_widgets_main_steam_restart_notification_coordinator_type_id = proton_plus_widgets_main_steam_restart_notification_coordinator_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_main_steam_restart_notification_coordinator_type_id__once, proton_plus_widgets_main_steam_restart_notification_coordinator_type_id);
	}
	return proton_plus_widgets_main_steam_restart_notification_coordinator_type_id__once;
}

