wayland-client-protocol-unstable.hpp

#pragma once
 
#include <array>
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
#include <wayland-client.hpp>
#include <wayland-client-protocol-extra.hpp>
 
struct zwp_fullscreen_shell_v1;
struct zwp_fullscreen_shell_mode_feedback_v1;
struct zwp_idle_inhibit_manager_v1;
struct zwp_idle_inhibitor_v1;
struct zwp_input_method_context_v1;
struct zwp_input_method_v1;
struct zwp_input_panel_v1;
struct zwp_input_panel_surface_v1;
struct zwp_input_timestamps_manager_v1;
struct zwp_input_timestamps_v1;
struct zwp_keyboard_shortcuts_inhibit_manager_v1;
struct zwp_keyboard_shortcuts_inhibitor_v1;
struct zwp_linux_dmabuf_v1;
struct zwp_linux_buffer_params_v1;
struct zwp_linux_explicit_synchronization_v1;
struct zwp_linux_surface_synchronization_v1;
struct zwp_linux_buffer_release_v1;
struct zwp_pointer_constraints_v1;
struct zwp_locked_pointer_v1;
struct zwp_confined_pointer_v1;
struct zwp_pointer_gestures_v1;
struct zwp_pointer_gesture_swipe_v1;
struct zwp_pointer_gesture_pinch_v1;
struct zwp_primary_selection_device_manager_v1;
struct zwp_primary_selection_device_v1;
struct zwp_primary_selection_offer_v1;
struct zwp_primary_selection_source_v1;
struct zwp_relative_pointer_manager_v1;
struct zwp_relative_pointer_v1;
struct zwp_tablet_manager_v1;
struct zwp_tablet_seat_v1;
struct zwp_tablet_tool_v1;
struct zwp_tablet_v1;
struct zwp_tablet_manager_v2;
struct zwp_tablet_seat_v2;
struct zwp_tablet_tool_v2;
struct zwp_tablet_v2;
struct zwp_tablet_pad_ring_v2;
struct zwp_tablet_pad_strip_v2;
struct zwp_tablet_pad_group_v2;
struct zwp_tablet_pad_v2;
struct zwp_text_input_v1;
struct zwp_text_input_manager_v1;
struct zwp_text_input_v3;
struct zwp_text_input_manager_v3;
struct zxdg_decoration_manager_v1;
struct zxdg_toplevel_decoration_v1;
struct zxdg_exporter_v1;
struct zxdg_importer_v1;
struct zxdg_exported_v1;
struct zxdg_imported_v1;
struct zxdg_exporter_v2;
struct zxdg_importer_v2;
struct zxdg_exported_v2;
struct zxdg_imported_v2;
struct zxdg_output_manager_v1;
struct zxdg_output_v1;
struct zxdg_shell_v6;
struct zxdg_positioner_v6;
struct zxdg_surface_v6;
struct zxdg_toplevel_v6;
struct zxdg_popup_v6;
struct zwp_xwayland_keyboard_grab_manager_v1;
struct zwp_xwayland_keyboard_grab_v1;
 
