/* launch-option-capability-resolver.c generated by valac 0.56.19, the Vala compiler
 * generated from launch-option-capability-resolver.vala, do not modify */

#include "protonplus_core.h"
#include <glib.h>
#include <stdlib.h>
#include <string.h>
#include <glib-object.h>
#include <gee.h>
#include <glib/gstdio.h>
#include <glib/gi18n-lib.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_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_0_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_ACTIVATE_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_MODIFY_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_SHOW_WHEN_INACTIVE_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KEEP_VISIBLE_WHEN_ACTIVE_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_REASON_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_NUM_PROPERTIES];
#define _g_free0(var) (var = (g_free (var), NULL))
enum  {
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_0_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_MANGOHUD_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMEMODE_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMESCOPE_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_SCOPEBUDDY_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_VKBASALT_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAME_PERFORMANCE_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_OBS_VKCAPTURE_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_NUM_PROPERTIES];

#define PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_TOOL_FEATURE_RULE (proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_type ())
#define PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_TOOL_FEATURE_RULE, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule))
#define PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_TOOL_FEATURE_RULE, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRuleClass))
#define PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_IS_LAUNCH_OPTION_TOOL_FEATURE_RULE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_TOOL_FEATURE_RULE))
#define PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_IS_LAUNCH_OPTION_TOOL_FEATURE_RULE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_TOOL_FEATURE_RULE))
#define PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_TOOL_FEATURE_RULE, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRuleClass))

typedef struct _ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule;
typedef struct _ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRuleClass ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRuleClass;
typedef struct _ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRulePrivate ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRulePrivate;
enum  {
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_0_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_CAPABILITY_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_MARKERS_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_NUM_PROPERTIES];
enum  {
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_RESOLVER_0_PROPERTY,
	PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_RESOLVER_NUM_PROPERTIES
};
static GParamSpec* proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_RESOLVER_NUM_PROPERTIES];
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
#define _g_regex_unref0(var) ((var == NULL) ? NULL : (var = (g_regex_unref (var), NULL)))
#define _g_string_free0(var) ((var == NULL) ? NULL : (var = (g_string_free (var, TRUE), NULL)))

struct _ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityPrivate {
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind _kind;
	gboolean _may_activate;
	gboolean _may_modify;
	gboolean _show_when_inactive;
	gboolean _keep_visible_when_active;
	gchar* _reason;
};

struct _ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponentsPrivate {
	gboolean _mangohud;
	gboolean _gamemode;
	gboolean _gamescope;
	gboolean _scopebuddy;
	gboolean _vkbasalt;
	gboolean _game_performance;
	gboolean _obs_vkcapture;
};

struct _ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule {
	GObject parent_instance;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRulePrivate * priv;
};

struct _ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRuleClass {
	GObjectClass parent_class;
};

struct _ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRulePrivate {
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _capability;
	gchar** _markers;
	gint _markers_length1;
	gint __markers_size_;
};

struct _ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolverPrivate {
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCatalog* catalog;
	GeeHashMap* tool_document_cache;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule** tool_feature_rules;
	gint tool_feature_rules_length1;
	gint _tool_feature_rules_size_;
};

static gint ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility_private_offset;
static gpointer proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_parent_class = NULL;
static gint ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents_private_offset;
static gpointer proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_parent_class = NULL;
static gint ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule_private_offset;
static gpointer proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_parent_class = NULL;
static gint ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver_private_offset;
static gpointer proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_parent_class = NULL;

static void proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_finalize (GObject * obj);
static GType proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_type_once (void);
static void _vala_proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_property (GObject * object,
                                                                                                   guint property_id,
                                                                                                   GValue * value,
                                                                                                   GParamSpec * pspec);
static void _vala_proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_property (GObject * object,
                                                                                                   guint property_id,
                                                                                                   const GValue * value,
                                                                                                   GParamSpec * pspec);
static void proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_finalize (GObject * obj);
static GType proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_type_once (void);
static void _vala_proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_property (GObject * object,
                                                                                                            guint property_id,
                                                                                                            GValue * value,
                                                                                                            GParamSpec * pspec);
static void _vala_proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_property (GObject * object,
                                                                                                            guint property_id,
                                                                                                            const GValue * value,
                                                                                                            GParamSpec * pspec);
VALA_EXTERN GType proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_type (void) G_GNUC_CONST ;
VALA_EXTERN ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_new (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability,
                                                                                                                                                           gchar** markers,
                                                                                                                                                           gint markers_length1);
VALA_EXTERN ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_construct (GType object_type,
                                                                                                                                                                 ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability,
                                                                                                                                                                 gchar** markers,
                                                                                                                                                                 gint markers_length1);
VALA_EXTERN ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_capability (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* self);
static void proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_set_capability (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* self,
                                                                                                     ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability value);
VALA_EXTERN gchar** proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_markers (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* self,
                                                                                                     gint* result_length1);
static void proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_set_markers (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* self,
                                                                                                  gchar** value,
                                                                                                  gint value_length1);
static gchar** _vala_array_dup18 (gchar** self,
                           gssize length);
static void proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_finalize (GObject * obj);
static GType proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_type_once (void);
static void _vala_proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_property (GObject * object,
                                                                                                         guint property_id,
                                                                                                         GValue * value,
                                                                                                         GParamSpec * pspec);
static void _vala_proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_set_property (GObject * object,
                                                                                                         guint property_id,
                                                                                                         const GValue * value,
                                                                                                         GParamSpec * pspec);
static ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                                                                                      ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* values,
                                                                                                                                                                      gint values_length1,
                                                                                                                                                                      ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability,
                                                                                                                                                                      gint* result_length1);
static gboolean proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_all_tools_advertise_feature (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                                        ProtonPlusModelsCompatibilityTool** tools,
                                                                                                                        gint tools_length1,
                                                                                                                        ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* rule);
static gchar* proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_documentation_for_tool (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                                 const gchar* tool_path);
static gboolean proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_contains_feature_marker (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                                    const gchar* documentation,
                                                                                                                    const gchar* marker);
static ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_unavailable (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                                                                                 ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind kind,
                                                                                                                                                                 gboolean active,
                                                                                                                                                                 const gchar* reason);
static ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_required_capabilities (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                                                                                          ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionMetadata* metadata,
                                                                                                                                                                          gint* result_length1);
static ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_kind_for (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                                                                                 ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability);
static gchar* proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_reason_for (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                     ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability);
static gboolean proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_contains_capability (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                                ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* values,
                                                                                                                gint values_length1,
                                                                                                                ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability);
static void proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_finalize (GObject * obj);
static GType proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_get_type_once (void);
static void _vala_array_destroy (gpointer array,
                          gssize array_length,
                          GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array,
                       gssize array_length,
                       GDestroyNotify destroy_func);
static inline gpointer _vala_memdup2 (gconstpointer mem,
                        gsize byte_size);

static const gchar* PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_RESOLVER_TOOL_FEATURE_FILES[6] = {"proton", "README.md", "CHANGELOG.md", "user_settings.sample.py", "docs/FSR4.md", "docs/EM-ADDITIONS.md"};

static GType
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_get_type_once (void)
{
	static const GEnumValue values[] = {{PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_AVAILABLE, "PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_AVAILABLE", "available"}, {PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_VARIANT_SELECTABLE_WITH_WARNING, "PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_VARIANT_SELECTABLE_WITH_WARNING", "variant-selectable-with-warning"}, {PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNAVAILABLE_RUNTIME, "PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNAVAILABLE_RUNTIME", "unavailable-runtime"}, {PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNAVAILABLE_COMPONENT, "PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNAVAILABLE_COMPONENT", "unavailable-component"}, {PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNAVAILABLE_HARDWARE, "PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNAVAILABLE_HARDWARE", "unavailable-hardware"}, {PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNSUPPORTED, "PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNSUPPORTED", "unsupported"}, {PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_LEGACY_ACTIVE_ONLY, "PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_LEGACY_ACTIVE_ONLY", "legacy-active-only"}, {PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNKNOWN_CONTEXT, "PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNKNOWN_CONTEXT", "unknown-context"}, {0, NULL, NULL}};
	GType proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_type_id;
	proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_type_id = g_enum_register_static ("ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind", values);
	return proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_type_id;
}

GType
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_get_type (void)
{
	static volatile gsize proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_type_id__once)) {
		GType proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_type_id;
		proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_type_id = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_type_id__once, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_type_id);
	}
	return proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_kind_type_id__once;
}