namespace wayland
{
class zwp_fullscreen_shell_v1_t;
enum class zwp_fullscreen_shell_v1_capability : uint32_t;
enum class zwp_fullscreen_shell_v1_present_method : uint32_t;
enum class zwp_fullscreen_shell_v1_error : uint32_t;
class zwp_fullscreen_shell_mode_feedback_v1_t;
class zwp_idle_inhibit_manager_v1_t;
class zwp_idle_inhibitor_v1_t;
class zwp_input_method_context_v1_t;
class zwp_input_method_v1_t;
class zwp_input_panel_v1_t;
class zwp_input_panel_surface_v1_t;
enum class zwp_input_panel_surface_v1_position : uint32_t;
class zwp_input_timestamps_manager_v1_t;
class zwp_input_timestamps_v1_t;
class zwp_keyboard_shortcuts_inhibit_manager_v1_t;
enum class zwp_keyboard_shortcuts_inhibit_manager_v1_error : uint32_t;
class zwp_keyboard_shortcuts_inhibitor_v1_t;
class zwp_linux_dmabuf_v1_t;
class zwp_linux_buffer_params_v1_t;
enum class zwp_linux_buffer_params_v1_error : uint32_t;
enum class zwp_linux_buffer_params_v1_flags : uint32_t;
class zwp_linux_explicit_synchronization_v1_t;
enum class zwp_linux_explicit_synchronization_v1_error : uint32_t;
class zwp_linux_surface_synchronization_v1_t;
enum class zwp_linux_surface_synchronization_v1_error : uint32_t;
class zwp_linux_buffer_release_v1_t;
class zwp_pointer_constraints_v1_t;
enum class zwp_pointer_constraints_v1_error : uint32_t;
enum class zwp_pointer_constraints_v1_lifetime : uint32_t;
class zwp_locked_pointer_v1_t;
class zwp_confined_pointer_v1_t;
class zwp_pointer_gestures_v1_t;
class zwp_pointer_gesture_swipe_v1_t;
class zwp_pointer_gesture_pinch_v1_t;
class zwp_primary_selection_device_manager_v1_t;
class zwp_primary_selection_device_v1_t;
class zwp_primary_selection_offer_v1_t;
class zwp_primary_selection_source_v1_t;
class zwp_relative_pointer_manager_v1_t;
class zwp_relative_pointer_v1_t;
class zwp_tablet_manager_v1_t;
class zwp_tablet_seat_v1_t;
class zwp_tablet_tool_v1_t;
enum class zwp_tablet_tool_v1_type : uint32_t;
enum class zwp_tablet_tool_v1_capability : uint32_t;
enum class zwp_tablet_tool_v1_button_state : uint32_t;
enum class zwp_tablet_tool_v1_error : uint32_t;
class zwp_tablet_v1_t;
class zwp_tablet_manager_v2_t;
class zwp_tablet_seat_v2_t;
class zwp_tablet_tool_v2_t;
enum class zwp_tablet_tool_v2_type : uint32_t;
enum class zwp_tablet_tool_v2_capability : uint32_t;
enum class zwp_tablet_tool_v2_button_state : uint32_t;
enum class zwp_tablet_tool_v2_error : uint32_t;
class zwp_tablet_v2_t;
class zwp_tablet_pad_ring_v2_t;
enum class zwp_tablet_pad_ring_v2_source : uint32_t;
class zwp_tablet_pad_strip_v2_t;
enum class zwp_tablet_pad_strip_v2_source : uint32_t;
class zwp_tablet_pad_group_v2_t;
class zwp_tablet_pad_v2_t;
enum class zwp_tablet_pad_v2_button_state : uint32_t;
class zwp_text_input_v1_t;
enum class zwp_text_input_v1_content_hint : uint32_t;
enum class zwp_text_input_v1_content_purpose : uint32_t;
enum class zwp_text_input_v1_preedit_style : uint32_t;
enum class zwp_text_input_v1_text_direction : uint32_t;
class zwp_text_input_manager_v1_t;
class zwp_text_input_v3_t;
enum class zwp_text_input_v3_change_cause : uint32_t;
struct zwp_text_input_v3_content_hint;
enum class zwp_text_input_v3_content_purpose : uint32_t;
class zwp_text_input_manager_v3_t;
class zxdg_decoration_manager_v1_t;
class zxdg_toplevel_decoration_v1_t;
enum class zxdg_toplevel_decoration_v1_error : uint32_t;
enum class zxdg_toplevel_decoration_v1_mode : uint32_t;
class zxdg_exporter_v1_t;
class zxdg_importer_v1_t;
class zxdg_exported_v1_t;
class zxdg_imported_v1_t;
class zxdg_exporter_v2_t;
class zxdg_importer_v2_t;
class zxdg_exported_v2_t;
class zxdg_imported_v2_t;
class zxdg_output_manager_v1_t;
class zxdg_output_v1_t;
class zxdg_shell_v6_t;
enum class zxdg_shell_v6_error : uint32_t;
class zxdg_positioner_v6_t;
enum class zxdg_positioner_v6_error : uint32_t;
struct zxdg_positioner_v6_anchor;
struct zxdg_positioner_v6_gravity;
struct zxdg_positioner_v6_constraint_adjustment;
class zxdg_surface_v6_t;
enum class zxdg_surface_v6_error : uint32_t;
class zxdg_toplevel_v6_t;
struct zxdg_toplevel_v6_resize_edge;
enum class zxdg_toplevel_v6_state : uint32_t;
class zxdg_popup_v6_t;
enum class zxdg_popup_v6_error : uint32_t;
class zwp_xwayland_keyboard_grab_manager_v1_t;
class zwp_xwayland_keyboard_grab_v1_t;
 
namespace detail
{
  extern const wl_interface zwp_fullscreen_shell_v1_interface;
  extern const wl_interface zwp_fullscreen_shell_mode_feedback_v1_interface;
  extern const wl_interface zwp_idle_inhibit_manager_v1_interface;
  extern const wl_interface zwp_idle_inhibitor_v1_interface;
  extern const wl_interface zwp_input_method_context_v1_interface;
  extern const wl_interface zwp_input_method_v1_interface;
  extern const wl_interface zwp_input_panel_v1_interface;
  extern const wl_interface zwp_input_panel_surface_v1_interface;
  extern const wl_interface zwp_input_timestamps_manager_v1_interface;
  extern const wl_interface zwp_input_timestamps_v1_interface;
  extern const wl_interface zwp_keyboard_shortcuts_inhibit_manager_v1_interface;
  extern const wl_interface zwp_keyboard_shortcuts_inhibitor_v1_interface;
  extern const wl_interface zwp_linux_dmabuf_v1_interface;
  extern const wl_interface zwp_linux_buffer_params_v1_interface;
  extern const wl_interface zwp_linux_explicit_synchronization_v1_interface;
  extern const wl_interface zwp_linux_surface_synchronization_v1_interface;
  extern const wl_interface zwp_linux_buffer_release_v1_interface;
  extern const wl_interface zwp_pointer_constraints_v1_interface;
  extern const wl_interface zwp_locked_pointer_v1_interface;
  extern const wl_interface zwp_confined_pointer_v1_interface;
  extern const wl_interface zwp_pointer_gestures_v1_interface;
  extern const wl_interface zwp_pointer_gesture_swipe_v1_interface;
  extern const wl_interface zwp_pointer_gesture_pinch_v1_interface;
  extern const wl_interface zwp_primary_selection_device_manager_v1_interface;
  extern const wl_interface zwp_primary_selection_device_v1_interface;
  extern const wl_interface zwp_primary_selection_offer_v1_interface;
  extern const wl_interface zwp_primary_selection_source_v1_interface;
  extern const wl_interface zwp_relative_pointer_manager_v1_interface;
  extern const wl_interface zwp_relative_pointer_v1_interface;
  extern const wl_interface zwp_tablet_manager_v1_interface;
  extern const wl_interface zwp_tablet_seat_v1_interface;
  extern const wl_interface zwp_tablet_tool_v1_interface;
  extern const wl_interface zwp_tablet_v1_interface;
  extern const wl_interface zwp_tablet_manager_v2_interface;
  extern const wl_interface zwp_tablet_seat_v2_interface;
  extern const wl_interface zwp_tablet_tool_v2_interface;
  extern const wl_interface zwp_tablet_v2_interface;
  extern const wl_interface zwp_tablet_pad_ring_v2_interface;
  extern const wl_interface zwp_tablet_pad_strip_v2_interface;
  extern const wl_interface zwp_tablet_pad_group_v2_interface;
  extern const wl_interface zwp_tablet_pad_v2_interface;
  extern const wl_interface zwp_text_input_v1_interface;
  extern const wl_interface zwp_text_input_manager_v1_interface;
  extern const wl_interface zwp_text_input_v3_interface;
  extern const wl_interface zwp_text_input_manager_v3_interface;
  extern const wl_interface zxdg_decoration_manager_v1_interface;
  extern const wl_interface zxdg_toplevel_decoration_v1_interface;
  extern const wl_interface zxdg_exporter_v1_interface;
  extern const wl_interface zxdg_importer_v1_interface;
  extern const wl_interface zxdg_exported_v1_interface;
  extern const wl_interface zxdg_imported_v1_interface;
  extern const wl_interface zxdg_exporter_v2_interface;
  extern const wl_interface zxdg_importer_v2_interface;
  extern const wl_interface zxdg_exported_v2_interface;
  extern const wl_interface zxdg_imported_v2_interface;
  extern const wl_interface zxdg_output_manager_v1_interface;
  extern const wl_interface zxdg_output_v1_interface;
  extern const wl_interface zxdg_shell_v6_interface;
  extern const wl_interface zxdg_positioner_v6_interface;
  extern const wl_interface zxdg_surface_v6_interface;
  extern const wl_interface zxdg_toplevel_v6_interface;
  extern const wl_interface zxdg_popup_v6_interface;
  extern const wl_interface zwp_xwayland_keyboard_grab_manager_v1_interface;
  extern const wl_interface zwp_xwayland_keyboard_grab_v1_interface;
}
 
class zwp_fullscreen_shell_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(zwp_fullscreen_shell_v1_capability)> capability;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_fullscreen_shell_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_fullscreen_shell_v1_t();
  explicit zwp_fullscreen_shell_v1_t(const proxy_t &proxy);
  zwp_fullscreen_shell_v1_t(zwp_fullscreen_shell_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_fullscreen_shell_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_fullscreen_shell_v1*() const;
 
  void release();
 
  static constexpr std::uint32_t release_since_version = 1;
 
  void present_surface(surface_t surface, zwp_fullscreen_shell_v1_present_method method, output_t output);
 
  static constexpr std::uint32_t present_surface_since_version = 1;
 
  zwp_fullscreen_shell_mode_feedback_v1_t present_surface_for_mode(surface_t surface, output_t output, int32_t framerate);
 
  static constexpr std::uint32_t present_surface_for_mode_since_version = 1;
 
  std::function<void(zwp_fullscreen_shell_v1_capability)> &on_capability();
 
};
 
enum class zwp_fullscreen_shell_v1_capability : uint32_t
  {
  arbitrary_modes = 1,
  cursor_plane = 2
};
 
enum class zwp_fullscreen_shell_v1_present_method : uint32_t
  {
  _default = 0,
  center = 1,
  zoom = 2,
  zoom_crop = 3,
  stretch = 4
};
 
enum class zwp_fullscreen_shell_v1_error : uint32_t
  {
  invalid_method = 0
};
 
 
class zwp_fullscreen_shell_mode_feedback_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void()> mode_successful;
    std::function<void()> mode_failed;
    std::function<void()> present_cancelled;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_fullscreen_shell_mode_feedback_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_fullscreen_shell_mode_feedback_v1_t();
  explicit zwp_fullscreen_shell_mode_feedback_v1_t(const proxy_t &proxy);
  zwp_fullscreen_shell_mode_feedback_v1_t(zwp_fullscreen_shell_mode_feedback_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_fullscreen_shell_mode_feedback_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_fullscreen_shell_mode_feedback_v1*() const;
 
  std::function<void()> &on_mode_successful();
 
  std::function<void()> &on_mode_failed();
 
  std::function<void()> &on_present_cancelled();
 
};
 
 
class zwp_idle_inhibit_manager_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_idle_inhibit_manager_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_idle_inhibit_manager_v1_t();
  explicit zwp_idle_inhibit_manager_v1_t(const proxy_t &proxy);
  zwp_idle_inhibit_manager_v1_t(zwp_idle_inhibit_manager_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_idle_inhibit_manager_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_idle_inhibit_manager_v1*() const;
 
  zwp_idle_inhibitor_v1_t create_inhibitor(surface_t surface);
 
  static constexpr std::uint32_t create_inhibitor_since_version = 1;
 
};
 
 
class zwp_idle_inhibitor_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_idle_inhibitor_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_idle_inhibitor_v1_t();
  explicit zwp_idle_inhibitor_v1_t(const proxy_t &proxy);
  zwp_idle_inhibitor_v1_t(zwp_idle_inhibitor_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_idle_inhibitor_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_idle_inhibitor_v1*() const;
 
};
 
 
class zwp_input_method_context_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(std::string, uint32_t, uint32_t)> surrounding_text;
    std::function<void()> reset;
    std::function<void(zwp_text_input_v1_content_hint, zwp_text_input_v1_content_purpose)> content_type;
    std::function<void(uint32_t, uint32_t)> invoke_action;
    std::function<void(uint32_t)> commit_state;
    std::function<void(std::string)> preferred_language;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_input_method_context_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_input_method_context_v1_t();
  explicit zwp_input_method_context_v1_t(const proxy_t &proxy);
  zwp_input_method_context_v1_t(zwp_input_method_context_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_input_method_context_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_input_method_context_v1*() const;
 
  void commit_string(uint32_t serial, std::string text);
 
  static constexpr std::uint32_t commit_string_since_version = 1;
 
  void preedit_string(uint32_t serial, std::string text, std::string commit);
 
  static constexpr std::uint32_t preedit_string_since_version = 1;
 
  void preedit_styling(uint32_t index, uint32_t length, zwp_text_input_v1_preedit_style style);
 
  static constexpr std::uint32_t preedit_styling_since_version = 1;
 
  void preedit_cursor(int32_t index);
 
  static constexpr std::uint32_t preedit_cursor_since_version = 1;
 
  void delete_surrounding_text(int32_t index, uint32_t length);
 
  static constexpr std::uint32_t delete_surrounding_text_since_version = 1;
 
  void cursor_position(int32_t index, int32_t anchor);
 
  static constexpr std::uint32_t cursor_position_since_version = 1;
 
  void modifiers_map(array_t map);
 
  static constexpr std::uint32_t modifiers_map_since_version = 1;
 
  void keysym(uint32_t serial, uint32_t time, uint32_t sym, keyboard_key_state state, uint32_t modifiers);
 
  static constexpr std::uint32_t keysym_since_version = 1;
 
  keyboard_t grab_keyboard();
 
  static constexpr std::uint32_t grab_keyboard_since_version = 1;
 
  void key(uint32_t serial, uint32_t time, uint32_t key, keyboard_key_state state);
 
  static constexpr std::uint32_t key_since_version = 1;
 
  void modifiers(uint32_t serial, uint32_t mods_depressed, uint32_t mods_latched, uint32_t mods_locked, uint32_t group);
 
  static constexpr std::uint32_t modifiers_since_version = 1;
 
  void language(uint32_t serial, std::string language);
 
  static constexpr std::uint32_t language_since_version = 1;
 
  void text_direction(uint32_t serial, uint32_t direction);
 
  static constexpr std::uint32_t text_direction_since_version = 1;
 
  std::function<void(std::string, uint32_t, uint32_t)> &on_surrounding_text();
 
  std::function<void()> &on_reset();
 
  std::function<void(zwp_text_input_v1_content_hint, zwp_text_input_v1_content_purpose)> &on_content_type();
 
  std::function<void(uint32_t, uint32_t)> &on_invoke_action();
 
  std::function<void(uint32_t)> &on_commit_state();
 
  std::function<void(std::string)> &on_preferred_language();
 
};
 
 
class zwp_input_method_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(zwp_input_method_context_v1_t)> activate;
    std::function<void(zwp_input_method_context_v1_t)> deactivate;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_input_method_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_input_method_v1_t();
  explicit zwp_input_method_v1_t(const proxy_t &proxy);
  zwp_input_method_v1_t(zwp_input_method_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_input_method_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_input_method_v1*() const;
 
  std::function<void(zwp_input_method_context_v1_t)> &on_activate();
 
  std::function<void(zwp_input_method_context_v1_t)> &on_deactivate();
 
};
 
 
class zwp_input_panel_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_input_panel_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_input_panel_v1_t();
  explicit zwp_input_panel_v1_t(const proxy_t &proxy);
  zwp_input_panel_v1_t(zwp_input_panel_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_input_panel_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_input_panel_v1*() const;
 
  zwp_input_panel_surface_v1_t get_input_panel_surface(surface_t surface);
 
  static constexpr std::uint32_t get_input_panel_surface_since_version = 1;
 
};
 
 
class zwp_input_panel_surface_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_input_panel_surface_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_input_panel_surface_v1_t();
  explicit zwp_input_panel_surface_v1_t(const proxy_t &proxy);
  zwp_input_panel_surface_v1_t(zwp_input_panel_surface_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_input_panel_surface_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_input_panel_surface_v1*() const;
 
  void set_toplevel(output_t output, zwp_input_panel_surface_v1_position position);
 
  static constexpr std::uint32_t set_toplevel_since_version = 1;
 
  void set_overlay_panel();
 
  static constexpr std::uint32_t set_overlay_panel_since_version = 1;
 
};
 
enum class zwp_input_panel_surface_v1_position : uint32_t
  {
  center_bottom = 0
};
 
 
class zwp_input_timestamps_manager_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_input_timestamps_manager_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_input_timestamps_manager_v1_t();
  explicit zwp_input_timestamps_manager_v1_t(const proxy_t &proxy);
  zwp_input_timestamps_manager_v1_t(zwp_input_timestamps_manager_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_input_timestamps_manager_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_input_timestamps_manager_v1*() const;
 
  zwp_input_timestamps_v1_t get_keyboard_timestamps(keyboard_t keyboard);
 
  static constexpr std::uint32_t get_keyboard_timestamps_since_version = 1;
 
  zwp_input_timestamps_v1_t get_pointer_timestamps(pointer_t pointer);
 
  static constexpr std::uint32_t get_pointer_timestamps_since_version = 1;
 
  zwp_input_timestamps_v1_t get_touch_timestamps(touch_t touch);
 
  static constexpr std::uint32_t get_touch_timestamps_since_version = 1;
 
};
 
 
class zwp_input_timestamps_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t, uint32_t, uint32_t)> timestamp;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_input_timestamps_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_input_timestamps_v1_t();
  explicit zwp_input_timestamps_v1_t(const proxy_t &proxy);
  zwp_input_timestamps_v1_t(zwp_input_timestamps_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_input_timestamps_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_input_timestamps_v1*() const;
 
  std::function<void(uint32_t, uint32_t, uint32_t)> &on_timestamp();
 
};
 
 
class zwp_keyboard_shortcuts_inhibit_manager_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_keyboard_shortcuts_inhibit_manager_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_keyboard_shortcuts_inhibit_manager_v1_t();
  explicit zwp_keyboard_shortcuts_inhibit_manager_v1_t(const proxy_t &proxy);
  zwp_keyboard_shortcuts_inhibit_manager_v1_t(zwp_keyboard_shortcuts_inhibit_manager_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_keyboard_shortcuts_inhibit_manager_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_keyboard_shortcuts_inhibit_manager_v1*() const;
 
  zwp_keyboard_shortcuts_inhibitor_v1_t inhibit_shortcuts(surface_t surface, seat_t seat);
 
  static constexpr std::uint32_t inhibit_shortcuts_since_version = 1;
 
};
 
enum class zwp_keyboard_shortcuts_inhibit_manager_v1_error : uint32_t
  {
  already_inhibited = 0
};
 
 
class zwp_keyboard_shortcuts_inhibitor_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void()> active;
    std::function<void()> inactive;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_keyboard_shortcuts_inhibitor_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_keyboard_shortcuts_inhibitor_v1_t();
  explicit zwp_keyboard_shortcuts_inhibitor_v1_t(const proxy_t &proxy);
  zwp_keyboard_shortcuts_inhibitor_v1_t(zwp_keyboard_shortcuts_inhibitor_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_keyboard_shortcuts_inhibitor_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_keyboard_shortcuts_inhibitor_v1*() const;
 
  std::function<void()> &on_active();
 
  std::function<void()> &on_inactive();
 
};
 
 
class zwp_linux_dmabuf_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t)> format;
    std::function<void(uint32_t, uint32_t, uint32_t)> modifier;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_linux_dmabuf_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_linux_dmabuf_v1_t();
  explicit zwp_linux_dmabuf_v1_t(const proxy_t &proxy);
  zwp_linux_dmabuf_v1_t(zwp_linux_dmabuf_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_linux_dmabuf_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_linux_dmabuf_v1*() const;
 
  zwp_linux_buffer_params_v1_t create_params();
 
  static constexpr std::uint32_t create_params_since_version = 1;
 
  std::function<void(uint32_t)> &on_format();
 
  std::function<void(uint32_t, uint32_t, uint32_t)> &on_modifier();
 
};
 
 
class zwp_linux_buffer_params_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(buffer_t)> created;
    std::function<void()> failed;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_linux_buffer_params_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_linux_buffer_params_v1_t();
  explicit zwp_linux_buffer_params_v1_t(const proxy_t &proxy);
  zwp_linux_buffer_params_v1_t(zwp_linux_buffer_params_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_linux_buffer_params_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_linux_buffer_params_v1*() const;
 
  void add(int fd, uint32_t plane_idx, uint32_t offset, uint32_t stride, uint32_t modifier_hi, uint32_t modifier_lo);
 
  static constexpr std::uint32_t add_since_version = 1;
 
  void create(int32_t width, int32_t height, uint32_t format, zwp_linux_buffer_params_v1_flags flags);
 
  static constexpr std::uint32_t create_since_version = 1;
 
  buffer_t create_immed(int32_t width, int32_t height, uint32_t format, zwp_linux_buffer_params_v1_flags flags);
 
  static constexpr std::uint32_t create_immed_since_version = 2;
 
  bool can_create_immed() const;
 
  std::function<void(buffer_t)> &on_created();
 
  std::function<void()> &on_failed();
 
};
 
enum class zwp_linux_buffer_params_v1_error : uint32_t
  {
  already_used = 0,
  plane_idx = 1,
  plane_set = 2,
  incomplete = 3,
  invalid_format = 4,
  invalid_dimensions = 5,
  out_of_bounds = 6,
  invalid_wl_buffer = 7
};
 
enum class zwp_linux_buffer_params_v1_flags : uint32_t
  {
  y_invert = 1,
  interlaced = 2,
  bottom_first = 4
};
 
 
class zwp_linux_explicit_synchronization_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_linux_explicit_synchronization_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_linux_explicit_synchronization_v1_t();
  explicit zwp_linux_explicit_synchronization_v1_t(const proxy_t &proxy);
  zwp_linux_explicit_synchronization_v1_t(zwp_linux_explicit_synchronization_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_linux_explicit_synchronization_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_linux_explicit_synchronization_v1*() const;
 
  zwp_linux_surface_synchronization_v1_t get_synchronization(surface_t surface);
 
  static constexpr std::uint32_t get_synchronization_since_version = 1;
 
};
 
enum class zwp_linux_explicit_synchronization_v1_error : uint32_t
  {
  synchronization_exists = 0
};
 
 
class zwp_linux_surface_synchronization_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_linux_surface_synchronization_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_linux_surface_synchronization_v1_t();
  explicit zwp_linux_surface_synchronization_v1_t(const proxy_t &proxy);
  zwp_linux_surface_synchronization_v1_t(zwp_linux_surface_synchronization_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_linux_surface_synchronization_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_linux_surface_synchronization_v1*() const;
 
  void set_acquire_fence(int fd);
 
  static constexpr std::uint32_t set_acquire_fence_since_version = 1;
 
  zwp_linux_buffer_release_v1_t get_release();
 
  static constexpr std::uint32_t get_release_since_version = 1;
 
};
 
enum class zwp_linux_surface_synchronization_v1_error : uint32_t
  {
  invalid_fence = 0,
  duplicate_fence = 1,
  duplicate_release = 2,
  no_surface = 3,
  unsupported_buffer = 4,
  no_buffer = 5
};
 
 
class zwp_linux_buffer_release_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(int)> fenced_release;
    std::function<void()> immediate_release;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_linux_buffer_release_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_linux_buffer_release_v1_t();
  explicit zwp_linux_buffer_release_v1_t(const proxy_t &proxy);
  zwp_linux_buffer_release_v1_t(zwp_linux_buffer_release_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_linux_buffer_release_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_linux_buffer_release_v1*() const;
 
  std::function<void(int)> &on_fenced_release();
 
  std::function<void()> &on_immediate_release();
 
};
 
 
class zwp_pointer_constraints_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_pointer_constraints_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_pointer_constraints_v1_t();
  explicit zwp_pointer_constraints_v1_t(const proxy_t &proxy);
  zwp_pointer_constraints_v1_t(zwp_pointer_constraints_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_pointer_constraints_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_pointer_constraints_v1*() const;
 
  zwp_locked_pointer_v1_t lock_pointer(surface_t surface, pointer_t pointer, region_t region, zwp_pointer_constraints_v1_lifetime lifetime);
 
  static constexpr std::uint32_t lock_pointer_since_version = 1;
 
  zwp_confined_pointer_v1_t confine_pointer(surface_t surface, pointer_t pointer, region_t region, zwp_pointer_constraints_v1_lifetime lifetime);
 
  static constexpr std::uint32_t confine_pointer_since_version = 1;
 
};
 