static inline gpointer
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_instance_private (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self)
{
	return G_STRUCT_MEMBER_P (self, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility_private_offset);
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility*
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_construct (GType object_type,
                                                                                     ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind kind,
                                                                                     gboolean may_activate,
                                                                                     gboolean may_modify,
                                                                                     gboolean show_when_inactive,
                                                                                     gboolean keep_visible_when_active,
                                                                                     const gchar* reason)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility * self = NULL;
	g_return_val_if_fail (reason != NULL, NULL);
	self = (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility*) g_object_new (object_type, "kind", kind, "may-activate", may_activate, "may-modify", may_modify, "show-when-inactive", show_when_inactive, "keep-visible-when-active", keep_visible_when_active, "reason", reason, NULL);
	return self;
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility*
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_new (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind kind,
                                                                               gboolean may_activate,
                                                                               gboolean may_modify,
                                                                               gboolean show_when_inactive,
                                                                               gboolean keep_visible_when_active,
                                                                               const gchar* reason)
{
	return proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_construct (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_ELIGIBILITY, kind, may_activate, may_modify, show_when_inactive, keep_visible_when_active, reason);
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_kind (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_kind;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_kind (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self,
                                                                                    ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind value)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_kind (self);
	if (old_value != value) {
		self->priv->_kind = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_may_activate (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_may_activate;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_may_activate (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self,
                                                                                            gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_may_activate (self);
	if (old_value != value) {
		self->priv->_may_activate = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_ACTIVATE_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_may_modify (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_may_modify;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_may_modify (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self,
                                                                                          gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_may_modify (self);
	if (old_value != value) {
		self->priv->_may_modify = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_MODIFY_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_show_when_inactive (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_show_when_inactive;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_show_when_inactive (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self,
                                                                                                  gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_show_when_inactive (self);
	if (old_value != value) {
		self->priv->_show_when_inactive = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_SHOW_WHEN_INACTIVE_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_keep_visible_when_active (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_keep_visible_when_active;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_keep_visible_when_active (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self,
                                                                                                        gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_keep_visible_when_active (self);
	if (old_value != value) {
		self->priv->_keep_visible_when_active = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KEEP_VISIBLE_WHEN_ACTIVE_PROPERTY]);
	}
}

const gchar*
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_reason (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self)
{
	const gchar* result;
	const gchar* _tmp0_;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_reason;
	result = _tmp0_;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_reason (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* self,
                                                                                      const gchar* value)
{
	gchar* old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_reason (self);
	if (g_strcmp0 (value, old_value) != 0) {
		gchar* _tmp0_;
		_tmp0_ = g_strdup (value);
		_g_free0 (self->priv->_reason);
		self->priv->_reason = _tmp0_;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_REASON_PROPERTY]);
	}
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_class_init (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityClass * klass,
                                                                                      gpointer klass_data)
{
	proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_property;
	G_OBJECT_CLASS (klass)->finalize = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_PROPERTY] = g_param_spec_enum ("kind", "kind", "kind", PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_ELIGIBILITY_KIND, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_ACTIVATE_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_ACTIVATE_PROPERTY] = g_param_spec_boolean ("may-activate", "may-activate", "may-activate", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_MODIFY_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_MODIFY_PROPERTY] = g_param_spec_boolean ("may-modify", "may-modify", "may-modify", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_SHOW_WHEN_INACTIVE_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_SHOW_WHEN_INACTIVE_PROPERTY] = g_param_spec_boolean ("show-when-inactive", "show-when-inactive", "show-when-inactive", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KEEP_VISIBLE_WHEN_ACTIVE_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KEEP_VISIBLE_WHEN_ACTIVE_PROPERTY] = g_param_spec_boolean ("keep-visible-when-active", "keep-visible-when-active", "keep-visible-when-active", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_REASON_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_REASON_PROPERTY] = g_param_spec_string ("reason", "reason", "reason", NULL, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_instance_init (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility * self,
                                                                                         gpointer klass)
{
	self->priv = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_instance_private (self);
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_finalize (GObject * obj)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_ELIGIBILITY, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility);
	_g_free0 (self->priv->_reason);
	G_OBJECT_CLASS (proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_parent_class)->finalize (obj);
}

static GType
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility), 0, (GInstanceInitFunc) proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_instance_init, NULL };
	GType proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_type_id;
	proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility", &g_define_type_info, 0);
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility_private_offset = g_type_add_instance_private (proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_type_id, sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityPrivate));
	return proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_type_id;
}

GType
proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_type (void)
{
	static volatile gsize proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_type_id__once)) {
		GType proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_type_id;
		proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_type_id = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_type_id__once, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_type_id);
	}
	return proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_type_id__once;
}

static void
_vala_proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_property (GObject * object,
                                                                                              guint property_id,
                                                                                              GValue * value,
                                                                                              GParamSpec * pspec)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_ELIGIBILITY, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_PROPERTY:
		g_value_set_enum (value, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_kind (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_ACTIVATE_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_may_activate (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_MODIFY_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_may_modify (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_SHOW_WHEN_INACTIVE_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_show_when_inactive (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KEEP_VISIBLE_WHEN_ACTIVE_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_keep_visible_when_active (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_REASON_PROPERTY:
		g_value_set_string (value, proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_reason (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_property (GObject * object,
                                                                                              guint property_id,
                                                                                              const GValue * value,
                                                                                              GParamSpec * pspec)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_ELIGIBILITY, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_kind (self, g_value_get_enum (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_ACTIVATE_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_may_activate (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_MAY_MODIFY_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_may_modify (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_SHOW_WHEN_INACTIVE_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_show_when_inactive (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KEEP_VISIBLE_WHEN_ACTIVE_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_keep_visible_when_active (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_REASON_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_set_reason (self, g_value_get_string (value));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_instance_private (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self)
{
	return G_STRUCT_MEMBER_P (self, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents_private_offset);
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents*
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_construct (GType object_type,
                                                                                              gboolean mangohud,
                                                                                              gboolean gamemode,
                                                                                              gboolean gamescope,
                                                                                              gboolean scopebuddy,
                                                                                              gboolean vkbasalt,
                                                                                              gboolean game_performance,
                                                                                              gboolean obs_vkcapture)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents * self = NULL;
	self = (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents*) g_object_new (object_type, "mangohud", mangohud, "gamemode", gamemode, "gamescope", gamescope, "scopebuddy", scopebuddy, "vkbasalt", vkbasalt, "game-performance", game_performance, "obs-vkcapture", obs_vkcapture, NULL);
	return self;
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents*
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_new (gboolean mangohud,
                                                                                        gboolean gamemode,
                                                                                        gboolean gamescope,
                                                                                        gboolean scopebuddy,
                                                                                        gboolean vkbasalt,
                                                                                        gboolean game_performance,
                                                                                        gboolean obs_vkcapture)
{
	return proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_construct (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_INSTALLED_COMPONENTS, mangohud, gamemode, gamescope, scopebuddy, vkbasalt, game_performance, obs_vkcapture);
}

gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_mangohud (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_mangohud;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_mangohud (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self,
                                                                                                 gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_mangohud (self);
	if (old_value != value) {
		self->priv->_mangohud = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_MANGOHUD_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_gamemode (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_gamemode;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_gamemode (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self,
                                                                                                 gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_gamemode (self);
	if (old_value != value) {
		self->priv->_gamemode = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMEMODE_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_gamescope (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_gamescope;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_gamescope (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self,
                                                                                                  gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_gamescope (self);
	if (old_value != value) {
		self->priv->_gamescope = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMESCOPE_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_scopebuddy (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_scopebuddy;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_scopebuddy (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self,
                                                                                                   gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_scopebuddy (self);
	if (old_value != value) {
		self->priv->_scopebuddy = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_SCOPEBUDDY_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_vkbasalt (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_vkbasalt;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_vkbasalt (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self,
                                                                                                 gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_vkbasalt (self);
	if (old_value != value) {
		self->priv->_vkbasalt = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_VKBASALT_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_game_performance (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_game_performance;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_game_performance (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self,
                                                                                                         gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_game_performance (self);
	if (old_value != value) {
		self->priv->_game_performance = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAME_PERFORMANCE_PROPERTY]);
	}
}

gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_obs_vkcapture (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	result = self->priv->_obs_vkcapture;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_obs_vkcapture (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* self,
                                                                                                      gboolean value)
{
	gboolean old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_obs_vkcapture (self);
	if (old_value != value) {
		self->priv->_obs_vkcapture = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_OBS_VKCAPTURE_PROPERTY]);
	}
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_class_init (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponentsClass * klass,
                                                                                               gpointer klass_data)
{
	proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_property;
	G_OBJECT_CLASS (klass)->finalize = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_MANGOHUD_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_MANGOHUD_PROPERTY] = g_param_spec_boolean ("mangohud", "mangohud", "mangohud", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMEMODE_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMEMODE_PROPERTY] = g_param_spec_boolean ("gamemode", "gamemode", "gamemode", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMESCOPE_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMESCOPE_PROPERTY] = g_param_spec_boolean ("gamescope", "gamescope", "gamescope", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_SCOPEBUDDY_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_SCOPEBUDDY_PROPERTY] = g_param_spec_boolean ("scopebuddy", "scopebuddy", "scopebuddy", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_VKBASALT_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_VKBASALT_PROPERTY] = g_param_spec_boolean ("vkbasalt", "vkbasalt", "vkbasalt", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAME_PERFORMANCE_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAME_PERFORMANCE_PROPERTY] = g_param_spec_boolean ("game-performance", "game-performance", "game-performance", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_OBS_VKCAPTURE_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_OBS_VKCAPTURE_PROPERTY] = g_param_spec_boolean ("obs-vkcapture", "obs-vkcapture", "obs-vkcapture", FALSE, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_instance_init (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents * self,
                                                                                                  gpointer klass)
{
	self->priv = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_instance_private (self);
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_finalize (GObject * obj)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_INSTALLED_COMPONENTS, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents);
	G_OBJECT_CLASS (proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_parent_class)->finalize (obj);
}

static GType
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponentsClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents), 0, (GInstanceInitFunc) proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_instance_init, NULL };
	GType proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_type_id;
	proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents", &g_define_type_info, 0);
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents_private_offset = g_type_add_instance_private (proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_type_id, sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponentsPrivate));
	return proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_type_id;
}

GType
proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_type (void)
{
	static volatile gsize proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_type_id__once)) {
		GType proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_type_id;
		proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_type_id = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_type_id__once, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_type_id);
	}
	return proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_type_id__once;
}

static void
_vala_proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_property (GObject * object,
                                                                                                       guint property_id,
                                                                                                       GValue * value,
                                                                                                       GParamSpec * pspec)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_INSTALLED_COMPONENTS, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_MANGOHUD_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_mangohud (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMEMODE_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_gamemode (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMESCOPE_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_gamescope (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_SCOPEBUDDY_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_scopebuddy (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_VKBASALT_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_vkbasalt (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAME_PERFORMANCE_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_game_performance (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_OBS_VKCAPTURE_PROPERTY:
		g_value_set_boolean (value, proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_obs_vkcapture (self));
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_property (GObject * object,
                                                                                                       guint property_id,
                                                                                                       const GValue * value,
                                                                                                       GParamSpec * pspec)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_INSTALLED_COMPONENTS, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_MANGOHUD_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_mangohud (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMEMODE_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_gamemode (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAMESCOPE_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_gamescope (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_SCOPEBUDDY_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_scopebuddy (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_VKBASALT_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_vkbasalt (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_GAME_PERFORMANCE_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_game_performance (self, g_value_get_boolean (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_INSTALLED_COMPONENTS_OBS_VKCAPTURE_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_set_obs_vkcapture (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_games_launch_options_editor_launch_option_tool_feature_rule_get_instance_private (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* self)
{
	return G_STRUCT_MEMBER_P (self, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule_private_offset);
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule*
proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_construct (GType object_type,
                                                                                           ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability,
                                                                                           gchar** markers,
                                                                                           gint markers_length1)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule * self = NULL;
	self = (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule*) g_object_new (object_type, "capability", capability, "markers", markers, NULL);
	return self;
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule*
proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_new (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability,
                                                                                     gchar** markers,
                                                                                     gint markers_length1)
{
	return proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_construct (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_TOOL_FEATURE_RULE, capability, markers, markers_length1);
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability
proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_capability (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* self)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability result;
	g_return_val_if_fail (self != NULL, 0);
	result = self->priv->_capability;
	return result;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_set_capability (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* self,
                                                                                                ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability value)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability old_value;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_capability (self);
	if (old_value != value) {
		self->priv->_capability = value;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_CAPABILITY_PROPERTY]);
	}
}

gchar**
proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_markers (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* self,
                                                                                             gint* result_length1)
{
	gchar** result;
	gchar** _tmp0_;
	gint _tmp0__length1;
	gchar** _tmp1_;
	gint _tmp1__length1;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = self->priv->_markers;
	_tmp0__length1 = self->priv->_markers_length1;
	_tmp1_ = _tmp0_;
	_tmp1__length1 = _tmp0__length1;
	if (result_length1) {
		*result_length1 = _tmp1__length1;
	}
	result = _tmp1_;
	return result;
}

static gchar**
_vala_array_dup18 (gchar** self,
                   gssize length)
{
	if (length >= 0) {
		gchar** result;
		gssize i;
		result = g_new0 (gchar*, length + 1);
		for (i = 0; i < length; i++) {
			gchar* _tmp0_;
			_tmp0_ = g_strdup (self[i]);
			result[i] = _tmp0_;
		}
		return result;
	}
	return NULL;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_set_markers (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* self,
                                                                                             gchar** value,
                                                                                             gint value_length1)
{
	gchar** old_value;
	gint old_value_length;
	g_return_if_fail (self != NULL);
	old_value = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_markers (self, &old_value_length);
	if (old_value != value) {
		gchar** _tmp0_;
		gint _tmp0__length1;
		_tmp0_ = (value != NULL) ? _vala_array_dup18 (value, value_length1) : value;
		_tmp0__length1 = value_length1;
		self->priv->_markers = (_vala_array_free (self->priv->_markers, self->priv->_markers_length1, (GDestroyNotify) g_free), NULL);
		self->priv->_markers = _tmp0_;
		self->priv->_markers_length1 = _tmp0__length1;
		self->priv->__markers_size_ = self->priv->_markers_length1;
		g_object_notify_by_pspec ((GObject *) self, proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_MARKERS_PROPERTY]);
	}
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_class_init (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRuleClass * klass,
                                                                                            gpointer klass_data)
{
	proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule_private_offset);
	G_OBJECT_CLASS (klass)->get_property = _vala_proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_property;
	G_OBJECT_CLASS (klass)->set_property = _vala_proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_set_property;
	G_OBJECT_CLASS (klass)->finalize = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_finalize;
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_CAPABILITY_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_CAPABILITY_PROPERTY] = g_param_spec_enum ("capability", "capability", "capability", PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_CAPABILITY, 0, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
	g_object_class_install_property (G_OBJECT_CLASS (klass), PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_MARKERS_PROPERTY, proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_properties[PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_MARKERS_PROPERTY] = g_param_spec_boxed ("markers", "markers", "markers", G_TYPE_STRV, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY));
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_instance_init (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule * self,
                                                                                               gpointer klass)
{
	self->priv = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_instance_private (self);
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_finalize (GObject * obj)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_TOOL_FEATURE_RULE, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule);
	self->priv->_markers = (_vala_array_free (self->priv->_markers, self->priv->_markers_length1, (GDestroyNotify) g_free), NULL);
	G_OBJECT_CLASS (proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_parent_class)->finalize (obj);
}

static GType
proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRuleClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule), 0, (GInstanceInitFunc) proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_instance_init, NULL };
	GType proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_type_id;
	proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule", &g_define_type_info, 0);
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule_private_offset = g_type_add_instance_private (proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_type_id, sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRulePrivate));
	return proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_type_id;
}

GType
proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_type (void)
{
	static volatile gsize proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_type_id__once)) {
		GType proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_type_id;
		proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_type_id = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_type_id__once, proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_type_id);
	}
	return proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_type_id__once;
}

static void
_vala_proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_property (GObject * object,
                                                                                                    guint property_id,
                                                                                                    GValue * value,
                                                                                                    GParamSpec * pspec)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_TOOL_FEATURE_RULE, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_CAPABILITY_PROPERTY:
		g_value_set_enum (value, proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_capability (self));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_MARKERS_PROPERTY:
		{
			int length;
			g_value_set_boxed (value, proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_markers (self, &length));
		}
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static void
_vala_proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_set_property (GObject * object,
                                                                                                    guint property_id,
                                                                                                    const GValue * value,
                                                                                                    GParamSpec * pspec)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (object, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_TOOL_FEATURE_RULE, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule);
	switch (property_id) {
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_CAPABILITY_PROPERTY:
		proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_set_capability (self, g_value_get_enum (value));
		break;
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_TOOL_FEATURE_RULE_MARKERS_PROPERTY:
		{
			gpointer boxed;
			boxed = g_value_get_boxed (value);
			proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_set_markers (self, boxed, (boxed == NULL) ? 0 : g_strv_length (boxed));
		}
		break;
		default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
		break;
	}
}

static inline gpointer
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_get_instance_private (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self)
{
	return G_STRUCT_MEMBER_P (self, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver_private_offset);
}

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

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver*
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_construct (GType object_type,
                                                                                             ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCatalog* catalog)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver * self = NULL;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCatalog* _tmp0_ = NULL;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCatalog* _tmp1_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCatalog* _tmp3_;
	GeeHashMap* _tmp4_;
	gchar* _tmp5_;
	gchar** _tmp6_;
	gchar** _tmp7_;
	gint _tmp7__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp8_;
	gchar* _tmp9_;
	gchar** _tmp10_;
	gchar** _tmp11_;
	gint _tmp11__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp12_;
	gchar* _tmp13_;
	gchar** _tmp14_;
	gchar** _tmp15_;
	gint _tmp15__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp16_;
	gchar* _tmp17_;
	gchar** _tmp18_;
	gchar** _tmp19_;
	gint _tmp19__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp20_;
	gchar* _tmp21_;
	gchar** _tmp22_;
	gchar** _tmp23_;
	gint _tmp23__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp24_;
	gchar* _tmp25_;
	gchar** _tmp26_;
	gchar** _tmp27_;
	gint _tmp27__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp28_;
	gchar* _tmp29_;
	gchar** _tmp30_;
	gchar** _tmp31_;
	gint _tmp31__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp32_;
	gchar* _tmp33_;
	gchar** _tmp34_;
	gchar** _tmp35_;
	gint _tmp35__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp36_;
	gchar* _tmp37_;
	gchar** _tmp38_;
	gchar** _tmp39_;
	gint _tmp39__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp40_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule** _tmp41_;
	self = (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver*) g_object_new (object_type, NULL);
	_tmp1_ = _g_object_ref0 (catalog);
	_tmp0_ = _tmp1_;
	if (_tmp0_ == NULL) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCatalog* _tmp2_;
		_tmp2_ = proton_plus_widgets_games_launch_options_editor_launch_option_catalog_new ();
		_g_object_unref0 (_tmp0_);
		_tmp0_ = _tmp2_;
	}
	_tmp3_ = _tmp0_;
	_tmp0_ = NULL;
	_g_object_unref0 (self->priv->catalog);
	self->priv->catalog = _tmp3_;
	_tmp4_ = gee_hash_map_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
	_g_object_unref0 (self->priv->tool_document_cache);
	self->priv->tool_document_cache = _tmp4_;
	_tmp5_ = g_strdup ("PROTON_ENABLE_HDR");
	_tmp6_ = g_new0 (gchar*, 1 + 1);
	_tmp6_[0] = _tmp5_;
	_tmp7_ = _tmp6_;
	_tmp7__length1 = 1;
	_tmp8_ = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_new (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_LEGACY_PROTON_HDR, _tmp7_, 1);
	_tmp9_ = g_strdup ("DXVK_NO_HDR");
	_tmp10_ = g_new0 (gchar*, 1 + 1);
	_tmp10_[0] = _tmp9_;
	_tmp11_ = _tmp10_;
	_tmp11__length1 = 1;
	_tmp12_ = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_new (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_AUTO_HDR_CONTROL, _tmp11_, 1);
	_tmp13_ = g_strdup ("PROTON_FSR4_UPGRADE");
	_tmp14_ = g_new0 (gchar*, 1 + 1);
	_tmp14_[0] = _tmp13_;
	_tmp15_ = _tmp14_;
	_tmp15__length1 = 1;
	_tmp16_ = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_new (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_FSR4, _tmp15_, 1);
	_tmp17_ = g_strdup ("PROTON_FSR4_RDNA3_UPGRADE");
	_tmp18_ = g_new0 (gchar*, 1 + 1);
	_tmp18_[0] = _tmp17_;
	_tmp19_ = _tmp18_;
	_tmp19__length1 = 1;
	_tmp20_ = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_new (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_FSR4_RDNA3, _tmp19_, 1);
	_tmp21_ = g_strdup ("PROTON_MLFG_UPGRADE");
	_tmp22_ = g_new0 (gchar*, 1 + 1);
	_tmp22_[0] = _tmp21_;
	_tmp23_ = _tmp22_;
	_tmp23__length1 = 1;
	_tmp24_ = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_new (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_MLFG, _tmp23_, 1);
	_tmp25_ = g_strdup ("PROTON_DXVK_LOWLATENCY");
	_tmp26_ = g_new0 (gchar*, 1 + 1);
	_tmp26_[0] = _tmp25_;
	_tmp27_ = _tmp26_;
	_tmp27__length1 = 1;
	_tmp28_ = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_new (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_DXVK_LOW_LATENCY, _tmp27_, 1);
	_tmp29_ = g_strdup ("PROTON_VKD3D_LOWLATENCY");
	_tmp30_ = g_new0 (gchar*, 1 + 1);
	_tmp30_[0] = _tmp29_;
	_tmp31_ = _tmp30_;
	_tmp31__length1 = 1;
	_tmp32_ = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_new (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_VKD3D_LOW_LATENCY, _tmp31_, 1);
	_tmp33_ = g_strdup ("LOW_LATENCY_LAYER");
	_tmp34_ = g_new0 (gchar*, 1 + 1);
	_tmp34_[0] = _tmp33_;
	_tmp35_ = _tmp34_;
	_tmp35__length1 = 1;
	_tmp36_ = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_new (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_LOW_LATENCY_LAYER, _tmp35_, 1);
	_tmp37_ = g_strdup ("DXVK_NVAPI_VKREFLEX");
	_tmp38_ = g_new0 (gchar*, 1 + 1);
	_tmp38_[0] = _tmp37_;
	_tmp39_ = _tmp38_;
	_tmp39__length1 = 1;
	_tmp40_ = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_new (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_VULKAN_REFLEX_LAYER, _tmp39_, 1);
	_tmp41_ = g_new0 (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule*, 9 + 1);
	_tmp41_[0] = _tmp8_;
	_tmp41_[1] = _tmp12_;
	_tmp41_[2] = _tmp16_;
	_tmp41_[3] = _tmp20_;
	_tmp41_[4] = _tmp24_;
	_tmp41_[5] = _tmp28_;
	_tmp41_[6] = _tmp32_;
	_tmp41_[7] = _tmp36_;
	_tmp41_[8] = _tmp40_;
	self->priv->tool_feature_rules = (_vala_array_free (self->priv->tool_feature_rules, self->priv->tool_feature_rules_length1, (GDestroyNotify) g_object_unref), NULL);
	self->priv->tool_feature_rules = _tmp41_;
	self->priv->tool_feature_rules_length1 = 9;
	self->priv->_tool_feature_rules_size_ = self->priv->tool_feature_rules_length1;
	_tmp39_ = (_vala_array_free (_tmp39_, _tmp39__length1, (GDestroyNotify) g_free), NULL);
	_tmp35_ = (_vala_array_free (_tmp35_, _tmp35__length1, (GDestroyNotify) g_free), NULL);
	_tmp31_ = (_vala_array_free (_tmp31_, _tmp31__length1, (GDestroyNotify) g_free), NULL);
	_tmp27_ = (_vala_array_free (_tmp27_, _tmp27__length1, (GDestroyNotify) g_free), NULL);
	_tmp23_ = (_vala_array_free (_tmp23_, _tmp23__length1, (GDestroyNotify) g_free), NULL);
	_tmp19_ = (_vala_array_free (_tmp19_, _tmp19__length1, (GDestroyNotify) g_free), NULL);
	_tmp15_ = (_vala_array_free (_tmp15_, _tmp15__length1, (GDestroyNotify) g_free), NULL);
	_tmp11_ = (_vala_array_free (_tmp11_, _tmp11__length1, (GDestroyNotify) g_free), NULL);
	_tmp7_ = (_vala_array_free (_tmp7_, _tmp7__length1, (GDestroyNotify) g_free), NULL);
	_g_object_unref0 (_tmp0_);
	return self;
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver*
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_new (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCatalog* catalog)
{
	return proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_construct (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_CAPABILITY_RESOLVER, catalog);
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchCommandCapabilityContext*
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_resolve (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                           ProtonPlusModelsCompatibilityToolRuntimeKind* runtimes,
                                                                                           gint runtimes_length1,
                                                                                           gboolean all_steam,
                                                                                           ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionInstalledComponents* components,
                                                                                           ProtonPlusUtilsGpuVendor gpu_vendor,
                                                                                           ProtonPlusModelsCompatibilityTool** tools,
                                                                                           gint tools_length1)
{
	GeeHashMap* _tmp0_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* values = NULL;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp1_;
	gint values_length1;
	gint _values_size_;
	gboolean all_native = FALSE;
	gboolean all_proton = FALSE;
	gboolean _tmp19_;
	gboolean _tmp20_;
	gboolean _tmp24_;
	gboolean _tmp25_;
	gboolean _tmp29_;
	gboolean _tmp30_;
	gboolean _tmp34_;
	gboolean _tmp35_;
	gboolean _tmp39_;
	gboolean _tmp40_;
	gboolean _tmp44_;
	gboolean _tmp45_;
	gboolean _tmp49_;
	gboolean _tmp50_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp72_;
	gint _tmp72__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchCommandCapabilityContext* _tmp73_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchCommandCapabilityContext* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (components != NULL, NULL);
	_tmp0_ = self->priv->tool_document_cache;
	gee_abstract_map_clear ((GeeAbstractMap*) _tmp0_);
	_tmp1_ = g_new0 (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability, 0);
	values = _tmp1_;
	values_length1 = 0;
	_values_size_ = values_length1;
	if (all_steam) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp2_;
		gint _tmp2__length1;
		gint _tmp3_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp4_;
		_tmp2_ = values;
		_tmp2__length1 = values_length1;
		_tmp4_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp2_, (gint) _tmp2__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_STEAM, &_tmp3_);
		values = (g_free (values), NULL);
		values = _tmp4_;
		values_length1 = _tmp3_;
		_values_size_ = values_length1;
	}
	all_native = runtimes_length1 > 0;
	all_proton = runtimes_length1 > 0;
	{
		ProtonPlusModelsCompatibilityToolRuntimeKind* runtime_collection = NULL;
		gint runtime_collection_length1 = 0;
		gint _runtime_collection_size_ = 0;
		gint runtime_it = 0;
		runtime_collection = runtimes;
		runtime_collection_length1 = runtimes_length1;
		for (runtime_it = 0; runtime_it < runtime_collection_length1; runtime_it = runtime_it + 1) {
			ProtonPlusModelsCompatibilityToolRuntimeKind runtime = 0;
			runtime = runtime_collection[runtime_it];
			{
				gboolean _tmp5_ = FALSE;
				gboolean _tmp6_ = FALSE;
				if (all_native) {
					_tmp5_ = runtime == PROTON_PLUS_MODELS_COMPATIBILITY_TOOL_RUNTIME_KIND_NATIVE;
				} else {
					_tmp5_ = FALSE;
				}
				all_native = _tmp5_;
				if (all_proton) {
					_tmp6_ = runtime == PROTON_PLUS_MODELS_COMPATIBILITY_TOOL_RUNTIME_KIND_PROTON;
				} else {
					_tmp6_ = FALSE;
				}
				all_proton = _tmp6_;
			}
		}
	}
	if (all_native) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp7_;
		gint _tmp7__length1;
		gint _tmp8_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp9_;
		_tmp7_ = values;
		_tmp7__length1 = values_length1;
		_tmp9_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp7_, (gint) _tmp7__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_NATIVE_LINUX, &_tmp8_);
		values = (g_free (values), NULL);
		values = _tmp9_;
		values_length1 = _tmp8_;
		_values_size_ = values_length1;
	}
	if (all_proton) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp10_;
		gint _tmp10__length1;
		gint _tmp11_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp12_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp13_;
		gint _tmp13__length1;
		gint _tmp14_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp15_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp16_;
		gint _tmp16__length1;
		gint _tmp17_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp18_;
		_tmp10_ = values;
		_tmp10__length1 = values_length1;
		_tmp12_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp10_, (gint) _tmp10__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON, &_tmp11_);
		values = (g_free (values), NULL);
		values = _tmp12_;
		values_length1 = _tmp11_;
		_values_size_ = values_length1;
		_tmp13_ = values;
		_tmp13__length1 = values_length1;
		_tmp15_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp13_, (gint) _tmp13__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_DXVK, &_tmp14_);
		values = (g_free (values), NULL);
		values = _tmp15_;
		values_length1 = _tmp14_;
		_values_size_ = values_length1;
		_tmp16_ = values;
		_tmp16__length1 = values_length1;
		_tmp18_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp16_, (gint) _tmp16__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_VKD3D_PROTON, &_tmp17_);
		values = (g_free (values), NULL);
		values = _tmp18_;
		values_length1 = _tmp17_;
		_values_size_ = values_length1;
	}
	_tmp19_ = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_mangohud (components);
	_tmp20_ = _tmp19_;
	if (_tmp20_) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp21_;
		gint _tmp21__length1;
		gint _tmp22_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp23_;
		_tmp21_ = values;
		_tmp21__length1 = values_length1;
		_tmp23_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp21_, (gint) _tmp21__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_MANGOHUD, &_tmp22_);
		values = (g_free (values), NULL);
		values = _tmp23_;
		values_length1 = _tmp22_;
		_values_size_ = values_length1;
	}
	_tmp24_ = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_gamemode (components);
	_tmp25_ = _tmp24_;
	if (_tmp25_) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp26_;
		gint _tmp26__length1;
		gint _tmp27_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp28_;
		_tmp26_ = values;
		_tmp26__length1 = values_length1;
		_tmp28_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp26_, (gint) _tmp26__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_GAMEMODE, &_tmp27_);
		values = (g_free (values), NULL);
		values = _tmp28_;
		values_length1 = _tmp27_;
		_values_size_ = values_length1;
	}
	_tmp29_ = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_gamescope (components);
	_tmp30_ = _tmp29_;
	if (_tmp30_) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp31_;
		gint _tmp31__length1;
		gint _tmp32_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp33_;
		_tmp31_ = values;
		_tmp31__length1 = values_length1;
		_tmp33_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp31_, (gint) _tmp31__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_GAMESCOPE, &_tmp32_);
		values = (g_free (values), NULL);
		values = _tmp33_;
		values_length1 = _tmp32_;
		_values_size_ = values_length1;
	}
	_tmp34_ = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_scopebuddy (components);
	_tmp35_ = _tmp34_;
	if (_tmp35_) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp36_;
		gint _tmp36__length1;
		gint _tmp37_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp38_;
		_tmp36_ = values;
		_tmp36__length1 = values_length1;
		_tmp38_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp36_, (gint) _tmp36__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_SCOPEBUDDY, &_tmp37_);
		values = (g_free (values), NULL);
		values = _tmp38_;
		values_length1 = _tmp37_;
		_values_size_ = values_length1;
	}
	_tmp39_ = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_vkbasalt (components);
	_tmp40_ = _tmp39_;
	if (_tmp40_) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp41_;
		gint _tmp41__length1;
		gint _tmp42_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp43_;
		_tmp41_ = values;
		_tmp41__length1 = values_length1;
		_tmp43_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp41_, (gint) _tmp41__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_VKBASALT, &_tmp42_);
		values = (g_free (values), NULL);
		values = _tmp43_;
		values_length1 = _tmp42_;
		_values_size_ = values_length1;
	}
	_tmp44_ = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_game_performance (components);
	_tmp45_ = _tmp44_;
	if (_tmp45_) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp46_;
		gint _tmp46__length1;
		gint _tmp47_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp48_;
		_tmp46_ = values;
		_tmp46__length1 = values_length1;
		_tmp48_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp46_, (gint) _tmp46__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_GAME_PERFORMANCE, &_tmp47_);
		values = (g_free (values), NULL);
		values = _tmp48_;
		values_length1 = _tmp47_;
		_values_size_ = values_length1;
	}
	_tmp49_ = proton_plus_widgets_games_launch_options_editor_launch_option_installed_components_get_obs_vkcapture (components);
	_tmp50_ = _tmp49_;
	if (_tmp50_) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp51_;
		gint _tmp51__length1;
		gint _tmp52_ = 0;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp53_;
		_tmp51_ = values;
		_tmp51__length1 = values_length1;
		_tmp53_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp51_, (gint) _tmp51__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_OBS_VKCAPTURE, &_tmp52_);
		values = (g_free (values), NULL);
		values = _tmp53_;
		values_length1 = _tmp52_;
		_values_size_ = values_length1;
	}
	if (tools_length1 > 0) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule** _tmp54_;
		gint _tmp54__length1;
		_tmp54_ = self->priv->tool_feature_rules;
		_tmp54__length1 = self->priv->tool_feature_rules_length1;
		{
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule** rule_collection = NULL;
			gint rule_collection_length1 = 0;
			gint _rule_collection_size_ = 0;
			gint rule_it = 0;
			rule_collection = _tmp54_;
			rule_collection_length1 = _tmp54__length1;
			for (rule_it = 0; rule_it < rule_collection_length1; rule_it = rule_it + 1) {
				ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp55_;
				ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* rule = NULL;
				_tmp55_ = _g_object_ref0 (rule_collection[rule_it]);
				rule = _tmp55_;
				{
					ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp56_;
					_tmp56_ = rule;
					if (proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_all_tools_advertise_feature (self, tools, (gint) tools_length1, _tmp56_)) {
						ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp57_;
						gint _tmp57__length1;
						ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* _tmp58_;
						ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp59_;
						ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp60_;
						gint _tmp61_ = 0;
						ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp62_;
						_tmp57_ = values;
						_tmp57__length1 = values_length1;
						_tmp58_ = rule;
						_tmp59_ = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_capability (_tmp58_);
						_tmp60_ = _tmp59_;
						_tmp62_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp57_, (gint) _tmp57__length1, _tmp60_, &_tmp61_);
						values = (g_free (values), NULL);
						values = _tmp62_;
						values_length1 = _tmp61_;
						_values_size_ = values_length1;
					}
					_g_object_unref0 (rule);
				}
			}
		}
	}
	switch (gpu_vendor) {
		case PROTON_PLUS_UTILS_GPU_VENDOR_AMD:
		{
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp63_;
			gint _tmp63__length1;
			gint _tmp64_ = 0;
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp65_;
			_tmp63_ = values;
			_tmp63__length1 = values_length1;
			_tmp65_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp63_, (gint) _tmp63__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_AMD, &_tmp64_);
			values = (g_free (values), NULL);
			values = _tmp65_;
			values_length1 = _tmp64_;
			_values_size_ = values_length1;
			break;
		}
		case PROTON_PLUS_UTILS_GPU_VENDOR_NVIDIA:
		{
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp66_;
			gint _tmp66__length1;
			gint _tmp67_ = 0;
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp68_;
			_tmp66_ = values;
			_tmp66__length1 = values_length1;
			_tmp68_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp66_, (gint) _tmp66__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_NVIDIA, &_tmp67_);
			values = (g_free (values), NULL);
			values = _tmp68_;
			values_length1 = _tmp67_;
			_values_size_ = values_length1;
			break;
		}
		case PROTON_PLUS_UTILS_GPU_VENDOR_INTEL:
		{
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp69_;
			gint _tmp69__length1;
			gint _tmp70_ = 0;
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp71_;
			_tmp69_ = values;
			_tmp69__length1 = values_length1;
			_tmp71_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp69_, (gint) _tmp69__length1, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_INTEL, &_tmp70_);
			values = (g_free (values), NULL);
			values = _tmp71_;
			values_length1 = _tmp70_;
			_values_size_ = values_length1;
			break;
		}
		default:
		{
			break;
		}
	}
	_tmp72_ = values;
	_tmp72__length1 = values_length1;
	_tmp73_ = proton_plus_widgets_games_launch_options_editor_launch_command_capability_context_new (_tmp72_, _tmp72__length1);
	result = _tmp73_;
	values = (g_free (values), NULL);
	return result;
}

static gchar*
string_strip (const gchar* self)
{
	gchar* _result_ = NULL;
	gchar* _tmp0_;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = g_strdup (self);
	_result_ = _tmp0_;
	g_strstrip (_result_);
	result = _result_;
	return result;
}

static gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_all_tools_advertise_feature (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                               ProtonPlusModelsCompatibilityTool** tools,
                                                                                                               gint tools_length1,
                                                                                                               ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionToolFeatureRule* rule)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (rule != NULL, FALSE);
	if (tools_length1 == 0) {
		result = FALSE;
		return result;
	}
	{
		ProtonPlusModelsCompatibilityTool** tool_collection = NULL;
		gint tool_collection_length1 = 0;
		gint _tool_collection_size_ = 0;
		gint tool_it = 0;
		tool_collection = tools;
		tool_collection_length1 = tools_length1;
		for (tool_it = 0; tool_it < tool_collection_length1; tool_it = tool_it + 1) {
			ProtonPlusModelsCompatibilityTool* _tmp0_;
			ProtonPlusModelsCompatibilityTool* tool = NULL;
			_tmp0_ = _g_object_ref0 (tool_collection[tool_it]);
			tool = _tmp0_;
			{
				gboolean _tmp1_ = FALSE;
				ProtonPlusModelsCompatibilityTool* _tmp2_;
				gchar* documentation = NULL;
				ProtonPlusModelsCompatibilityTool* _tmp8_;
				const gchar* _tmp9_;
				const gchar* _tmp10_;
				gchar* _tmp11_;
				gboolean found = FALSE;
				gchar** _tmp12_;
				gint _tmp12__length1;
				gint _tmp13_ = 0;
				gchar** _tmp14_;
				gint _tmp14__length1;
				_tmp2_ = tool;
				if (proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_runtime_for_tool (self, _tmp2_) != PROTON_PLUS_MODELS_COMPATIBILITY_TOOL_RUNTIME_KIND_PROTON) {
					_tmp1_ = TRUE;
				} else {
					ProtonPlusModelsCompatibilityTool* _tmp3_;
					const gchar* _tmp4_;
					const gchar* _tmp5_;
					gchar* _tmp6_;
					gchar* _tmp7_;
					_tmp3_ = tool;
					_tmp4_ = proton_plus_models_compatibility_tool_get_inspection_path (_tmp3_);
					_tmp5_ = _tmp4_;
					_tmp6_ = string_strip (_tmp5_);
					_tmp7_ = _tmp6_;
					_tmp1_ = g_strcmp0 (_tmp7_, "") == 0;
					_g_free0 (_tmp7_);
				}
				if (_tmp1_) {
					result = FALSE;
					_g_object_unref0 (tool);
					return result;
				}
				_tmp8_ = tool;
				_tmp9_ = proton_plus_models_compatibility_tool_get_inspection_path (_tmp8_);
				_tmp10_ = _tmp9_;
				_tmp11_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_documentation_for_tool (self, _tmp10_);
				documentation = _tmp11_;
				found = FALSE;
				_tmp12_ = proton_plus_widgets_games_launch_options_editor_launch_option_tool_feature_rule_get_markers (rule, &_tmp13_);
				_tmp12__length1 = _tmp13_;
				_tmp14_ = _tmp12_;
				_tmp14__length1 = _tmp12__length1;
				{
					gchar** marker_collection = NULL;
					gint marker_collection_length1 = 0;
					gint _marker_collection_size_ = 0;
					gint marker_it = 0;
					marker_collection = _tmp14_;
					marker_collection_length1 = _tmp14__length1;
					for (marker_it = 0; marker_it < marker_collection_length1; marker_it = marker_it + 1) {
						gchar* _tmp15_;
						gchar* marker = NULL;
						_tmp15_ = g_strdup (marker_collection[marker_it]);
						marker = _tmp15_;
						{
							const gchar* _tmp16_;
							const gchar* _tmp17_;
							_tmp16_ = documentation;
							_tmp17_ = marker;
							if (proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_contains_feature_marker (self, _tmp16_, _tmp17_)) {
								found = TRUE;
								_g_free0 (marker);
								break;
							}
							_g_free0 (marker);
						}
					}
				}
				if (!found) {
					result = FALSE;
					_g_free0 (documentation);
					_g_object_unref0 (tool);
					return result;
				}
				_g_free0 (documentation);
				_g_object_unref0 (tool);
			}
		}
	}
	result = TRUE;
	return result;
}

static gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_contains_feature_marker (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                           const gchar* documentation,
                                                                                                           const gchar* marker)
{
	gboolean _tmp7_ = FALSE;
	GError* _inner_error0_ = NULL;
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	g_return_val_if_fail (documentation != NULL, FALSE);
	g_return_val_if_fail (marker != NULL, FALSE);
	{
		gchar* pattern = NULL;
		gchar* _tmp0_;
		gchar* _tmp1_;
		gchar* _tmp2_;
		gchar* _tmp3_;
		GRegex* _tmp4_ = NULL;
		GRegex* _tmp5_;
		_tmp0_ = g_regex_escape_string (marker, -1);
		_tmp1_ = _tmp0_;
		_tmp2_ = g_strdup_printf ("(^|[^A-Za-z0-9_])%s([^A-Za-z0-9_]|$)", _tmp1_);
		_tmp3_ = _tmp2_;
		_g_free0 (_tmp1_);
		pattern = _tmp3_;
		_tmp5_ = g_regex_new (pattern, G_REGEX_MULTILINE, 0, &_inner_error0_);
		_tmp4_ = _tmp5_;
		if (G_UNLIKELY (_inner_error0_ != NULL)) {
			gboolean _tmp6_ = FALSE;
			_g_free0 (pattern);
			if (_inner_error0_->domain == G_REGEX_ERROR) {
				goto __catch0_g_regex_error;
			}
			g_critical ("file %s: line %d: unexpected 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 _tmp6_;
		}
		result = g_regex_match (_tmp4_, documentation, 0, NULL);
		_g_regex_unref0 (_tmp4_);
		_g_free0 (pattern);
		return result;
	}
	goto __finally0;
	__catch0_g_regex_error:
	{
		g_clear_error (&_inner_error0_);
		result = FALSE;
		return result;
	}
	__finally0:
	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 _tmp7_;
}

static gchar*
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_documentation_for_tool (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                          const gchar* tool_path)
{
	GeeHashMap* _tmp0_;
	GString* documents = NULL;
	GString* _tmp3_;
	gchar* _result_ = NULL;
	GString* _tmp11_;
	const gchar* _tmp12_;
	gchar* _tmp13_;
	GeeHashMap* _tmp14_;
	const gchar* _tmp15_;
	GError* _inner_error0_ = NULL;
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (tool_path != NULL, NULL);
	_tmp0_ = self->priv->tool_document_cache;
	if (gee_abstract_map_has_key ((GeeAbstractMap*) _tmp0_, tool_path)) {
		GeeHashMap* _tmp1_;
		gpointer _tmp2_;
		_tmp1_ = self->priv->tool_document_cache;
		_tmp2_ = gee_abstract_map_get ((GeeAbstractMap*) _tmp1_, tool_path);
		result = (gchar*) _tmp2_;
		return result;
	}
	_tmp3_ = g_string_new ("");
	documents = _tmp3_;
	{
		const gchar** relative_path_collection = NULL;
		gint relative_path_collection_length1 = 0;
		gint _relative_path_collection_size_ = 0;
		gint relative_path_it = 0;
		relative_path_collection = PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_RESOLVER_TOOL_FEATURE_FILES;
		relative_path_collection_length1 = G_N_ELEMENTS (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_RESOLVER_TOOL_FEATURE_FILES);
		for (relative_path_it = 0; relative_path_it < relative_path_collection_length1; relative_path_it = relative_path_it + 1) {
			const gchar* relative_path = NULL;
			relative_path = relative_path_collection[relative_path_it];
			{
				gchar* contents = NULL;
				gchar* path = NULL;
				const gchar* _tmp4_;
				gchar* _tmp5_;
				_tmp4_ = relative_path;
				_tmp5_ = g_build_filename (tool_path, _tmp4_, NULL);
				path = _tmp5_;
				{
					const gchar* _tmp6_;
					gchar* _tmp7_ = NULL;
					GString* _tmp8_;
					const gchar* _tmp9_;
					GString* _tmp10_;
					_tmp6_ = path;
					g_file_get_contents (_tmp6_, &_tmp7_, NULL, &_inner_error0_);
					_g_free0 (contents);
					contents = _tmp7_;
					if (G_UNLIKELY (_inner_error0_ != NULL)) {
						if (_inner_error0_->domain == G_FILE_ERROR) {
							goto __catch0_g_file_error;
						}
						_g_free0 (path);
						_g_free0 (contents);
						_g_string_free0 (documents);
						g_critical ("file %s: line %d: unexpected 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 NULL;
					}
					_tmp8_ = documents;
					_tmp9_ = contents;
					g_string_append (_tmp8_, _tmp9_);
					_tmp10_ = documents;
					g_string_append_c (_tmp10_, '\n');
				}
				goto __finally0;
				__catch0_g_file_error:
				{
					g_clear_error (&_inner_error0_);
				}
				__finally0:
				if (G_UNLIKELY (_inner_error0_ != NULL)) {
					_g_free0 (path);
					_g_free0 (contents);
					_g_string_free0 (documents);
					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 NULL;
				}
				_g_free0 (path);
				_g_free0 (contents);
			}
		}
	}
	_tmp11_ = documents;
	_tmp12_ = _tmp11_->str;
	_tmp13_ = g_strdup (_tmp12_);
	_result_ = _tmp13_;
	_tmp14_ = self->priv->tool_document_cache;
	_tmp15_ = _result_;
	gee_abstract_map_set ((GeeAbstractMap*) _tmp14_, tool_path, _tmp15_);
	result = _result_;
	_g_string_free0 (documents);
	return result;
}

ProtonPlusModelsCompatibilityToolRuntimeKind
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_runtime_for_tool (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                    ProtonPlusModelsCompatibilityTool* tool)
{
	ProtonPlusModelsCompatibilityToolRuntimeKind result;
	g_return_val_if_fail (self != NULL, 0);
	result = proton_plus_models_launchers_steam_get_compatibility_tool_runtime_kind (tool);
	return result;
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility*
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_evaluate (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                            ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionMetadata* metadata,
                                                                                            ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchCommandCapabilityContext* context,
                                                                                            gboolean active)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* semantics = NULL;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp0_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp1_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp2_;
	gboolean _tmp3_ = FALSE;
	gboolean _tmp4_ = FALSE;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp5_;
	gboolean _tmp13_ = FALSE;
	gboolean _tmp14_ = FALSE;
	gboolean _tmp15_ = FALSE;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp16_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSupport _tmp17_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSupport _tmp18_;
	gint _tmp30_ = 0;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp31_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp36_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemanticKind _tmp37_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemanticKind _tmp38_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp53_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSupport _tmp54_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSupport _tmp55_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp57_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (metadata != NULL, NULL);
	_tmp0_ = proton_plus_widgets_games_launch_options_editor_launch_option_metadata_get_semantics (metadata);
	_tmp1_ = _tmp0_;
	_tmp2_ = _g_object_ref0 (_tmp1_);
	semantics = _tmp2_;
	_tmp5_ = semantics;
	if (_tmp5_ == NULL) {
		_tmp4_ = TRUE;
	} else {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp6_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSupport _tmp7_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSupport _tmp8_;
		_tmp6_ = semantics;
		_tmp7_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_support (_tmp6_);
		_tmp8_ = _tmp7_;
		_tmp4_ = _tmp8_ == PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_SUPPORT_UNSUPPORTED;
	}
	if (_tmp4_) {
		_tmp3_ = TRUE;
	} else {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp9_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSupport _tmp10_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSupport _tmp11_;
		_tmp9_ = semantics;
		_tmp10_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_support (_tmp9_);
		_tmp11_ = _tmp10_;
		_tmp3_ = _tmp11_ == PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_SUPPORT_UNKNOWN_UNVERIFIED;
	}
	if (_tmp3_) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp12_;
		_tmp12_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_unavailable (self, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNSUPPORTED, active, _ ("This option is unsupported and cannot be newly enabled."));
		result = _tmp12_;
		_g_object_unref0 (semantics);
		return result;
	}
	_tmp16_ = semantics;
	_tmp17_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_support (_tmp16_);
	_tmp18_ = _tmp17_;
	if (_tmp18_ == PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_SUPPORT_LEGACY_DEPRECATED) {
		_tmp15_ = TRUE;
	} else {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp19_;
		gboolean _tmp20_;
		gboolean _tmp21_;
		_tmp19_ = semantics;
		_tmp20_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_managed_emission (_tmp19_);
		_tmp21_ = _tmp20_;
		_tmp15_ = !_tmp21_;
	}
	if (_tmp15_) {
		_tmp14_ = TRUE;
	} else {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp22_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemanticKind _tmp23_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemanticKind _tmp24_;
		_tmp22_ = semantics;
		_tmp23_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_kind (_tmp22_);
		_tmp24_ = _tmp23_;
		_tmp14_ = _tmp24_ == PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_SEMANTIC_KIND_OPAQUE_CONTEXT_DEPENDENT;
	}
	if (_tmp14_) {
		_tmp13_ = TRUE;
	} else {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp25_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemanticKind _tmp26_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemanticKind _tmp27_;
		_tmp25_ = semantics;
		_tmp26_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_kind (_tmp25_);
		_tmp27_ = _tmp26_;
		_tmp13_ = _tmp27_ == PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_SEMANTIC_KIND_COMMAND_BOUNDARY;
	}
	if (_tmp13_) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp28_;
		_tmp28_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_unavailable (self, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_LEGACY_ACTIVE_ONLY, active, _ ("This legacy option is preserved but cannot be newly enabled."));
		result = _tmp28_;
		_g_object_unref0 (semantics);
		return result;
	}
	if (context == NULL) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp29_;
		_tmp29_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_unavailable (self, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNKNOWN_CONTEXT, active, _ ("Compatibility-tool capabilities are not known yet."));
		result = _tmp29_;
		_g_object_unref0 (semantics);
		return result;
	}
	_tmp31_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_required_capabilities (self, metadata, &_tmp30_);
	{
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* capability_collection = NULL;
		gint capability_collection_length1 = 0;
		gint _capability_collection_size_ = 0;
		gint capability_it = 0;
		capability_collection = _tmp31_;
		capability_collection_length1 = _tmp30_;
		for (capability_it = 0; capability_it < capability_collection_length1; capability_it = capability_it + 1) {
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability = 0;
			capability = capability_collection[capability_it];
			{
				if (!proton_plus_widgets_games_launch_options_editor_launch_command_capability_context_has (context, capability)) {
					gchar* _tmp32_;
					gchar* _tmp33_;
					ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp34_;
					ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp35_;
					_tmp32_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_reason_for (self, capability);
					_tmp33_ = _tmp32_;
					_tmp34_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_unavailable (self, proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_kind_for (self, capability), active, _tmp33_);
					_tmp35_ = _tmp34_;
					_g_free0 (_tmp33_);
					result = _tmp35_;
					capability_collection = (g_free (capability_collection), NULL);
					_g_object_unref0 (semantics);
					return result;
				}
			}
		}
		capability_collection = (g_free (capability_collection), NULL);
	}
	_tmp36_ = semantics;
	_tmp37_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_kind (_tmp36_);
	_tmp38_ = _tmp37_;
	if (_tmp38_ == PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_SEMANTIC_KIND_WRAPPER_SELECTOR) {
		gboolean has_available_wrapper = FALSE;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp39_;
		gchar** _tmp40_;
		gint _tmp40__length1;
		gint _tmp41_ = 0;
		gchar** _tmp42_;
		gint _tmp42__length1;
		has_available_wrapper = FALSE;
		_tmp39_ = semantics;
		_tmp40_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_selectable_wrapper_ids (_tmp39_, &_tmp41_);
		_tmp40__length1 = _tmp41_;
		_tmp42_ = _tmp40_;
		_tmp42__length1 = _tmp40__length1;
		{
			gchar** id_collection = NULL;
			gint id_collection_length1 = 0;
			gint _id_collection_size_ = 0;
			gint id_it = 0;
			id_collection = _tmp42_;
			id_collection_length1 = _tmp42__length1;
			for (id_it = 0; id_it < id_collection_length1; id_it = id_it + 1) {
				gchar* _tmp43_;
				gchar* id = NULL;
				_tmp43_ = g_strdup (id_collection[id_it]);
				id = _tmp43_;
				{
					ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* wrapper = NULL;
					ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCatalog* _tmp44_;
					const gchar* _tmp45_;
					ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp46_;
					gboolean _tmp47_ = FALSE;
					ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp48_;
					_tmp44_ = self->priv->catalog;
					_tmp45_ = id;
					_tmp46_ = proton_plus_widgets_games_launch_options_editor_launch_option_catalog_lookup_wrapper (_tmp44_, _tmp45_);
					wrapper = _tmp46_;
					_tmp48_ = wrapper;
					if (_tmp48_ != NULL) {
						ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp49_;
						ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp50_;
						ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp51_;
						_tmp49_ = wrapper;
						_tmp50_ = proton_plus_widgets_games_launch_options_editor_launch_wrapper_definition_get_required_capability (_tmp49_);
						_tmp51_ = _tmp50_;
						_tmp47_ = proton_plus_widgets_games_launch_options_editor_launch_command_capability_context_has (context, _tmp51_);
					} else {
						_tmp47_ = FALSE;
					}
					if (_tmp47_) {
						has_available_wrapper = TRUE;
						_g_object_unref0 (wrapper);
						_g_free0 (id);
						break;
					}
					_g_object_unref0 (wrapper);
					_g_free0 (id);
				}
			}
		}
		if (!has_available_wrapper) {
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp52_;
			_tmp52_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_unavailable (self, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNAVAILABLE_COMPONENT, active, _ ("Requires an available launch backend."));
			result = _tmp52_;
			_g_object_unref0 (semantics);
			return result;
		}
	}
	_tmp53_ = semantics;
	_tmp54_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_support (_tmp53_);
	_tmp55_ = _tmp54_;
	if (_tmp55_ == PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_SUPPORT_VARIANT_SPECIFIC) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp56_;
		_tmp56_ = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_new (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_VARIANT_SELECTABLE_WITH_WARNING, TRUE, TRUE, TRUE, TRUE, _ ("Requires a compatible Proton variant."));
		result = _tmp56_;
		_g_object_unref0 (semantics);
		return result;
	}
	_tmp57_ = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_new (PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_AVAILABLE, TRUE, TRUE, TRUE, TRUE, "");
	result = _tmp57_;
	_g_object_unref0 (semantics);
	return result;
}

ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility*
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_evaluate_selection (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                      ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionMetadata* metadata,
                                                                                                      ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchCommandSelection* selection,
                                                                                                      ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchCommandCapabilityContext* context,
                                                                                                      gboolean active)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* eligibility = NULL;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp0_;
	gboolean _tmp1_ = FALSE;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp2_;
	gboolean _tmp3_;
	gboolean _tmp4_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* wrapper = NULL;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCatalog* _tmp7_;
	const gchar* _tmp8_;
	const gchar* _tmp9_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp10_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp11_;
	gboolean _tmp13_ = FALSE;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (metadata != NULL, NULL);
	g_return_val_if_fail (selection != NULL, NULL);
	_tmp0_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_evaluate (self, metadata, context, active);
	eligibility = _tmp0_;
	_tmp2_ = eligibility;
	_tmp3_ = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_get_may_activate (_tmp2_);
	_tmp4_ = _tmp3_;
	if (!_tmp4_) {
		_tmp1_ = TRUE;
	} else {
		const gchar* _tmp5_;
		const gchar* _tmp6_;
		_tmp5_ = proton_plus_widgets_games_launch_options_editor_launch_command_selection_get_wrapper_id (selection);
		_tmp6_ = _tmp5_;
		_tmp1_ = g_strcmp0 (_tmp6_, "") == 0;
	}
	if (_tmp1_) {
		result = eligibility;
		return result;
	}
	_tmp7_ = self->priv->catalog;
	_tmp8_ = proton_plus_widgets_games_launch_options_editor_launch_command_selection_get_wrapper_id (selection);
	_tmp9_ = _tmp8_;
	_tmp10_ = proton_plus_widgets_games_launch_options_editor_launch_option_catalog_lookup_wrapper (_tmp7_, _tmp9_);
	wrapper = _tmp10_;
	_tmp11_ = wrapper;
	if (_tmp11_ == NULL) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp12_;
		_tmp12_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_unavailable (self, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNSUPPORTED, active, _ ("The selected launch backend is not supported."));
		result = _tmp12_;
		_g_object_unref0 (wrapper);
		_g_object_unref0 (eligibility);
		return result;
	}
	if (context == NULL) {
		_tmp13_ = TRUE;
	} else {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp14_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp15_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp16_;
		_tmp14_ = wrapper;
		_tmp15_ = proton_plus_widgets_games_launch_options_editor_launch_wrapper_definition_get_required_capability (_tmp14_);
		_tmp16_ = _tmp15_;
		_tmp13_ = !proton_plus_widgets_games_launch_options_editor_launch_command_capability_context_has (context, _tmp16_);
	}
	if (_tmp13_) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp17_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp18_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp19_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp20_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp21_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp22_;
		gchar* _tmp23_;
		gchar* _tmp24_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp25_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp26_;
		_tmp17_ = wrapper;
		_tmp18_ = proton_plus_widgets_games_launch_options_editor_launch_wrapper_definition_get_required_capability (_tmp17_);
		_tmp19_ = _tmp18_;
		_tmp20_ = wrapper;
		_tmp21_ = proton_plus_widgets_games_launch_options_editor_launch_wrapper_definition_get_required_capability (_tmp20_);
		_tmp22_ = _tmp21_;
		_tmp23_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_reason_for (self, _tmp22_);
		_tmp24_ = _tmp23_;
		_tmp25_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_unavailable (self, proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_kind_for (self, _tmp19_), active, _tmp24_);
		_tmp26_ = _tmp25_;
		_g_free0 (_tmp24_);
		result = _tmp26_;
		_g_object_unref0 (wrapper);
		_g_object_unref0 (eligibility);
		return result;
	}
	result = eligibility;
	_g_object_unref0 (wrapper);
	return result;
}

static ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility*
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_unavailable (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                               ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind kind,
                                                                                               gboolean active,
                                                                                               const gchar* reason)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* _tmp0_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibility* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (reason != NULL, NULL);
	_tmp0_ = proton_plus_widgets_games_launch_options_editor_launch_option_eligibility_new (kind, FALSE, FALSE, FALSE, active, reason);
	result = _tmp0_;
	return result;
}

static ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability*
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_required_capabilities (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                         ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionMetadata* metadata,
                                                                                                         gint* result_length1)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* values = NULL;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp0_;
	gint values_length1;
	gint _values_size_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* semantics = NULL;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp1_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp2_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp3_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp4_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp6_;
	gint _tmp7_ = 0;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp8_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp13_;
	const gchar* _tmp14_;
	const gchar* _tmp15_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp33_;
	gint _tmp33__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* result;
	g_return_val_if_fail (self != NULL, NULL);
	g_return_val_if_fail (metadata != NULL, NULL);
	_tmp0_ = g_new0 (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability, 0);
	values = _tmp0_;
	values_length1 = 0;
	_values_size_ = values_length1;
	_tmp1_ = proton_plus_widgets_games_launch_options_editor_launch_option_metadata_get_semantics (metadata);
	_tmp2_ = _tmp1_;
	_tmp3_ = _g_object_ref0 (_tmp2_);
	semantics = _tmp3_;
	_tmp4_ = semantics;
	if (_tmp4_ == NULL) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp5_;
		gint _tmp5__length1;
		_tmp5_ = values;
		_tmp5__length1 = values_length1;
		if (result_length1) {
			*result_length1 = _tmp5__length1;
		}
		result = _tmp5_;
		_g_object_unref0 (semantics);
		return result;
	}
	_tmp6_ = semantics;
	_tmp8_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_required_capabilities (_tmp6_, &_tmp7_);
	{
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* capability_collection = NULL;
		gint capability_collection_length1 = 0;
		gint _capability_collection_size_ = 0;
		gint capability_it = 0;
		capability_collection = _tmp8_;
		capability_collection_length1 = _tmp7_;
		for (capability_it = 0; capability_it < capability_collection_length1; capability_it = capability_it + 1) {
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability = 0;
			capability = capability_collection[capability_it];
			{
				ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp9_;
				gint _tmp9__length1;
				_tmp9_ = values;
				_tmp9__length1 = values_length1;
				if (!proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_contains_capability (self, _tmp9_, (gint) _tmp9__length1, capability)) {
					ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp10_;
					gint _tmp10__length1;
					gint _tmp11_ = 0;
					ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp12_;
					_tmp10_ = values;
					_tmp10__length1 = values_length1;
					_tmp12_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp10_, (gint) _tmp10__length1, capability, &_tmp11_);
					values = (g_free (values), NULL);
					values = _tmp12_;
					values_length1 = _tmp11_;
					_values_size_ = values_length1;
				}
			}
		}
		capability_collection = (g_free (capability_collection), NULL);
	}
	_tmp13_ = semantics;
	_tmp14_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_wrapper_id (_tmp13_);
	_tmp15_ = _tmp14_;
	if (g_strcmp0 (_tmp15_, "") != 0) {
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* wrapper = NULL;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCatalog* _tmp16_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionSemantics* _tmp17_;
		const gchar* _tmp18_;
		const gchar* _tmp19_;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp20_;
		gboolean _tmp21_ = FALSE;
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp22_;
		_tmp16_ = self->priv->catalog;
		_tmp17_ = semantics;
		_tmp18_ = proton_plus_widgets_games_launch_options_editor_launch_option_semantics_get_wrapper_id (_tmp17_);
		_tmp19_ = _tmp18_;
		_tmp20_ = proton_plus_widgets_games_launch_options_editor_launch_option_catalog_lookup_wrapper (_tmp16_, _tmp19_);
		wrapper = _tmp20_;
		_tmp22_ = wrapper;
		if (_tmp22_ != NULL) {
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp23_;
			gint _tmp23__length1;
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp24_;
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp25_;
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp26_;
			_tmp23_ = values;
			_tmp23__length1 = values_length1;
			_tmp24_ = wrapper;
			_tmp25_ = proton_plus_widgets_games_launch_options_editor_launch_wrapper_definition_get_required_capability (_tmp24_);
			_tmp26_ = _tmp25_;
			_tmp21_ = !proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_contains_capability (self, _tmp23_, (gint) _tmp23__length1, _tmp26_);
		} else {
			_tmp21_ = FALSE;
		}
		if (_tmp21_) {
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp27_;
			gint _tmp27__length1;
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchWrapperDefinition* _tmp28_;
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp29_;
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp30_;
			gint _tmp31_ = 0;
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp32_;
			_tmp27_ = values;
			_tmp27__length1 = values_length1;
			_tmp28_ = wrapper;
			_tmp29_ = proton_plus_widgets_games_launch_options_editor_launch_wrapper_definition_get_required_capability (_tmp28_);
			_tmp30_ = _tmp29_;
			_tmp32_ = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (self, _tmp27_, (gint) _tmp27__length1, _tmp30_, &_tmp31_);
			values = (g_free (values), NULL);
			values = _tmp32_;
			values_length1 = _tmp31_;
			_values_size_ = values_length1;
		}
		_g_object_unref0 (wrapper);
	}
	_tmp33_ = values;
	_tmp33__length1 = values_length1;
	if (result_length1) {
		*result_length1 = _tmp33__length1;
	}
	result = _tmp33_;
	_g_object_unref0 (semantics);
	return result;
}

static ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability*
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_append_capability (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                     ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* values,
                                                                                                     gint values_length1,
                                                                                                     ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability,
                                                                                                     gint* result_length1)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* expanded = NULL;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp0_;
	gint expanded_length1;
	gint _expanded_size_;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp5_;
	gint _tmp5__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp6_;
	gint _tmp6__length1;
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* result;
	g_return_val_if_fail (self != NULL, NULL);
	_tmp0_ = g_new0 (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability, values_length1 + 1);
	expanded = _tmp0_;
	expanded_length1 = values_length1 + 1;
	_expanded_size_ = expanded_length1;
	{
		gint index = 0;
		index = 0;
		{
			gboolean _tmp1_ = FALSE;
			_tmp1_ = TRUE;
			while (TRUE) {
				ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* _tmp3_;
				gint _tmp3__length1;
				ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability _tmp4_;
				if (!_tmp1_) {
					gint _tmp2_;
					_tmp2_ = index;
					index = _tmp2_ + 1;
				}
				_tmp1_ = FALSE;
				if (!(index < values_length1)) {
					break;
				}
				_tmp3_ = expanded;
				_tmp3__length1 = expanded_length1;
				_tmp4_ = values[index];
				_tmp3_[index] = _tmp4_;
			}
		}
	}
	_tmp5_ = expanded;
	_tmp5__length1 = expanded_length1;
	_tmp5_[values_length1] = capability;
	_tmp6_ = expanded;
	_tmp6__length1 = expanded_length1;
	if (result_length1) {
		*result_length1 = _tmp6__length1;
	}
	result = _tmp6_;
	return result;
}