enum class zwp_pointer_constraints_v1_error : uint32_t
  {
  already_constrained = 1
};
 
enum class zwp_pointer_constraints_v1_lifetime : uint32_t
  {
  oneshot = 1,
  persistent = 2
};
 
 
class zwp_locked_pointer_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void()> locked;
    std::function<void()> unlocked;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_locked_pointer_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_locked_pointer_v1_t();
  explicit zwp_locked_pointer_v1_t(const proxy_t &proxy);
  zwp_locked_pointer_v1_t(zwp_locked_pointer_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_locked_pointer_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_locked_pointer_v1*() const;
 
  void set_cursor_position_hint(double surface_x, double surface_y);
 
  static constexpr std::uint32_t set_cursor_position_hint_since_version = 1;
 
  void set_region(region_t region);
 
  static constexpr std::uint32_t set_region_since_version = 1;
 
  std::function<void()> &on_locked();
 
  std::function<void()> &on_unlocked();
 
};
 
 
class zwp_confined_pointer_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void()> confined;
    std::function<void()> unconfined;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_confined_pointer_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_confined_pointer_v1_t();
  explicit zwp_confined_pointer_v1_t(const proxy_t &proxy);
  zwp_confined_pointer_v1_t(zwp_confined_pointer_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_confined_pointer_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_confined_pointer_v1*() const;
 
  void set_region(region_t region);
 
  static constexpr std::uint32_t set_region_since_version = 1;
 
  std::function<void()> &on_confined();
 
  std::function<void()> &on_unconfined();
 
};
 
 
class zwp_pointer_gestures_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_pointer_gestures_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_pointer_gestures_v1_t();
  explicit zwp_pointer_gestures_v1_t(const proxy_t &proxy);
  zwp_pointer_gestures_v1_t(zwp_pointer_gestures_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_pointer_gestures_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_pointer_gestures_v1*() const;
 
  zwp_pointer_gesture_swipe_v1_t get_swipe_gesture(pointer_t pointer);
 
  static constexpr std::uint32_t get_swipe_gesture_since_version = 1;
 
  zwp_pointer_gesture_pinch_v1_t get_pinch_gesture(pointer_t pointer);
 
  static constexpr std::uint32_t get_pinch_gesture_since_version = 1;
 
  void release();
 
  static constexpr std::uint32_t release_since_version = 2;
 
  bool can_release() const;
 
};
 
 
class zwp_pointer_gesture_swipe_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t, uint32_t, surface_t, uint32_t)> begin;
    std::function<void(uint32_t, double, double)> update;
    std::function<void(uint32_t, uint32_t, int32_t)> end;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_pointer_gesture_swipe_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_pointer_gesture_swipe_v1_t();
  explicit zwp_pointer_gesture_swipe_v1_t(const proxy_t &proxy);
  zwp_pointer_gesture_swipe_v1_t(zwp_pointer_gesture_swipe_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_pointer_gesture_swipe_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_pointer_gesture_swipe_v1*() const;
 
  std::function<void(uint32_t, uint32_t, surface_t, uint32_t)> &on_begin();
 
  std::function<void(uint32_t, double, double)> &on_update();
 
  std::function<void(uint32_t, uint32_t, int32_t)> &on_end();
 
};
 
 
class zwp_pointer_gesture_pinch_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t, uint32_t, surface_t, uint32_t)> begin;
    std::function<void(uint32_t, double, double, double, double)> update;
    std::function<void(uint32_t, uint32_t, int32_t)> end;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_pointer_gesture_pinch_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_pointer_gesture_pinch_v1_t();
  explicit zwp_pointer_gesture_pinch_v1_t(const proxy_t &proxy);
  zwp_pointer_gesture_pinch_v1_t(zwp_pointer_gesture_pinch_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_pointer_gesture_pinch_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_pointer_gesture_pinch_v1*() const;
 
  std::function<void(uint32_t, uint32_t, surface_t, uint32_t)> &on_begin();
 
  std::function<void(uint32_t, double, double, double, double)> &on_update();
 
  std::function<void(uint32_t, uint32_t, int32_t)> &on_end();
 
};
 
 
class zwp_primary_selection_device_manager_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_primary_selection_device_manager_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_primary_selection_device_manager_v1_t();
  explicit zwp_primary_selection_device_manager_v1_t(const proxy_t &proxy);
  zwp_primary_selection_device_manager_v1_t(zwp_primary_selection_device_manager_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_primary_selection_device_manager_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_primary_selection_device_manager_v1*() const;
 
  zwp_primary_selection_source_v1_t create_source();
 
  static constexpr std::uint32_t create_source_since_version = 1;
 
  zwp_primary_selection_device_v1_t get_device(seat_t seat);
 
  static constexpr std::uint32_t get_device_since_version = 1;
 
};
 
 
class zwp_primary_selection_device_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(zwp_primary_selection_offer_v1_t)> data_offer;
    std::function<void(zwp_primary_selection_offer_v1_t)> selection;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_primary_selection_device_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_primary_selection_device_v1_t();
  explicit zwp_primary_selection_device_v1_t(const proxy_t &proxy);
  zwp_primary_selection_device_v1_t(zwp_primary_selection_device_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_primary_selection_device_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_primary_selection_device_v1*() const;
 
  void set_selection(zwp_primary_selection_source_v1_t source, uint32_t serial);
 
  static constexpr std::uint32_t set_selection_since_version = 1;
 
  std::function<void(zwp_primary_selection_offer_v1_t)> &on_data_offer();
 
  std::function<void(zwp_primary_selection_offer_v1_t)> &on_selection();
 
};
 
 
class zwp_primary_selection_offer_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(std::string)> offer;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_primary_selection_offer_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_primary_selection_offer_v1_t();
  explicit zwp_primary_selection_offer_v1_t(const proxy_t &proxy);
  zwp_primary_selection_offer_v1_t(zwp_primary_selection_offer_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_primary_selection_offer_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_primary_selection_offer_v1*() const;
 
  void receive(std::string mime_type, int fd);
 
  static constexpr std::uint32_t receive_since_version = 1;
 
  std::function<void(std::string)> &on_offer();
 
};
 
 
class zwp_primary_selection_source_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(std::string, int)> send;
    std::function<void()> cancelled;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_primary_selection_source_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_primary_selection_source_v1_t();
  explicit zwp_primary_selection_source_v1_t(const proxy_t &proxy);
  zwp_primary_selection_source_v1_t(zwp_primary_selection_source_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_primary_selection_source_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_primary_selection_source_v1*() const;
 
  void offer(std::string mime_type);
 
  static constexpr std::uint32_t offer_since_version = 1;
 
  std::function<void(std::string, int)> &on_send();
 
  std::function<void()> &on_cancelled();
 
};
 
 
class zwp_relative_pointer_manager_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_relative_pointer_manager_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_relative_pointer_manager_v1_t();
  explicit zwp_relative_pointer_manager_v1_t(const proxy_t &proxy);
  zwp_relative_pointer_manager_v1_t(zwp_relative_pointer_manager_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_relative_pointer_manager_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_relative_pointer_manager_v1*() const;
 
  zwp_relative_pointer_v1_t get_relative_pointer(pointer_t pointer);
 
  static constexpr std::uint32_t get_relative_pointer_since_version = 1;
 
};
 
 
class zwp_relative_pointer_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t, uint32_t, double, double, double, double)> relative_motion;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_relative_pointer_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_relative_pointer_v1_t();
  explicit zwp_relative_pointer_v1_t(const proxy_t &proxy);
  zwp_relative_pointer_v1_t(zwp_relative_pointer_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_relative_pointer_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_relative_pointer_v1*() const;
 
  std::function<void(uint32_t, uint32_t, double, double, double, double)> &on_relative_motion();
 
};
 
 
class zwp_tablet_manager_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_manager_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_manager_v1_t();
  explicit zwp_tablet_manager_v1_t(const proxy_t &proxy);
  zwp_tablet_manager_v1_t(zwp_tablet_manager_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_manager_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_manager_v1*() const;
 
  zwp_tablet_seat_v1_t get_tablet_seat(seat_t seat);
 
  static constexpr std::uint32_t get_tablet_seat_since_version = 1;
 
};
 
 
class zwp_tablet_seat_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(zwp_tablet_v1_t)> tablet_added;
    std::function<void(zwp_tablet_tool_v1_t)> tool_added;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_seat_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_seat_v1_t();
  explicit zwp_tablet_seat_v1_t(const proxy_t &proxy);
  zwp_tablet_seat_v1_t(zwp_tablet_seat_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_seat_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_seat_v1*() const;
 
  std::function<void(zwp_tablet_v1_t)> &on_tablet_added();
 
  std::function<void(zwp_tablet_tool_v1_t)> &on_tool_added();
 
};
 
 
class zwp_tablet_tool_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(zwp_tablet_tool_v1_type)> type;
    std::function<void(uint32_t, uint32_t)> hardware_serial;
    std::function<void(uint32_t, uint32_t)> hardware_id_wacom;
    std::function<void(zwp_tablet_tool_v1_capability)> capability;
    std::function<void()> done;
    std::function<void()> removed;
    std::function<void(uint32_t, zwp_tablet_v1_t, surface_t)> proximity_in;
    std::function<void()> proximity_out;
    std::function<void(uint32_t)> down;
    std::function<void()> up;
    std::function<void(double, double)> motion;
    std::function<void(uint32_t)> pressure;
    std::function<void(uint32_t)> distance;
    std::function<void(int32_t, int32_t)> tilt;
    std::function<void(int32_t)> rotation;
    std::function<void(int32_t)> slider;
    std::function<void(int32_t, int32_t)> wheel;
    std::function<void(uint32_t, uint32_t, zwp_tablet_tool_v1_button_state)> button;
    std::function<void(uint32_t)> frame;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_tool_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_tool_v1_t();
  explicit zwp_tablet_tool_v1_t(const proxy_t &proxy);
  zwp_tablet_tool_v1_t(zwp_tablet_tool_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_tool_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_tool_v1*() const;
 
  void set_cursor(uint32_t serial, surface_t surface, int32_t hotspot_x, int32_t hotspot_y);
 
  static constexpr std::uint32_t set_cursor_since_version = 1;
 
  std::function<void(zwp_tablet_tool_v1_type)> &on_type();
 
  std::function<void(uint32_t, uint32_t)> &on_hardware_serial();
 
  std::function<void(uint32_t, uint32_t)> &on_hardware_id_wacom();
 
  std::function<void(zwp_tablet_tool_v1_capability)> &on_capability();
 
  std::function<void()> &on_done();
 
  std::function<void()> &on_removed();
 
  std::function<void(uint32_t, zwp_tablet_v1_t, surface_t)> &on_proximity_in();
 
  std::function<void()> &on_proximity_out();
 
  std::function<void(uint32_t)> &on_down();
 
  std::function<void()> &on_up();
 
  std::function<void(double, double)> &on_motion();
 
  std::function<void(uint32_t)> &on_pressure();
 
  std::function<void(uint32_t)> &on_distance();
 
  std::function<void(int32_t, int32_t)> &on_tilt();
 
  std::function<void(int32_t)> &on_rotation();
 
  std::function<void(int32_t)> &on_slider();
 
  std::function<void(int32_t, int32_t)> &on_wheel();
 
  std::function<void(uint32_t, uint32_t, zwp_tablet_tool_v1_button_state)> &on_button();
 
  std::function<void(uint32_t)> &on_frame();
 
};
 
enum class zwp_tablet_tool_v1_type : uint32_t
  {
  pen = 0x140,
  eraser = 0x141,
  brush = 0x142,
  pencil = 0x143,
  airbrush = 0x144,
  finger = 0x145,
  mouse = 0x146,
  lens = 0x147
};
 
enum class zwp_tablet_tool_v1_capability : uint32_t
  {
  tilt = 1,
  pressure = 2,
  distance = 3,
  rotation = 4,
  slider = 5,
  wheel = 6
};
 
enum class zwp_tablet_tool_v1_button_state : uint32_t
  {
  released = 0,
  pressed = 1
};
 
enum class zwp_tablet_tool_v1_error : uint32_t
  {
  role = 0
};
 
 
class zwp_tablet_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(std::string)> name;
    std::function<void(uint32_t, uint32_t)> id;
    std::function<void(std::string)> path;
    std::function<void()> done;
    std::function<void()> removed;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_v1_t();
  explicit zwp_tablet_v1_t(const proxy_t &proxy);
  zwp_tablet_v1_t(zwp_tablet_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_v1*() const;
 
  std::function<void(std::string)> &on_name();
 
  std::function<void(uint32_t, uint32_t)> &on_id();
 
  std::function<void(std::string)> &on_path();
 
  std::function<void()> &on_done();
 
  std::function<void()> &on_removed();
 
};
 
 
class zwp_tablet_manager_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_manager_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_manager_v2_t();
  explicit zwp_tablet_manager_v2_t(const proxy_t &proxy);
  zwp_tablet_manager_v2_t(zwp_tablet_manager_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_manager_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_manager_v2*() const;
 
  zwp_tablet_seat_v2_t get_tablet_seat(seat_t seat);
 
  static constexpr std::uint32_t get_tablet_seat_since_version = 1;
 
};
 
 
class zwp_tablet_seat_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(zwp_tablet_v2_t)> tablet_added;
    std::function<void(zwp_tablet_tool_v2_t)> tool_added;
    std::function<void(zwp_tablet_pad_v2_t)> pad_added;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_seat_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_seat_v2_t();
  explicit zwp_tablet_seat_v2_t(const proxy_t &proxy);
  zwp_tablet_seat_v2_t(zwp_tablet_seat_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_seat_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_seat_v2*() const;
 
  std::function<void(zwp_tablet_v2_t)> &on_tablet_added();
 
  std::function<void(zwp_tablet_tool_v2_t)> &on_tool_added();
 
  std::function<void(zwp_tablet_pad_v2_t)> &on_pad_added();
 
};
 
 
class zwp_tablet_tool_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(zwp_tablet_tool_v2_type)> type;
    std::function<void(uint32_t, uint32_t)> hardware_serial;
    std::function<void(uint32_t, uint32_t)> hardware_id_wacom;
    std::function<void(zwp_tablet_tool_v2_capability)> capability;
    std::function<void()> done;
    std::function<void()> removed;
    std::function<void(uint32_t, zwp_tablet_v2_t, surface_t)> proximity_in;
    std::function<void()> proximity_out;
    std::function<void(uint32_t)> down;
    std::function<void()> up;
    std::function<void(double, double)> motion;
    std::function<void(uint32_t)> pressure;
    std::function<void(uint32_t)> distance;
    std::function<void(double, double)> tilt;
    std::function<void(double)> rotation;
    std::function<void(int32_t)> slider;
    std::function<void(double, int32_t)> wheel;
    std::function<void(uint32_t, uint32_t, zwp_tablet_tool_v2_button_state)> button;
    std::function<void(uint32_t)> frame;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_tool_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_tool_v2_t();
  explicit zwp_tablet_tool_v2_t(const proxy_t &proxy);
  zwp_tablet_tool_v2_t(zwp_tablet_tool_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_tool_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_tool_v2*() const;
 
  void set_cursor(uint32_t serial, surface_t surface, int32_t hotspot_x, int32_t hotspot_y);
 
  static constexpr std::uint32_t set_cursor_since_version = 1;
 
  std::function<void(zwp_tablet_tool_v2_type)> &on_type();
 
  std::function<void(uint32_t, uint32_t)> &on_hardware_serial();
 
  std::function<void(uint32_t, uint32_t)> &on_hardware_id_wacom();
 
  std::function<void(zwp_tablet_tool_v2_capability)> &on_capability();
 
  std::function<void()> &on_done();
 
  std::function<void()> &on_removed();
 
  std::function<void(uint32_t, zwp_tablet_v2_t, surface_t)> &on_proximity_in();
 
  std::function<void()> &on_proximity_out();
 
  std::function<void(uint32_t)> &on_down();
 
  std::function<void()> &on_up();
 
  std::function<void(double, double)> &on_motion();
 
  std::function<void(uint32_t)> &on_pressure();
 
  std::function<void(uint32_t)> &on_distance();
 
  std::function<void(double, double)> &on_tilt();
 
  std::function<void(double)> &on_rotation();
 
  std::function<void(int32_t)> &on_slider();
 
  std::function<void(double, int32_t)> &on_wheel();
 
  std::function<void(uint32_t, uint32_t, zwp_tablet_tool_v2_button_state)> &on_button();
 
  std::function<void(uint32_t)> &on_frame();
 
};
 
enum class zwp_tablet_tool_v2_type : uint32_t
  {
  pen = 0x140,
  eraser = 0x141,
  brush = 0x142,
  pencil = 0x143,
  airbrush = 0x144,
  finger = 0x145,
  mouse = 0x146,
  lens = 0x147
};
 
enum class zwp_tablet_tool_v2_capability : uint32_t
  {
  tilt = 1,
  pressure = 2,
  distance = 3,
  rotation = 4,
  slider = 5,
  wheel = 6
};
 
enum class zwp_tablet_tool_v2_button_state : uint32_t
  {
  released = 0,
  pressed = 1
};
 
enum class zwp_tablet_tool_v2_error : uint32_t
  {
  role = 0
};
 
 
class zwp_tablet_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(std::string)> name;
    std::function<void(uint32_t, uint32_t)> id;
    std::function<void(std::string)> path;
    std::function<void()> done;
    std::function<void()> removed;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_v2_t();
  explicit zwp_tablet_v2_t(const proxy_t &proxy);
  zwp_tablet_v2_t(zwp_tablet_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_v2*() const;
 
  std::function<void(std::string)> &on_name();
 
  std::function<void(uint32_t, uint32_t)> &on_id();
 
  std::function<void(std::string)> &on_path();
 
  std::function<void()> &on_done();
 
  std::function<void()> &on_removed();
 
};
 
 
class zwp_tablet_pad_ring_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(zwp_tablet_pad_ring_v2_source)> source;
    std::function<void(double)> angle;
    std::function<void()> stop;
    std::function<void(uint32_t)> frame;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_pad_ring_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_pad_ring_v2_t();
  explicit zwp_tablet_pad_ring_v2_t(const proxy_t &proxy);
  zwp_tablet_pad_ring_v2_t(zwp_tablet_pad_ring_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_pad_ring_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_pad_ring_v2*() const;
 
  void set_feedback(std::string description, uint32_t serial);
 
  static constexpr std::uint32_t set_feedback_since_version = 1;
 
  std::function<void(zwp_tablet_pad_ring_v2_source)> &on_source();
 
  std::function<void(double)> &on_angle();
 
  std::function<void()> &on_stop();
 
  std::function<void(uint32_t)> &on_frame();
 
};
 