static gboolean
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_contains_capability (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                                       ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* values,
                                                                                                       gint values_length1,
                                                                                                       ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability)
{
	gboolean result;
	g_return_val_if_fail (self != NULL, FALSE);
	{
		ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability* value_collection = NULL;
		gint value_collection_length1 = 0;
		gint _value_collection_size_ = 0;
		gint value_it = 0;
		value_collection = values;
		value_collection_length1 = values_length1;
		for (value_it = 0; value_it < value_collection_length1; value_it = value_it + 1) {
			ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability value = 0;
			value = value_collection[value_it];
			{
				if (value == capability) {
					result = TRUE;
					return result;
				}
			}
		}
	}
	result = FALSE;
	return result;
}

static ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_kind_for (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                            ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionEligibilityKind result;
	g_return_val_if_fail (self != NULL, 0);
	switch (capability) {
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_AMD:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_NVIDIA:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_INTEL:
		{
			result = PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNAVAILABLE_HARDWARE;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_MANGOHUD:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_GAMEMODE:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_GAME_PERFORMANCE:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_OBS_VKCAPTURE:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_GAMESCOPE:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_SCOPEBUDDY:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_VKBASALT:
		{
			result = PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNAVAILABLE_COMPONENT;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_DXVK:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_VKD3D_PROTON:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_NATIVE_LINUX:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_LEGACY_PROTON_HDR:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_AUTO_HDR_CONTROL:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_FSR4:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_FSR4_RDNA3:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_MLFG:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_DXVK_LOW_LATENCY:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_VKD3D_LOW_LATENCY:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_LOW_LATENCY_LAYER:
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_VULKAN_REFLEX_LAYER:
		{
			result = PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNAVAILABLE_RUNTIME;
			return result;
		}
		default:
		{
			result = PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_ELIGIBILITY_KIND_UNKNOWN_CONTEXT;
			return result;
		}
	}
}

static gchar*
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_reason_for (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver* self,
                                                                                              ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapability capability)
{
	gchar* result;
	g_return_val_if_fail (self != NULL, NULL);
	switch (capability) {
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_AMD:
		{
			gchar* _tmp0_;
			_tmp0_ = g_strdup (_ ("Requires an AMD GPU."));
			result = _tmp0_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_NVIDIA:
		{
			gchar* _tmp1_;
			_tmp1_ = g_strdup (_ ("Requires an NVIDIA GPU."));
			result = _tmp1_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_INTEL:
		{
			gchar* _tmp2_;
			_tmp2_ = g_strdup (_ ("Requires an Intel GPU."));
			result = _tmp2_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_MANGOHUD:
		{
			gchar* _tmp3_;
			_tmp3_ = g_strdup (_ ("Requires MangoHud, which is not available."));
			result = _tmp3_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_GAMEMODE:
		{
			gchar* _tmp4_;
			_tmp4_ = g_strdup (_ ("Requires GameMode, which is not available."));
			result = _tmp4_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_GAME_PERFORMANCE:
		{
			gchar* _tmp5_;
			_tmp5_ = g_strdup (_ ("Requires the CachyOS game-performance command, which is not available."));
			result = _tmp5_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_OBS_VKCAPTURE:
		{
			gchar* _tmp6_;
			_tmp6_ = g_strdup (_ ("Requires obs-vkcapture, which is not available."));
			result = _tmp6_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_GAMESCOPE:
		{
			gchar* _tmp7_;
			_tmp7_ = g_strdup (_ ("Requires Gamescope, which is not available."));
			result = _tmp7_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_SCOPEBUDDY:
		{
			gchar* _tmp8_;
			_tmp8_ = g_strdup (_ ("Requires ScopeBuddy, which is not available."));
			result = _tmp8_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_VKBASALT:
		{
			gchar* _tmp9_;
			_tmp9_ = g_strdup (_ ("Requires vkBasalt, which is not available."));
			result = _tmp9_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_DXVK:
		{
			gchar* _tmp10_;
			_tmp10_ = g_strdup (_ ("Requires DXVK from the selected compatibility tool."));
			result = _tmp10_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_VKD3D_PROTON:
		{
			gchar* _tmp11_;
			_tmp11_ = g_strdup (_ ("Requires VKD3D-Proton from the selected compatibility tool."));
			result = _tmp11_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_NATIVE_LINUX:
		{
			gchar* _tmp12_;
			_tmp12_ = g_strdup (_ ("Not supported by the selected compatibility tool."));
			result = _tmp12_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_LEGACY_PROTON_HDR:
		{
			gchar* _tmp13_;
			_tmp13_ = g_strdup (_ ("The selected Proton build does not advertise legacy PROTON_ENABLE_HDR " \
"support."));
			result = _tmp13_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_AUTO_HDR_CONTROL:
		{
			gchar* _tmp14_;
			_tmp14_ = g_strdup (_ ("The selected Proton build does not advertise automatic-HDR opt-out sup" \
"port."));
			result = _tmp14_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_FSR4:
		{
			gchar* _tmp15_;
			_tmp15_ = g_strdup (_ ("The selected Proton build does not advertise PROTON_FSR4_UPGRADE suppo" \
"rt."));
			result = _tmp15_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_FSR4_RDNA3:
		{
			gchar* _tmp16_;
			_tmp16_ = g_strdup (_ ("The selected Proton build does not advertise the legacy RDNA3 FSR 4 sw" \
"itch."));
			result = _tmp16_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_MLFG:
		{
			gchar* _tmp17_;
			_tmp17_ = g_strdup (_ ("The selected Proton build does not advertise PROTON_MLFG_UPGRADE suppo" \
"rt."));
			result = _tmp17_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_DXVK_LOW_LATENCY:
		{
			gchar* _tmp18_;
			_tmp18_ = g_strdup (_ ("The selected Proton build does not advertise its DXVK low-latency opti" \
"on."));
			result = _tmp18_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_PROTON_VKD3D_LOW_LATENCY:
		{
			gchar* _tmp19_;
			_tmp19_ = g_strdup (_ ("The selected Proton build does not advertise its VKD3D-Proton low-late" \
"ncy option."));
			result = _tmp19_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_LOW_LATENCY_LAYER:
		{
			gchar* _tmp20_;
			_tmp20_ = g_strdup (_ ("The selected Proton build does not advertise the low-latency Vulkan la" \
"yer."));
			result = _tmp20_;
			return result;
		}
		case PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_LAUNCH_OPTION_CAPABILITY_VULKAN_REFLEX_LAYER:
		{
			gchar* _tmp21_;
			_tmp21_ = g_strdup (_ ("The selected Proton build does not advertise its Vulkan Reflex layer."));
			result = _tmp21_;
			return result;
		}
		default:
		{
			gchar* _tmp22_;
			_tmp22_ = g_strdup (_ ("Not supported by the selected compatibility tool."));
			result = _tmp22_;
			return result;
		}
	}
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_class_init (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolverClass * klass,
                                                                                              gpointer klass_data)
{
	proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_parent_class = g_type_class_peek_parent (klass);
	g_type_class_adjust_private_offset (klass, &ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver_private_offset);
	G_OBJECT_CLASS (klass)->finalize = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_finalize;
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_instance_init (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver * self,
                                                                                                 gpointer klass)
{
	self->priv = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_get_instance_private (self);
}

static void
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_finalize (GObject * obj)
{
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver * self;
	self = G_TYPE_CHECK_INSTANCE_CAST (obj, PROTON_PLUS_WIDGETS_GAMES_LAUNCH_OPTIONS_EDITOR_TYPE_LAUNCH_OPTION_CAPABILITY_RESOLVER, ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver);
	_g_object_unref0 (self->priv->catalog);
	_g_object_unref0 (self->priv->tool_document_cache);
	self->priv->tool_feature_rules = (_vala_array_free (self->priv->tool_feature_rules, self->priv->tool_feature_rules_length1, (GDestroyNotify) g_object_unref), NULL);
	G_OBJECT_CLASS (proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_parent_class)->finalize (obj);
}

static GType
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolverClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver), 0, (GInstanceInitFunc) proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_instance_init, NULL };
	GType proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_type_id;
	proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_type_id = g_type_register_static (G_TYPE_OBJECT, "ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver", &g_define_type_info, 0);
	ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolver_private_offset = g_type_add_instance_private (proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_type_id, sizeof (ProtonPlusWidgetsGamesLaunchOptionsEditorLaunchOptionCapabilityResolverPrivate));
	return proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_type_id;
}

GType
proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_get_type (void)
{
	static volatile gsize proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_type_id__once = 0;
	if (g_once_init_enter (&proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_type_id__once)) {
		GType proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_type_id;
		proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_type_id = proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_get_type_once ();
		g_once_init_leave (&proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_type_id__once, proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_type_id);
	}
	return proton_plus_widgets_games_launch_options_editor_launch_option_capability_resolver_type_id__once;
}

static void
_vala_array_destroy (gpointer array,
                     gssize array_length,
                     GDestroyNotify destroy_func)
{
	if ((array != NULL) && (destroy_func != NULL)) {
		gssize i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}

static void
_vala_array_free (gpointer array,
                  gssize array_length,
                  GDestroyNotify destroy_func)
{
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}

static inline gpointer
_vala_memdup2 (gconstpointer mem,
               gsize byte_size)
{
	gpointer new_mem;
	if (mem && byte_size != 0) {
		new_mem = g_malloc (byte_size);
		memcpy (new_mem, mem, byte_size);
	} else {
		new_mem = NULL;
	}
	return new_mem;
}