enum class zwp_tablet_pad_ring_v2_source : uint32_t
  {
  finger = 1
};
 
 
class zwp_tablet_pad_strip_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(zwp_tablet_pad_strip_v2_source)> source;
    std::function<void(uint32_t)> position;
    std::function<void()> stop;
    std::function<void(uint32_t)> frame;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_pad_strip_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_pad_strip_v2_t();
  explicit zwp_tablet_pad_strip_v2_t(const proxy_t &proxy);
  zwp_tablet_pad_strip_v2_t(zwp_tablet_pad_strip_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_pad_strip_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_pad_strip_v2*() const;
 
  void set_feedback(std::string description, uint32_t serial);
 
  static constexpr std::uint32_t set_feedback_since_version = 1;
 
  std::function<void(zwp_tablet_pad_strip_v2_source)> &on_source();
 
  std::function<void(uint32_t)> &on_position();
 
  std::function<void()> &on_stop();
 
  std::function<void(uint32_t)> &on_frame();
 
};
 
enum class zwp_tablet_pad_strip_v2_source : uint32_t
  {
  finger = 1
};
 
 
class zwp_tablet_pad_group_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(array_t)> buttons;
    std::function<void(zwp_tablet_pad_ring_v2_t)> ring;
    std::function<void(zwp_tablet_pad_strip_v2_t)> strip;
    std::function<void(uint32_t)> modes;
    std::function<void()> done;
    std::function<void(uint32_t, uint32_t, uint32_t)> mode_switch;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_pad_group_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_pad_group_v2_t();
  explicit zwp_tablet_pad_group_v2_t(const proxy_t &proxy);
  zwp_tablet_pad_group_v2_t(zwp_tablet_pad_group_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_pad_group_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_pad_group_v2*() const;
 
  std::function<void(array_t)> &on_buttons();
 
  std::function<void(zwp_tablet_pad_ring_v2_t)> &on_ring();
 
  std::function<void(zwp_tablet_pad_strip_v2_t)> &on_strip();
 
  std::function<void(uint32_t)> &on_modes();
 
  std::function<void()> &on_done();
 
  std::function<void(uint32_t, uint32_t, uint32_t)> &on_mode_switch();
 
};
 
 
class zwp_tablet_pad_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(zwp_tablet_pad_group_v2_t)> group;
    std::function<void(std::string)> path;
    std::function<void(uint32_t)> buttons;
    std::function<void()> done;
    std::function<void(uint32_t, uint32_t, zwp_tablet_pad_v2_button_state)> button;
    std::function<void(uint32_t, zwp_tablet_v2_t, surface_t)> enter;
    std::function<void(uint32_t, surface_t)> leave;
    std::function<void()> removed;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_tablet_pad_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_tablet_pad_v2_t();
  explicit zwp_tablet_pad_v2_t(const proxy_t &proxy);
  zwp_tablet_pad_v2_t(zwp_tablet_pad_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_tablet_pad_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_tablet_pad_v2*() const;
 
  void set_feedback(uint32_t button, std::string description, uint32_t serial);
 
  static constexpr std::uint32_t set_feedback_since_version = 1;
 
  std::function<void(zwp_tablet_pad_group_v2_t)> &on_group();
 
  std::function<void(std::string)> &on_path();
 
  std::function<void(uint32_t)> &on_buttons();
 
  std::function<void()> &on_done();
 
  std::function<void(uint32_t, uint32_t, zwp_tablet_pad_v2_button_state)> &on_button();
 
  std::function<void(uint32_t, zwp_tablet_v2_t, surface_t)> &on_enter();
 
  std::function<void(uint32_t, surface_t)> &on_leave();
 
  std::function<void()> &on_removed();
 
};
 
enum class zwp_tablet_pad_v2_button_state : uint32_t
  {
  released = 0,
  pressed = 1
};
 
 
class zwp_text_input_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(surface_t)> enter;
    std::function<void()> leave;
    std::function<void(array_t)> modifiers_map;
    std::function<void(uint32_t)> input_panel_state;
    std::function<void(uint32_t, std::string, std::string)> preedit_string;
    std::function<void(uint32_t, uint32_t, zwp_text_input_v1_preedit_style)> preedit_styling;
    std::function<void(int32_t)> preedit_cursor;
    std::function<void(uint32_t, std::string)> commit_string;
    std::function<void(int32_t, int32_t)> cursor_position;
    std::function<void(int32_t, uint32_t)> delete_surrounding_text;
    std::function<void(uint32_t, uint32_t, uint32_t, keyboard_key_state, uint32_t)> keysym;
    std::function<void(uint32_t, std::string)> language;
    std::function<void(uint32_t, zwp_text_input_v1_text_direction)> text_direction;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_text_input_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_text_input_v1_t();
  explicit zwp_text_input_v1_t(const proxy_t &proxy);
  zwp_text_input_v1_t(zwp_text_input_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_text_input_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_text_input_v1*() const;
 
  void activate(seat_t seat, surface_t surface);
 
  static constexpr std::uint32_t activate_since_version = 1;
 
  void deactivate(seat_t seat);
 
  static constexpr std::uint32_t deactivate_since_version = 1;
 
  void show_input_panel();
 
  static constexpr std::uint32_t show_input_panel_since_version = 1;
 
  void hide_input_panel();
 
  static constexpr std::uint32_t hide_input_panel_since_version = 1;
 
  void reset();
 
  static constexpr std::uint32_t reset_since_version = 1;
 
  void set_surrounding_text(std::string text, uint32_t cursor, uint32_t anchor);
 
  static constexpr std::uint32_t set_surrounding_text_since_version = 1;
 
  void set_content_type(zwp_text_input_v1_content_hint hint, zwp_text_input_v1_content_purpose purpose);
 
  static constexpr std::uint32_t set_content_type_since_version = 1;
 
  void set_cursor_rectangle(int32_t x, int32_t y, int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_cursor_rectangle_since_version = 1;
 
  void set_preferred_language(std::string language);
 
  static constexpr std::uint32_t set_preferred_language_since_version = 1;
 
  void commit_state(uint32_t serial);
 
  static constexpr std::uint32_t commit_state_since_version = 1;
 
  void invoke_action(uint32_t button, uint32_t index);
 
  static constexpr std::uint32_t invoke_action_since_version = 1;
 
  std::function<void(surface_t)> &on_enter();
 
  std::function<void()> &on_leave();
 
  std::function<void(array_t)> &on_modifiers_map();
 
  std::function<void(uint32_t)> &on_input_panel_state();
 
  std::function<void(uint32_t, std::string, std::string)> &on_preedit_string();
 
  std::function<void(uint32_t, uint32_t, zwp_text_input_v1_preedit_style)> &on_preedit_styling();
 
  std::function<void(int32_t)> &on_preedit_cursor();
 
  std::function<void(uint32_t, std::string)> &on_commit_string();
 
  std::function<void(int32_t, int32_t)> &on_cursor_position();
 
  std::function<void(int32_t, uint32_t)> &on_delete_surrounding_text();
 
  std::function<void(uint32_t, uint32_t, uint32_t, keyboard_key_state, uint32_t)> &on_keysym();
 
  std::function<void(uint32_t, std::string)> &on_language();
 
  std::function<void(uint32_t, zwp_text_input_v1_text_direction)> &on_text_direction();
 
};
 
enum class zwp_text_input_v1_content_hint : uint32_t
  {
  none = 0x0,
  _default = 0x7,
  password = 0xc0,
  auto_completion = 0x1,
  auto_correction = 0x2,
  auto_capitalization = 0x4,
  lowercase = 0x8,
  uppercase = 0x10,
  titlecase = 0x20,
  hidden_text = 0x40,
  sensitive_data = 0x80,
  latin = 0x100,
  multiline = 0x200
};
 
enum class zwp_text_input_v1_content_purpose : uint32_t
  {
  normal = 0,
  alpha = 1,
  digits = 2,
  number = 3,
  phone = 4,
  url = 5,
  email = 6,
  name = 7,
  password = 8,
  date = 9,
  time = 10,
  datetime = 11,
  terminal = 12
};
 
enum class zwp_text_input_v1_preedit_style : uint32_t
  {
  _default = 0,
  none = 1,
  active = 2,
  inactive = 3,
  highlight = 4,
  underline = 5,
  selection = 6,
  incorrect = 7
};
 
enum class zwp_text_input_v1_text_direction : uint32_t
  {
  _auto = 0,
  ltr = 1,
  rtl = 2
};
 
 
class zwp_text_input_manager_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_text_input_manager_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_text_input_manager_v1_t();
  explicit zwp_text_input_manager_v1_t(const proxy_t &proxy);
  zwp_text_input_manager_v1_t(zwp_text_input_manager_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_text_input_manager_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_text_input_manager_v1*() const;
 
  zwp_text_input_v1_t create_text_input();
 
  static constexpr std::uint32_t create_text_input_since_version = 1;
 
};
 
 
class zwp_text_input_v3_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(surface_t)> enter;
    std::function<void(surface_t)> leave;
    std::function<void(std::string, int32_t, int32_t)> preedit_string;
    std::function<void(std::string)> commit_string;
    std::function<void(uint32_t, uint32_t)> delete_surrounding_text;
    std::function<void(uint32_t)> done;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_text_input_v3_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_text_input_v3_t();
  explicit zwp_text_input_v3_t(const proxy_t &proxy);
  zwp_text_input_v3_t(zwp_text_input_v3 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_text_input_v3_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_text_input_v3*() const;
 
  void enable();
 
  static constexpr std::uint32_t enable_since_version = 1;
 
  void disable();
 
  static constexpr std::uint32_t disable_since_version = 1;
 
  void set_surrounding_text(std::string text, int32_t cursor, int32_t anchor);
 
  static constexpr std::uint32_t set_surrounding_text_since_version = 1;
 
  void set_text_change_cause(zwp_text_input_v3_change_cause cause);
 
  static constexpr std::uint32_t set_text_change_cause_since_version = 1;
 
  void set_content_type(zwp_text_input_v3_content_hint hint, zwp_text_input_v3_content_purpose purpose);
 
  static constexpr std::uint32_t set_content_type_since_version = 1;
 
  void set_cursor_rectangle(int32_t x, int32_t y, int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_cursor_rectangle_since_version = 1;
 
  void commit();
 
  static constexpr std::uint32_t commit_since_version = 1;
 
  std::function<void(surface_t)> &on_enter();
 
  std::function<void(surface_t)> &on_leave();
 
  std::function<void(std::string, int32_t, int32_t)> &on_preedit_string();
 
  std::function<void(std::string)> &on_commit_string();
 
  std::function<void(uint32_t, uint32_t)> &on_delete_surrounding_text();
 
  std::function<void(uint32_t)> &on_done();
 
};
 
enum class zwp_text_input_v3_change_cause : uint32_t
  {
  input_method = 0,
  other = 1
};
 
struct zwp_text_input_v3_content_hint : public detail::bitfield<10, 27>
{
  zwp_text_input_v3_content_hint(const detail::bitfield<10, 27> &b)
    : detail::bitfield<10, 27>(b) {}
  zwp_text_input_v3_content_hint(const uint32_t value)
    : detail::bitfield<10, 27>(value) {}
  static const detail::bitfield<10, 27> none;
  static const detail::bitfield<10, 27> completion;
  static const detail::bitfield<10, 27> spellcheck;
  static const detail::bitfield<10, 27> auto_capitalization;
  static const detail::bitfield<10, 27> lowercase;
  static const detail::bitfield<10, 27> uppercase;
  static const detail::bitfield<10, 27> titlecase;
  static const detail::bitfield<10, 27> hidden_text;
  static const detail::bitfield<10, 27> sensitive_data;
  static const detail::bitfield<10, 27> latin;
  static const detail::bitfield<10, 27> multiline;
};
 
enum class zwp_text_input_v3_content_purpose : uint32_t
  {
  normal = 0,
  alpha = 1,
  digits = 2,
  number = 3,
  phone = 4,
  url = 5,
  email = 6,
  name = 7,
  password = 8,
  pin = 9,
  date = 10,
  time = 11,
  datetime = 12,
  terminal = 13
};
 
 
class zwp_text_input_manager_v3_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_text_input_manager_v3_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_text_input_manager_v3_t();
  explicit zwp_text_input_manager_v3_t(const proxy_t &proxy);
  zwp_text_input_manager_v3_t(zwp_text_input_manager_v3 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_text_input_manager_v3_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_text_input_manager_v3*() const;
 
  zwp_text_input_v3_t get_text_input(seat_t seat);
 
  static constexpr std::uint32_t get_text_input_since_version = 1;
 
};
 
 
class zxdg_decoration_manager_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_decoration_manager_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_decoration_manager_v1_t();
  explicit zxdg_decoration_manager_v1_t(const proxy_t &proxy);
  zxdg_decoration_manager_v1_t(zxdg_decoration_manager_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_decoration_manager_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_decoration_manager_v1*() const;
 
  zxdg_toplevel_decoration_v1_t get_toplevel_decoration(xdg_toplevel_t toplevel);
 
  static constexpr std::uint32_t get_toplevel_decoration_since_version = 1;
 
};
 
 
class zxdg_toplevel_decoration_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(zxdg_toplevel_decoration_v1_mode)> configure;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_toplevel_decoration_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_toplevel_decoration_v1_t();
  explicit zxdg_toplevel_decoration_v1_t(const proxy_t &proxy);
  zxdg_toplevel_decoration_v1_t(zxdg_toplevel_decoration_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_toplevel_decoration_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_toplevel_decoration_v1*() const;
 
  void set_mode(zxdg_toplevel_decoration_v1_mode mode);
 
  static constexpr std::uint32_t set_mode_since_version = 1;
 
  void unset_mode();
 
  static constexpr std::uint32_t unset_mode_since_version = 1;
 
  std::function<void(zxdg_toplevel_decoration_v1_mode)> &on_configure();
 
};
 
enum class zxdg_toplevel_decoration_v1_error : uint32_t
  {
  unconfigured_buffer = 0,
  already_constructed = 1,
  orphaned = 2
};
 
enum class zxdg_toplevel_decoration_v1_mode : uint32_t
  {
  client_side = 1,
  server_side = 2
};
 
 
class zxdg_exporter_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_exporter_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_exporter_v1_t();
  explicit zxdg_exporter_v1_t(const proxy_t &proxy);
  zxdg_exporter_v1_t(zxdg_exporter_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_exporter_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_exporter_v1*() const;
 
  zxdg_exported_v1_t _export(surface_t surface);
 
  static constexpr std::uint32_t export_since_version = 1;
 
};
 
 
class zxdg_importer_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_importer_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_importer_v1_t();
  explicit zxdg_importer_v1_t(const proxy_t &proxy);
  zxdg_importer_v1_t(zxdg_importer_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_importer_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_importer_v1*() const;
 
  zxdg_imported_v1_t import(std::string handle);
 
  static constexpr std::uint32_t import_since_version = 1;
 
};
 
 
class zxdg_exported_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(std::string)> handle;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_exported_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_exported_v1_t();
  explicit zxdg_exported_v1_t(const proxy_t &proxy);
  zxdg_exported_v1_t(zxdg_exported_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_exported_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_exported_v1*() const;
 
  std::function<void(std::string)> &on_handle();
 
};
 
 
class zxdg_imported_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void()> destroyed;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_imported_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_imported_v1_t();
  explicit zxdg_imported_v1_t(const proxy_t &proxy);
  zxdg_imported_v1_t(zxdg_imported_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_imported_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_imported_v1*() const;
 
  void set_parent_of(surface_t surface);
 
  static constexpr std::uint32_t set_parent_of_since_version = 1;
 
  std::function<void()> &on_destroyed();
 
};
 
 
class zxdg_exporter_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_exporter_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_exporter_v2_t();
  explicit zxdg_exporter_v2_t(const proxy_t &proxy);
  zxdg_exporter_v2_t(zxdg_exporter_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_exporter_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_exporter_v2*() const;
 
  zxdg_exported_v2_t export_toplevel(surface_t surface);
 
  static constexpr std::uint32_t export_toplevel_since_version = 1;
 
};
 
 
class zxdg_importer_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_importer_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_importer_v2_t();
  explicit zxdg_importer_v2_t(const proxy_t &proxy);
  zxdg_importer_v2_t(zxdg_importer_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_importer_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_importer_v2*() const;
 
  zxdg_imported_v2_t import_toplevel(std::string handle);
 
  static constexpr std::uint32_t import_toplevel_since_version = 1;
 
};
 
 
class zxdg_exported_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(std::string)> handle;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_exported_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_exported_v2_t();
  explicit zxdg_exported_v2_t(const proxy_t &proxy);
  zxdg_exported_v2_t(zxdg_exported_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_exported_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_exported_v2*() const;
 
  std::function<void(std::string)> &on_handle();
 
};
 
 
class zxdg_imported_v2_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void()> destroyed;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_imported_v2_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_imported_v2_t();
  explicit zxdg_imported_v2_t(const proxy_t &proxy);
  zxdg_imported_v2_t(zxdg_imported_v2 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_imported_v2_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_imported_v2*() const;
 
  void set_parent_of(surface_t surface);
 
  static constexpr std::uint32_t set_parent_of_since_version = 1;
 
  std::function<void()> &on_destroyed();
 
};
 
 
class zxdg_output_manager_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_output_manager_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_output_manager_v1_t();
  explicit zxdg_output_manager_v1_t(const proxy_t &proxy);
  zxdg_output_manager_v1_t(zxdg_output_manager_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_output_manager_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_output_manager_v1*() const;
 
  zxdg_output_v1_t get_xdg_output(output_t output);
 
  static constexpr std::uint32_t get_xdg_output_since_version = 1;
 
};
 
 
class zxdg_output_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(int32_t, int32_t)> logical_position;
    std::function<void(int32_t, int32_t)> logical_size;
    std::function<void()> done;
    std::function<void(std::string)> name;
    std::function<void(std::string)> description;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_output_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_output_v1_t();
  explicit zxdg_output_v1_t(const proxy_t &proxy);
  zxdg_output_v1_t(zxdg_output_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_output_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_output_v1*() const;
 
  std::function<void(int32_t, int32_t)> &on_logical_position();
 
  std::function<void(int32_t, int32_t)> &on_logical_size();
 
  std::function<void()> &on_done();
 
  std::function<void(std::string)> &on_name();
 
  std::function<void(std::string)> &on_description();
 
};
 
 
class zxdg_shell_v6_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t)> ping;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_shell_v6_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_shell_v6_t();
  explicit zxdg_shell_v6_t(const proxy_t &proxy);
  zxdg_shell_v6_t(zxdg_shell_v6 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_shell_v6_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_shell_v6*() const;
 
  zxdg_positioner_v6_t create_positioner();
 
  static constexpr std::uint32_t create_positioner_since_version = 1;
 
  zxdg_surface_v6_t get_xdg_surface(surface_t surface);
 
  static constexpr std::uint32_t get_xdg_surface_since_version = 1;
 
  void pong(uint32_t serial);
 
  static constexpr std::uint32_t pong_since_version = 1;
 
  std::function<void(uint32_t)> &on_ping();
 
};
 
enum class zxdg_shell_v6_error : uint32_t
  {
  role = 0,
  defunct_surfaces = 1,
  not_the_topmost_popup = 2,
  invalid_popup_parent = 3,
  invalid_surface_state = 4,
  invalid_positioner = 5
};
 
 
class zxdg_positioner_v6_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_positioner_v6_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_positioner_v6_t();
  explicit zxdg_positioner_v6_t(const proxy_t &proxy);
  zxdg_positioner_v6_t(zxdg_positioner_v6 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_positioner_v6_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_positioner_v6*() const;
 
  void set_size(int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_size_since_version = 1;
 
  void set_anchor_rect(int32_t x, int32_t y, int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_anchor_rect_since_version = 1;
 
  void set_anchor(zxdg_positioner_v6_anchor anchor);
 
  static constexpr std::uint32_t set_anchor_since_version = 1;
 
  void set_gravity(zxdg_positioner_v6_gravity gravity);
 
  static constexpr std::uint32_t set_gravity_since_version = 1;
 
  void set_constraint_adjustment(zxdg_positioner_v6_constraint_adjustment constraint_adjustment);
 
  static constexpr std::uint32_t set_constraint_adjustment_since_version = 1;
 
  void set_offset(int32_t x, int32_t y);
 
  static constexpr std::uint32_t set_offset_since_version = 1;
 
};
 
enum class zxdg_positioner_v6_error : uint32_t
  {
  invalid_input = 0
};
 
struct zxdg_positioner_v6_anchor : public detail::bitfield<4, 33>
{
  zxdg_positioner_v6_anchor(const detail::bitfield<4, 33> &b)
    : detail::bitfield<4, 33>(b) {}
  zxdg_positioner_v6_anchor(const uint32_t value)
    : detail::bitfield<4, 33>(value) {}
  static const detail::bitfield<4, 33> none;
  static const detail::bitfield<4, 33> top;
  static const detail::bitfield<4, 33> bottom;
  static const detail::bitfield<4, 33> left;
  static const detail::bitfield<4, 33> right;
};
 
struct zxdg_positioner_v6_gravity : public detail::bitfield<4, 34>
{
  zxdg_positioner_v6_gravity(const detail::bitfield<4, 34> &b)
    : detail::bitfield<4, 34>(b) {}
  zxdg_positioner_v6_gravity(const uint32_t value)
    : detail::bitfield<4, 34>(value) {}
  static const detail::bitfield<4, 34> none;
  static const detail::bitfield<4, 34> top;
  static const detail::bitfield<4, 34> bottom;
  static const detail::bitfield<4, 34> left;
  static const detail::bitfield<4, 34> right;
};
 
struct zxdg_positioner_v6_constraint_adjustment : public detail::bitfield<6, 35>
{
  zxdg_positioner_v6_constraint_adjustment(const detail::bitfield<6, 35> &b)
    : detail::bitfield<6, 35>(b) {}
  zxdg_positioner_v6_constraint_adjustment(const uint32_t value)
    : detail::bitfield<6, 35>(value) {}
  static const detail::bitfield<6, 35> none;
  static const detail::bitfield<6, 35> slide_x;
  static const detail::bitfield<6, 35> slide_y;
  static const detail::bitfield<6, 35> flip_x;
  static const detail::bitfield<6, 35> flip_y;
  static const detail::bitfield<6, 35> resize_x;
  static const detail::bitfield<6, 35> resize_y;
};
 
 
class zxdg_surface_v6_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(uint32_t)> configure;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_surface_v6_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_surface_v6_t();
  explicit zxdg_surface_v6_t(const proxy_t &proxy);
  zxdg_surface_v6_t(zxdg_surface_v6 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_surface_v6_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_surface_v6*() const;
 
  zxdg_toplevel_v6_t get_toplevel();
 
  static constexpr std::uint32_t get_toplevel_since_version = 1;
 
  zxdg_popup_v6_t get_popup(zxdg_surface_v6_t parent, zxdg_positioner_v6_t positioner);
 
  static constexpr std::uint32_t get_popup_since_version = 1;
 
  void set_window_geometry(int32_t x, int32_t y, int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_window_geometry_since_version = 1;
 
  void ack_configure(uint32_t serial);
 
  static constexpr std::uint32_t ack_configure_since_version = 1;
 
  std::function<void(uint32_t)> &on_configure();
 
};
 
enum class zxdg_surface_v6_error : uint32_t
  {
  not_constructed = 1,
  already_constructed = 2,
  unconfigured_buffer = 3
};
 
 
class zxdg_toplevel_v6_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(int32_t, int32_t, array_t)> configure;
    std::function<void()> close;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_toplevel_v6_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_toplevel_v6_t();
  explicit zxdg_toplevel_v6_t(const proxy_t &proxy);
  zxdg_toplevel_v6_t(zxdg_toplevel_v6 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_toplevel_v6_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_toplevel_v6*() const;
 
  void set_parent(zxdg_toplevel_v6_t parent);
 
  static constexpr std::uint32_t set_parent_since_version = 1;
 
  void set_title(std::string title);
 
  static constexpr std::uint32_t set_title_since_version = 1;
 
  void set_app_id(std::string app_id);
 
  static constexpr std::uint32_t set_app_id_since_version = 1;
 
  void show_window_menu(seat_t seat, uint32_t serial, int32_t x, int32_t y);
 
  static constexpr std::uint32_t show_window_menu_since_version = 1;
 
  void move(seat_t seat, uint32_t serial);
 
  static constexpr std::uint32_t move_since_version = 1;
 
  void resize(seat_t seat, uint32_t serial, zxdg_toplevel_v6_resize_edge edges);
 
  static constexpr std::uint32_t resize_since_version = 1;
 
  void set_max_size(int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_max_size_since_version = 1;
 
  void set_min_size(int32_t width, int32_t height);
 
  static constexpr std::uint32_t set_min_size_since_version = 1;
 
  void set_maximized();
 
  static constexpr std::uint32_t set_maximized_since_version = 1;
 
  void unset_maximized();
 
  static constexpr std::uint32_t unset_maximized_since_version = 1;
 
  void set_fullscreen(output_t output);
 
  static constexpr std::uint32_t set_fullscreen_since_version = 1;
 
  void unset_fullscreen();
 
  static constexpr std::uint32_t unset_fullscreen_since_version = 1;
 
  void set_minimized();
 
  static constexpr std::uint32_t set_minimized_since_version = 1;
 
  std::function<void(int32_t, int32_t, array_t)> &on_configure();
 
  std::function<void()> &on_close();
 
};
 
struct zxdg_toplevel_v6_resize_edge : public detail::bitfield<4, 37>
{
  zxdg_toplevel_v6_resize_edge(const detail::bitfield<4, 37> &b)
    : detail::bitfield<4, 37>(b) {}
  zxdg_toplevel_v6_resize_edge(const uint32_t value)
    : detail::bitfield<4, 37>(value) {}
  static const detail::bitfield<4, 37> none;
  static const detail::bitfield<4, 37> top;
  static const detail::bitfield<4, 37> bottom;
  static const detail::bitfield<4, 37> left;
  static const detail::bitfield<4, 37> top_left;
  static const detail::bitfield<4, 37> bottom_left;
  static const detail::bitfield<4, 37> right;
  static const detail::bitfield<4, 37> top_right;
  static const detail::bitfield<4, 37> bottom_right;
};
 
enum class zxdg_toplevel_v6_state : uint32_t
  {
  maximized = 1,
  fullscreen = 2,
  resizing = 3,
  activated = 4
};
 
 
class zxdg_popup_v6_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
    std::function<void(int32_t, int32_t, int32_t, int32_t)> configure;
    std::function<void()> popup_done;
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zxdg_popup_v6_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zxdg_popup_v6_t();
  explicit zxdg_popup_v6_t(const proxy_t &proxy);
  zxdg_popup_v6_t(zxdg_popup_v6 *p, wrapper_type t = wrapper_type::standard);
 
  zxdg_popup_v6_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zxdg_popup_v6*() const;
 
  void grab(seat_t seat, uint32_t serial);
 
  static constexpr std::uint32_t grab_since_version = 1;
 
  std::function<void(int32_t, int32_t, int32_t, int32_t)> &on_configure();
 
  std::function<void()> &on_popup_done();
 
};
 
enum class zxdg_popup_v6_error : uint32_t
  {
  invalid_grab = 0
};
 
 
class zwp_xwayland_keyboard_grab_manager_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_xwayland_keyboard_grab_manager_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_xwayland_keyboard_grab_manager_v1_t();
  explicit zwp_xwayland_keyboard_grab_manager_v1_t(const proxy_t &proxy);
  zwp_xwayland_keyboard_grab_manager_v1_t(zwp_xwayland_keyboard_grab_manager_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_xwayland_keyboard_grab_manager_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_xwayland_keyboard_grab_manager_v1*() const;
 
  zwp_xwayland_keyboard_grab_v1_t grab_keyboard(surface_t surface, seat_t seat);
 
  static constexpr std::uint32_t grab_keyboard_since_version = 1;
 
};
 
 
class zwp_xwayland_keyboard_grab_v1_t : public proxy_t
{
private:
  struct events_t : public detail::events_base_t
  {
  };
 
  static int dispatcher(uint32_t opcode, std::vector<detail::any> args, std::shared_ptr<detail::events_base_t> e);
 
  zwp_xwayland_keyboard_grab_v1_t(proxy_t const &wrapped_proxy, construct_proxy_wrapper_tag /*unused*/);
 
public:
  zwp_xwayland_keyboard_grab_v1_t();
  explicit zwp_xwayland_keyboard_grab_v1_t(const proxy_t &proxy);
  zwp_xwayland_keyboard_grab_v1_t(zwp_xwayland_keyboard_grab_v1 *p, wrapper_type t = wrapper_type::standard);
 
  zwp_xwayland_keyboard_grab_v1_t proxy_create_wrapper();
 
  static const std::string interface_name;
 
  operator zwp_xwayland_keyboard_grab_v1*() const;
 
};
 
 
 
}