diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,3 +1,11 @@
+### 3.0.3
+
++ Update to haskell-gi(-base) 0.22
+
+### 3.0.2
+
++ Update stack version to 12.10
+
 ### 3.0.1
 
 + Initial release.
diff --git a/GI/Wnck.hs b/GI/Wnck.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck.hs
@@ -0,0 +1,56 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck
+    (     module GI.Wnck.Constants                ,
+    module GI.Wnck.Enums                    ,
+    module GI.Wnck.Flags                    ,
+    module GI.Wnck.Functions                ,
+    module GI.Wnck.Objects                  ,
+    module GI.Wnck.Structs                  ,
+
+
+
+    module Data.GI.Base                     ,
+
+
+    ) where
+
+import GI.Wnck.Constants
+import GI.Wnck.Enums
+import GI.Wnck.Flags
+import GI.Wnck.Functions
+import GI.Wnck.Objects
+import GI.Wnck.Structs
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+
+import Data.GI.Base
+
diff --git a/GI/Wnck/Constants.hs b/GI/Wnck/Constants.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Constants.hs
@@ -0,0 +1,75 @@
+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Constants
+    ( 
+    pattern MINOR_VERSION                   ,
+    pattern MICRO_VERSION                   ,
+    pattern MAJOR_VERSION                   ,
+    pattern DEFAULT_MINI_ICON_SIZE          ,
+    pattern DEFAULT_ICON_SIZE               ,
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+
+{- |
+/No description available in the introspection data./
+
+/Since: 3.0/
+-}
+pattern MINOR_VERSION = 32 :: Int32
+
+{- |
+/No description available in the introspection data./
+
+/Since: 3.0/
+-}
+pattern MICRO_VERSION = 0 :: Int32
+
+{- |
+/No description available in the introspection data./
+
+/Since: 3.0/
+-}
+pattern MAJOR_VERSION = 3 :: Int32
+
+{- |
+/No description available in the introspection data./
+-}
+pattern DEFAULT_MINI_ICON_SIZE = 16 :: Int32
+
+{- |
+/No description available in the introspection data./
+-}
+pattern DEFAULT_ICON_SIZE = 32 :: Int32
+
+
diff --git a/GI/Wnck/Enums.hs b/GI/Wnck/Enums.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Enums.hs
@@ -0,0 +1,500 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Enums
+    ( 
+
+ -- * Enumerations
+-- ** ClientType #enum:ClientType#
+
+    ClientType(..)                          ,
+
+
+-- ** LayoutCorner_ #enum:LayoutCorner_#
+
+    LayoutCorner_(..)                       ,
+
+
+-- ** LayoutOrientation_ #enum:LayoutOrientation_#
+
+    LayoutOrientation_(..)                  ,
+
+
+-- ** MotionDirection #enum:MotionDirection#
+
+    MotionDirection(..)                     ,
+
+
+-- ** PagerDisplayMode #enum:PagerDisplayMode#
+
+    PagerDisplayMode(..)                    ,
+
+
+-- ** TasklistGroupingType #enum:TasklistGroupingType#
+
+    TasklistGroupingType(..)                ,
+
+
+-- ** WindowGravity #enum:WindowGravity#
+
+    WindowGravity(..)                       ,
+
+
+-- ** WindowType #enum:WindowType#
+
+    WindowType(..)                          ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+
+-- Enum _LayoutOrientation
+{- |
+/No description available in the introspection data./
+-}
+data LayoutOrientation_ = 
+      LayoutOrientationHorizontal_
+    {- ^
+    /No description available in the introspection data./
+    -}
+    | LayoutOrientationVertical_
+    {- ^
+    /No description available in the introspection data./
+    -}
+    | AnotherLayoutOrientation_ Int
+    -- ^ Catch-all for unknown values
+    deriving (Show, Eq)
+
+instance P.Enum LayoutOrientation_ where
+    fromEnum LayoutOrientationHorizontal_ = 0
+    fromEnum LayoutOrientationVertical_ = 1
+    fromEnum (AnotherLayoutOrientation_ k) = k
+
+    toEnum 0 = LayoutOrientationHorizontal_
+    toEnum 1 = LayoutOrientationVertical_
+    toEnum k = AnotherLayoutOrientation_ k
+
+instance P.Ord LayoutOrientation_ where
+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)
+
+-- Enum _LayoutCorner
+{- |
+/No description available in the introspection data./
+-}
+data LayoutCorner_ = 
+      LayoutCornerTopleft_
+    {- ^
+    /No description available in the introspection data./
+    -}
+    | LayoutCornerTopright_
+    {- ^
+    /No description available in the introspection data./
+    -}
+    | LayoutCornerBottomright_
+    {- ^
+    /No description available in the introspection data./
+    -}
+    | LayoutCornerBottomleft_
+    {- ^
+    /No description available in the introspection data./
+    -}
+    | AnotherLayoutCorner_ Int
+    -- ^ Catch-all for unknown values
+    deriving (Show, Eq)
+
+instance P.Enum LayoutCorner_ where
+    fromEnum LayoutCornerTopleft_ = 0
+    fromEnum LayoutCornerTopright_ = 1
+    fromEnum LayoutCornerBottomright_ = 2
+    fromEnum LayoutCornerBottomleft_ = 3
+    fromEnum (AnotherLayoutCorner_ k) = k
+
+    toEnum 0 = LayoutCornerTopleft_
+    toEnum 1 = LayoutCornerTopright_
+    toEnum 2 = LayoutCornerBottomright_
+    toEnum 3 = LayoutCornerBottomleft_
+    toEnum k = AnotherLayoutCorner_ k
+
+instance P.Ord LayoutCorner_ where
+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)
+
+-- Enum WindowType
+{- |
+Type describing the semantic type of a 'GI.Wnck.Objects.Window.Window'.
+-}
+data WindowType = 
+      WindowTypeNormal
+    {- ^
+    the window is a normal window.
+    -}
+    | WindowTypeDesktop
+    {- ^
+    the window is a desktop.
+    -}
+    | WindowTypeDock
+    {- ^
+    the window is a dock or a panel.
+    -}
+    | WindowTypeDialog
+    {- ^
+    the window is a dialog window.
+    -}
+    | WindowTypeToolbar
+    {- ^
+    the window is a tearoff toolbar.
+    -}
+    | WindowTypeMenu
+    {- ^
+    the window is a tearoff menu.
+    -}
+    | WindowTypeUtility
+    {- ^
+    the window is a small persistent utility window, such
+    as a palette or toolbox.
+    -}
+    | WindowTypeSplashscreen
+    {- ^
+    the window is a splash screen displayed as an
+    application is starting up.
+    -}
+    | AnotherWindowType Int
+    -- ^ Catch-all for unknown values
+    deriving (Show, Eq)
+
+instance P.Enum WindowType where
+    fromEnum WindowTypeNormal = 0
+    fromEnum WindowTypeDesktop = 1
+    fromEnum WindowTypeDock = 2
+    fromEnum WindowTypeDialog = 3
+    fromEnum WindowTypeToolbar = 4
+    fromEnum WindowTypeMenu = 5
+    fromEnum WindowTypeUtility = 6
+    fromEnum WindowTypeSplashscreen = 7
+    fromEnum (AnotherWindowType k) = k
+
+    toEnum 0 = WindowTypeNormal
+    toEnum 1 = WindowTypeDesktop
+    toEnum 2 = WindowTypeDock
+    toEnum 3 = WindowTypeDialog
+    toEnum 4 = WindowTypeToolbar
+    toEnum 5 = WindowTypeMenu
+    toEnum 6 = WindowTypeUtility
+    toEnum 7 = WindowTypeSplashscreen
+    toEnum k = AnotherWindowType k
+
+instance P.Ord WindowType where
+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)
+
+foreign import ccall "wnck_window_type_get_type" c_wnck_window_type_get_type :: 
+    IO GType
+
+instance BoxedEnum WindowType where
+    boxedEnumType _ = c_wnck_window_type_get_type
+
+-- Enum WindowGravity
+{- |
+Flag used when changing the geometry of a 'GI.Wnck.Objects.Window.Window'. This is the gravity
+point to use as a reference for the new position.
+
+/Since: 2.16/
+-}
+data WindowGravity = 
+      WindowGravityCurrent
+    {- ^
+    keep the current gravity point.
+    -}
+    | WindowGravityNorthwest
+    {- ^
+    use the left top corner of the frame window
+    as gravity point.
+    -}
+    | WindowGravityNorth
+    {- ^
+    use the center of the frame window\'s top side as
+    gravity point.
+    -}
+    | WindowGravityNortheast
+    {- ^
+    use the right top corner of the frame window
+    as gravity point.
+    -}
+    | WindowGravityWest
+    {- ^
+    use the center of the frame window\'s left side as
+    gravity point.
+    -}
+    | WindowGravityCenter
+    {- ^
+    use the center of the frame window as gravity
+    point.
+    -}
+    | WindowGravityEast
+    {- ^
+    use the center of the frame window\'s right side
+    as gravity point.
+    -}
+    | WindowGravitySouthwest
+    {- ^
+    use the left bottom corner of the frame
+    window as gravity point.
+    -}
+    | WindowGravitySouth
+    {- ^
+    use the center of the frame window\'s bottom side
+    as gravity point.
+    -}
+    | WindowGravitySoutheast
+    {- ^
+    use the right bottom corner of the frame
+    window as gravity point.
+    -}
+    | WindowGravityStatic
+    {- ^
+    use the left top corner of the client window as
+    gravity point.
+    -}
+    | AnotherWindowGravity Int
+    -- ^ Catch-all for unknown values
+    deriving (Show, Eq)
+
+instance P.Enum WindowGravity where
+    fromEnum WindowGravityCurrent = 0
+    fromEnum WindowGravityNorthwest = 1
+    fromEnum WindowGravityNorth = 2
+    fromEnum WindowGravityNortheast = 3
+    fromEnum WindowGravityWest = 4
+    fromEnum WindowGravityCenter = 5
+    fromEnum WindowGravityEast = 6
+    fromEnum WindowGravitySouthwest = 7
+    fromEnum WindowGravitySouth = 8
+    fromEnum WindowGravitySoutheast = 9
+    fromEnum WindowGravityStatic = 10
+    fromEnum (AnotherWindowGravity k) = k
+
+    toEnum 0 = WindowGravityCurrent
+    toEnum 1 = WindowGravityNorthwest
+    toEnum 2 = WindowGravityNorth
+    toEnum 3 = WindowGravityNortheast
+    toEnum 4 = WindowGravityWest
+    toEnum 5 = WindowGravityCenter
+    toEnum 6 = WindowGravityEast
+    toEnum 7 = WindowGravitySouthwest
+    toEnum 8 = WindowGravitySouth
+    toEnum 9 = WindowGravitySoutheast
+    toEnum 10 = WindowGravityStatic
+    toEnum k = AnotherWindowGravity k
+
+instance P.Ord WindowGravity where
+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)
+
+foreign import ccall "wnck_window_gravity_get_type" c_wnck_window_gravity_get_type :: 
+    IO GType
+
+instance BoxedEnum WindowGravity where
+    boxedEnumType _ = c_wnck_window_gravity_get_type
+
+-- Enum TasklistGroupingType
+{- |
+Type defining the policy of the 'GI.Wnck.Objects.Tasklist.Tasklist' for grouping multiple
+'GI.Wnck.Objects.Window.Window' of the same 'GI.Wnck.Objects.Application.Application'.
+-}
+data TasklistGroupingType = 
+      TasklistGroupingTypeNeverGroup
+    {- ^
+    never group multiple 'GI.Wnck.Objects.Window.Window' of the same
+    'GI.Wnck.Objects.Application.Application'.
+    -}
+    | TasklistGroupingTypeAutoGroup
+    {- ^
+    group multiple 'GI.Wnck.Objects.Window.Window' of the same
+    'GI.Wnck.Objects.Application.Application' for some 'GI.Wnck.Objects.Application.Application', when there is not enough place
+    to have a good-looking list of all 'GI.Wnck.Objects.Window.Window'.
+    -}
+    | TasklistGroupingTypeAlwaysGroup
+    {- ^
+    always group multiple 'GI.Wnck.Objects.Window.Window' of the same
+    'GI.Wnck.Objects.Application.Application', for all 'GI.Wnck.Objects.Application.Application'.
+    -}
+    | AnotherTasklistGroupingType Int
+    -- ^ Catch-all for unknown values
+    deriving (Show, Eq)
+
+instance P.Enum TasklistGroupingType where
+    fromEnum TasklistGroupingTypeNeverGroup = 0
+    fromEnum TasklistGroupingTypeAutoGroup = 1
+    fromEnum TasklistGroupingTypeAlwaysGroup = 2
+    fromEnum (AnotherTasklistGroupingType k) = k
+
+    toEnum 0 = TasklistGroupingTypeNeverGroup
+    toEnum 1 = TasklistGroupingTypeAutoGroup
+    toEnum 2 = TasklistGroupingTypeAlwaysGroup
+    toEnum k = AnotherTasklistGroupingType k
+
+instance P.Ord TasklistGroupingType where
+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)
+
+foreign import ccall "wnck_tasklist_grouping_type_get_type" c_wnck_tasklist_grouping_type_get_type :: 
+    IO GType
+
+instance BoxedEnum TasklistGroupingType where
+    boxedEnumType _ = c_wnck_tasklist_grouping_type_get_type
+
+-- Enum PagerDisplayMode
+{- |
+Mode defining what a 'GI.Wnck.Objects.Pager.Pager' will display.
+-}
+data PagerDisplayMode = 
+      PagerDisplayModeName
+    {- ^
+    the 'GI.Wnck.Objects.Pager.Pager' will only display the names of the
+    workspaces.
+    -}
+    | PagerDisplayModeContent
+    {- ^
+    the 'GI.Wnck.Objects.Pager.Pager' will display a representation
+    for each window in the workspaces.
+    -}
+    | AnotherPagerDisplayMode Int
+    -- ^ Catch-all for unknown values
+    deriving (Show, Eq)
+
+instance P.Enum PagerDisplayMode where
+    fromEnum PagerDisplayModeName = 0
+    fromEnum PagerDisplayModeContent = 1
+    fromEnum (AnotherPagerDisplayMode k) = k
+
+    toEnum 0 = PagerDisplayModeName
+    toEnum 1 = PagerDisplayModeContent
+    toEnum k = AnotherPagerDisplayMode k
+
+instance P.Ord PagerDisplayMode where
+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)
+
+foreign import ccall "wnck_pager_display_mode_get_type" c_wnck_pager_display_mode_get_type :: 
+    IO GType
+
+instance BoxedEnum PagerDisplayMode where
+    boxedEnumType _ = c_wnck_pager_display_mode_get_type
+
+-- Enum MotionDirection
+{- |
+Type defining a direction in which to search a neighbor 'GI.Wnck.Objects.Workspace.Workspace'.
+
+/Since: 2.14/
+-}
+data MotionDirection = 
+      MotionDirectionUp
+    {- ^
+    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' above another
+    'GI.Wnck.Objects.Workspace.Workspace'.
+    -}
+    | MotionDirectionDown
+    {- ^
+    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' below another
+    'GI.Wnck.Objects.Workspace.Workspace'.
+    -}
+    | MotionDirectionLeft
+    {- ^
+    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' at the left of another
+    'GI.Wnck.Objects.Workspace.Workspace'.
+    -}
+    | MotionDirectionRight
+    {- ^
+    search a neighbor 'GI.Wnck.Objects.Workspace.Workspace' at the right of another
+    'GI.Wnck.Objects.Workspace.Workspace'.
+    -}
+    | AnotherMotionDirection Int
+    -- ^ Catch-all for unknown values
+    deriving (Show, Eq)
+
+instance P.Enum MotionDirection where
+    fromEnum MotionDirectionUp = -1
+    fromEnum MotionDirectionDown = -2
+    fromEnum MotionDirectionLeft = -3
+    fromEnum MotionDirectionRight = -4
+    fromEnum (AnotherMotionDirection k) = k
+
+    toEnum -1 = MotionDirectionUp
+    toEnum -2 = MotionDirectionDown
+    toEnum -3 = MotionDirectionLeft
+    toEnum -4 = MotionDirectionRight
+    toEnum k = AnotherMotionDirection k
+
+instance P.Ord MotionDirection where
+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)
+
+foreign import ccall "wnck_motion_direction_get_type" c_wnck_motion_direction_get_type :: 
+    IO GType
+
+instance BoxedEnum MotionDirection where
+    boxedEnumType _ = c_wnck_motion_direction_get_type
+
+-- Enum ClientType
+{- |
+Type describing the role of the libwnck user.
+
+/Since: 2.14/
+-}
+data ClientType = 
+      ClientTypeApplication
+    {- ^
+    the libwnck user is a normal application.
+    -}
+    | ClientTypePager
+    {- ^
+    the libwnck user is an utility application dealing
+    with window management, like pagers and taskbars.
+    -}
+    | AnotherClientType Int
+    -- ^ Catch-all for unknown values
+    deriving (Show, Eq)
+
+instance P.Enum ClientType where
+    fromEnum ClientTypeApplication = 1
+    fromEnum ClientTypePager = 2
+    fromEnum (AnotherClientType k) = k
+
+    toEnum 1 = ClientTypeApplication
+    toEnum 2 = ClientTypePager
+    toEnum k = AnotherClientType k
+
+instance P.Ord ClientType where
+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)
+
+foreign import ccall "wnck_client_type_get_type" c_wnck_client_type_get_type :: 
+    IO GType
+
+instance BoxedEnum ClientType where
+    boxedEnumType _ = c_wnck_client_type_get_type
+
+
diff --git a/GI/Wnck/Enums.hs-boot b/GI/Wnck/Enums.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Enums.hs-boot
@@ -0,0 +1,46 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Enums where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+data LayoutOrientation_
+instance P.Enum LayoutOrientation_ where
+data LayoutCorner_
+instance P.Enum LayoutCorner_ where
+data WindowType
+instance P.Enum WindowType where
+instance BoxedEnum WindowType where
+data WindowGravity
+instance P.Enum WindowGravity where
+instance BoxedEnum WindowGravity where
+data TasklistGroupingType
+instance P.Enum TasklistGroupingType where
+instance BoxedEnum TasklistGroupingType where
+data PagerDisplayMode
+instance P.Enum PagerDisplayMode where
+instance BoxedEnum PagerDisplayMode where
+data MotionDirection
+instance P.Enum MotionDirection where
+instance BoxedEnum MotionDirection where
+data ClientType
+instance P.Enum ClientType where
+instance BoxedEnum ClientType where
diff --git a/GI/Wnck/Flags.hs b/GI/Wnck/Flags.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Flags.hs
@@ -0,0 +1,364 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Flags
+    ( 
+
+ -- * Flags
+-- ** WindowActions #flag:WindowActions#
+
+    WindowActions(..)                       ,
+
+
+-- ** WindowMoveResizeMask #flag:WindowMoveResizeMask#
+
+    WindowMoveResizeMask(..)                ,
+
+
+-- ** WindowState #flag:WindowState#
+
+    WindowState(..)                         ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+
+-- Flags WindowState
+{- |
+Type used as a bitmask to describe the state of a 'GI.Wnck.Objects.Window.Window'.
+-}
+data WindowState = 
+      WindowStateMinimized
+    {- ^
+    the window is minimized.
+    -}
+    | WindowStateMaximizedHorizontally
+    {- ^
+    the window is horizontically
+    maximized.
+    -}
+    | WindowStateMaximizedVertically
+    {- ^
+    the window is vertically maximized.
+    -}
+    | WindowStateShaded
+    {- ^
+    the window is shaded.
+    -}
+    | WindowStateSkipPager
+    {- ^
+    the window should not be included on pagers.
+    -}
+    | WindowStateSkipTasklist
+    {- ^
+    the window should not be included on
+    tasklists.
+    -}
+    | WindowStateSticky
+    {- ^
+    the window is sticky (see
+    'GI.Wnck.Objects.Window.windowIsSticky').
+    -}
+    | WindowStateHidden
+    {- ^
+    the window is not visible on its 'GI.Wnck.Objects.Workspace.Workspace'
+    and viewport (when minimized, for example).
+    -}
+    | WindowStateFullscreen
+    {- ^
+    the window is fullscreen.
+    -}
+    | WindowStateDemandsAttention
+    {- ^
+    the window needs attention (because
+    the window requested activation but the window manager refused it, for
+    example).
+    -}
+    | WindowStateUrgent
+    {- ^
+    the window requires a response from the user.
+    -}
+    | WindowStateAbove
+    {- ^
+    the window is above other windows (see
+    'GI.Wnck.Objects.Window.windowMakeAbove').
+    -}
+    | WindowStateBelow
+    {- ^
+    the window is below other windows (see
+    'GI.Wnck.Objects.Window.windowMakeBelow').
+    -}
+    | AnotherWindowState Int
+    -- ^ Catch-all for unknown values
+    deriving (Show, Eq)
+
+instance P.Enum WindowState where
+    fromEnum WindowStateMinimized = 1
+    fromEnum WindowStateMaximizedHorizontally = 2
+    fromEnum WindowStateMaximizedVertically = 4
+    fromEnum WindowStateShaded = 8
+    fromEnum WindowStateSkipPager = 16
+    fromEnum WindowStateSkipTasklist = 32
+    fromEnum WindowStateSticky = 64
+    fromEnum WindowStateHidden = 128
+    fromEnum WindowStateFullscreen = 256
+    fromEnum WindowStateDemandsAttention = 512
+    fromEnum WindowStateUrgent = 1024
+    fromEnum WindowStateAbove = 2048
+    fromEnum WindowStateBelow = 4096
+    fromEnum (AnotherWindowState k) = k
+
+    toEnum 1 = WindowStateMinimized
+    toEnum 2 = WindowStateMaximizedHorizontally
+    toEnum 4 = WindowStateMaximizedVertically
+    toEnum 8 = WindowStateShaded
+    toEnum 16 = WindowStateSkipPager
+    toEnum 32 = WindowStateSkipTasklist
+    toEnum 64 = WindowStateSticky
+    toEnum 128 = WindowStateHidden
+    toEnum 256 = WindowStateFullscreen
+    toEnum 512 = WindowStateDemandsAttention
+    toEnum 1024 = WindowStateUrgent
+    toEnum 2048 = WindowStateAbove
+    toEnum 4096 = WindowStateBelow
+    toEnum k = AnotherWindowState k
+
+instance P.Ord WindowState where
+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)
+
+foreign import ccall "wnck_window_state_get_type" c_wnck_window_state_get_type :: 
+    IO GType
+
+instance BoxedFlags WindowState where
+    boxedFlagsType _ = c_wnck_window_state_get_type
+
+instance IsGFlag WindowState
+
+-- Flags WindowMoveResizeMask
+{- |
+Flag used as a bitmask when changing the geometry of a 'GI.Wnck.Objects.Window.Window'. This
+indicates which part of the geometry should be changed.
+
+/Since: 2.16/
+-}
+data WindowMoveResizeMask = 
+      WindowMoveResizeMaskX
+    {- ^
+    X coordinate of the window should be changed.
+    -}
+    | WindowMoveResizeMaskY
+    {- ^
+    Y coordinate of the window should be changed.
+    -}
+    | WindowMoveResizeMaskWidth
+    {- ^
+    width of the window should be changed.
+    -}
+    | WindowMoveResizeMaskHeight
+    {- ^
+    height of the window should be changed.
+    -}
+    | AnotherWindowMoveResizeMask Int
+    -- ^ Catch-all for unknown values
+    deriving (Show, Eq)
+
+instance P.Enum WindowMoveResizeMask where
+    fromEnum WindowMoveResizeMaskX = 1
+    fromEnum WindowMoveResizeMaskY = 2
+    fromEnum WindowMoveResizeMaskWidth = 4
+    fromEnum WindowMoveResizeMaskHeight = 8
+    fromEnum (AnotherWindowMoveResizeMask k) = k
+
+    toEnum 1 = WindowMoveResizeMaskX
+    toEnum 2 = WindowMoveResizeMaskY
+    toEnum 4 = WindowMoveResizeMaskWidth
+    toEnum 8 = WindowMoveResizeMaskHeight
+    toEnum k = AnotherWindowMoveResizeMask k
+
+instance P.Ord WindowMoveResizeMask where
+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)
+
+foreign import ccall "wnck_window_move_resize_mask_get_type" c_wnck_window_move_resize_mask_get_type :: 
+    IO GType
+
+instance BoxedFlags WindowMoveResizeMask where
+    boxedFlagsType _ = c_wnck_window_move_resize_mask_get_type
+
+instance IsGFlag WindowMoveResizeMask
+
+-- Flags WindowActions
+{- |
+Type used as a bitmask to describe the actions that can be done for a
+'GI.Wnck.Objects.Window.Window'.
+-}
+data WindowActions = 
+      WindowActionsMove
+    {- ^
+    the window may be moved around the screen.
+    -}
+    | WindowActionsResize
+    {- ^
+    the window may be resized.
+    -}
+    | WindowActionsShade
+    {- ^
+    the window may be shaded.
+    -}
+    | WindowActionsStick
+    {- ^
+    the window may be sticked.
+    -}
+    | WindowActionsMaximizeHorizontally
+    {- ^
+    the window may be maximized
+    horizontally.
+    -}
+    | WindowActionsMaximizeVertically
+    {- ^
+    the window may be maximized
+    vertically.
+    -}
+    | WindowActionsChangeWorkspace
+    {- ^
+    the window may be moved between
+    workspaces, or (un)pinned.
+    -}
+    | WindowActionsClose
+    {- ^
+    the window may be closed.
+    -}
+    | WindowActionsUnmaximizeHorizontally
+    {- ^
+    the window may be unmaximized
+    horizontally.
+    -}
+    | WindowActionsUnmaximizeVertically
+    {- ^
+    the window may be maximized
+    vertically.
+    -}
+    | WindowActionsUnshade
+    {- ^
+    the window may be unshaded.
+    -}
+    | WindowActionsUnstick
+    {- ^
+    the window may be unsticked.
+    -}
+    | WindowActionsMinimize
+    {- ^
+    the window may be minimized.
+    -}
+    | WindowActionsUnminimize
+    {- ^
+    the window may be unminimized.
+    -}
+    | WindowActionsMaximize
+    {- ^
+    the window may be maximized.
+    -}
+    | WindowActionsUnmaximize
+    {- ^
+    the window may be unmaximized.
+    -}
+    | WindowActionsFullscreen
+    {- ^
+    the window may be brought to fullscreen.
+    -}
+    | WindowActionsAbove
+    {- ^
+    the window may be made above other windows.
+    -}
+    | WindowActionsBelow
+    {- ^
+    the window may be made below other windows.
+    -}
+    | AnotherWindowActions Int
+    -- ^ Catch-all for unknown values
+    deriving (Show, Eq)
+
+instance P.Enum WindowActions where
+    fromEnum WindowActionsMove = 1
+    fromEnum WindowActionsResize = 2
+    fromEnum WindowActionsShade = 4
+    fromEnum WindowActionsStick = 8
+    fromEnum WindowActionsMaximizeHorizontally = 16
+    fromEnum WindowActionsMaximizeVertically = 32
+    fromEnum WindowActionsChangeWorkspace = 64
+    fromEnum WindowActionsClose = 128
+    fromEnum WindowActionsUnmaximizeHorizontally = 256
+    fromEnum WindowActionsUnmaximizeVertically = 512
+    fromEnum WindowActionsUnshade = 1024
+    fromEnum WindowActionsUnstick = 2048
+    fromEnum WindowActionsMinimize = 4096
+    fromEnum WindowActionsUnminimize = 8192
+    fromEnum WindowActionsMaximize = 16384
+    fromEnum WindowActionsUnmaximize = 32768
+    fromEnum WindowActionsFullscreen = 65536
+    fromEnum WindowActionsAbove = 131072
+    fromEnum WindowActionsBelow = 262144
+    fromEnum (AnotherWindowActions k) = k
+
+    toEnum 1 = WindowActionsMove
+    toEnum 2 = WindowActionsResize
+    toEnum 4 = WindowActionsShade
+    toEnum 8 = WindowActionsStick
+    toEnum 16 = WindowActionsMaximizeHorizontally
+    toEnum 32 = WindowActionsMaximizeVertically
+    toEnum 64 = WindowActionsChangeWorkspace
+    toEnum 128 = WindowActionsClose
+    toEnum 256 = WindowActionsUnmaximizeHorizontally
+    toEnum 512 = WindowActionsUnmaximizeVertically
+    toEnum 1024 = WindowActionsUnshade
+    toEnum 2048 = WindowActionsUnstick
+    toEnum 4096 = WindowActionsMinimize
+    toEnum 8192 = WindowActionsUnminimize
+    toEnum 16384 = WindowActionsMaximize
+    toEnum 32768 = WindowActionsUnmaximize
+    toEnum 65536 = WindowActionsFullscreen
+    toEnum 131072 = WindowActionsAbove
+    toEnum 262144 = WindowActionsBelow
+    toEnum k = AnotherWindowActions k
+
+instance P.Ord WindowActions where
+    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)
+
+foreign import ccall "wnck_window_actions_get_type" c_wnck_window_actions_get_type :: 
+    IO GType
+
+instance BoxedFlags WindowActions where
+    boxedFlagsType _ = c_wnck_window_actions_get_type
+
+instance IsGFlag WindowActions
+
+
diff --git a/GI/Wnck/Flags.hs-boot b/GI/Wnck/Flags.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Flags.hs-boot
@@ -0,0 +1,36 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Flags where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+data WindowState
+instance P.Enum WindowState where
+instance BoxedFlags WindowState where
+instance IsGFlag WindowState
+data WindowMoveResizeMask
+instance P.Enum WindowMoveResizeMask where
+instance BoxedFlags WindowMoveResizeMask where
+instance IsGFlag WindowMoveResizeMask
+data WindowActions
+instance P.Enum WindowActions where
+instance BoxedFlags WindowActions where
+instance IsGFlag WindowActions
diff --git a/GI/Wnck/Functions.hs b/GI/Wnck/Functions.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Functions.hs
@@ -0,0 +1,290 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Functions
+    ( 
+
+ -- * Methods
+-- ** pidReadResourceUsage #method:pidReadResourceUsage#
+
+    pidReadResourceUsage                    ,
+
+
+-- ** setClientType #method:setClientType#
+
+    setClientType                           ,
+
+
+-- ** setDefaultIconSize #method:setDefaultIconSize#
+
+    setDefaultIconSize                      ,
+
+
+-- ** setDefaultMiniIconSize #method:setDefaultMiniIconSize#
+
+    setDefaultMiniIconSize                  ,
+
+
+-- ** shutdown #method:shutdown#
+
+    shutdown                                ,
+
+
+-- ** xidReadResourceUsage #method:xidReadResourceUsage#
+
+    xidReadResourceUsage                    ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+import qualified GI.Gdk.Objects.Display as Gdk.Display
+import {-# SOURCE #-} qualified GI.Wnck.Enums as Wnck.Enums
+import {-# SOURCE #-} qualified GI.Wnck.Structs.ResourceUsage as Wnck.ResourceUsage
+
+-- function wnck_xid_read_resource_usage
+-- Args : [Arg {argCName = "gdk_display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a <classname>GdkDisplay</classname>.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xid", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an X window ID.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "usage", argType = TInterface (Name {namespace = "Wnck", name = "ResourceUsage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the X resource usage of the application owning\nthe X window ID @xid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_xid_read_resource_usage" wnck_xid_read_resource_usage :: 
+    Ptr Gdk.Display.Display ->              -- gdk_display : TInterface (Name {namespace = "Gdk", name = "Display"})
+    CULong ->                               -- xid : TBasicType TULong
+    Ptr Wnck.ResourceUsage.ResourceUsage -> -- usage : TInterface (Name {namespace = "Wnck", name = "ResourceUsage"})
+    IO ()
+
+{- |
+Looks for the X resource usage of the application owning the X window ID
+/@xid@/ on display /@gdisplay@/. If no resource usage can be found, then all
+fields of /@usage@/ are set to 0.
+
+To properly work, this function requires the XRes extension on the X server.
+
+/Since: 2.6/
+-}
+xidReadResourceUsage ::
+    (B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a) =>
+    a
+    {- ^ /@gdkDisplay@/: a \<classname>GdkDisplay\<\/classname>. -}
+    -> CULong
+    {- ^ /@xid@/: an X window ID. -}
+    -> Wnck.ResourceUsage.ResourceUsage
+    {- ^ /@usage@/: return location for the X resource usage of the application owning
+the X window ID /@xid@/. -}
+    -> m ()
+xidReadResourceUsage gdkDisplay xid usage = liftIO $ do
+    gdkDisplay' <- unsafeManagedPtrCastPtr gdkDisplay
+    usage' <- unsafeManagedPtrGetPtr usage
+    wnck_xid_read_resource_usage gdkDisplay' xid usage'
+    touchManagedPtr gdkDisplay
+    touchManagedPtr usage
+    return ()
+
+
+-- function wnck_shutdown
+-- Args : []
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_shutdown" wnck_shutdown :: 
+    IO ()
+
+{- |
+Makes libwnck stop listening to events and tear down all resources from
+libwnck. This should be done if you are not going to need the state change
+notifications for an extended period of time, to avoid wakeups with every
+key and focus event.
+
+After this, all pointers to Wnck object you might still hold are invalid.
+
+Due to the fact that \<link
+linkend=\"getting-started.pitfalls.memory-management\">Wnck objects are all
+owned by libwnck\<\/link>, users of this API through introspection should be
+extremely careful: they must explicitly clear variables referencing objects
+before this call. Failure to do so might result in crashes.
+
+/Since: 3.4/
+-}
+shutdown ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    m ()
+shutdown  = liftIO $ do
+    wnck_shutdown
+    return ()
+
+
+-- function wnck_set_default_mini_icon_size
+-- Args : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the default size for windows and application mini icons.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_set_default_mini_icon_size" wnck_set_default_mini_icon_size :: 
+    Word64 ->                               -- size : TBasicType TUInt64
+    IO ()
+
+{- |
+The default main icon size is 'GI.Wnck.Constants.DEFAULT_MINI_ICON_SIZE'. This function
+allows to change this value.
+
+/Since: 2.4.6/
+-}
+setDefaultMiniIconSize ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    Word64
+    {- ^ /@size@/: the default size for windows and application mini icons. -}
+    -> m ()
+setDefaultMiniIconSize size = liftIO $ do
+    wnck_set_default_mini_icon_size size
+    return ()
+
+
+-- function wnck_set_default_icon_size
+-- Args : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the default size for windows and application standard icons.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_set_default_icon_size" wnck_set_default_icon_size :: 
+    Word64 ->                               -- size : TBasicType TUInt64
+    IO ()
+
+{- |
+The default main icon size is 'GI.Wnck.Constants.DEFAULT_ICON_SIZE'. This function allows
+to change this value.
+
+/Since: 2.4.6/
+-}
+setDefaultIconSize ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    Word64
+    {- ^ /@size@/: the default size for windows and application standard icons. -}
+    -> m ()
+setDefaultIconSize size = liftIO $ do
+    wnck_set_default_icon_size size
+    return ()
+
+
+-- function wnck_set_client_type
+-- Args : [Arg {argCName = "ewmh_sourceindication_client_type", argType = TInterface (Name {namespace = "Wnck", name = "ClientType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a role for the client.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_set_client_type" wnck_set_client_type :: 
+    CUInt ->                                -- ewmh_sourceindication_client_type : TInterface (Name {namespace = "Wnck", name = "ClientType"})
+    IO ()
+
+{- |
+Sets the role of the libwnck user.
+
+The default role is 'GI.Wnck.Enums.ClientTypeApplication'. Therefore, for
+applications providing some window management features, like pagers or
+tasklists, it is important to set the role to 'GI.Wnck.Enums.ClientTypePager' for
+libwnck to properly work.
+
+This function should only be called once per program. Additional calls
+with the same client type will be silently ignored. An attempt to change
+the client type to a differnet value after it has already been set will
+be ignored and a critical warning will be logged.
+
+/Since: 2.14/
+-}
+setClientType ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    Wnck.Enums.ClientType
+    {- ^ /@ewmhSourceindicationClientType@/: a role for the client. -}
+    -> m ()
+setClientType ewmhSourceindicationClientType = liftIO $ do
+    let ewmhSourceindicationClientType' = (fromIntegral . fromEnum) ewmhSourceindicationClientType
+    wnck_set_client_type ewmhSourceindicationClientType'
+    return ()
+
+
+-- function wnck_pid_read_resource_usage
+-- Args : [Arg {argCName = "gdk_display", argType = TInterface (Name {namespace = "Gdk", name = "Display"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a <classname>GdkDisplay</classname>.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pid", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a process ID.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "usage", argType = TInterface (Name {namespace = "Wnck", name = "ResourceUsage"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the X resource usage of the application with\nprocess ID @pid.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_pid_read_resource_usage" wnck_pid_read_resource_usage :: 
+    Ptr Gdk.Display.Display ->              -- gdk_display : TInterface (Name {namespace = "Gdk", name = "Display"})
+    CULong ->                               -- pid : TBasicType TULong
+    Ptr Wnck.ResourceUsage.ResourceUsage -> -- usage : TInterface (Name {namespace = "Wnck", name = "ResourceUsage"})
+    IO ()
+
+{- |
+Looks for the X resource usage of the application with process ID /@pid@/ on
+display /@gdisplay@/. If no resource usage can be found, then all fields of
+/@usage@/ are set to 0.
+
+In order to find the resource usage of an application that does not have an
+X window visible to libwnck (panel applets do not have any toplevel windows,
+for example), 'GI.Wnck.Functions.pidReadResourceUsage' walks through the whole tree of
+X windows. Since this walk is expensive in CPU, a cache is created. This
+cache is updated in the background. This means there is a non-null
+probability that no resource usage will be found for an application, even if
+it is an X client. If this happens, calling 'GI.Wnck.Functions.pidReadResourceUsage'
+again after a few seconds should work.
+
+To properly work, this function requires the XRes extension on the X server.
+
+/Since: 2.6/
+-}
+pidReadResourceUsage ::
+    (B.CallStack.HasCallStack, MonadIO m, Gdk.Display.IsDisplay a) =>
+    a
+    {- ^ /@gdkDisplay@/: a \<classname>GdkDisplay\<\/classname>. -}
+    -> CULong
+    {- ^ /@pid@/: a process ID. -}
+    -> Wnck.ResourceUsage.ResourceUsage
+    {- ^ /@usage@/: return location for the X resource usage of the application with
+process ID /@pid@/. -}
+    -> m ()
+pidReadResourceUsage gdkDisplay pid usage = liftIO $ do
+    gdkDisplay' <- unsafeManagedPtrCastPtr gdkDisplay
+    usage' <- unsafeManagedPtrGetPtr usage
+    wnck_pid_read_resource_usage gdkDisplay' pid usage'
+    touchManagedPtr gdkDisplay
+    touchManagedPtr usage
+    return ()
+
+
+
diff --git a/GI/Wnck/Objects.hs b/GI/Wnck/Objects.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects.hs
@@ -0,0 +1,59 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Objects
+    (     module GI.Wnck.Objects.ActionMenu       ,
+    module GI.Wnck.Objects.Application      ,
+    module GI.Wnck.Objects.ClassGroup       ,
+    module GI.Wnck.Objects.ImageMenuItem    ,
+    module GI.Wnck.Objects.Pager            ,
+    module GI.Wnck.Objects.Screen           ,
+    module GI.Wnck.Objects.Selector         ,
+    module GI.Wnck.Objects.Tasklist         ,
+    module GI.Wnck.Objects.Window           ,
+    module GI.Wnck.Objects.Workspace        ,
+
+
+    ) where
+
+import GI.Wnck.Objects.ActionMenu
+import GI.Wnck.Objects.Application
+import GI.Wnck.Objects.ClassGroup
+import GI.Wnck.Objects.ImageMenuItem
+import GI.Wnck.Objects.Pager
+import GI.Wnck.Objects.Screen
+import GI.Wnck.Objects.Selector
+import GI.Wnck.Objects.Tasklist
+import GI.Wnck.Objects.Window
+import GI.Wnck.Objects.Workspace
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+
+
diff --git a/GI/Wnck/Objects/ActionMenu.hs b/GI/Wnck/Objects/ActionMenu.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/ActionMenu.hs
@@ -0,0 +1,568 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+The 'GI.Wnck.Objects.ActionMenu.ActionMenu' struct contains only private fields and should not be
+directly accessed.
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Objects.ActionMenu
+    ( 
+
+-- * Exported types
+    ActionMenu(..)                          ,
+    IsActionMenu                            ,
+    toActionMenu                            ,
+    noActionMenu                            ,
+
+
+ -- * Methods
+-- ** new #method:new#
+
+    actionMenuNew                           ,
+
+
+
+
+ -- * Properties
+-- ** window #attr:window#
+{- | /No description available in the introspection data./
+-}
+#if ENABLE_OVERLOADING
+    ActionMenuWindowPropertyInfo            ,
+#endif
+#if ENABLE_OVERLOADING
+    actionMenuWindow                        ,
+#endif
+    constructActionMenuWindow               ,
+    getActionMenuWindow                     ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
+import qualified GI.GObject.Objects.Object as GObject.Object
+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
+import qualified GI.Gtk.Objects.Container as Gtk.Container
+import qualified GI.Gtk.Objects.Menu as Gtk.Menu
+import qualified GI.Gtk.Objects.MenuShell as Gtk.MenuShell
+import qualified GI.Gtk.Objects.Widget as Gtk.Widget
+import {-# SOURCE #-} qualified GI.Wnck.Objects.Window as Wnck.Window
+
+-- | Memory-managed wrapper type.
+newtype ActionMenu = ActionMenu (ManagedPtr ActionMenu)
+foreign import ccall "wnck_action_menu_get_type"
+    c_wnck_action_menu_get_type :: IO GType
+
+instance GObject ActionMenu where
+    gobjectType = c_wnck_action_menu_get_type
+    
+
+-- | Type class for types which can be safely cast to `ActionMenu`, for instance with `toActionMenu`.
+class (GObject o, O.IsDescendantOf ActionMenu o) => IsActionMenu o
+instance (GObject o, O.IsDescendantOf ActionMenu o) => IsActionMenu o
+
+instance O.HasParentTypes ActionMenu
+type instance O.ParentTypes ActionMenu = '[Gtk.Menu.Menu, Gtk.MenuShell.MenuShell, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]
+
+-- | Cast to `ActionMenu`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
+toActionMenu :: (MonadIO m, IsActionMenu o) => o -> m ActionMenu
+toActionMenu = liftIO . unsafeCastTo ActionMenu
+
+-- | A convenience alias for `Nothing` :: `Maybe` `ActionMenu`.
+noActionMenu :: Maybe ActionMenu
+noActionMenu = Nothing
+
+#if ENABLE_OVERLOADING
+type family ResolveActionMenuMethod (t :: Symbol) (o :: *) :: * where
+    ResolveActionMenuMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
+    ResolveActionMenuMethod "activateItem" o = Gtk.MenuShell.MenuShellActivateItemMethodInfo
+    ResolveActionMenuMethod "add" o = Gtk.Container.ContainerAddMethodInfo
+    ResolveActionMenuMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
+    ResolveActionMenuMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
+    ResolveActionMenuMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
+    ResolveActionMenuMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
+    ResolveActionMenuMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
+    ResolveActionMenuMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
+    ResolveActionMenuMethod "append" o = Gtk.MenuShell.MenuShellAppendMethodInfo
+    ResolveActionMenuMethod "attach" o = Gtk.Menu.MenuAttachMethodInfo
+    ResolveActionMenuMethod "attachToWidget" o = Gtk.Menu.MenuAttachToWidgetMethodInfo
+    ResolveActionMenuMethod "bindModel" o = Gtk.MenuShell.MenuShellBindModelMethodInfo
+    ResolveActionMenuMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
+    ResolveActionMenuMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
+    ResolveActionMenuMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
+    ResolveActionMenuMethod "cancel" o = Gtk.MenuShell.MenuShellCancelMethodInfo
+    ResolveActionMenuMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
+    ResolveActionMenuMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
+    ResolveActionMenuMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
+    ResolveActionMenuMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
+    ResolveActionMenuMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
+    ResolveActionMenuMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
+    ResolveActionMenuMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
+    ResolveActionMenuMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
+    ResolveActionMenuMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
+    ResolveActionMenuMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
+    ResolveActionMenuMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
+    ResolveActionMenuMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
+    ResolveActionMenuMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
+    ResolveActionMenuMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
+    ResolveActionMenuMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
+    ResolveActionMenuMethod "deactivate" o = Gtk.MenuShell.MenuShellDeactivateMethodInfo
+    ResolveActionMenuMethod "deselect" o = Gtk.MenuShell.MenuShellDeselectMethodInfo
+    ResolveActionMenuMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
+    ResolveActionMenuMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
+    ResolveActionMenuMethod "detach" o = Gtk.Menu.MenuDetachMethodInfo
+    ResolveActionMenuMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
+    ResolveActionMenuMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
+    ResolveActionMenuMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
+    ResolveActionMenuMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
+    ResolveActionMenuMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
+    ResolveActionMenuMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
+    ResolveActionMenuMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
+    ResolveActionMenuMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
+    ResolveActionMenuMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
+    ResolveActionMenuMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
+    ResolveActionMenuMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
+    ResolveActionMenuMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
+    ResolveActionMenuMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
+    ResolveActionMenuMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
+    ResolveActionMenuMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
+    ResolveActionMenuMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
+    ResolveActionMenuMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
+    ResolveActionMenuMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
+    ResolveActionMenuMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
+    ResolveActionMenuMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
+    ResolveActionMenuMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
+    ResolveActionMenuMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
+    ResolveActionMenuMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
+    ResolveActionMenuMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
+    ResolveActionMenuMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
+    ResolveActionMenuMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
+    ResolveActionMenuMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
+    ResolveActionMenuMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
+    ResolveActionMenuMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
+    ResolveActionMenuMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
+    ResolveActionMenuMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
+    ResolveActionMenuMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
+    ResolveActionMenuMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
+    ResolveActionMenuMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
+    ResolveActionMenuMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
+    ResolveActionMenuMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
+    ResolveActionMenuMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
+    ResolveActionMenuMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
+    ResolveActionMenuMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
+    ResolveActionMenuMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
+    ResolveActionMenuMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
+    ResolveActionMenuMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
+    ResolveActionMenuMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
+    ResolveActionMenuMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
+    ResolveActionMenuMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
+    ResolveActionMenuMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
+    ResolveActionMenuMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
+    ResolveActionMenuMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
+    ResolveActionMenuMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
+    ResolveActionMenuMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
+    ResolveActionMenuMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
+    ResolveActionMenuMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
+    ResolveActionMenuMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
+    ResolveActionMenuMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
+    ResolveActionMenuMethod "insert" o = Gtk.MenuShell.MenuShellInsertMethodInfo
+    ResolveActionMenuMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
+    ResolveActionMenuMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
+    ResolveActionMenuMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
+    ResolveActionMenuMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
+    ResolveActionMenuMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
+    ResolveActionMenuMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
+    ResolveActionMenuMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
+    ResolveActionMenuMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
+    ResolveActionMenuMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
+    ResolveActionMenuMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
+    ResolveActionMenuMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
+    ResolveActionMenuMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
+    ResolveActionMenuMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
+    ResolveActionMenuMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
+    ResolveActionMenuMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
+    ResolveActionMenuMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
+    ResolveActionMenuMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
+    ResolveActionMenuMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
+    ResolveActionMenuMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
+    ResolveActionMenuMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
+    ResolveActionMenuMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
+    ResolveActionMenuMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
+    ResolveActionMenuMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
+    ResolveActionMenuMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
+    ResolveActionMenuMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
+    ResolveActionMenuMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
+    ResolveActionMenuMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
+    ResolveActionMenuMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
+    ResolveActionMenuMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
+    ResolveActionMenuMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
+    ResolveActionMenuMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
+    ResolveActionMenuMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
+    ResolveActionMenuMethod "placeOnMonitor" o = Gtk.Menu.MenuPlaceOnMonitorMethodInfo
+    ResolveActionMenuMethod "popdown" o = Gtk.Menu.MenuPopdownMethodInfo
+    ResolveActionMenuMethod "popup" o = Gtk.Menu.MenuPopupMethodInfo
+    ResolveActionMenuMethod "popupAtPointer" o = Gtk.Menu.MenuPopupAtPointerMethodInfo
+    ResolveActionMenuMethod "popupAtRect" o = Gtk.Menu.MenuPopupAtRectMethodInfo
+    ResolveActionMenuMethod "popupAtWidget" o = Gtk.Menu.MenuPopupAtWidgetMethodInfo
+    ResolveActionMenuMethod "popupForDevice" o = Gtk.Menu.MenuPopupForDeviceMethodInfo
+    ResolveActionMenuMethod "prepend" o = Gtk.MenuShell.MenuShellPrependMethodInfo
+    ResolveActionMenuMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
+    ResolveActionMenuMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
+    ResolveActionMenuMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
+    ResolveActionMenuMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
+    ResolveActionMenuMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
+    ResolveActionMenuMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
+    ResolveActionMenuMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
+    ResolveActionMenuMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
+    ResolveActionMenuMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
+    ResolveActionMenuMethod "ref" o = GObject.Object.ObjectRefMethodInfo
+    ResolveActionMenuMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
+    ResolveActionMenuMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
+    ResolveActionMenuMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
+    ResolveActionMenuMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
+    ResolveActionMenuMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
+    ResolveActionMenuMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
+    ResolveActionMenuMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
+    ResolveActionMenuMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
+    ResolveActionMenuMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
+    ResolveActionMenuMethod "reorderChild" o = Gtk.Menu.MenuReorderChildMethodInfo
+    ResolveActionMenuMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
+    ResolveActionMenuMethod "reposition" o = Gtk.Menu.MenuRepositionMethodInfo
+    ResolveActionMenuMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
+    ResolveActionMenuMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
+    ResolveActionMenuMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
+    ResolveActionMenuMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
+    ResolveActionMenuMethod "selectFirst" o = Gtk.MenuShell.MenuShellSelectFirstMethodInfo
+    ResolveActionMenuMethod "selectItem" o = Gtk.MenuShell.MenuShellSelectItemMethodInfo
+    ResolveActionMenuMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
+    ResolveActionMenuMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
+    ResolveActionMenuMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
+    ResolveActionMenuMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
+    ResolveActionMenuMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
+    ResolveActionMenuMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
+    ResolveActionMenuMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
+    ResolveActionMenuMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
+    ResolveActionMenuMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
+    ResolveActionMenuMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
+    ResolveActionMenuMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
+    ResolveActionMenuMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
+    ResolveActionMenuMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
+    ResolveActionMenuMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
+    ResolveActionMenuMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
+    ResolveActionMenuMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
+    ResolveActionMenuMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
+    ResolveActionMenuMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
+    ResolveActionMenuMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
+    ResolveActionMenuMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
+    ResolveActionMenuMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
+    ResolveActionMenuMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
+    ResolveActionMenuMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
+    ResolveActionMenuMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
+    ResolveActionMenuMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
+    ResolveActionMenuMethod "getAccelGroup" o = Gtk.Menu.MenuGetAccelGroupMethodInfo
+    ResolveActionMenuMethod "getAccelPath" o = Gtk.Menu.MenuGetAccelPathMethodInfo
+    ResolveActionMenuMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
+    ResolveActionMenuMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
+    ResolveActionMenuMethod "getActive" o = Gtk.Menu.MenuGetActiveMethodInfo
+    ResolveActionMenuMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
+    ResolveActionMenuMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
+    ResolveActionMenuMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
+    ResolveActionMenuMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
+    ResolveActionMenuMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
+    ResolveActionMenuMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
+    ResolveActionMenuMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
+    ResolveActionMenuMethod "getAttachWidget" o = Gtk.Menu.MenuGetAttachWidgetMethodInfo
+    ResolveActionMenuMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
+    ResolveActionMenuMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
+    ResolveActionMenuMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
+    ResolveActionMenuMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
+    ResolveActionMenuMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
+    ResolveActionMenuMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
+    ResolveActionMenuMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
+    ResolveActionMenuMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
+    ResolveActionMenuMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
+    ResolveActionMenuMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
+    ResolveActionMenuMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
+    ResolveActionMenuMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
+    ResolveActionMenuMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
+    ResolveActionMenuMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
+    ResolveActionMenuMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
+    ResolveActionMenuMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
+    ResolveActionMenuMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
+    ResolveActionMenuMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
+    ResolveActionMenuMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
+    ResolveActionMenuMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
+    ResolveActionMenuMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
+    ResolveActionMenuMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
+    ResolveActionMenuMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
+    ResolveActionMenuMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
+    ResolveActionMenuMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
+    ResolveActionMenuMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
+    ResolveActionMenuMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
+    ResolveActionMenuMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
+    ResolveActionMenuMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
+    ResolveActionMenuMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
+    ResolveActionMenuMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
+    ResolveActionMenuMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
+    ResolveActionMenuMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
+    ResolveActionMenuMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
+    ResolveActionMenuMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
+    ResolveActionMenuMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
+    ResolveActionMenuMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
+    ResolveActionMenuMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
+    ResolveActionMenuMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
+    ResolveActionMenuMethod "getMonitor" o = Gtk.Menu.MenuGetMonitorMethodInfo
+    ResolveActionMenuMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
+    ResolveActionMenuMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
+    ResolveActionMenuMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
+    ResolveActionMenuMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
+    ResolveActionMenuMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
+    ResolveActionMenuMethod "getParentShell" o = Gtk.MenuShell.MenuShellGetParentShellMethodInfo
+    ResolveActionMenuMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
+    ResolveActionMenuMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
+    ResolveActionMenuMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
+    ResolveActionMenuMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
+    ResolveActionMenuMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
+    ResolveActionMenuMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
+    ResolveActionMenuMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
+    ResolveActionMenuMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
+    ResolveActionMenuMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
+    ResolveActionMenuMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
+    ResolveActionMenuMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
+    ResolveActionMenuMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
+    ResolveActionMenuMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
+    ResolveActionMenuMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
+    ResolveActionMenuMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
+    ResolveActionMenuMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
+    ResolveActionMenuMethod "getReserveToggleSize" o = Gtk.Menu.MenuGetReserveToggleSizeMethodInfo
+    ResolveActionMenuMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
+    ResolveActionMenuMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
+    ResolveActionMenuMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
+    ResolveActionMenuMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
+    ResolveActionMenuMethod "getSelectedItem" o = Gtk.MenuShell.MenuShellGetSelectedItemMethodInfo
+    ResolveActionMenuMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
+    ResolveActionMenuMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
+    ResolveActionMenuMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
+    ResolveActionMenuMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
+    ResolveActionMenuMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
+    ResolveActionMenuMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
+    ResolveActionMenuMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
+    ResolveActionMenuMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
+    ResolveActionMenuMethod "getTakeFocus" o = Gtk.MenuShell.MenuShellGetTakeFocusMethodInfo
+    ResolveActionMenuMethod "getTearoffState" o = Gtk.Menu.MenuGetTearoffStateMethodInfo
+    ResolveActionMenuMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
+    ResolveActionMenuMethod "getTitle" o = Gtk.Menu.MenuGetTitleMethodInfo
+    ResolveActionMenuMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
+    ResolveActionMenuMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
+    ResolveActionMenuMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
+    ResolveActionMenuMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
+    ResolveActionMenuMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
+    ResolveActionMenuMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
+    ResolveActionMenuMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
+    ResolveActionMenuMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
+    ResolveActionMenuMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
+    ResolveActionMenuMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
+    ResolveActionMenuMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
+    ResolveActionMenuMethod "setAccelGroup" o = Gtk.Menu.MenuSetAccelGroupMethodInfo
+    ResolveActionMenuMethod "setAccelPath" o = Gtk.Menu.MenuSetAccelPathMethodInfo
+    ResolveActionMenuMethod "setActive" o = Gtk.Menu.MenuSetActiveMethodInfo
+    ResolveActionMenuMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
+    ResolveActionMenuMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
+    ResolveActionMenuMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
+    ResolveActionMenuMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
+    ResolveActionMenuMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
+    ResolveActionMenuMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
+    ResolveActionMenuMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
+    ResolveActionMenuMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
+    ResolveActionMenuMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
+    ResolveActionMenuMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
+    ResolveActionMenuMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
+    ResolveActionMenuMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
+    ResolveActionMenuMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
+    ResolveActionMenuMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
+    ResolveActionMenuMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
+    ResolveActionMenuMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
+    ResolveActionMenuMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
+    ResolveActionMenuMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
+    ResolveActionMenuMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
+    ResolveActionMenuMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
+    ResolveActionMenuMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
+    ResolveActionMenuMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
+    ResolveActionMenuMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
+    ResolveActionMenuMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
+    ResolveActionMenuMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
+    ResolveActionMenuMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
+    ResolveActionMenuMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
+    ResolveActionMenuMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
+    ResolveActionMenuMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
+    ResolveActionMenuMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
+    ResolveActionMenuMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
+    ResolveActionMenuMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
+    ResolveActionMenuMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
+    ResolveActionMenuMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
+    ResolveActionMenuMethod "setMonitor" o = Gtk.Menu.MenuSetMonitorMethodInfo
+    ResolveActionMenuMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
+    ResolveActionMenuMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
+    ResolveActionMenuMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
+    ResolveActionMenuMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
+    ResolveActionMenuMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
+    ResolveActionMenuMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
+    ResolveActionMenuMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
+    ResolveActionMenuMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
+    ResolveActionMenuMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
+    ResolveActionMenuMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
+    ResolveActionMenuMethod "setReserveToggleSize" o = Gtk.Menu.MenuSetReserveToggleSizeMethodInfo
+    ResolveActionMenuMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
+    ResolveActionMenuMethod "setScreen" o = Gtk.Menu.MenuSetScreenMethodInfo
+    ResolveActionMenuMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
+    ResolveActionMenuMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
+    ResolveActionMenuMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
+    ResolveActionMenuMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
+    ResolveActionMenuMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
+    ResolveActionMenuMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
+    ResolveActionMenuMethod "setTakeFocus" o = Gtk.MenuShell.MenuShellSetTakeFocusMethodInfo
+    ResolveActionMenuMethod "setTearoffState" o = Gtk.Menu.MenuSetTearoffStateMethodInfo
+    ResolveActionMenuMethod "setTitle" o = Gtk.Menu.MenuSetTitleMethodInfo
+    ResolveActionMenuMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
+    ResolveActionMenuMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
+    ResolveActionMenuMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
+    ResolveActionMenuMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
+    ResolveActionMenuMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
+    ResolveActionMenuMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
+    ResolveActionMenuMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
+    ResolveActionMenuMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
+    ResolveActionMenuMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
+    ResolveActionMenuMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolveActionMenuMethod t ActionMenu, O.MethodInfo info ActionMenu p) => OL.IsLabel t (ActionMenu -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+--- XXX Duplicated object with different types:
+  --- Name {namespace = "Wnck", name = "ActionMenu"} -> Property {propName = "window", propType = TBasicType TPtr, propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, propDeprecated = Nothing}
+  --- Name {namespace = "Gtk", name = "Widget"} -> Property {propName = "window", propType = TInterface (Name {namespace = "Gdk", name = "Window"}), propFlags = [PropertyReadable], propReadNullable = Nothing, propWriteNullable = Nothing, propTransfer = TransferNothing, propDoc = Documentation {rawDocText = Just "The widget's window if it is realized, %NULL otherwise.", sinceVersion = Just "2.14"}, propDeprecated = Nothing}
+-- VVV Prop "window"
+   -- Type: TBasicType TPtr
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+   -- Nullable: (Nothing,Nothing)
+
+{- |
+Get the value of the “@window@” property.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' actionMenu #window
+@
+-}
+getActionMenuWindow :: (MonadIO m, IsActionMenu o) => o -> m (Ptr ())
+getActionMenuWindow obj = liftIO $ B.Properties.getObjectPropertyPtr obj "window"
+
+{- |
+Construct a `GValueConstruct` with valid value for the “@window@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
+-}
+constructActionMenuWindow :: (IsActionMenu o) => Ptr () -> IO (GValueConstruct o)
+constructActionMenuWindow val = B.Properties.constructObjectPropertyPtr "window" val
+
+#if ENABLE_OVERLOADING
+data ActionMenuWindowPropertyInfo
+instance AttrInfo ActionMenuWindowPropertyInfo where
+    type AttrAllowedOps ActionMenuWindowPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint ActionMenuWindowPropertyInfo = (~) (Ptr ())
+    type AttrBaseTypeConstraint ActionMenuWindowPropertyInfo = IsActionMenu
+    type AttrGetType ActionMenuWindowPropertyInfo = (Ptr ())
+    type AttrLabel ActionMenuWindowPropertyInfo = "window"
+    type AttrOrigin ActionMenuWindowPropertyInfo = ActionMenu
+    attrGet _ = getActionMenuWindow
+    attrSet _ = undefined
+    attrConstruct _ = constructActionMenuWindow
+    attrClear _ = undefined
+#endif
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList ActionMenu
+type instance O.AttributeList ActionMenu = ActionMenuAttributeList
+type ActionMenuAttributeList = ('[ '("accelGroup", Gtk.Menu.MenuAccelGroupPropertyInfo), '("accelPath", Gtk.Menu.MenuAccelPathPropertyInfo), '("active", Gtk.Menu.MenuActivePropertyInfo), '("anchorHints", Gtk.Menu.MenuAnchorHintsPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("attachWidget", Gtk.Menu.MenuAttachWidgetPropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("menuTypeHint", Gtk.Menu.MenuMenuTypeHintPropertyInfo), '("monitor", Gtk.Menu.MenuMonitorPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("rectAnchorDx", Gtk.Menu.MenuRectAnchorDxPropertyInfo), '("rectAnchorDy", Gtk.Menu.MenuRectAnchorDyPropertyInfo), '("reserveToggleSize", Gtk.Menu.MenuReserveToggleSizePropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("takeFocus", Gtk.MenuShell.MenuShellTakeFocusPropertyInfo), '("tearoffState", Gtk.Menu.MenuTearoffStatePropertyInfo), '("tearoffTitle", Gtk.Menu.MenuTearoffTitlePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", ActionMenuWindowPropertyInfo)] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+actionMenuWindow :: AttrLabelProxy "window"
+actionMenuWindow = AttrLabelProxy
+
+#endif
+
+#if ENABLE_OVERLOADING
+type instance O.SignalList ActionMenu = ActionMenuSignalList
+type ActionMenuSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activateCurrent", Gtk.MenuShell.MenuShellActivateCurrentSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("cancel", Gtk.MenuShell.MenuShellCancelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("cycleFocus", Gtk.MenuShell.MenuShellCycleFocusSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deactivate", Gtk.MenuShell.MenuShellDeactivateSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("insert", Gtk.MenuShell.MenuShellInsertSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveCurrent", Gtk.MenuShell.MenuShellMoveCurrentSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveScroll", Gtk.Menu.MenuMoveScrollSignalInfo), '("moveSelected", Gtk.MenuShell.MenuShellMoveSelectedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("poppedUp", Gtk.Menu.MenuPoppedUpSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionDone", Gtk.MenuShell.MenuShellSelectionDoneSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])
+
+#endif
+
+-- method ActionMenu::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #WnckWindow for which a menu will be created.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "ActionMenu"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_action_menu_new" wnck_action_menu_new :: 
+    Ptr Wnck.Window.Window ->               -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO (Ptr ActionMenu)
+
+{- |
+Creates a new 'GI.Wnck.Objects.ActionMenu.ActionMenu'. The 'GI.Wnck.Objects.ActionMenu.ActionMenu' will be filled with menu
+items for window operations on /@window@/.
+
+/Since: 2.22/
+-}
+actionMenuNew ::
+    (B.CallStack.HasCallStack, MonadIO m, Wnck.Window.IsWindow a) =>
+    a
+    {- ^ /@window@/: the 'GI.Wnck.Objects.Window.Window' for which a menu will be created. -}
+    -> m ActionMenu
+    {- ^ __Returns:__ a newly created 'GI.Wnck.Objects.ActionMenu.ActionMenu'. -}
+actionMenuNew window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_action_menu_new window'
+    checkUnexpectedReturnNULL "actionMenuNew" result
+    result' <- (newObject ActionMenu) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+#endif
+
+
diff --git a/GI/Wnck/Objects/ActionMenu.hs-boot b/GI/Wnck/Objects/ActionMenu.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/ActionMenu.hs-boot
@@ -0,0 +1,32 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Objects.ActionMenu where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype ActionMenu = ActionMenu (ManagedPtr ActionMenu)
+instance GObject ActionMenu where
+class (GObject o, O.IsDescendantOf ActionMenu o) => IsActionMenu o
+instance (GObject o, O.IsDescendantOf ActionMenu o) => IsActionMenu o
+instance O.HasParentTypes ActionMenu
+#if ENABLE_OVERLOADING
+data ActionMenuWindowPropertyInfo
+#endif
diff --git a/GI/Wnck/Objects/Application.hs b/GI/Wnck/Objects/Application.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Application.hs
@@ -0,0 +1,810 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+The 'GI.Wnck.Objects.Application.Application' struct contains only private fields and should not be
+directly accessed.
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Objects.Application
+    ( 
+
+-- * Exported types
+    Application(..)                         ,
+    IsApplication                           ,
+    toApplication                           ,
+    noApplication                           ,
+
+
+ -- * Methods
+-- ** get #method:get#
+
+    applicationGet                          ,
+
+
+-- ** getIcon #method:getIcon#
+
+#if ENABLE_OVERLOADING
+    ApplicationGetIconMethodInfo            ,
+#endif
+    applicationGetIcon                      ,
+
+
+-- ** getIconIsFallback #method:getIconIsFallback#
+
+#if ENABLE_OVERLOADING
+    ApplicationGetIconIsFallbackMethodInfo  ,
+#endif
+    applicationGetIconIsFallback            ,
+
+
+-- ** getIconName #method:getIconName#
+
+#if ENABLE_OVERLOADING
+    ApplicationGetIconNameMethodInfo        ,
+#endif
+    applicationGetIconName                  ,
+
+
+-- ** getMiniIcon #method:getMiniIcon#
+
+#if ENABLE_OVERLOADING
+    ApplicationGetMiniIconMethodInfo        ,
+#endif
+    applicationGetMiniIcon                  ,
+
+
+-- ** getNWindows #method:getNWindows#
+
+#if ENABLE_OVERLOADING
+    ApplicationGetNWindowsMethodInfo        ,
+#endif
+    applicationGetNWindows                  ,
+
+
+-- ** getName #method:getName#
+
+#if ENABLE_OVERLOADING
+    ApplicationGetNameMethodInfo            ,
+#endif
+    applicationGetName                      ,
+
+
+-- ** getPid #method:getPid#
+
+#if ENABLE_OVERLOADING
+    ApplicationGetPidMethodInfo             ,
+#endif
+    applicationGetPid                       ,
+
+
+-- ** getStartupId #method:getStartupId#
+
+#if ENABLE_OVERLOADING
+    ApplicationGetStartupIdMethodInfo       ,
+#endif
+    applicationGetStartupId                 ,
+
+
+-- ** getWindows #method:getWindows#
+
+#if ENABLE_OVERLOADING
+    ApplicationGetWindowsMethodInfo         ,
+#endif
+    applicationGetWindows                   ,
+
+
+-- ** getXid #method:getXid#
+
+#if ENABLE_OVERLOADING
+    ApplicationGetXidMethodInfo             ,
+#endif
+    applicationGetXid                       ,
+
+
+
+
+ -- * Signals
+-- ** iconChanged #signal:iconChanged#
+
+    ApplicationIconChangedCallback          ,
+#if ENABLE_OVERLOADING
+    ApplicationIconChangedSignalInfo        ,
+#endif
+    C_ApplicationIconChangedCallback        ,
+    afterApplicationIconChanged             ,
+    genClosure_ApplicationIconChanged       ,
+    mk_ApplicationIconChangedCallback       ,
+    noApplicationIconChangedCallback        ,
+    onApplicationIconChanged                ,
+    wrap_ApplicationIconChangedCallback     ,
+
+
+-- ** nameChanged #signal:nameChanged#
+
+    ApplicationNameChangedCallback          ,
+#if ENABLE_OVERLOADING
+    ApplicationNameChangedSignalInfo        ,
+#endif
+    C_ApplicationNameChangedCallback        ,
+    afterApplicationNameChanged             ,
+    genClosure_ApplicationNameChanged       ,
+    mk_ApplicationNameChangedCallback       ,
+    noApplicationNameChangedCallback        ,
+    onApplicationNameChanged                ,
+    wrap_ApplicationNameChangedCallback     ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+import qualified GI.GObject.Objects.Object as GObject.Object
+import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
+import {-# SOURCE #-} qualified GI.Wnck.Objects.Window as Wnck.Window
+
+-- | Memory-managed wrapper type.
+newtype Application = Application (ManagedPtr Application)
+foreign import ccall "wnck_application_get_type"
+    c_wnck_application_get_type :: IO GType
+
+instance GObject Application where
+    gobjectType = c_wnck_application_get_type
+    
+
+-- | Type class for types which can be safely cast to `Application`, for instance with `toApplication`.
+class (GObject o, O.IsDescendantOf Application o) => IsApplication o
+instance (GObject o, O.IsDescendantOf Application o) => IsApplication o
+
+instance O.HasParentTypes Application
+type instance O.ParentTypes Application = '[GObject.Object.Object]
+
+-- | Cast to `Application`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
+toApplication :: (MonadIO m, IsApplication o) => o -> m Application
+toApplication = liftIO . unsafeCastTo Application
+
+-- | A convenience alias for `Nothing` :: `Maybe` `Application`.
+noApplication :: Maybe Application
+noApplication = Nothing
+
+#if ENABLE_OVERLOADING
+type family ResolveApplicationMethod (t :: Symbol) (o :: *) :: * where
+    ResolveApplicationMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
+    ResolveApplicationMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
+    ResolveApplicationMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
+    ResolveApplicationMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
+    ResolveApplicationMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
+    ResolveApplicationMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
+    ResolveApplicationMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
+    ResolveApplicationMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
+    ResolveApplicationMethod "ref" o = GObject.Object.ObjectRefMethodInfo
+    ResolveApplicationMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
+    ResolveApplicationMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
+    ResolveApplicationMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
+    ResolveApplicationMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
+    ResolveApplicationMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
+    ResolveApplicationMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
+    ResolveApplicationMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
+    ResolveApplicationMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
+    ResolveApplicationMethod "getIcon" o = ApplicationGetIconMethodInfo
+    ResolveApplicationMethod "getIconIsFallback" o = ApplicationGetIconIsFallbackMethodInfo
+    ResolveApplicationMethod "getIconName" o = ApplicationGetIconNameMethodInfo
+    ResolveApplicationMethod "getMiniIcon" o = ApplicationGetMiniIconMethodInfo
+    ResolveApplicationMethod "getNWindows" o = ApplicationGetNWindowsMethodInfo
+    ResolveApplicationMethod "getName" o = ApplicationGetNameMethodInfo
+    ResolveApplicationMethod "getPid" o = ApplicationGetPidMethodInfo
+    ResolveApplicationMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
+    ResolveApplicationMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
+    ResolveApplicationMethod "getStartupId" o = ApplicationGetStartupIdMethodInfo
+    ResolveApplicationMethod "getWindows" o = ApplicationGetWindowsMethodInfo
+    ResolveApplicationMethod "getXid" o = ApplicationGetXidMethodInfo
+    ResolveApplicationMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
+    ResolveApplicationMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
+    ResolveApplicationMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolveApplicationMethod t Application, O.MethodInfo info Application p) => OL.IsLabel t (Application -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+-- signal Application::icon-changed
+{- |
+Emitted when the icon of /@app@/ changes.
+-}
+type ApplicationIconChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ApplicationIconChangedCallback`@.
+noApplicationIconChangedCallback :: Maybe ApplicationIconChangedCallback
+noApplicationIconChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ApplicationIconChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ApplicationIconChangedCallback`.
+foreign import ccall "wrapper"
+    mk_ApplicationIconChangedCallback :: C_ApplicationIconChangedCallback -> IO (FunPtr C_ApplicationIconChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ApplicationIconChanged :: MonadIO m => ApplicationIconChangedCallback -> m (GClosure C_ApplicationIconChangedCallback)
+genClosure_ApplicationIconChanged cb = liftIO $ do
+    let cb' = wrap_ApplicationIconChangedCallback cb
+    mk_ApplicationIconChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ApplicationIconChangedCallback` into a `C_ApplicationIconChangedCallback`.
+wrap_ApplicationIconChangedCallback ::
+    ApplicationIconChangedCallback ->
+    C_ApplicationIconChangedCallback
+wrap_ApplicationIconChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@icon-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' application #iconChanged callback
+@
+-}
+onApplicationIconChanged :: (IsApplication a, MonadIO m) => a -> ApplicationIconChangedCallback -> m SignalHandlerId
+onApplicationIconChanged obj cb = liftIO $ do
+    let cb' = wrap_ApplicationIconChangedCallback cb
+    cb'' <- mk_ApplicationIconChangedCallback cb'
+    connectSignalFunPtr obj "icon-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@icon-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' application #iconChanged callback
+@
+-}
+afterApplicationIconChanged :: (IsApplication a, MonadIO m) => a -> ApplicationIconChangedCallback -> m SignalHandlerId
+afterApplicationIconChanged obj cb = liftIO $ do
+    let cb' = wrap_ApplicationIconChangedCallback cb
+    cb'' <- mk_ApplicationIconChangedCallback cb'
+    connectSignalFunPtr obj "icon-changed" cb'' SignalConnectAfter
+
+
+-- signal Application::name-changed
+{- |
+Emitted when the name of /@app@/ changes.
+-}
+type ApplicationNameChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ApplicationNameChangedCallback`@.
+noApplicationNameChangedCallback :: Maybe ApplicationNameChangedCallback
+noApplicationNameChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ApplicationNameChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ApplicationNameChangedCallback`.
+foreign import ccall "wrapper"
+    mk_ApplicationNameChangedCallback :: C_ApplicationNameChangedCallback -> IO (FunPtr C_ApplicationNameChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ApplicationNameChanged :: MonadIO m => ApplicationNameChangedCallback -> m (GClosure C_ApplicationNameChangedCallback)
+genClosure_ApplicationNameChanged cb = liftIO $ do
+    let cb' = wrap_ApplicationNameChangedCallback cb
+    mk_ApplicationNameChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ApplicationNameChangedCallback` into a `C_ApplicationNameChangedCallback`.
+wrap_ApplicationNameChangedCallback ::
+    ApplicationNameChangedCallback ->
+    C_ApplicationNameChangedCallback
+wrap_ApplicationNameChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@name-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' application #nameChanged callback
+@
+-}
+onApplicationNameChanged :: (IsApplication a, MonadIO m) => a -> ApplicationNameChangedCallback -> m SignalHandlerId
+onApplicationNameChanged obj cb = liftIO $ do
+    let cb' = wrap_ApplicationNameChangedCallback cb
+    cb'' <- mk_ApplicationNameChangedCallback cb'
+    connectSignalFunPtr obj "name-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@name-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' application #nameChanged callback
+@
+-}
+afterApplicationNameChanged :: (IsApplication a, MonadIO m) => a -> ApplicationNameChangedCallback -> m SignalHandlerId
+afterApplicationNameChanged obj cb = liftIO $ do
+    let cb' = wrap_ApplicationNameChangedCallback cb
+    cb'' <- mk_ApplicationNameChangedCallback cb'
+    connectSignalFunPtr obj "name-changed" cb'' SignalConnectAfter
+
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList Application
+type instance O.AttributeList Application = ApplicationAttributeList
+type ApplicationAttributeList = ('[ ] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+#endif
+
+#if ENABLE_OVERLOADING
+data ApplicationIconChangedSignalInfo
+instance SignalInfo ApplicationIconChangedSignalInfo where
+    type HaskellCallbackType ApplicationIconChangedSignalInfo = ApplicationIconChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ApplicationIconChangedCallback cb
+        cb'' <- mk_ApplicationIconChangedCallback cb'
+        connectSignalFunPtr obj "icon-changed" cb'' connectMode
+
+data ApplicationNameChangedSignalInfo
+instance SignalInfo ApplicationNameChangedSignalInfo where
+    type HaskellCallbackType ApplicationNameChangedSignalInfo = ApplicationNameChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ApplicationNameChangedCallback cb
+        cb'' <- mk_ApplicationNameChangedCallback cb'
+        connectSignalFunPtr obj "name-changed" cb'' connectMode
+
+type instance O.SignalList Application = ApplicationSignalList
+type ApplicationSignalList = ('[ '("iconChanged", ApplicationIconChangedSignalInfo), '("nameChanged", ApplicationNameChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+#endif
+
+-- method Application::get_icon
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_application_get_icon" wnck_application_get_icon :: 
+    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})
+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)
+
+{- |
+Gets the icon to be used for /@app@/. If no icon is set for /@app@/, a
+suboptimal heuristic is used to find an appropriate icon. If no icon was
+found, a fallback icon is used.
+-}
+applicationGetIcon ::
+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
+    a
+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}
+    -> m GdkPixbuf.Pixbuf.Pixbuf
+    {- ^ __Returns:__ the icon for /@app@/. The caller should
+reference the returned \<classname>GdkPixbuf\<\/classname> if it needs to keep
+the icon around. -}
+applicationGetIcon app = liftIO $ do
+    app' <- unsafeManagedPtrCastPtr app
+    result <- wnck_application_get_icon app'
+    checkUnexpectedReturnNULL "applicationGetIcon" result
+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result
+    touchManagedPtr app
+    return result'
+
+#if ENABLE_OVERLOADING
+data ApplicationGetIconMethodInfo
+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetIconMethodInfo a signature where
+    overloadedMethod _ = applicationGetIcon
+
+#endif
+
+-- method Application::get_icon_is_fallback
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_application_get_icon_is_fallback" wnck_application_get_icon_is_fallback :: 
+    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})
+    IO CInt
+
+{- |
+Gets whether a default fallback icon is used for /@app@/ (because none
+was set on /@app@/).
+-}
+applicationGetIconIsFallback ::
+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
+    a
+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application' -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if the icon for /@app@/ is a fallback, 'False' otherwise. -}
+applicationGetIconIsFallback app = liftIO $ do
+    app' <- unsafeManagedPtrCastPtr app
+    result <- wnck_application_get_icon_is_fallback app'
+    let result' = (/= 0) result
+    touchManagedPtr app
+    return result'
+
+#if ENABLE_OVERLOADING
+data ApplicationGetIconIsFallbackMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetIconIsFallbackMethodInfo a signature where
+    overloadedMethod _ = applicationGetIconIsFallback
+
+#endif
+
+-- method Application::get_icon_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_application_get_icon_name" wnck_application_get_icon_name :: 
+    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})
+    IO CString
+
+{- |
+Gets the icon name of /@app@/ (to be used when /@app@/ is minimized). Since
+there is no way to properly find this name, various suboptimal heuristics
+are used to find it.
+-}
+applicationGetIconName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
+    a
+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application' -}
+    -> m T.Text
+    {- ^ __Returns:__ the icon name of /@app@/, or a fallback icon name if no icon name
+is available. -}
+applicationGetIconName app = liftIO $ do
+    app' <- unsafeManagedPtrCastPtr app
+    result <- wnck_application_get_icon_name app'
+    checkUnexpectedReturnNULL "applicationGetIconName" result
+    result' <- cstringToText result
+    touchManagedPtr app
+    return result'
+
+#if ENABLE_OVERLOADING
+data ApplicationGetIconNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetIconNameMethodInfo a signature where
+    overloadedMethod _ = applicationGetIconName
+
+#endif
+
+-- method Application::get_mini_icon
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_application_get_mini_icon" wnck_application_get_mini_icon :: 
+    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})
+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)
+
+{- |
+Gets the mini-icon to be used for /@app@/. If no mini-icon is set for /@app@/,
+a suboptimal heuristic is used to find an appropriate icon. If no mini-icon
+was found, a fallback mini-icon is used.
+-}
+applicationGetMiniIcon ::
+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
+    a
+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}
+    -> m GdkPixbuf.Pixbuf.Pixbuf
+    {- ^ __Returns:__ the mini-icon for /@app@/. The caller should
+reference the returned \<classname>GdkPixbuf\<\/classname> if it needs to keep
+the mini-icon around. -}
+applicationGetMiniIcon app = liftIO $ do
+    app' <- unsafeManagedPtrCastPtr app
+    result <- wnck_application_get_mini_icon app'
+    checkUnexpectedReturnNULL "applicationGetMiniIcon" result
+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result
+    touchManagedPtr app
+    return result'
+
+#if ENABLE_OVERLOADING
+data ApplicationGetMiniIconMethodInfo
+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetMiniIconMethodInfo a signature where
+    overloadedMethod _ = applicationGetMiniIcon
+
+#endif
+
+-- method Application::get_n_windows
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_application_get_n_windows" wnck_application_get_n_windows :: 
+    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})
+    IO Int32
+
+{- |
+Gets the number of 'GI.Wnck.Objects.Window.Window' belonging to /@app@/.
+-}
+applicationGetNWindows ::
+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
+    a
+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}
+    -> m Int32
+    {- ^ __Returns:__ the number of 'GI.Wnck.Objects.Window.Window' belonging to /@app@/. -}
+applicationGetNWindows app = liftIO $ do
+    app' <- unsafeManagedPtrCastPtr app
+    result <- wnck_application_get_n_windows app'
+    touchManagedPtr app
+    return result
+
+#if ENABLE_OVERLOADING
+data ApplicationGetNWindowsMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetNWindowsMethodInfo a signature where
+    overloadedMethod _ = applicationGetNWindows
+
+#endif
+
+-- method Application::get_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_application_get_name" wnck_application_get_name :: 
+    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})
+    IO CString
+
+{- |
+Gets the name of /@app@/. Since there is no way to properly find this name,
+various suboptimal heuristics are used to find it. GTK+ should probably have
+a function to allow applications to set the _NET_WM_NAME property on the
+group leader as the application name, and the \<ulink
+url=\"http:\/\/standards.freedesktop.org\/wm-spec\/wm-spec-latest.html\">EWMH\<\/ulink>
+should say that this is where the application name goes.
+-}
+applicationGetName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
+    a
+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}
+    -> m T.Text
+    {- ^ __Returns:__ the name of /@app@/, or a fallback name if no name is available. -}
+applicationGetName app = liftIO $ do
+    app' <- unsafeManagedPtrCastPtr app
+    result <- wnck_application_get_name app'
+    checkUnexpectedReturnNULL "applicationGetName" result
+    result' <- cstringToText result
+    touchManagedPtr app
+    return result'
+
+#if ENABLE_OVERLOADING
+data ApplicationGetNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetNameMethodInfo a signature where
+    overloadedMethod _ = applicationGetName
+
+#endif
+
+-- method Application::get_pid
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_application_get_pid" wnck_application_get_pid :: 
+    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})
+    IO Int32
+
+{- |
+Gets the process ID of /@app@/.
+-}
+applicationGetPid ::
+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
+    a
+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}
+    -> m Int32
+    {- ^ __Returns:__ the process ID of /@app@/, or 0 if none is available. -}
+applicationGetPid app = liftIO $ do
+    app' <- unsafeManagedPtrCastPtr app
+    result <- wnck_application_get_pid app'
+    touchManagedPtr app
+    return result
+
+#if ENABLE_OVERLOADING
+data ApplicationGetPidMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetPidMethodInfo a signature where
+    overloadedMethod _ = applicationGetPid
+
+#endif
+
+-- method Application::get_startup_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_application_get_startup_id" wnck_application_get_startup_id :: 
+    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})
+    IO CString
+
+{- |
+Gets the startup sequence ID used for startup notification of /@app@/.
+
+/Since: 2.2/
+-}
+applicationGetStartupId ::
+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
+    a
+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}
+    -> m T.Text
+    {- ^ __Returns:__ the startup sequence ID used for startup notification of /@app@/,
+or 'Nothing' if none is available. -}
+applicationGetStartupId app = liftIO $ do
+    app' <- unsafeManagedPtrCastPtr app
+    result <- wnck_application_get_startup_id app'
+    checkUnexpectedReturnNULL "applicationGetStartupId" result
+    result' <- cstringToText result
+    touchManagedPtr app
+    return result'
+
+#if ENABLE_OVERLOADING
+data ApplicationGetStartupIdMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetStartupIdMethodInfo a signature where
+    overloadedMethod _ = applicationGetStartupId
+
+#endif
+
+-- method Application::get_windows
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TGList (TInterface (Name {namespace = "Wnck", name = "Window"})))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_application_get_windows" wnck_application_get_windows :: 
+    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})
+    IO (Ptr (GList (Ptr Wnck.Window.Window)))
+
+{- |
+Gets the list of 'GI.Wnck.Objects.Window.Window' belonging to /@app@/.
+-}
+applicationGetWindows ::
+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
+    a
+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}
+    -> m [Wnck.Window.Window]
+    {- ^ __Returns:__ the list of
+'GI.Wnck.Objects.Window.Window' belonging to /@app@/, or 'Nothing' if the application contains no
+window. The list should not be modified nor freed, as it is owned by /@app@/. -}
+applicationGetWindows app = liftIO $ do
+    app' <- unsafeManagedPtrCastPtr app
+    result <- wnck_application_get_windows app'
+    result' <- unpackGList result
+    result'' <- mapM (newObject Wnck.Window.Window) result'
+    touchManagedPtr app
+    return result''
+
+#if ENABLE_OVERLOADING
+data ApplicationGetWindowsMethodInfo
+instance (signature ~ (m [Wnck.Window.Window]), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetWindowsMethodInfo a signature where
+    overloadedMethod _ = applicationGetWindows
+
+#endif
+
+-- method Application::get_xid
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "app", argType = TInterface (Name {namespace = "Wnck", name = "Application"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckApplication.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TULong)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_application_get_xid" wnck_application_get_xid :: 
+    Ptr Application ->                      -- app : TInterface (Name {namespace = "Wnck", name = "Application"})
+    IO CULong
+
+{- |
+Gets the X window ID of the group leader window for /@app@/.
+-}
+applicationGetXid ::
+    (B.CallStack.HasCallStack, MonadIO m, IsApplication a) =>
+    a
+    {- ^ /@app@/: a 'GI.Wnck.Objects.Application.Application'. -}
+    -> m CULong
+    {- ^ __Returns:__ the X window ID of the group leader window for /@app@/. -}
+applicationGetXid app = liftIO $ do
+    app' <- unsafeManagedPtrCastPtr app
+    result <- wnck_application_get_xid app'
+    touchManagedPtr app
+    return result
+
+#if ENABLE_OVERLOADING
+data ApplicationGetXidMethodInfo
+instance (signature ~ (m CULong), MonadIO m, IsApplication a) => O.MethodInfo ApplicationGetXidMethodInfo a signature where
+    overloadedMethod _ = applicationGetXid
+
+#endif
+
+-- method Application::get
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "xwindow", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X window ID of a group leader.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Application"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_application_get" wnck_application_get :: 
+    CULong ->                               -- xwindow : TBasicType TULong
+    IO (Ptr Application)
+
+{- |
+Gets the 'GI.Wnck.Objects.Application.Application' corresponding to the group leader with /@xwindow@/
+as X window ID.
+-}
+applicationGet ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    CULong
+    {- ^ /@xwindow@/: the X window ID of a group leader. -}
+    -> m Application
+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Application.Application' corresponding to
+/@xwindow@/, or 'Nothing' if there no such 'GI.Wnck.Objects.Application.Application' could be found. The
+returned 'GI.Wnck.Objects.Application.Application' is owned by libwnck and must not be referenced or
+unreferenced. -}
+applicationGet xwindow = liftIO $ do
+    result <- wnck_application_get xwindow
+    checkUnexpectedReturnNULL "applicationGet" result
+    result' <- (newObject Application) result
+    return result'
+
+#if ENABLE_OVERLOADING
+#endif
+
+
diff --git a/GI/Wnck/Objects/Application.hs-boot b/GI/Wnck/Objects/Application.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Application.hs-boot
@@ -0,0 +1,65 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Objects.Application where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype Application = Application (ManagedPtr Application)
+instance GObject Application where
+class (GObject o, O.IsDescendantOf Application o) => IsApplication o
+instance (GObject o, O.IsDescendantOf Application o) => IsApplication o
+instance O.HasParentTypes Application
+#if ENABLE_OVERLOADING
+data ApplicationIconChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ApplicationNameChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ApplicationGetIconMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ApplicationGetIconIsFallbackMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ApplicationGetIconNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ApplicationGetMiniIconMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ApplicationGetNWindowsMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ApplicationGetNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ApplicationGetPidMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ApplicationGetStartupIdMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ApplicationGetWindowsMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ApplicationGetXidMethodInfo
+#endif
diff --git a/GI/Wnck/Objects/ClassGroup.hs b/GI/Wnck/Objects/ClassGroup.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/ClassGroup.hs
@@ -0,0 +1,653 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+The 'GI.Wnck.Objects.ClassGroup.ClassGroup' struct contains only private fields and should not be
+directly accessed.
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Objects.ClassGroup
+    ( 
+
+-- * Exported types
+    ClassGroup(..)                          ,
+    IsClassGroup                            ,
+    toClassGroup                            ,
+    noClassGroup                            ,
+
+
+ -- * Methods
+-- ** get #method:get#
+
+    classGroupGet                           ,
+
+
+-- ** getIcon #method:getIcon#
+
+#if ENABLE_OVERLOADING
+    ClassGroupGetIconMethodInfo             ,
+#endif
+    classGroupGetIcon                       ,
+
+
+-- ** getId #method:getId#
+
+#if ENABLE_OVERLOADING
+    ClassGroupGetIdMethodInfo               ,
+#endif
+    classGroupGetId                         ,
+
+
+-- ** getMiniIcon #method:getMiniIcon#
+
+#if ENABLE_OVERLOADING
+    ClassGroupGetMiniIconMethodInfo         ,
+#endif
+    classGroupGetMiniIcon                   ,
+
+
+-- ** getName #method:getName#
+
+#if ENABLE_OVERLOADING
+    ClassGroupGetNameMethodInfo             ,
+#endif
+    classGroupGetName                       ,
+
+
+-- ** getResClass #method:getResClass#
+
+#if ENABLE_OVERLOADING
+    ClassGroupGetResClassMethodInfo         ,
+#endif
+    classGroupGetResClass                   ,
+
+
+-- ** getWindows #method:getWindows#
+
+#if ENABLE_OVERLOADING
+    ClassGroupGetWindowsMethodInfo          ,
+#endif
+    classGroupGetWindows                    ,
+
+
+
+
+ -- * Signals
+-- ** iconChanged #signal:iconChanged#
+
+    C_ClassGroupIconChangedCallback         ,
+    ClassGroupIconChangedCallback           ,
+#if ENABLE_OVERLOADING
+    ClassGroupIconChangedSignalInfo         ,
+#endif
+    afterClassGroupIconChanged              ,
+    genClosure_ClassGroupIconChanged        ,
+    mk_ClassGroupIconChangedCallback        ,
+    noClassGroupIconChangedCallback         ,
+    onClassGroupIconChanged                 ,
+    wrap_ClassGroupIconChangedCallback      ,
+
+
+-- ** nameChanged #signal:nameChanged#
+
+    C_ClassGroupNameChangedCallback         ,
+    ClassGroupNameChangedCallback           ,
+#if ENABLE_OVERLOADING
+    ClassGroupNameChangedSignalInfo         ,
+#endif
+    afterClassGroupNameChanged              ,
+    genClosure_ClassGroupNameChanged        ,
+    mk_ClassGroupNameChangedCallback        ,
+    noClassGroupNameChangedCallback         ,
+    onClassGroupNameChanged                 ,
+    wrap_ClassGroupNameChangedCallback      ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+import qualified GI.GObject.Objects.Object as GObject.Object
+import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
+import {-# SOURCE #-} qualified GI.Wnck.Objects.Window as Wnck.Window
+
+-- | Memory-managed wrapper type.
+newtype ClassGroup = ClassGroup (ManagedPtr ClassGroup)
+foreign import ccall "wnck_class_group_get_type"
+    c_wnck_class_group_get_type :: IO GType
+
+instance GObject ClassGroup where
+    gobjectType = c_wnck_class_group_get_type
+    
+
+-- | Type class for types which can be safely cast to `ClassGroup`, for instance with `toClassGroup`.
+class (GObject o, O.IsDescendantOf ClassGroup o) => IsClassGroup o
+instance (GObject o, O.IsDescendantOf ClassGroup o) => IsClassGroup o
+
+instance O.HasParentTypes ClassGroup
+type instance O.ParentTypes ClassGroup = '[GObject.Object.Object]
+
+-- | Cast to `ClassGroup`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
+toClassGroup :: (MonadIO m, IsClassGroup o) => o -> m ClassGroup
+toClassGroup = liftIO . unsafeCastTo ClassGroup
+
+-- | A convenience alias for `Nothing` :: `Maybe` `ClassGroup`.
+noClassGroup :: Maybe ClassGroup
+noClassGroup = Nothing
+
+#if ENABLE_OVERLOADING
+type family ResolveClassGroupMethod (t :: Symbol) (o :: *) :: * where
+    ResolveClassGroupMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
+    ResolveClassGroupMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
+    ResolveClassGroupMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
+    ResolveClassGroupMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
+    ResolveClassGroupMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
+    ResolveClassGroupMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
+    ResolveClassGroupMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
+    ResolveClassGroupMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
+    ResolveClassGroupMethod "ref" o = GObject.Object.ObjectRefMethodInfo
+    ResolveClassGroupMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
+    ResolveClassGroupMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
+    ResolveClassGroupMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
+    ResolveClassGroupMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
+    ResolveClassGroupMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
+    ResolveClassGroupMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
+    ResolveClassGroupMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
+    ResolveClassGroupMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
+    ResolveClassGroupMethod "getIcon" o = ClassGroupGetIconMethodInfo
+    ResolveClassGroupMethod "getId" o = ClassGroupGetIdMethodInfo
+    ResolveClassGroupMethod "getMiniIcon" o = ClassGroupGetMiniIconMethodInfo
+    ResolveClassGroupMethod "getName" o = ClassGroupGetNameMethodInfo
+    ResolveClassGroupMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
+    ResolveClassGroupMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
+    ResolveClassGroupMethod "getResClass" o = ClassGroupGetResClassMethodInfo
+    ResolveClassGroupMethod "getWindows" o = ClassGroupGetWindowsMethodInfo
+    ResolveClassGroupMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
+    ResolveClassGroupMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
+    ResolveClassGroupMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolveClassGroupMethod t ClassGroup, O.MethodInfo info ClassGroup p) => OL.IsLabel t (ClassGroup -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+-- signal ClassGroup::icon-changed
+{- |
+Emitted when the icon of /@classGroup@/ changes.
+-}
+type ClassGroupIconChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassGroupIconChangedCallback`@.
+noClassGroupIconChangedCallback :: Maybe ClassGroupIconChangedCallback
+noClassGroupIconChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ClassGroupIconChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ClassGroupIconChangedCallback`.
+foreign import ccall "wrapper"
+    mk_ClassGroupIconChangedCallback :: C_ClassGroupIconChangedCallback -> IO (FunPtr C_ClassGroupIconChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ClassGroupIconChanged :: MonadIO m => ClassGroupIconChangedCallback -> m (GClosure C_ClassGroupIconChangedCallback)
+genClosure_ClassGroupIconChanged cb = liftIO $ do
+    let cb' = wrap_ClassGroupIconChangedCallback cb
+    mk_ClassGroupIconChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ClassGroupIconChangedCallback` into a `C_ClassGroupIconChangedCallback`.
+wrap_ClassGroupIconChangedCallback ::
+    ClassGroupIconChangedCallback ->
+    C_ClassGroupIconChangedCallback
+wrap_ClassGroupIconChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@icon-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' classGroup #iconChanged callback
+@
+-}
+onClassGroupIconChanged :: (IsClassGroup a, MonadIO m) => a -> ClassGroupIconChangedCallback -> m SignalHandlerId
+onClassGroupIconChanged obj cb = liftIO $ do
+    let cb' = wrap_ClassGroupIconChangedCallback cb
+    cb'' <- mk_ClassGroupIconChangedCallback cb'
+    connectSignalFunPtr obj "icon-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@icon-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' classGroup #iconChanged callback
+@
+-}
+afterClassGroupIconChanged :: (IsClassGroup a, MonadIO m) => a -> ClassGroupIconChangedCallback -> m SignalHandlerId
+afterClassGroupIconChanged obj cb = liftIO $ do
+    let cb' = wrap_ClassGroupIconChangedCallback cb
+    cb'' <- mk_ClassGroupIconChangedCallback cb'
+    connectSignalFunPtr obj "icon-changed" cb'' SignalConnectAfter
+
+
+-- signal ClassGroup::name-changed
+{- |
+Emitted when the name of /@classGroup@/ changes.
+-}
+type ClassGroupNameChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ClassGroupNameChangedCallback`@.
+noClassGroupNameChangedCallback :: Maybe ClassGroupNameChangedCallback
+noClassGroupNameChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ClassGroupNameChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ClassGroupNameChangedCallback`.
+foreign import ccall "wrapper"
+    mk_ClassGroupNameChangedCallback :: C_ClassGroupNameChangedCallback -> IO (FunPtr C_ClassGroupNameChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ClassGroupNameChanged :: MonadIO m => ClassGroupNameChangedCallback -> m (GClosure C_ClassGroupNameChangedCallback)
+genClosure_ClassGroupNameChanged cb = liftIO $ do
+    let cb' = wrap_ClassGroupNameChangedCallback cb
+    mk_ClassGroupNameChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ClassGroupNameChangedCallback` into a `C_ClassGroupNameChangedCallback`.
+wrap_ClassGroupNameChangedCallback ::
+    ClassGroupNameChangedCallback ->
+    C_ClassGroupNameChangedCallback
+wrap_ClassGroupNameChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@name-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' classGroup #nameChanged callback
+@
+-}
+onClassGroupNameChanged :: (IsClassGroup a, MonadIO m) => a -> ClassGroupNameChangedCallback -> m SignalHandlerId
+onClassGroupNameChanged obj cb = liftIO $ do
+    let cb' = wrap_ClassGroupNameChangedCallback cb
+    cb'' <- mk_ClassGroupNameChangedCallback cb'
+    connectSignalFunPtr obj "name-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@name-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' classGroup #nameChanged callback
+@
+-}
+afterClassGroupNameChanged :: (IsClassGroup a, MonadIO m) => a -> ClassGroupNameChangedCallback -> m SignalHandlerId
+afterClassGroupNameChanged obj cb = liftIO $ do
+    let cb' = wrap_ClassGroupNameChangedCallback cb
+    cb'' <- mk_ClassGroupNameChangedCallback cb'
+    connectSignalFunPtr obj "name-changed" cb'' SignalConnectAfter
+
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList ClassGroup
+type instance O.AttributeList ClassGroup = ClassGroupAttributeList
+type ClassGroupAttributeList = ('[ ] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+#endif
+
+#if ENABLE_OVERLOADING
+data ClassGroupIconChangedSignalInfo
+instance SignalInfo ClassGroupIconChangedSignalInfo where
+    type HaskellCallbackType ClassGroupIconChangedSignalInfo = ClassGroupIconChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ClassGroupIconChangedCallback cb
+        cb'' <- mk_ClassGroupIconChangedCallback cb'
+        connectSignalFunPtr obj "icon-changed" cb'' connectMode
+
+data ClassGroupNameChangedSignalInfo
+instance SignalInfo ClassGroupNameChangedSignalInfo where
+    type HaskellCallbackType ClassGroupNameChangedSignalInfo = ClassGroupNameChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ClassGroupNameChangedCallback cb
+        cb'' <- mk_ClassGroupNameChangedCallback cb'
+        connectSignalFunPtr obj "name-changed" cb'' connectMode
+
+type instance O.SignalList ClassGroup = ClassGroupSignalList
+type ClassGroupSignalList = ('[ '("iconChanged", ClassGroupIconChangedSignalInfo), '("nameChanged", ClassGroupNameChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+#endif
+
+-- method ClassGroup::get_icon
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_class_group_get_icon" wnck_class_group_get_icon :: 
+    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})
+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)
+
+{- |
+Gets the icon to be used for /@classGroup@/. Since there is no way to
+properly find the icon, a suboptimal heuristic is used to find it. The icon
+is the first icon found by looking at all the 'GI.Wnck.Objects.Application.Application' for each
+'GI.Wnck.Objects.Window.Window' in /@classGroup@/, then at all the 'GI.Wnck.Objects.Window.Window' in /@classGroup@/. If
+no icon was found, a fallback icon is used.
+
+/Since: 2.2/
+-}
+classGroupGetIcon ::
+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>
+    a
+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}
+    -> m GdkPixbuf.Pixbuf.Pixbuf
+    {- ^ __Returns:__ the icon for /@classGroup@/. The caller should
+reference the returned \<classname>GdkPixbuf\<\/classname> if it needs to keep
+the icon around. -}
+classGroupGetIcon classGroup = liftIO $ do
+    classGroup' <- unsafeManagedPtrCastPtr classGroup
+    result <- wnck_class_group_get_icon classGroup'
+    checkUnexpectedReturnNULL "classGroupGetIcon" result
+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result
+    touchManagedPtr classGroup
+    return result'
+
+#if ENABLE_OVERLOADING
+data ClassGroupGetIconMethodInfo
+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetIconMethodInfo a signature where
+    overloadedMethod _ = classGroupGetIcon
+
+#endif
+
+-- method ClassGroup::get_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_class_group_get_id" wnck_class_group_get_id :: 
+    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})
+    IO CString
+
+{- |
+Gets the identifier name for /@classGroup@/. This is the resource class for
+/@classGroup@/.
+
+/Since: 3.2/
+-}
+classGroupGetId ::
+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>
+    a
+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}
+    -> m T.Text
+    {- ^ __Returns:__ the identifier name of /@classGroup@/, or an
+empty string if the group has no identifier name. -}
+classGroupGetId classGroup = liftIO $ do
+    classGroup' <- unsafeManagedPtrCastPtr classGroup
+    result <- wnck_class_group_get_id classGroup'
+    checkUnexpectedReturnNULL "classGroupGetId" result
+    result' <- cstringToText result
+    touchManagedPtr classGroup
+    return result'
+
+#if ENABLE_OVERLOADING
+data ClassGroupGetIdMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetIdMethodInfo a signature where
+    overloadedMethod _ = classGroupGetId
+
+#endif
+
+-- method ClassGroup::get_mini_icon
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_class_group_get_mini_icon" wnck_class_group_get_mini_icon :: 
+    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})
+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)
+
+{- |
+Gets the mini-icon to be used for /@classGroup@/. Since there is no way to
+properly find the mini-icon, the same suboptimal heuristic as the one for
+'GI.Wnck.Objects.ClassGroup.classGroupGetIcon' is used to find it.
+
+/Since: 2.2/
+-}
+classGroupGetMiniIcon ::
+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>
+    a
+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}
+    -> m GdkPixbuf.Pixbuf.Pixbuf
+    {- ^ __Returns:__ the mini-icon for /@classGroup@/. The caller
+should reference the returned \<classname>GdkPixbuf\<\/classname> if it needs
+to keep the mini-icon around. -}
+classGroupGetMiniIcon classGroup = liftIO $ do
+    classGroup' <- unsafeManagedPtrCastPtr classGroup
+    result <- wnck_class_group_get_mini_icon classGroup'
+    checkUnexpectedReturnNULL "classGroupGetMiniIcon" result
+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result
+    touchManagedPtr classGroup
+    return result'
+
+#if ENABLE_OVERLOADING
+data ClassGroupGetMiniIconMethodInfo
+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetMiniIconMethodInfo a signature where
+    overloadedMethod _ = classGroupGetMiniIcon
+
+#endif
+
+-- method ClassGroup::get_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_class_group_get_name" wnck_class_group_get_name :: 
+    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})
+    IO CString
+
+{- |
+Gets an human-readable name for /@classGroup@/. Since there is no way to
+properly find this name, a suboptimal heuristic is used to find it. The name
+is the name of all 'GI.Wnck.Objects.Application.Application' for each 'GI.Wnck.Objects.Window.Window' in /@classGroup@/ if
+they all have the same name. If all 'GI.Wnck.Objects.Application.Application' don\'t have the same
+name, the name is the name of all 'GI.Wnck.Objects.Window.Window' in /@classGroup@/ if they all
+have the same name. If all 'GI.Wnck.Objects.Window.Window' don\'t have the same name, the
+resource class name is used.
+
+/Since: 2.2/
+-}
+classGroupGetName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>
+    a
+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}
+    -> m T.Text
+    {- ^ __Returns:__ an human-readable name for /@classGroup@/. -}
+classGroupGetName classGroup = liftIO $ do
+    classGroup' <- unsafeManagedPtrCastPtr classGroup
+    result <- wnck_class_group_get_name classGroup'
+    checkUnexpectedReturnNULL "classGroupGetName" result
+    result' <- cstringToText result
+    touchManagedPtr classGroup
+    return result'
+
+#if ENABLE_OVERLOADING
+data ClassGroupGetNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetNameMethodInfo a signature where
+    overloadedMethod _ = classGroupGetName
+
+#endif
+
+-- method ClassGroup::get_res_class
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_class_group_get_res_class" wnck_class_group_get_res_class :: 
+    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})
+    IO CString
+
+{-# DEPRECATED classGroupGetResClass ["(Since version 3.2)","Use 'GI.Wnck.Objects.ClassGroup.classGroupGetId' instead."] #-}
+{- |
+Gets the resource class name for /@classGroup@/.
+
+/Since: 2.2/
+-}
+classGroupGetResClass ::
+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>
+    a
+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}
+    -> m T.Text
+    {- ^ __Returns:__ the resource class name of /@classGroup@/, or an
+empty string if the group has no resource class name. -}
+classGroupGetResClass classGroup = liftIO $ do
+    classGroup' <- unsafeManagedPtrCastPtr classGroup
+    result <- wnck_class_group_get_res_class classGroup'
+    checkUnexpectedReturnNULL "classGroupGetResClass" result
+    result' <- cstringToText result
+    touchManagedPtr classGroup
+    return result'
+
+#if ENABLE_OVERLOADING
+data ClassGroupGetResClassMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetResClassMethodInfo a signature where
+    overloadedMethod _ = classGroupGetResClass
+
+#endif
+
+-- method ClassGroup::get_windows
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "class_group", argType = TInterface (Name {namespace = "Wnck", name = "ClassGroup"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckClassGroup.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TGList (TInterface (Name {namespace = "Wnck", name = "Window"})))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_class_group_get_windows" wnck_class_group_get_windows :: 
+    Ptr ClassGroup ->                       -- class_group : TInterface (Name {namespace = "Wnck", name = "ClassGroup"})
+    IO (Ptr (GList (Ptr Wnck.Window.Window)))
+
+{- |
+Gets the list of 'GI.Wnck.Objects.Window.Window' that are grouped in /@classGroup@/.
+
+/Since: 2.2/
+-}
+classGroupGetWindows ::
+    (B.CallStack.HasCallStack, MonadIO m, IsClassGroup a) =>
+    a
+    {- ^ /@classGroup@/: a 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}
+    -> m [Wnck.Window.Window]
+    {- ^ __Returns:__ the list of
+'GI.Wnck.Objects.Window.Window' grouped in /@classGroup@/, or 'Nothing' if the group contains no
+window. The list should not be modified nor freed, as it is owned by
+/@classGroup@/. -}
+classGroupGetWindows classGroup = liftIO $ do
+    classGroup' <- unsafeManagedPtrCastPtr classGroup
+    result <- wnck_class_group_get_windows classGroup'
+    result' <- unpackGList result
+    result'' <- mapM (newObject Wnck.Window.Window) result'
+    touchManagedPtr classGroup
+    return result''
+
+#if ENABLE_OVERLOADING
+data ClassGroupGetWindowsMethodInfo
+instance (signature ~ (m [Wnck.Window.Window]), MonadIO m, IsClassGroup a) => O.MethodInfo ClassGroupGetWindowsMethodInfo a signature where
+    overloadedMethod _ = classGroupGetWindows
+
+#endif
+
+-- method ClassGroup::get
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "identifier name of the sought resource class.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "ClassGroup"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_class_group_get" wnck_class_group_get :: 
+    CString ->                              -- id : TBasicType TUTF8
+    IO (Ptr ClassGroup)
+
+{- |
+Gets the 'GI.Wnck.Objects.ClassGroup.ClassGroup' corresponding to /@id@/.
+
+/Since: 2.2/
+-}
+classGroupGet ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    T.Text
+    {- ^ /@id@/: identifier name of the sought resource class. -}
+    -> m ClassGroup
+    {- ^ __Returns:__ the 'GI.Wnck.Objects.ClassGroup.ClassGroup' corresponding to
+/@id@/, or 'Nothing' if there is no 'GI.Wnck.Objects.ClassGroup.ClassGroup' with the specified
+/@id@/. The returned 'GI.Wnck.Objects.ClassGroup.ClassGroup' is owned by libwnck and must not be
+referenced or unreferenced. -}
+classGroupGet id = liftIO $ do
+    id' <- textToCString id
+    result <- wnck_class_group_get id'
+    checkUnexpectedReturnNULL "classGroupGet" result
+    result' <- (newObject ClassGroup) result
+    freeMem id'
+    return result'
+
+#if ENABLE_OVERLOADING
+#endif
+
+
diff --git a/GI/Wnck/Objects/ClassGroup.hs-boot b/GI/Wnck/Objects/ClassGroup.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/ClassGroup.hs-boot
@@ -0,0 +1,53 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Objects.ClassGroup where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype ClassGroup = ClassGroup (ManagedPtr ClassGroup)
+instance GObject ClassGroup where
+class (GObject o, O.IsDescendantOf ClassGroup o) => IsClassGroup o
+instance (GObject o, O.IsDescendantOf ClassGroup o) => IsClassGroup o
+instance O.HasParentTypes ClassGroup
+#if ENABLE_OVERLOADING
+data ClassGroupIconChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ClassGroupNameChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ClassGroupGetIconMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ClassGroupGetIdMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ClassGroupGetMiniIconMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ClassGroupGetNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ClassGroupGetResClassMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ClassGroupGetWindowsMethodInfo
+#endif
diff --git a/GI/Wnck/Objects/ImageMenuItem.hs b/GI/Wnck/Objects/ImageMenuItem.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/ImageMenuItem.hs
@@ -0,0 +1,695 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+/No description available in the introspection data./
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Objects.ImageMenuItem
+    ( 
+
+-- * Exported types
+    ImageMenuItem(..)                       ,
+    IsImageMenuItem                         ,
+    toImageMenuItem                         ,
+    noImageMenuItem                         ,
+
+
+ -- * Methods
+-- ** makeLabelBold #method:makeLabelBold#
+
+#if ENABLE_OVERLOADING
+    ImageMenuItemMakeLabelBoldMethodInfo    ,
+#endif
+    imageMenuItemMakeLabelBold              ,
+
+
+-- ** makeLabelNormal #method:makeLabelNormal#
+
+#if ENABLE_OVERLOADING
+    ImageMenuItemMakeLabelNormalMethodInfo  ,
+#endif
+    imageMenuItemMakeLabelNormal            ,
+
+
+-- ** new #method:new#
+
+    imageMenuItemNew                        ,
+
+
+-- ** newWithLabel #method:newWithLabel#
+
+    imageMenuItemNewWithLabel               ,
+
+
+-- ** setImageFromIconPixbuf #method:setImageFromIconPixbuf#
+
+#if ENABLE_OVERLOADING
+    ImageMenuItemSetImageFromIconPixbufMethodInfo,
+#endif
+    imageMenuItemSetImageFromIconPixbuf     ,
+
+
+-- ** setImageFromWindow #method:setImageFromWindow#
+
+#if ENABLE_OVERLOADING
+    ImageMenuItemSetImageFromWindowMethodInfo,
+#endif
+    imageMenuItemSetImageFromWindow         ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
+import qualified GI.GObject.Objects.Object as GObject.Object
+import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
+import qualified GI.Gtk.Interfaces.Actionable as Gtk.Actionable
+import qualified GI.Gtk.Interfaces.Activatable as Gtk.Activatable
+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
+import qualified GI.Gtk.Objects.Bin as Gtk.Bin
+import qualified GI.Gtk.Objects.Container as Gtk.Container
+import qualified GI.Gtk.Objects.MenuItem as Gtk.MenuItem
+import qualified GI.Gtk.Objects.Widget as Gtk.Widget
+import {-# SOURCE #-} qualified GI.Wnck.Objects.Window as Wnck.Window
+
+-- | Memory-managed wrapper type.
+newtype ImageMenuItem = ImageMenuItem (ManagedPtr ImageMenuItem)
+foreign import ccall "wnck_image_menu_item_get_type"
+    c_wnck_image_menu_item_get_type :: IO GType
+
+instance GObject ImageMenuItem where
+    gobjectType = c_wnck_image_menu_item_get_type
+    
+
+-- | Type class for types which can be safely cast to `ImageMenuItem`, for instance with `toImageMenuItem`.
+class (GObject o, O.IsDescendantOf ImageMenuItem o) => IsImageMenuItem o
+instance (GObject o, O.IsDescendantOf ImageMenuItem o) => IsImageMenuItem o
+
+instance O.HasParentTypes ImageMenuItem
+type instance O.ParentTypes ImageMenuItem = '[Gtk.MenuItem.MenuItem, Gtk.Bin.Bin, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Actionable.Actionable, Gtk.Activatable.Activatable, Gtk.Buildable.Buildable]
+
+-- | Cast to `ImageMenuItem`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
+toImageMenuItem :: (MonadIO m, IsImageMenuItem o) => o -> m ImageMenuItem
+toImageMenuItem = liftIO . unsafeCastTo ImageMenuItem
+
+-- | A convenience alias for `Nothing` :: `Maybe` `ImageMenuItem`.
+noImageMenuItem :: Maybe ImageMenuItem
+noImageMenuItem = Nothing
+
+#if ENABLE_OVERLOADING
+type family ResolveImageMenuItemMethod (t :: Symbol) (o :: *) :: * where
+    ResolveImageMenuItemMethod "activate" o = Gtk.MenuItem.MenuItemActivateMethodInfo
+    ResolveImageMenuItemMethod "add" o = Gtk.Container.ContainerAddMethodInfo
+    ResolveImageMenuItemMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
+    ResolveImageMenuItemMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
+    ResolveImageMenuItemMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
+    ResolveImageMenuItemMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
+    ResolveImageMenuItemMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
+    ResolveImageMenuItemMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
+    ResolveImageMenuItemMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
+    ResolveImageMenuItemMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
+    ResolveImageMenuItemMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
+    ResolveImageMenuItemMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
+    ResolveImageMenuItemMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
+    ResolveImageMenuItemMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
+    ResolveImageMenuItemMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
+    ResolveImageMenuItemMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
+    ResolveImageMenuItemMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
+    ResolveImageMenuItemMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
+    ResolveImageMenuItemMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
+    ResolveImageMenuItemMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
+    ResolveImageMenuItemMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
+    ResolveImageMenuItemMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
+    ResolveImageMenuItemMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
+    ResolveImageMenuItemMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
+    ResolveImageMenuItemMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
+    ResolveImageMenuItemMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
+    ResolveImageMenuItemMethod "deselect" o = Gtk.MenuItem.MenuItemDeselectMethodInfo
+    ResolveImageMenuItemMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
+    ResolveImageMenuItemMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
+    ResolveImageMenuItemMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
+    ResolveImageMenuItemMethod "doSetRelatedAction" o = Gtk.Activatable.ActivatableDoSetRelatedActionMethodInfo
+    ResolveImageMenuItemMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
+    ResolveImageMenuItemMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
+    ResolveImageMenuItemMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
+    ResolveImageMenuItemMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
+    ResolveImageMenuItemMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
+    ResolveImageMenuItemMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
+    ResolveImageMenuItemMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
+    ResolveImageMenuItemMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
+    ResolveImageMenuItemMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
+    ResolveImageMenuItemMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
+    ResolveImageMenuItemMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
+    ResolveImageMenuItemMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
+    ResolveImageMenuItemMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
+    ResolveImageMenuItemMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
+    ResolveImageMenuItemMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
+    ResolveImageMenuItemMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
+    ResolveImageMenuItemMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
+    ResolveImageMenuItemMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
+    ResolveImageMenuItemMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
+    ResolveImageMenuItemMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
+    ResolveImageMenuItemMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
+    ResolveImageMenuItemMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
+    ResolveImageMenuItemMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
+    ResolveImageMenuItemMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
+    ResolveImageMenuItemMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
+    ResolveImageMenuItemMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
+    ResolveImageMenuItemMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
+    ResolveImageMenuItemMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
+    ResolveImageMenuItemMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
+    ResolveImageMenuItemMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
+    ResolveImageMenuItemMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
+    ResolveImageMenuItemMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
+    ResolveImageMenuItemMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
+    ResolveImageMenuItemMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
+    ResolveImageMenuItemMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
+    ResolveImageMenuItemMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
+    ResolveImageMenuItemMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
+    ResolveImageMenuItemMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
+    ResolveImageMenuItemMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
+    ResolveImageMenuItemMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
+    ResolveImageMenuItemMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
+    ResolveImageMenuItemMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
+    ResolveImageMenuItemMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
+    ResolveImageMenuItemMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
+    ResolveImageMenuItemMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
+    ResolveImageMenuItemMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
+    ResolveImageMenuItemMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
+    ResolveImageMenuItemMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
+    ResolveImageMenuItemMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
+    ResolveImageMenuItemMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
+    ResolveImageMenuItemMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
+    ResolveImageMenuItemMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
+    ResolveImageMenuItemMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
+    ResolveImageMenuItemMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
+    ResolveImageMenuItemMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
+    ResolveImageMenuItemMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
+    ResolveImageMenuItemMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
+    ResolveImageMenuItemMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
+    ResolveImageMenuItemMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
+    ResolveImageMenuItemMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
+    ResolveImageMenuItemMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
+    ResolveImageMenuItemMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
+    ResolveImageMenuItemMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
+    ResolveImageMenuItemMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
+    ResolveImageMenuItemMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
+    ResolveImageMenuItemMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
+    ResolveImageMenuItemMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
+    ResolveImageMenuItemMethod "makeLabelBold" o = ImageMenuItemMakeLabelBoldMethodInfo
+    ResolveImageMenuItemMethod "makeLabelNormal" o = ImageMenuItemMakeLabelNormalMethodInfo
+    ResolveImageMenuItemMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
+    ResolveImageMenuItemMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
+    ResolveImageMenuItemMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
+    ResolveImageMenuItemMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
+    ResolveImageMenuItemMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
+    ResolveImageMenuItemMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
+    ResolveImageMenuItemMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
+    ResolveImageMenuItemMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
+    ResolveImageMenuItemMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
+    ResolveImageMenuItemMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
+    ResolveImageMenuItemMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
+    ResolveImageMenuItemMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
+    ResolveImageMenuItemMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
+    ResolveImageMenuItemMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
+    ResolveImageMenuItemMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
+    ResolveImageMenuItemMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
+    ResolveImageMenuItemMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
+    ResolveImageMenuItemMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
+    ResolveImageMenuItemMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
+    ResolveImageMenuItemMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
+    ResolveImageMenuItemMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
+    ResolveImageMenuItemMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
+    ResolveImageMenuItemMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
+    ResolveImageMenuItemMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
+    ResolveImageMenuItemMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
+    ResolveImageMenuItemMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
+    ResolveImageMenuItemMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
+    ResolveImageMenuItemMethod "ref" o = GObject.Object.ObjectRefMethodInfo
+    ResolveImageMenuItemMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
+    ResolveImageMenuItemMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
+    ResolveImageMenuItemMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
+    ResolveImageMenuItemMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
+    ResolveImageMenuItemMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
+    ResolveImageMenuItemMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
+    ResolveImageMenuItemMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
+    ResolveImageMenuItemMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
+    ResolveImageMenuItemMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
+    ResolveImageMenuItemMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
+    ResolveImageMenuItemMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
+    ResolveImageMenuItemMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
+    ResolveImageMenuItemMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
+    ResolveImageMenuItemMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
+    ResolveImageMenuItemMethod "select" o = Gtk.MenuItem.MenuItemSelectMethodInfo
+    ResolveImageMenuItemMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
+    ResolveImageMenuItemMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
+    ResolveImageMenuItemMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
+    ResolveImageMenuItemMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
+    ResolveImageMenuItemMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
+    ResolveImageMenuItemMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
+    ResolveImageMenuItemMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
+    ResolveImageMenuItemMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
+    ResolveImageMenuItemMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
+    ResolveImageMenuItemMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
+    ResolveImageMenuItemMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
+    ResolveImageMenuItemMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
+    ResolveImageMenuItemMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
+    ResolveImageMenuItemMethod "syncActionProperties" o = Gtk.Activatable.ActivatableSyncActionPropertiesMethodInfo
+    ResolveImageMenuItemMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
+    ResolveImageMenuItemMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
+    ResolveImageMenuItemMethod "toggleSizeAllocate" o = Gtk.MenuItem.MenuItemToggleSizeAllocateMethodInfo
+    ResolveImageMenuItemMethod "toggleSizeRequest" o = Gtk.MenuItem.MenuItemToggleSizeRequestMethodInfo
+    ResolveImageMenuItemMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
+    ResolveImageMenuItemMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
+    ResolveImageMenuItemMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
+    ResolveImageMenuItemMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
+    ResolveImageMenuItemMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
+    ResolveImageMenuItemMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
+    ResolveImageMenuItemMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
+    ResolveImageMenuItemMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
+    ResolveImageMenuItemMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
+    ResolveImageMenuItemMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
+    ResolveImageMenuItemMethod "getAccelPath" o = Gtk.MenuItem.MenuItemGetAccelPathMethodInfo
+    ResolveImageMenuItemMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
+    ResolveImageMenuItemMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
+    ResolveImageMenuItemMethod "getActionName" o = Gtk.Actionable.ActionableGetActionNameMethodInfo
+    ResolveImageMenuItemMethod "getActionTargetValue" o = Gtk.Actionable.ActionableGetActionTargetValueMethodInfo
+    ResolveImageMenuItemMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
+    ResolveImageMenuItemMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
+    ResolveImageMenuItemMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
+    ResolveImageMenuItemMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
+    ResolveImageMenuItemMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
+    ResolveImageMenuItemMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
+    ResolveImageMenuItemMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
+    ResolveImageMenuItemMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
+    ResolveImageMenuItemMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
+    ResolveImageMenuItemMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
+    ResolveImageMenuItemMethod "getChild" o = Gtk.Bin.BinGetChildMethodInfo
+    ResolveImageMenuItemMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
+    ResolveImageMenuItemMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
+    ResolveImageMenuItemMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
+    ResolveImageMenuItemMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
+    ResolveImageMenuItemMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
+    ResolveImageMenuItemMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
+    ResolveImageMenuItemMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
+    ResolveImageMenuItemMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
+    ResolveImageMenuItemMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
+    ResolveImageMenuItemMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
+    ResolveImageMenuItemMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
+    ResolveImageMenuItemMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
+    ResolveImageMenuItemMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
+    ResolveImageMenuItemMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
+    ResolveImageMenuItemMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
+    ResolveImageMenuItemMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
+    ResolveImageMenuItemMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
+    ResolveImageMenuItemMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
+    ResolveImageMenuItemMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
+    ResolveImageMenuItemMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
+    ResolveImageMenuItemMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
+    ResolveImageMenuItemMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
+    ResolveImageMenuItemMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
+    ResolveImageMenuItemMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
+    ResolveImageMenuItemMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
+    ResolveImageMenuItemMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
+    ResolveImageMenuItemMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
+    ResolveImageMenuItemMethod "getLabel" o = Gtk.MenuItem.MenuItemGetLabelMethodInfo
+    ResolveImageMenuItemMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
+    ResolveImageMenuItemMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
+    ResolveImageMenuItemMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
+    ResolveImageMenuItemMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
+    ResolveImageMenuItemMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
+    ResolveImageMenuItemMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
+    ResolveImageMenuItemMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
+    ResolveImageMenuItemMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
+    ResolveImageMenuItemMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
+    ResolveImageMenuItemMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
+    ResolveImageMenuItemMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
+    ResolveImageMenuItemMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
+    ResolveImageMenuItemMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
+    ResolveImageMenuItemMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
+    ResolveImageMenuItemMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
+    ResolveImageMenuItemMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
+    ResolveImageMenuItemMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
+    ResolveImageMenuItemMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
+    ResolveImageMenuItemMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
+    ResolveImageMenuItemMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
+    ResolveImageMenuItemMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
+    ResolveImageMenuItemMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
+    ResolveImageMenuItemMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
+    ResolveImageMenuItemMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
+    ResolveImageMenuItemMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
+    ResolveImageMenuItemMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
+    ResolveImageMenuItemMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
+    ResolveImageMenuItemMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
+    ResolveImageMenuItemMethod "getRelatedAction" o = Gtk.Activatable.ActivatableGetRelatedActionMethodInfo
+    ResolveImageMenuItemMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
+    ResolveImageMenuItemMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
+    ResolveImageMenuItemMethod "getReserveIndicator" o = Gtk.MenuItem.MenuItemGetReserveIndicatorMethodInfo
+    ResolveImageMenuItemMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
+    ResolveImageMenuItemMethod "getRightJustified" o = Gtk.MenuItem.MenuItemGetRightJustifiedMethodInfo
+    ResolveImageMenuItemMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
+    ResolveImageMenuItemMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
+    ResolveImageMenuItemMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
+    ResolveImageMenuItemMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
+    ResolveImageMenuItemMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
+    ResolveImageMenuItemMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
+    ResolveImageMenuItemMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
+    ResolveImageMenuItemMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
+    ResolveImageMenuItemMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
+    ResolveImageMenuItemMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
+    ResolveImageMenuItemMethod "getSubmenu" o = Gtk.MenuItem.MenuItemGetSubmenuMethodInfo
+    ResolveImageMenuItemMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
+    ResolveImageMenuItemMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
+    ResolveImageMenuItemMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
+    ResolveImageMenuItemMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
+    ResolveImageMenuItemMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
+    ResolveImageMenuItemMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
+    ResolveImageMenuItemMethod "getUseActionAppearance" o = Gtk.Activatable.ActivatableGetUseActionAppearanceMethodInfo
+    ResolveImageMenuItemMethod "getUseUnderline" o = Gtk.MenuItem.MenuItemGetUseUnderlineMethodInfo
+    ResolveImageMenuItemMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
+    ResolveImageMenuItemMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
+    ResolveImageMenuItemMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
+    ResolveImageMenuItemMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
+    ResolveImageMenuItemMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
+    ResolveImageMenuItemMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
+    ResolveImageMenuItemMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
+    ResolveImageMenuItemMethod "setAccelPath" o = Gtk.MenuItem.MenuItemSetAccelPathMethodInfo
+    ResolveImageMenuItemMethod "setActionName" o = Gtk.Actionable.ActionableSetActionNameMethodInfo
+    ResolveImageMenuItemMethod "setActionTargetValue" o = Gtk.Actionable.ActionableSetActionTargetValueMethodInfo
+    ResolveImageMenuItemMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
+    ResolveImageMenuItemMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
+    ResolveImageMenuItemMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
+    ResolveImageMenuItemMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
+    ResolveImageMenuItemMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
+    ResolveImageMenuItemMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
+    ResolveImageMenuItemMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
+    ResolveImageMenuItemMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
+    ResolveImageMenuItemMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
+    ResolveImageMenuItemMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
+    ResolveImageMenuItemMethod "setDetailedActionName" o = Gtk.Actionable.ActionableSetDetailedActionNameMethodInfo
+    ResolveImageMenuItemMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
+    ResolveImageMenuItemMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
+    ResolveImageMenuItemMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
+    ResolveImageMenuItemMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
+    ResolveImageMenuItemMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
+    ResolveImageMenuItemMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
+    ResolveImageMenuItemMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
+    ResolveImageMenuItemMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
+    ResolveImageMenuItemMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
+    ResolveImageMenuItemMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
+    ResolveImageMenuItemMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
+    ResolveImageMenuItemMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
+    ResolveImageMenuItemMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
+    ResolveImageMenuItemMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
+    ResolveImageMenuItemMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
+    ResolveImageMenuItemMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
+    ResolveImageMenuItemMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
+    ResolveImageMenuItemMethod "setImageFromIconPixbuf" o = ImageMenuItemSetImageFromIconPixbufMethodInfo
+    ResolveImageMenuItemMethod "setImageFromWindow" o = ImageMenuItemSetImageFromWindowMethodInfo
+    ResolveImageMenuItemMethod "setLabel" o = Gtk.MenuItem.MenuItemSetLabelMethodInfo
+    ResolveImageMenuItemMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
+    ResolveImageMenuItemMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
+    ResolveImageMenuItemMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
+    ResolveImageMenuItemMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
+    ResolveImageMenuItemMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
+    ResolveImageMenuItemMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
+    ResolveImageMenuItemMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
+    ResolveImageMenuItemMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
+    ResolveImageMenuItemMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
+    ResolveImageMenuItemMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
+    ResolveImageMenuItemMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
+    ResolveImageMenuItemMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
+    ResolveImageMenuItemMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
+    ResolveImageMenuItemMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
+    ResolveImageMenuItemMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
+    ResolveImageMenuItemMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
+    ResolveImageMenuItemMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
+    ResolveImageMenuItemMethod "setRelatedAction" o = Gtk.Activatable.ActivatableSetRelatedActionMethodInfo
+    ResolveImageMenuItemMethod "setReserveIndicator" o = Gtk.MenuItem.MenuItemSetReserveIndicatorMethodInfo
+    ResolveImageMenuItemMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
+    ResolveImageMenuItemMethod "setRightJustified" o = Gtk.MenuItem.MenuItemSetRightJustifiedMethodInfo
+    ResolveImageMenuItemMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
+    ResolveImageMenuItemMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
+    ResolveImageMenuItemMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
+    ResolveImageMenuItemMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
+    ResolveImageMenuItemMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
+    ResolveImageMenuItemMethod "setSubmenu" o = Gtk.MenuItem.MenuItemSetSubmenuMethodInfo
+    ResolveImageMenuItemMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
+    ResolveImageMenuItemMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
+    ResolveImageMenuItemMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
+    ResolveImageMenuItemMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
+    ResolveImageMenuItemMethod "setUseActionAppearance" o = Gtk.Activatable.ActivatableSetUseActionAppearanceMethodInfo
+    ResolveImageMenuItemMethod "setUseUnderline" o = Gtk.MenuItem.MenuItemSetUseUnderlineMethodInfo
+    ResolveImageMenuItemMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
+    ResolveImageMenuItemMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
+    ResolveImageMenuItemMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
+    ResolveImageMenuItemMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
+    ResolveImageMenuItemMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
+    ResolveImageMenuItemMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
+    ResolveImageMenuItemMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolveImageMenuItemMethod t ImageMenuItem, O.MethodInfo info ImageMenuItem p) => OL.IsLabel t (ImageMenuItem -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList ImageMenuItem
+type instance O.AttributeList ImageMenuItem = ImageMenuItemAttributeList
+type ImageMenuItemAttributeList = ('[ '("accelPath", Gtk.MenuItem.MenuItemAccelPathPropertyInfo), '("actionName", Gtk.Actionable.ActionableActionNamePropertyInfo), '("actionTarget", Gtk.Actionable.ActionableActionTargetPropertyInfo), '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("label", Gtk.MenuItem.MenuItemLabelPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("relatedAction", Gtk.Activatable.ActivatableRelatedActionPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("rightJustified", Gtk.MenuItem.MenuItemRightJustifiedPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("submenu", Gtk.MenuItem.MenuItemSubmenuPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("useActionAppearance", Gtk.Activatable.ActivatableUseActionAppearancePropertyInfo), '("useUnderline", Gtk.MenuItem.MenuItemUseUnderlinePropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+#endif
+
+#if ENABLE_OVERLOADING
+type instance O.SignalList ImageMenuItem = ImageMenuItemSignalList
+type ImageMenuItemSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activate", Gtk.MenuItem.MenuItemActivateSignalInfo), '("activateItem", Gtk.MenuItem.MenuItemActivateItemSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("deselect", Gtk.MenuItem.MenuItemDeselectSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("select", Gtk.MenuItem.MenuItemSelectSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("toggleSizeAllocate", Gtk.MenuItem.MenuItemToggleSizeAllocateSignalInfo), '("toggleSizeRequest", Gtk.MenuItem.MenuItemToggleSizeRequestSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])
+
+#endif
+
+-- method ImageMenuItem::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_image_menu_item_new" wnck_image_menu_item_new :: 
+    IO (Ptr ImageMenuItem)
+
+{- |
+/No description available in the introspection data./
+-}
+imageMenuItemNew ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    m ImageMenuItem
+imageMenuItemNew  = liftIO $ do
+    result <- wnck_image_menu_item_new
+    checkUnexpectedReturnNULL "imageMenuItemNew" result
+    result' <- (newObject ImageMenuItem) result
+    return result'
+
+#if ENABLE_OVERLOADING
+#endif
+
+-- method ImageMenuItem::new_with_label
+-- method type : Constructor
+-- Args : [Arg {argCName = "label", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_image_menu_item_new_with_label" wnck_image_menu_item_new_with_label :: 
+    CString ->                              -- label : TBasicType TUTF8
+    IO (Ptr ImageMenuItem)
+
+{- |
+/No description available in the introspection data./
+-}
+imageMenuItemNewWithLabel ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    T.Text
+    -> m ImageMenuItem
+imageMenuItemNewWithLabel label = liftIO $ do
+    label' <- textToCString label
+    result <- wnck_image_menu_item_new_with_label label'
+    checkUnexpectedReturnNULL "imageMenuItemNewWithLabel" result
+    result' <- (newObject ImageMenuItem) result
+    freeMem label'
+    return result'
+
+#if ENABLE_OVERLOADING
+#endif
+
+-- method ImageMenuItem::make_label_bold
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_image_menu_item_make_label_bold" wnck_image_menu_item_make_label_bold :: 
+    Ptr ImageMenuItem ->                    -- item : TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"})
+    IO ()
+
+{- |
+/No description available in the introspection data./
+-}
+imageMenuItemMakeLabelBold ::
+    (B.CallStack.HasCallStack, MonadIO m, IsImageMenuItem a) =>
+    a
+    -> m ()
+imageMenuItemMakeLabelBold item = liftIO $ do
+    item' <- unsafeManagedPtrCastPtr item
+    wnck_image_menu_item_make_label_bold item'
+    touchManagedPtr item
+    return ()
+
+#if ENABLE_OVERLOADING
+data ImageMenuItemMakeLabelBoldMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsImageMenuItem a) => O.MethodInfo ImageMenuItemMakeLabelBoldMethodInfo a signature where
+    overloadedMethod _ = imageMenuItemMakeLabelBold
+
+#endif
+
+-- method ImageMenuItem::make_label_normal
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_image_menu_item_make_label_normal" wnck_image_menu_item_make_label_normal :: 
+    Ptr ImageMenuItem ->                    -- item : TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"})
+    IO ()
+
+{- |
+/No description available in the introspection data./
+-}
+imageMenuItemMakeLabelNormal ::
+    (B.CallStack.HasCallStack, MonadIO m, IsImageMenuItem a) =>
+    a
+    -> m ()
+imageMenuItemMakeLabelNormal item = liftIO $ do
+    item' <- unsafeManagedPtrCastPtr item
+    wnck_image_menu_item_make_label_normal item'
+    touchManagedPtr item
+    return ()
+
+#if ENABLE_OVERLOADING
+data ImageMenuItemMakeLabelNormalMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsImageMenuItem a) => O.MethodInfo ImageMenuItemMakeLabelNormalMethodInfo a signature where
+    overloadedMethod _ = imageMenuItemMakeLabelNormal
+
+#endif
+
+-- method ImageMenuItem::set_image_from_icon_pixbuf
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pixbuf", argType = TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_image_menu_item_set_image_from_icon_pixbuf" wnck_image_menu_item_set_image_from_icon_pixbuf :: 
+    Ptr ImageMenuItem ->                    -- item : TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"})
+    Ptr GdkPixbuf.Pixbuf.Pixbuf ->          -- pixbuf : TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"})
+    IO ()
+
+{- |
+/No description available in the introspection data./
+-}
+imageMenuItemSetImageFromIconPixbuf ::
+    (B.CallStack.HasCallStack, MonadIO m, IsImageMenuItem a, GdkPixbuf.Pixbuf.IsPixbuf b) =>
+    a
+    -> b
+    -> m ()
+imageMenuItemSetImageFromIconPixbuf item pixbuf = liftIO $ do
+    item' <- unsafeManagedPtrCastPtr item
+    pixbuf' <- unsafeManagedPtrCastPtr pixbuf
+    wnck_image_menu_item_set_image_from_icon_pixbuf item' pixbuf'
+    touchManagedPtr item
+    touchManagedPtr pixbuf
+    return ()
+
+#if ENABLE_OVERLOADING
+data ImageMenuItemSetImageFromIconPixbufMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, IsImageMenuItem a, GdkPixbuf.Pixbuf.IsPixbuf b) => O.MethodInfo ImageMenuItemSetImageFromIconPixbufMethodInfo a signature where
+    overloadedMethod _ = imageMenuItemSetImageFromIconPixbuf
+
+#endif
+
+-- method ImageMenuItem::set_image_from_window
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "item", argType = TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Nothing, sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_image_menu_item_set_image_from_window" wnck_image_menu_item_set_image_from_window :: 
+    Ptr ImageMenuItem ->                    -- item : TInterface (Name {namespace = "Wnck", name = "ImageMenuItem"})
+    Ptr Wnck.Window.Window ->               -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+/No description available in the introspection data./
+-}
+imageMenuItemSetImageFromWindow ::
+    (B.CallStack.HasCallStack, MonadIO m, IsImageMenuItem a, Wnck.Window.IsWindow b) =>
+    a
+    -> b
+    -> m ()
+imageMenuItemSetImageFromWindow item window = liftIO $ do
+    item' <- unsafeManagedPtrCastPtr item
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_image_menu_item_set_image_from_window item' window'
+    touchManagedPtr item
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data ImageMenuItemSetImageFromWindowMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, IsImageMenuItem a, Wnck.Window.IsWindow b) => O.MethodInfo ImageMenuItemSetImageFromWindowMethodInfo a signature where
+    overloadedMethod _ = imageMenuItemSetImageFromWindow
+
+#endif
+
+
diff --git a/GI/Wnck/Objects/ImageMenuItem.hs-boot b/GI/Wnck/Objects/ImageMenuItem.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/ImageMenuItem.hs-boot
@@ -0,0 +1,41 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Objects.ImageMenuItem where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype ImageMenuItem = ImageMenuItem (ManagedPtr ImageMenuItem)
+instance GObject ImageMenuItem where
+class (GObject o, O.IsDescendantOf ImageMenuItem o) => IsImageMenuItem o
+instance (GObject o, O.IsDescendantOf ImageMenuItem o) => IsImageMenuItem o
+instance O.HasParentTypes ImageMenuItem
+#if ENABLE_OVERLOADING
+data ImageMenuItemMakeLabelBoldMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ImageMenuItemMakeLabelNormalMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ImageMenuItemSetImageFromIconPixbufMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ImageMenuItemSetImageFromWindowMethodInfo
+#endif
diff --git a/GI/Wnck/Objects/Pager.hs b/GI/Wnck/Objects/Pager.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Pager.hs
@@ -0,0 +1,798 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+The 'GI.Wnck.Objects.Pager.Pager' struct contains only private fields and should not be
+directly accessed.
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Objects.Pager
+    ( 
+
+-- * Exported types
+    Pager(..)                               ,
+    IsPager                                 ,
+    toPager                                 ,
+    noPager                                 ,
+
+
+ -- * Methods
+-- ** getWrapOnScroll #method:getWrapOnScroll#
+
+#if ENABLE_OVERLOADING
+    PagerGetWrapOnScrollMethodInfo          ,
+#endif
+    pagerGetWrapOnScroll                    ,
+
+
+-- ** new #method:new#
+
+    pagerNew                                ,
+
+
+-- ** setDisplayMode #method:setDisplayMode#
+
+#if ENABLE_OVERLOADING
+    PagerSetDisplayModeMethodInfo           ,
+#endif
+    pagerSetDisplayMode                     ,
+
+
+-- ** setNRows #method:setNRows#
+
+#if ENABLE_OVERLOADING
+    PagerSetNRowsMethodInfo                 ,
+#endif
+    pagerSetNRows                           ,
+
+
+-- ** setOrientation #method:setOrientation#
+
+#if ENABLE_OVERLOADING
+    PagerSetOrientationMethodInfo           ,
+#endif
+    pagerSetOrientation                     ,
+
+
+-- ** setShadowType #method:setShadowType#
+
+#if ENABLE_OVERLOADING
+    PagerSetShadowTypeMethodInfo            ,
+#endif
+    pagerSetShadowType                      ,
+
+
+-- ** setShowAll #method:setShowAll#
+
+#if ENABLE_OVERLOADING
+    PagerSetShowAllMethodInfo               ,
+#endif
+    pagerSetShowAll                         ,
+
+
+-- ** setWrapOnScroll #method:setWrapOnScroll#
+
+#if ENABLE_OVERLOADING
+    PagerSetWrapOnScrollMethodInfo          ,
+#endif
+    pagerSetWrapOnScroll                    ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
+import qualified GI.GObject.Objects.Object as GObject.Object
+import qualified GI.Gtk.Enums as Gtk.Enums
+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
+import qualified GI.Gtk.Objects.Widget as Gtk.Widget
+import {-# SOURCE #-} qualified GI.Wnck.Enums as Wnck.Enums
+
+-- | Memory-managed wrapper type.
+newtype Pager = Pager (ManagedPtr Pager)
+foreign import ccall "wnck_pager_get_type"
+    c_wnck_pager_get_type :: IO GType
+
+instance GObject Pager where
+    gobjectType = c_wnck_pager_get_type
+    
+
+-- | Type class for types which can be safely cast to `Pager`, for instance with `toPager`.
+class (GObject o, O.IsDescendantOf Pager o) => IsPager o
+instance (GObject o, O.IsDescendantOf Pager o) => IsPager o
+
+instance O.HasParentTypes Pager
+type instance O.ParentTypes Pager = '[Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]
+
+-- | Cast to `Pager`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
+toPager :: (MonadIO m, IsPager o) => o -> m Pager
+toPager = liftIO . unsafeCastTo Pager
+
+-- | A convenience alias for `Nothing` :: `Maybe` `Pager`.
+noPager :: Maybe Pager
+noPager = Nothing
+
+#if ENABLE_OVERLOADING
+type family ResolvePagerMethod (t :: Symbol) (o :: *) :: * where
+    ResolvePagerMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
+    ResolvePagerMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
+    ResolvePagerMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
+    ResolvePagerMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
+    ResolvePagerMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
+    ResolvePagerMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
+    ResolvePagerMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
+    ResolvePagerMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
+    ResolvePagerMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
+    ResolvePagerMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
+    ResolvePagerMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
+    ResolvePagerMethod "childNotify" o = Gtk.Widget.WidgetChildNotifyMethodInfo
+    ResolvePagerMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
+    ResolvePagerMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
+    ResolvePagerMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
+    ResolvePagerMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
+    ResolvePagerMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
+    ResolvePagerMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
+    ResolvePagerMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
+    ResolvePagerMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
+    ResolvePagerMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
+    ResolvePagerMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
+    ResolvePagerMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
+    ResolvePagerMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
+    ResolvePagerMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
+    ResolvePagerMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
+    ResolvePagerMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
+    ResolvePagerMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
+    ResolvePagerMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
+    ResolvePagerMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
+    ResolvePagerMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
+    ResolvePagerMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
+    ResolvePagerMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
+    ResolvePagerMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
+    ResolvePagerMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
+    ResolvePagerMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
+    ResolvePagerMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
+    ResolvePagerMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
+    ResolvePagerMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
+    ResolvePagerMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
+    ResolvePagerMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
+    ResolvePagerMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
+    ResolvePagerMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
+    ResolvePagerMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
+    ResolvePagerMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
+    ResolvePagerMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
+    ResolvePagerMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
+    ResolvePagerMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
+    ResolvePagerMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
+    ResolvePagerMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
+    ResolvePagerMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
+    ResolvePagerMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
+    ResolvePagerMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
+    ResolvePagerMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
+    ResolvePagerMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
+    ResolvePagerMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
+    ResolvePagerMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
+    ResolvePagerMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
+    ResolvePagerMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
+    ResolvePagerMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
+    ResolvePagerMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
+    ResolvePagerMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
+    ResolvePagerMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
+    ResolvePagerMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
+    ResolvePagerMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
+    ResolvePagerMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
+    ResolvePagerMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
+    ResolvePagerMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
+    ResolvePagerMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
+    ResolvePagerMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
+    ResolvePagerMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
+    ResolvePagerMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
+    ResolvePagerMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
+    ResolvePagerMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
+    ResolvePagerMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
+    ResolvePagerMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
+    ResolvePagerMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
+    ResolvePagerMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
+    ResolvePagerMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
+    ResolvePagerMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
+    ResolvePagerMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
+    ResolvePagerMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
+    ResolvePagerMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
+    ResolvePagerMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
+    ResolvePagerMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
+    ResolvePagerMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
+    ResolvePagerMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
+    ResolvePagerMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
+    ResolvePagerMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
+    ResolvePagerMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
+    ResolvePagerMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
+    ResolvePagerMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
+    ResolvePagerMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
+    ResolvePagerMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
+    ResolvePagerMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
+    ResolvePagerMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
+    ResolvePagerMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
+    ResolvePagerMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
+    ResolvePagerMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
+    ResolvePagerMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
+    ResolvePagerMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
+    ResolvePagerMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
+    ResolvePagerMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
+    ResolvePagerMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
+    ResolvePagerMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
+    ResolvePagerMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
+    ResolvePagerMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
+    ResolvePagerMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
+    ResolvePagerMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
+    ResolvePagerMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
+    ResolvePagerMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
+    ResolvePagerMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
+    ResolvePagerMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
+    ResolvePagerMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
+    ResolvePagerMethod "ref" o = GObject.Object.ObjectRefMethodInfo
+    ResolvePagerMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
+    ResolvePagerMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
+    ResolvePagerMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
+    ResolvePagerMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
+    ResolvePagerMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
+    ResolvePagerMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
+    ResolvePagerMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
+    ResolvePagerMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
+    ResolvePagerMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
+    ResolvePagerMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
+    ResolvePagerMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
+    ResolvePagerMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
+    ResolvePagerMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
+    ResolvePagerMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
+    ResolvePagerMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
+    ResolvePagerMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
+    ResolvePagerMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
+    ResolvePagerMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
+    ResolvePagerMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
+    ResolvePagerMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
+    ResolvePagerMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
+    ResolvePagerMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
+    ResolvePagerMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
+    ResolvePagerMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
+    ResolvePagerMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
+    ResolvePagerMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
+    ResolvePagerMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
+    ResolvePagerMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
+    ResolvePagerMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
+    ResolvePagerMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
+    ResolvePagerMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
+    ResolvePagerMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
+    ResolvePagerMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
+    ResolvePagerMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
+    ResolvePagerMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
+    ResolvePagerMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
+    ResolvePagerMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
+    ResolvePagerMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
+    ResolvePagerMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
+    ResolvePagerMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
+    ResolvePagerMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
+    ResolvePagerMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
+    ResolvePagerMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
+    ResolvePagerMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
+    ResolvePagerMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
+    ResolvePagerMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
+    ResolvePagerMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
+    ResolvePagerMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
+    ResolvePagerMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
+    ResolvePagerMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
+    ResolvePagerMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
+    ResolvePagerMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
+    ResolvePagerMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
+    ResolvePagerMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
+    ResolvePagerMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
+    ResolvePagerMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
+    ResolvePagerMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
+    ResolvePagerMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
+    ResolvePagerMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
+    ResolvePagerMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
+    ResolvePagerMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
+    ResolvePagerMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
+    ResolvePagerMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
+    ResolvePagerMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
+    ResolvePagerMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
+    ResolvePagerMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
+    ResolvePagerMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
+    ResolvePagerMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
+    ResolvePagerMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
+    ResolvePagerMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
+    ResolvePagerMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
+    ResolvePagerMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
+    ResolvePagerMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
+    ResolvePagerMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
+    ResolvePagerMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
+    ResolvePagerMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
+    ResolvePagerMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
+    ResolvePagerMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
+    ResolvePagerMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
+    ResolvePagerMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
+    ResolvePagerMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
+    ResolvePagerMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
+    ResolvePagerMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
+    ResolvePagerMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
+    ResolvePagerMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
+    ResolvePagerMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
+    ResolvePagerMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
+    ResolvePagerMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
+    ResolvePagerMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
+    ResolvePagerMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
+    ResolvePagerMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
+    ResolvePagerMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
+    ResolvePagerMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
+    ResolvePagerMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
+    ResolvePagerMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
+    ResolvePagerMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
+    ResolvePagerMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
+    ResolvePagerMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
+    ResolvePagerMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
+    ResolvePagerMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
+    ResolvePagerMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
+    ResolvePagerMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
+    ResolvePagerMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
+    ResolvePagerMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
+    ResolvePagerMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
+    ResolvePagerMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
+    ResolvePagerMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
+    ResolvePagerMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
+    ResolvePagerMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
+    ResolvePagerMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
+    ResolvePagerMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
+    ResolvePagerMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
+    ResolvePagerMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
+    ResolvePagerMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
+    ResolvePagerMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
+    ResolvePagerMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
+    ResolvePagerMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
+    ResolvePagerMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
+    ResolvePagerMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
+    ResolvePagerMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
+    ResolvePagerMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
+    ResolvePagerMethod "getWrapOnScroll" o = PagerGetWrapOnScrollMethodInfo
+    ResolvePagerMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
+    ResolvePagerMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
+    ResolvePagerMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
+    ResolvePagerMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
+    ResolvePagerMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
+    ResolvePagerMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
+    ResolvePagerMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
+    ResolvePagerMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
+    ResolvePagerMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
+    ResolvePagerMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
+    ResolvePagerMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
+    ResolvePagerMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
+    ResolvePagerMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
+    ResolvePagerMethod "setDisplayMode" o = PagerSetDisplayModeMethodInfo
+    ResolvePagerMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
+    ResolvePagerMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
+    ResolvePagerMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
+    ResolvePagerMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
+    ResolvePagerMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
+    ResolvePagerMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
+    ResolvePagerMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
+    ResolvePagerMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
+    ResolvePagerMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
+    ResolvePagerMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
+    ResolvePagerMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
+    ResolvePagerMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
+    ResolvePagerMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
+    ResolvePagerMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
+    ResolvePagerMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
+    ResolvePagerMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
+    ResolvePagerMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
+    ResolvePagerMethod "setNRows" o = PagerSetNRowsMethodInfo
+    ResolvePagerMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
+    ResolvePagerMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
+    ResolvePagerMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
+    ResolvePagerMethod "setOrientation" o = PagerSetOrientationMethodInfo
+    ResolvePagerMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
+    ResolvePagerMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
+    ResolvePagerMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
+    ResolvePagerMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
+    ResolvePagerMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
+    ResolvePagerMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
+    ResolvePagerMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
+    ResolvePagerMethod "setShadowType" o = PagerSetShadowTypeMethodInfo
+    ResolvePagerMethod "setShowAll" o = PagerSetShowAllMethodInfo
+    ResolvePagerMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
+    ResolvePagerMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
+    ResolvePagerMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
+    ResolvePagerMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
+    ResolvePagerMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
+    ResolvePagerMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
+    ResolvePagerMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
+    ResolvePagerMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
+    ResolvePagerMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
+    ResolvePagerMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
+    ResolvePagerMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
+    ResolvePagerMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
+    ResolvePagerMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
+    ResolvePagerMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
+    ResolvePagerMethod "setWrapOnScroll" o = PagerSetWrapOnScrollMethodInfo
+    ResolvePagerMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolvePagerMethod t Pager, O.MethodInfo info Pager p) => OL.IsLabel t (Pager -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList Pager
+type instance O.AttributeList Pager = PagerAttributeList
+type PagerAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+#endif
+
+#if ENABLE_OVERLOADING
+type instance O.SignalList Pager = PagerSignalList
+type PagerSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])
+
+#endif
+
+-- method Pager::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Pager"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_pager_new" wnck_pager_new :: 
+    IO (Ptr Pager)
+
+{- |
+Creates a new 'GI.Wnck.Objects.Pager.Pager'. The 'GI.Wnck.Objects.Pager.Pager' will show the 'GI.Wnck.Objects.Workspace.Workspace' of the
+'GI.Wnck.Objects.Screen.Screen' it is on.
+-}
+pagerNew ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    m Pager
+    {- ^ __Returns:__ a newly created 'GI.Wnck.Objects.Pager.Pager'. -}
+pagerNew  = liftIO $ do
+    result <- wnck_pager_new
+    checkUnexpectedReturnNULL "pagerNew" result
+    result' <- (newObject Pager) result
+    return result'
+
+#if ENABLE_OVERLOADING
+#endif
+
+-- method Pager::get_wrap_on_scroll
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_pager_get_wrap_on_scroll" wnck_pager_get_wrap_on_scroll :: 
+    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})
+    IO CInt
+
+{- |
+/No description available in the introspection data./
+
+/Since: 3.24.0/
+-}
+pagerGetWrapOnScroll ::
+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>
+    a
+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if the /@pager@/ wraps workspaces on a scroll event that
+hits a border, 'False' otherwise. -}
+pagerGetWrapOnScroll pager = liftIO $ do
+    pager' <- unsafeManagedPtrCastPtr pager
+    result <- wnck_pager_get_wrap_on_scroll pager'
+    let result' = (/= 0) result
+    touchManagedPtr pager
+    return result'
+
+#if ENABLE_OVERLOADING
+data PagerGetWrapOnScrollMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsPager a) => O.MethodInfo PagerGetWrapOnScrollMethodInfo a signature where
+    overloadedMethod _ = pagerGetWrapOnScroll
+
+#endif
+
+-- method Pager::set_display_mode
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Wnck", name = "PagerDisplayMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a display mode.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_pager_set_display_mode" wnck_pager_set_display_mode :: 
+    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})
+    CUInt ->                                -- mode : TInterface (Name {namespace = "Wnck", name = "PagerDisplayMode"})
+    IO ()
+
+{- |
+Sets the display mode for /@pager@/ to /@mode@/.
+-}
+pagerSetDisplayMode ::
+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>
+    a
+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}
+    -> Wnck.Enums.PagerDisplayMode
+    {- ^ /@mode@/: a display mode. -}
+    -> m ()
+pagerSetDisplayMode pager mode = liftIO $ do
+    pager' <- unsafeManagedPtrCastPtr pager
+    let mode' = (fromIntegral . fromEnum) mode
+    wnck_pager_set_display_mode pager' mode'
+    touchManagedPtr pager
+    return ()
+
+#if ENABLE_OVERLOADING
+data PagerSetDisplayModeMethodInfo
+instance (signature ~ (Wnck.Enums.PagerDisplayMode -> m ()), MonadIO m, IsPager a) => O.MethodInfo PagerSetDisplayModeMethodInfo a signature where
+    overloadedMethod _ = pagerSetDisplayMode
+
+#endif
+
+-- method Pager::set_n_rows
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_rows", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of rows to use for the layout of #WnckWorkspace on the\n#WnckScreen @pager is watching.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_pager_set_n_rows" wnck_pager_set_n_rows :: 
+    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})
+    Int32 ->                                -- n_rows : TBasicType TInt
+    IO CInt
+
+{- |
+Tries to change the number of rows in the layout of 'GI.Wnck.Objects.Workspace.Workspace' on the
+'GI.Wnck.Objects.Screen.Screen' /@pager@/ is watching. Since no more than one application should
+set this property of a 'GI.Wnck.Objects.Screen.Screen' at a time, setting the layout is not
+guaranteed to work.
+
+If /@pager@/ has not been added to a widget hierarchy, the call will fail
+because /@pager@/ can\'t know the screen on which to modify the layout.
+-}
+pagerSetNRows ::
+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>
+    a
+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}
+    -> Int32
+    {- ^ /@nRows@/: the number of rows to use for the layout of 'GI.Wnck.Objects.Workspace.Workspace' on the
+'GI.Wnck.Objects.Screen.Screen' /@pager@/ is watching. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if the layout of 'GI.Wnck.Objects.Workspace.Workspace' has been successfully
+changed or did not need to be changed, 'False' otherwise. -}
+pagerSetNRows pager nRows = liftIO $ do
+    pager' <- unsafeManagedPtrCastPtr pager
+    result <- wnck_pager_set_n_rows pager' nRows
+    let result' = (/= 0) result
+    touchManagedPtr pager
+    return result'
+
+#if ENABLE_OVERLOADING
+data PagerSetNRowsMethodInfo
+instance (signature ~ (Int32 -> m Bool), MonadIO m, IsPager a) => O.MethodInfo PagerSetNRowsMethodInfo a signature where
+    overloadedMethod _ = pagerSetNRows
+
+#endif
+
+-- method Pager::set_orientation
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "orientation", argType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "orientation to use for the layout of #WnckWorkspace on the\n#WnckScreen @pager is watching.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_pager_set_orientation" wnck_pager_set_orientation :: 
+    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})
+    CUInt ->                                -- orientation : TInterface (Name {namespace = "Gtk", name = "Orientation"})
+    IO CInt
+
+{- |
+Tries to change the orientation of the layout of 'GI.Wnck.Objects.Workspace.Workspace' on the
+'GI.Wnck.Objects.Screen.Screen' /@pager@/ is watching. Since no more than one application should
+set this property of a 'GI.Wnck.Objects.Screen.Screen' at a time, setting the layout is not
+guaranteed to work.
+
+If /@orientation@/ is 'GI.Gtk.Enums.OrientationHorizontal', the 'GI.Wnck.Objects.Workspace.Workspace' will be
+laid out in rows, with the first 'GI.Wnck.Objects.Workspace.Workspace' in the top left corner.
+
+If /@orientation@/ is 'GI.Gtk.Enums.OrientationVertical', the 'GI.Wnck.Objects.Workspace.Workspace' will be
+laid out in columns, with the first 'GI.Wnck.Objects.Workspace.Workspace' in the top left corner.
+
+For example, if the layout contains one row, but the orientation of the
+layout is vertical, the 'GI.Wnck.Objects.Pager.Pager' will display a column of 'GI.Wnck.Objects.Workspace.Workspace'.
+
+Note that setting the orientation will have an effect on the geometry
+management: if /@orientation@/ is 'GI.Gtk.Enums.OrientationHorizontal',
+'GI.Gtk.Enums.SizeRequestModeWidthForHeight' will be used as request mode; if
+/@orientation@/ is 'GI.Gtk.Enums.OrientationVertical', GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH
+will be used instead.
+
+If /@pager@/ has not been added to a widget hierarchy, the call will fail
+because /@pager@/ can\'t know the screen on which to modify the orientation.
+-}
+pagerSetOrientation ::
+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>
+    a
+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}
+    -> Gtk.Enums.Orientation
+    {- ^ /@orientation@/: orientation to use for the layout of 'GI.Wnck.Objects.Workspace.Workspace' on the
+'GI.Wnck.Objects.Screen.Screen' /@pager@/ is watching. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if the layout of 'GI.Wnck.Objects.Workspace.Workspace' has been successfully
+changed or did not need to be changed, 'False' otherwise. -}
+pagerSetOrientation pager orientation = liftIO $ do
+    pager' <- unsafeManagedPtrCastPtr pager
+    let orientation' = (fromIntegral . fromEnum) orientation
+    result <- wnck_pager_set_orientation pager' orientation'
+    let result' = (/= 0) result
+    touchManagedPtr pager
+    return result'
+
+#if ENABLE_OVERLOADING
+data PagerSetOrientationMethodInfo
+instance (signature ~ (Gtk.Enums.Orientation -> m Bool), MonadIO m, IsPager a) => O.MethodInfo PagerSetOrientationMethodInfo a signature where
+    overloadedMethod _ = pagerSetOrientation
+
+#endif
+
+-- method Pager::set_shadow_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shadow_type", argType = TInterface (Name {namespace = "Gtk", name = "ShadowType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a shadow type.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_pager_set_shadow_type" wnck_pager_set_shadow_type :: 
+    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})
+    CUInt ->                                -- shadow_type : TInterface (Name {namespace = "Gtk", name = "ShadowType"})
+    IO ()
+
+{- |
+Sets the shadow type for /@pager@/ to /@shadowType@/. The main use of this
+function is proper integration of 'GI.Wnck.Objects.Pager.Pager' in panels with non-system
+backgrounds.
+
+/Since: 2.2/
+-}
+pagerSetShadowType ::
+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>
+    a
+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}
+    -> Gtk.Enums.ShadowType
+    {- ^ /@shadowType@/: a shadow type. -}
+    -> m ()
+pagerSetShadowType pager shadowType = liftIO $ do
+    pager' <- unsafeManagedPtrCastPtr pager
+    let shadowType' = (fromIntegral . fromEnum) shadowType
+    wnck_pager_set_shadow_type pager' shadowType'
+    touchManagedPtr pager
+    return ()
+
+#if ENABLE_OVERLOADING
+data PagerSetShadowTypeMethodInfo
+instance (signature ~ (Gtk.Enums.ShadowType -> m ()), MonadIO m, IsPager a) => O.MethodInfo PagerSetShadowTypeMethodInfo a signature where
+    overloadedMethod _ = pagerSetShadowType
+
+#endif
+
+-- method Pager::set_show_all
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show_all_workspaces", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to display all #WnckWorkspace in @pager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_pager_set_show_all" wnck_pager_set_show_all :: 
+    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})
+    CInt ->                                 -- show_all_workspaces : TBasicType TBoolean
+    IO ()
+
+{- |
+Sets /@pager@/ to display all 'GI.Wnck.Objects.Workspace.Workspace' or not, according to
+/@showAllWorkspaces@/.
+-}
+pagerSetShowAll ::
+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>
+    a
+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}
+    -> Bool
+    {- ^ /@showAllWorkspaces@/: whether to display all 'GI.Wnck.Objects.Workspace.Workspace' in /@pager@/. -}
+    -> m ()
+pagerSetShowAll pager showAllWorkspaces = liftIO $ do
+    pager' <- unsafeManagedPtrCastPtr pager
+    let showAllWorkspaces' = (fromIntegral . fromEnum) showAllWorkspaces
+    wnck_pager_set_show_all pager' showAllWorkspaces'
+    touchManagedPtr pager
+    return ()
+
+#if ENABLE_OVERLOADING
+data PagerSetShowAllMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, IsPager a) => O.MethodInfo PagerSetShowAllMethodInfo a signature where
+    overloadedMethod _ = pagerSetShowAll
+
+#endif
+
+-- method Pager::set_wrap_on_scroll
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "pager", argType = TInterface (Name {namespace = "Wnck", name = "Pager"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckPager.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wrap_on_scroll", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a boolean.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_pager_set_wrap_on_scroll" wnck_pager_set_wrap_on_scroll :: 
+    Ptr Pager ->                            -- pager : TInterface (Name {namespace = "Wnck", name = "Pager"})
+    CInt ->                                 -- wrap_on_scroll : TBasicType TBoolean
+    IO ()
+
+{- |
+Sets the wrapping behavior of the /@pager@/. Setting it to 'True' will
+wrap arround to the start when scrolling over the end and vice
+versa. By default it is set to 'False'.
+
+/Since: 3.24.0/
+-}
+pagerSetWrapOnScroll ::
+    (B.CallStack.HasCallStack, MonadIO m, IsPager a) =>
+    a
+    {- ^ /@pager@/: a 'GI.Wnck.Objects.Pager.Pager'. -}
+    -> Bool
+    {- ^ /@wrapOnScroll@/: a boolean. -}
+    -> m ()
+pagerSetWrapOnScroll pager wrapOnScroll = liftIO $ do
+    pager' <- unsafeManagedPtrCastPtr pager
+    let wrapOnScroll' = (fromIntegral . fromEnum) wrapOnScroll
+    wnck_pager_set_wrap_on_scroll pager' wrapOnScroll'
+    touchManagedPtr pager
+    return ()
+
+#if ENABLE_OVERLOADING
+data PagerSetWrapOnScrollMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, IsPager a) => O.MethodInfo PagerSetWrapOnScrollMethodInfo a signature where
+    overloadedMethod _ = pagerSetWrapOnScroll
+
+#endif
+
+
diff --git a/GI/Wnck/Objects/Pager.hs-boot b/GI/Wnck/Objects/Pager.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Pager.hs-boot
@@ -0,0 +1,50 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Objects.Pager where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype Pager = Pager (ManagedPtr Pager)
+instance GObject Pager where
+class (GObject o, O.IsDescendantOf Pager o) => IsPager o
+instance (GObject o, O.IsDescendantOf Pager o) => IsPager o
+instance O.HasParentTypes Pager
+#if ENABLE_OVERLOADING
+data PagerGetWrapOnScrollMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data PagerSetDisplayModeMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data PagerSetNRowsMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data PagerSetOrientationMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data PagerSetShadowTypeMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data PagerSetShowAllMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data PagerSetWrapOnScrollMethodInfo
+#endif
diff --git a/GI/Wnck/Objects/Screen.hs b/GI/Wnck/Objects/Screen.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Screen.hs
@@ -0,0 +1,2754 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+The 'GI.Wnck.Objects.Screen.Screen' struct contains only private fields and should not be
+directly accessed.
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Objects.Screen
+    ( 
+
+-- * Exported types
+    Screen(..)                              ,
+    IsScreen                                ,
+    toScreen                                ,
+    noScreen                                ,
+
+
+ -- * Methods
+-- ** calcWorkspaceLayout #method:calcWorkspaceLayout#
+
+#if ENABLE_OVERLOADING
+    ScreenCalcWorkspaceLayoutMethodInfo     ,
+#endif
+    screenCalcWorkspaceLayout               ,
+
+
+-- ** changeWorkspaceCount #method:changeWorkspaceCount#
+
+#if ENABLE_OVERLOADING
+    ScreenChangeWorkspaceCountMethodInfo    ,
+#endif
+    screenChangeWorkspaceCount              ,
+
+
+-- ** forceUpdate #method:forceUpdate#
+
+#if ENABLE_OVERLOADING
+    ScreenForceUpdateMethodInfo             ,
+#endif
+    screenForceUpdate                       ,
+
+
+-- ** freeWorkspaceLayout #method:freeWorkspaceLayout#
+
+    screenFreeWorkspaceLayout               ,
+
+
+-- ** get #method:get#
+
+    screenGet                               ,
+
+
+-- ** getActiveWindow #method:getActiveWindow#
+
+#if ENABLE_OVERLOADING
+    ScreenGetActiveWindowMethodInfo         ,
+#endif
+    screenGetActiveWindow                   ,
+
+
+-- ** getActiveWorkspace #method:getActiveWorkspace#
+
+#if ENABLE_OVERLOADING
+    ScreenGetActiveWorkspaceMethodInfo      ,
+#endif
+    screenGetActiveWorkspace                ,
+
+
+-- ** getBackgroundPixmap #method:getBackgroundPixmap#
+
+#if ENABLE_OVERLOADING
+    ScreenGetBackgroundPixmapMethodInfo     ,
+#endif
+    screenGetBackgroundPixmap               ,
+
+
+-- ** getDefault #method:getDefault#
+
+    screenGetDefault                        ,
+
+
+-- ** getForRoot #method:getForRoot#
+
+    screenGetForRoot                        ,
+
+
+-- ** getHeight #method:getHeight#
+
+#if ENABLE_OVERLOADING
+    ScreenGetHeightMethodInfo               ,
+#endif
+    screenGetHeight                         ,
+
+
+-- ** getNumber #method:getNumber#
+
+#if ENABLE_OVERLOADING
+    ScreenGetNumberMethodInfo               ,
+#endif
+    screenGetNumber                         ,
+
+
+-- ** getPreviouslyActiveWindow #method:getPreviouslyActiveWindow#
+
+#if ENABLE_OVERLOADING
+    ScreenGetPreviouslyActiveWindowMethodInfo,
+#endif
+    screenGetPreviouslyActiveWindow         ,
+
+
+-- ** getShowingDesktop #method:getShowingDesktop#
+
+#if ENABLE_OVERLOADING
+    ScreenGetShowingDesktopMethodInfo       ,
+#endif
+    screenGetShowingDesktop                 ,
+
+
+-- ** getWidth #method:getWidth#
+
+#if ENABLE_OVERLOADING
+    ScreenGetWidthMethodInfo                ,
+#endif
+    screenGetWidth                          ,
+
+
+-- ** getWindowManagerName #method:getWindowManagerName#
+
+#if ENABLE_OVERLOADING
+    ScreenGetWindowManagerNameMethodInfo    ,
+#endif
+    screenGetWindowManagerName              ,
+
+
+-- ** getWindows #method:getWindows#
+
+#if ENABLE_OVERLOADING
+    ScreenGetWindowsMethodInfo              ,
+#endif
+    screenGetWindows                        ,
+
+
+-- ** getWindowsStacked #method:getWindowsStacked#
+
+#if ENABLE_OVERLOADING
+    ScreenGetWindowsStackedMethodInfo       ,
+#endif
+    screenGetWindowsStacked                 ,
+
+
+-- ** getWorkspace #method:getWorkspace#
+
+#if ENABLE_OVERLOADING
+    ScreenGetWorkspaceMethodInfo            ,
+#endif
+    screenGetWorkspace                      ,
+
+
+-- ** getWorkspaceCount #method:getWorkspaceCount#
+
+#if ENABLE_OVERLOADING
+    ScreenGetWorkspaceCountMethodInfo       ,
+#endif
+    screenGetWorkspaceCount                 ,
+
+
+-- ** getWorkspaces #method:getWorkspaces#
+
+#if ENABLE_OVERLOADING
+    ScreenGetWorkspacesMethodInfo           ,
+#endif
+    screenGetWorkspaces                     ,
+
+
+-- ** moveViewport #method:moveViewport#
+
+#if ENABLE_OVERLOADING
+    ScreenMoveViewportMethodInfo            ,
+#endif
+    screenMoveViewport                      ,
+
+
+-- ** netWmSupports #method:netWmSupports#
+
+#if ENABLE_OVERLOADING
+    ScreenNetWmSupportsMethodInfo           ,
+#endif
+    screenNetWmSupports                     ,
+
+
+-- ** releaseWorkspaceLayout #method:releaseWorkspaceLayout#
+
+#if ENABLE_OVERLOADING
+    ScreenReleaseWorkspaceLayoutMethodInfo  ,
+#endif
+    screenReleaseWorkspaceLayout            ,
+
+
+-- ** toggleShowingDesktop #method:toggleShowingDesktop#
+
+#if ENABLE_OVERLOADING
+    ScreenToggleShowingDesktopMethodInfo    ,
+#endif
+    screenToggleShowingDesktop              ,
+
+
+-- ** trySetWorkspaceLayout #method:trySetWorkspaceLayout#
+
+#if ENABLE_OVERLOADING
+    ScreenTrySetWorkspaceLayoutMethodInfo   ,
+#endif
+    screenTrySetWorkspaceLayout             ,
+
+
+
+
+ -- * Signals
+-- ** activeWindowChanged #signal:activeWindowChanged#
+
+    C_ScreenActiveWindowChangedCallback     ,
+    ScreenActiveWindowChangedCallback       ,
+#if ENABLE_OVERLOADING
+    ScreenActiveWindowChangedSignalInfo     ,
+#endif
+    afterScreenActiveWindowChanged          ,
+    genClosure_ScreenActiveWindowChanged    ,
+    mk_ScreenActiveWindowChangedCallback    ,
+    noScreenActiveWindowChangedCallback     ,
+    onScreenActiveWindowChanged             ,
+    wrap_ScreenActiveWindowChangedCallback  ,
+
+
+-- ** activeWorkspaceChanged #signal:activeWorkspaceChanged#
+
+    C_ScreenActiveWorkspaceChangedCallback  ,
+    ScreenActiveWorkspaceChangedCallback    ,
+#if ENABLE_OVERLOADING
+    ScreenActiveWorkspaceChangedSignalInfo  ,
+#endif
+    afterScreenActiveWorkspaceChanged       ,
+    genClosure_ScreenActiveWorkspaceChanged ,
+    mk_ScreenActiveWorkspaceChangedCallback ,
+    noScreenActiveWorkspaceChangedCallback  ,
+    onScreenActiveWorkspaceChanged          ,
+    wrap_ScreenActiveWorkspaceChangedCallback,
+
+
+-- ** applicationClosed #signal:applicationClosed#
+
+    C_ScreenApplicationClosedCallback       ,
+    ScreenApplicationClosedCallback         ,
+#if ENABLE_OVERLOADING
+    ScreenApplicationClosedSignalInfo       ,
+#endif
+    afterScreenApplicationClosed            ,
+    genClosure_ScreenApplicationClosed      ,
+    mk_ScreenApplicationClosedCallback      ,
+    noScreenApplicationClosedCallback       ,
+    onScreenApplicationClosed               ,
+    wrap_ScreenApplicationClosedCallback    ,
+
+
+-- ** applicationOpened #signal:applicationOpened#
+
+    C_ScreenApplicationOpenedCallback       ,
+    ScreenApplicationOpenedCallback         ,
+#if ENABLE_OVERLOADING
+    ScreenApplicationOpenedSignalInfo       ,
+#endif
+    afterScreenApplicationOpened            ,
+    genClosure_ScreenApplicationOpened      ,
+    mk_ScreenApplicationOpenedCallback      ,
+    noScreenApplicationOpenedCallback       ,
+    onScreenApplicationOpened               ,
+    wrap_ScreenApplicationOpenedCallback    ,
+
+
+-- ** backgroundChanged #signal:backgroundChanged#
+
+    C_ScreenBackgroundChangedCallback       ,
+    ScreenBackgroundChangedCallback         ,
+#if ENABLE_OVERLOADING
+    ScreenBackgroundChangedSignalInfo       ,
+#endif
+    afterScreenBackgroundChanged            ,
+    genClosure_ScreenBackgroundChanged      ,
+    mk_ScreenBackgroundChangedCallback      ,
+    noScreenBackgroundChangedCallback       ,
+    onScreenBackgroundChanged               ,
+    wrap_ScreenBackgroundChangedCallback    ,
+
+
+-- ** classGroupClosed #signal:classGroupClosed#
+
+    C_ScreenClassGroupClosedCallback        ,
+    ScreenClassGroupClosedCallback          ,
+#if ENABLE_OVERLOADING
+    ScreenClassGroupClosedSignalInfo        ,
+#endif
+    afterScreenClassGroupClosed             ,
+    genClosure_ScreenClassGroupClosed       ,
+    mk_ScreenClassGroupClosedCallback       ,
+    noScreenClassGroupClosedCallback        ,
+    onScreenClassGroupClosed                ,
+    wrap_ScreenClassGroupClosedCallback     ,
+
+
+-- ** classGroupOpened #signal:classGroupOpened#
+
+    C_ScreenClassGroupOpenedCallback        ,
+    ScreenClassGroupOpenedCallback          ,
+#if ENABLE_OVERLOADING
+    ScreenClassGroupOpenedSignalInfo        ,
+#endif
+    afterScreenClassGroupOpened             ,
+    genClosure_ScreenClassGroupOpened       ,
+    mk_ScreenClassGroupOpenedCallback       ,
+    noScreenClassGroupOpenedCallback        ,
+    onScreenClassGroupOpened                ,
+    wrap_ScreenClassGroupOpenedCallback     ,
+
+
+-- ** showingDesktopChanged #signal:showingDesktopChanged#
+
+    C_ScreenShowingDesktopChangedCallback   ,
+    ScreenShowingDesktopChangedCallback     ,
+#if ENABLE_OVERLOADING
+    ScreenShowingDesktopChangedSignalInfo   ,
+#endif
+    afterScreenShowingDesktopChanged        ,
+    genClosure_ScreenShowingDesktopChanged  ,
+    mk_ScreenShowingDesktopChangedCallback  ,
+    noScreenShowingDesktopChangedCallback   ,
+    onScreenShowingDesktopChanged           ,
+    wrap_ScreenShowingDesktopChangedCallback,
+
+
+-- ** viewportsChanged #signal:viewportsChanged#
+
+    C_ScreenViewportsChangedCallback        ,
+    ScreenViewportsChangedCallback          ,
+#if ENABLE_OVERLOADING
+    ScreenViewportsChangedSignalInfo        ,
+#endif
+    afterScreenViewportsChanged             ,
+    genClosure_ScreenViewportsChanged       ,
+    mk_ScreenViewportsChangedCallback       ,
+    noScreenViewportsChangedCallback        ,
+    onScreenViewportsChanged                ,
+    wrap_ScreenViewportsChangedCallback     ,
+
+
+-- ** windowClosed #signal:windowClosed#
+
+    C_ScreenWindowClosedCallback            ,
+    ScreenWindowClosedCallback              ,
+#if ENABLE_OVERLOADING
+    ScreenWindowClosedSignalInfo            ,
+#endif
+    afterScreenWindowClosed                 ,
+    genClosure_ScreenWindowClosed           ,
+    mk_ScreenWindowClosedCallback           ,
+    noScreenWindowClosedCallback            ,
+    onScreenWindowClosed                    ,
+    wrap_ScreenWindowClosedCallback         ,
+
+
+-- ** windowManagerChanged #signal:windowManagerChanged#
+
+    C_ScreenWindowManagerChangedCallback    ,
+    ScreenWindowManagerChangedCallback      ,
+#if ENABLE_OVERLOADING
+    ScreenWindowManagerChangedSignalInfo    ,
+#endif
+    afterScreenWindowManagerChanged         ,
+    genClosure_ScreenWindowManagerChanged   ,
+    mk_ScreenWindowManagerChangedCallback   ,
+    noScreenWindowManagerChangedCallback    ,
+    onScreenWindowManagerChanged            ,
+    wrap_ScreenWindowManagerChangedCallback ,
+
+
+-- ** windowOpened #signal:windowOpened#
+
+    C_ScreenWindowOpenedCallback            ,
+    ScreenWindowOpenedCallback              ,
+#if ENABLE_OVERLOADING
+    ScreenWindowOpenedSignalInfo            ,
+#endif
+    afterScreenWindowOpened                 ,
+    genClosure_ScreenWindowOpened           ,
+    mk_ScreenWindowOpenedCallback           ,
+    noScreenWindowOpenedCallback            ,
+    onScreenWindowOpened                    ,
+    wrap_ScreenWindowOpenedCallback         ,
+
+
+-- ** windowStackingChanged #signal:windowStackingChanged#
+
+    C_ScreenWindowStackingChangedCallback   ,
+    ScreenWindowStackingChangedCallback     ,
+#if ENABLE_OVERLOADING
+    ScreenWindowStackingChangedSignalInfo   ,
+#endif
+    afterScreenWindowStackingChanged        ,
+    genClosure_ScreenWindowStackingChanged  ,
+    mk_ScreenWindowStackingChangedCallback  ,
+    noScreenWindowStackingChangedCallback   ,
+    onScreenWindowStackingChanged           ,
+    wrap_ScreenWindowStackingChangedCallback,
+
+
+-- ** workspaceCreated #signal:workspaceCreated#
+
+    C_ScreenWorkspaceCreatedCallback        ,
+    ScreenWorkspaceCreatedCallback          ,
+#if ENABLE_OVERLOADING
+    ScreenWorkspaceCreatedSignalInfo        ,
+#endif
+    afterScreenWorkspaceCreated             ,
+    genClosure_ScreenWorkspaceCreated       ,
+    mk_ScreenWorkspaceCreatedCallback       ,
+    noScreenWorkspaceCreatedCallback        ,
+    onScreenWorkspaceCreated                ,
+    wrap_ScreenWorkspaceCreatedCallback     ,
+
+
+-- ** workspaceDestroyed #signal:workspaceDestroyed#
+
+    C_ScreenWorkspaceDestroyedCallback      ,
+    ScreenWorkspaceDestroyedCallback        ,
+#if ENABLE_OVERLOADING
+    ScreenWorkspaceDestroyedSignalInfo      ,
+#endif
+    afterScreenWorkspaceDestroyed           ,
+    genClosure_ScreenWorkspaceDestroyed     ,
+    mk_ScreenWorkspaceDestroyedCallback     ,
+    noScreenWorkspaceDestroyedCallback      ,
+    onScreenWorkspaceDestroyed              ,
+    wrap_ScreenWorkspaceDestroyedCallback   ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+import qualified GI.GObject.Objects.Object as GObject.Object
+import {-# SOURCE #-} qualified GI.Wnck.Objects.Application as Wnck.Application
+import {-# SOURCE #-} qualified GI.Wnck.Objects.ClassGroup as Wnck.ClassGroup
+import {-# SOURCE #-} qualified GI.Wnck.Objects.Window as Wnck.Window
+import {-# SOURCE #-} qualified GI.Wnck.Objects.Workspace as Wnck.Workspace
+import {-# SOURCE #-} qualified GI.Wnck.Structs.WorkspaceLayout as Wnck.WorkspaceLayout
+
+-- | Memory-managed wrapper type.
+newtype Screen = Screen (ManagedPtr Screen)
+foreign import ccall "wnck_screen_get_type"
+    c_wnck_screen_get_type :: IO GType
+
+instance GObject Screen where
+    gobjectType = c_wnck_screen_get_type
+    
+
+-- | Type class for types which can be safely cast to `Screen`, for instance with `toScreen`.
+class (GObject o, O.IsDescendantOf Screen o) => IsScreen o
+instance (GObject o, O.IsDescendantOf Screen o) => IsScreen o
+
+instance O.HasParentTypes Screen
+type instance O.ParentTypes Screen = '[GObject.Object.Object]
+
+-- | Cast to `Screen`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
+toScreen :: (MonadIO m, IsScreen o) => o -> m Screen
+toScreen = liftIO . unsafeCastTo Screen
+
+-- | A convenience alias for `Nothing` :: `Maybe` `Screen`.
+noScreen :: Maybe Screen
+noScreen = Nothing
+
+#if ENABLE_OVERLOADING
+type family ResolveScreenMethod (t :: Symbol) (o :: *) :: * where
+    ResolveScreenMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
+    ResolveScreenMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
+    ResolveScreenMethod "calcWorkspaceLayout" o = ScreenCalcWorkspaceLayoutMethodInfo
+    ResolveScreenMethod "changeWorkspaceCount" o = ScreenChangeWorkspaceCountMethodInfo
+    ResolveScreenMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
+    ResolveScreenMethod "forceUpdate" o = ScreenForceUpdateMethodInfo
+    ResolveScreenMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
+    ResolveScreenMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
+    ResolveScreenMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
+    ResolveScreenMethod "moveViewport" o = ScreenMoveViewportMethodInfo
+    ResolveScreenMethod "netWmSupports" o = ScreenNetWmSupportsMethodInfo
+    ResolveScreenMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
+    ResolveScreenMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
+    ResolveScreenMethod "ref" o = GObject.Object.ObjectRefMethodInfo
+    ResolveScreenMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
+    ResolveScreenMethod "releaseWorkspaceLayout" o = ScreenReleaseWorkspaceLayoutMethodInfo
+    ResolveScreenMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
+    ResolveScreenMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
+    ResolveScreenMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
+    ResolveScreenMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
+    ResolveScreenMethod "toggleShowingDesktop" o = ScreenToggleShowingDesktopMethodInfo
+    ResolveScreenMethod "trySetWorkspaceLayout" o = ScreenTrySetWorkspaceLayoutMethodInfo
+    ResolveScreenMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
+    ResolveScreenMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
+    ResolveScreenMethod "getActiveWindow" o = ScreenGetActiveWindowMethodInfo
+    ResolveScreenMethod "getActiveWorkspace" o = ScreenGetActiveWorkspaceMethodInfo
+    ResolveScreenMethod "getBackgroundPixmap" o = ScreenGetBackgroundPixmapMethodInfo
+    ResolveScreenMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
+    ResolveScreenMethod "getHeight" o = ScreenGetHeightMethodInfo
+    ResolveScreenMethod "getNumber" o = ScreenGetNumberMethodInfo
+    ResolveScreenMethod "getPreviouslyActiveWindow" o = ScreenGetPreviouslyActiveWindowMethodInfo
+    ResolveScreenMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
+    ResolveScreenMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
+    ResolveScreenMethod "getShowingDesktop" o = ScreenGetShowingDesktopMethodInfo
+    ResolveScreenMethod "getWidth" o = ScreenGetWidthMethodInfo
+    ResolveScreenMethod "getWindowManagerName" o = ScreenGetWindowManagerNameMethodInfo
+    ResolveScreenMethod "getWindows" o = ScreenGetWindowsMethodInfo
+    ResolveScreenMethod "getWindowsStacked" o = ScreenGetWindowsStackedMethodInfo
+    ResolveScreenMethod "getWorkspace" o = ScreenGetWorkspaceMethodInfo
+    ResolveScreenMethod "getWorkspaceCount" o = ScreenGetWorkspaceCountMethodInfo
+    ResolveScreenMethod "getWorkspaces" o = ScreenGetWorkspacesMethodInfo
+    ResolveScreenMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
+    ResolveScreenMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
+    ResolveScreenMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolveScreenMethod t Screen, O.MethodInfo info Screen p) => OL.IsLabel t (Screen -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+-- signal Screen::active-window-changed
+{- |
+Emitted when the active window on /@screen@/ has changed.
+-}
+type ScreenActiveWindowChangedCallback =
+    Wnck.Window.Window
+    {- ^ /@previouslyActiveWindow@/: the previously active 'GI.Wnck.Objects.Window.Window' before this
+change. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenActiveWindowChangedCallback`@.
+noScreenActiveWindowChangedCallback :: Maybe ScreenActiveWindowChangedCallback
+noScreenActiveWindowChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenActiveWindowChangedCallback =
+    Ptr () ->                               -- object
+    Ptr Wnck.Window.Window ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenActiveWindowChangedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenActiveWindowChangedCallback :: C_ScreenActiveWindowChangedCallback -> IO (FunPtr C_ScreenActiveWindowChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenActiveWindowChanged :: MonadIO m => ScreenActiveWindowChangedCallback -> m (GClosure C_ScreenActiveWindowChangedCallback)
+genClosure_ScreenActiveWindowChanged cb = liftIO $ do
+    let cb' = wrap_ScreenActiveWindowChangedCallback cb
+    mk_ScreenActiveWindowChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenActiveWindowChangedCallback` into a `C_ScreenActiveWindowChangedCallback`.
+wrap_ScreenActiveWindowChangedCallback ::
+    ScreenActiveWindowChangedCallback ->
+    C_ScreenActiveWindowChangedCallback
+wrap_ScreenActiveWindowChangedCallback _cb _ previouslyActiveWindow _ = do
+    previouslyActiveWindow' <- (newObject Wnck.Window.Window) previouslyActiveWindow
+    _cb  previouslyActiveWindow'
+
+
+{- |
+Connect a signal handler for the “@active-window-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #activeWindowChanged callback
+@
+-}
+onScreenActiveWindowChanged :: (IsScreen a, MonadIO m) => a -> ScreenActiveWindowChangedCallback -> m SignalHandlerId
+onScreenActiveWindowChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenActiveWindowChangedCallback cb
+    cb'' <- mk_ScreenActiveWindowChangedCallback cb'
+    connectSignalFunPtr obj "active-window-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@active-window-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #activeWindowChanged callback
+@
+-}
+afterScreenActiveWindowChanged :: (IsScreen a, MonadIO m) => a -> ScreenActiveWindowChangedCallback -> m SignalHandlerId
+afterScreenActiveWindowChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenActiveWindowChangedCallback cb
+    cb'' <- mk_ScreenActiveWindowChangedCallback cb'
+    connectSignalFunPtr obj "active-window-changed" cb'' SignalConnectAfter
+
+
+-- signal Screen::active-workspace-changed
+{- |
+Emitted when the active workspace on /@screen@/ has changed.
+-}
+type ScreenActiveWorkspaceChangedCallback =
+    Wnck.Workspace.Workspace
+    {- ^ /@previouslyActiveSpace@/: the previously active 'GI.Wnck.Objects.Workspace.Workspace' before this
+change. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenActiveWorkspaceChangedCallback`@.
+noScreenActiveWorkspaceChangedCallback :: Maybe ScreenActiveWorkspaceChangedCallback
+noScreenActiveWorkspaceChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenActiveWorkspaceChangedCallback =
+    Ptr () ->                               -- object
+    Ptr Wnck.Workspace.Workspace ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenActiveWorkspaceChangedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenActiveWorkspaceChangedCallback :: C_ScreenActiveWorkspaceChangedCallback -> IO (FunPtr C_ScreenActiveWorkspaceChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenActiveWorkspaceChanged :: MonadIO m => ScreenActiveWorkspaceChangedCallback -> m (GClosure C_ScreenActiveWorkspaceChangedCallback)
+genClosure_ScreenActiveWorkspaceChanged cb = liftIO $ do
+    let cb' = wrap_ScreenActiveWorkspaceChangedCallback cb
+    mk_ScreenActiveWorkspaceChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenActiveWorkspaceChangedCallback` into a `C_ScreenActiveWorkspaceChangedCallback`.
+wrap_ScreenActiveWorkspaceChangedCallback ::
+    ScreenActiveWorkspaceChangedCallback ->
+    C_ScreenActiveWorkspaceChangedCallback
+wrap_ScreenActiveWorkspaceChangedCallback _cb _ previouslyActiveSpace _ = do
+    previouslyActiveSpace' <- (newObject Wnck.Workspace.Workspace) previouslyActiveSpace
+    _cb  previouslyActiveSpace'
+
+
+{- |
+Connect a signal handler for the “@active-workspace-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #activeWorkspaceChanged callback
+@
+-}
+onScreenActiveWorkspaceChanged :: (IsScreen a, MonadIO m) => a -> ScreenActiveWorkspaceChangedCallback -> m SignalHandlerId
+onScreenActiveWorkspaceChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenActiveWorkspaceChangedCallback cb
+    cb'' <- mk_ScreenActiveWorkspaceChangedCallback cb'
+    connectSignalFunPtr obj "active-workspace-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@active-workspace-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #activeWorkspaceChanged callback
+@
+-}
+afterScreenActiveWorkspaceChanged :: (IsScreen a, MonadIO m) => a -> ScreenActiveWorkspaceChangedCallback -> m SignalHandlerId
+afterScreenActiveWorkspaceChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenActiveWorkspaceChangedCallback cb
+    cb'' <- mk_ScreenActiveWorkspaceChangedCallback cb'
+    connectSignalFunPtr obj "active-workspace-changed" cb'' SignalConnectAfter
+
+
+-- signal Screen::application-closed
+{- |
+Emitted when a 'GI.Wnck.Objects.Application.Application' is closed on /@screen@/.
+-}
+type ScreenApplicationClosedCallback =
+    Wnck.Application.Application
+    {- ^ /@app@/: the closed 'GI.Wnck.Objects.Application.Application'. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenApplicationClosedCallback`@.
+noScreenApplicationClosedCallback :: Maybe ScreenApplicationClosedCallback
+noScreenApplicationClosedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenApplicationClosedCallback =
+    Ptr () ->                               -- object
+    Ptr Wnck.Application.Application ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenApplicationClosedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenApplicationClosedCallback :: C_ScreenApplicationClosedCallback -> IO (FunPtr C_ScreenApplicationClosedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenApplicationClosed :: MonadIO m => ScreenApplicationClosedCallback -> m (GClosure C_ScreenApplicationClosedCallback)
+genClosure_ScreenApplicationClosed cb = liftIO $ do
+    let cb' = wrap_ScreenApplicationClosedCallback cb
+    mk_ScreenApplicationClosedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenApplicationClosedCallback` into a `C_ScreenApplicationClosedCallback`.
+wrap_ScreenApplicationClosedCallback ::
+    ScreenApplicationClosedCallback ->
+    C_ScreenApplicationClosedCallback
+wrap_ScreenApplicationClosedCallback _cb _ app _ = do
+    app' <- (newObject Wnck.Application.Application) app
+    _cb  app'
+
+
+{- |
+Connect a signal handler for the “@application-closed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #applicationClosed callback
+@
+-}
+onScreenApplicationClosed :: (IsScreen a, MonadIO m) => a -> ScreenApplicationClosedCallback -> m SignalHandlerId
+onScreenApplicationClosed obj cb = liftIO $ do
+    let cb' = wrap_ScreenApplicationClosedCallback cb
+    cb'' <- mk_ScreenApplicationClosedCallback cb'
+    connectSignalFunPtr obj "application-closed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@application-closed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #applicationClosed callback
+@
+-}
+afterScreenApplicationClosed :: (IsScreen a, MonadIO m) => a -> ScreenApplicationClosedCallback -> m SignalHandlerId
+afterScreenApplicationClosed obj cb = liftIO $ do
+    let cb' = wrap_ScreenApplicationClosedCallback cb
+    cb'' <- mk_ScreenApplicationClosedCallback cb'
+    connectSignalFunPtr obj "application-closed" cb'' SignalConnectAfter
+
+
+-- signal Screen::application-opened
+{- |
+Emitted when a new 'GI.Wnck.Objects.Application.Application' is opened on /@screen@/.
+-}
+type ScreenApplicationOpenedCallback =
+    Wnck.Application.Application
+    {- ^ /@app@/: the opened 'GI.Wnck.Objects.Application.Application'. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenApplicationOpenedCallback`@.
+noScreenApplicationOpenedCallback :: Maybe ScreenApplicationOpenedCallback
+noScreenApplicationOpenedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenApplicationOpenedCallback =
+    Ptr () ->                               -- object
+    Ptr Wnck.Application.Application ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenApplicationOpenedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenApplicationOpenedCallback :: C_ScreenApplicationOpenedCallback -> IO (FunPtr C_ScreenApplicationOpenedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenApplicationOpened :: MonadIO m => ScreenApplicationOpenedCallback -> m (GClosure C_ScreenApplicationOpenedCallback)
+genClosure_ScreenApplicationOpened cb = liftIO $ do
+    let cb' = wrap_ScreenApplicationOpenedCallback cb
+    mk_ScreenApplicationOpenedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenApplicationOpenedCallback` into a `C_ScreenApplicationOpenedCallback`.
+wrap_ScreenApplicationOpenedCallback ::
+    ScreenApplicationOpenedCallback ->
+    C_ScreenApplicationOpenedCallback
+wrap_ScreenApplicationOpenedCallback _cb _ app _ = do
+    app' <- (newObject Wnck.Application.Application) app
+    _cb  app'
+
+
+{- |
+Connect a signal handler for the “@application-opened@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #applicationOpened callback
+@
+-}
+onScreenApplicationOpened :: (IsScreen a, MonadIO m) => a -> ScreenApplicationOpenedCallback -> m SignalHandlerId
+onScreenApplicationOpened obj cb = liftIO $ do
+    let cb' = wrap_ScreenApplicationOpenedCallback cb
+    cb'' <- mk_ScreenApplicationOpenedCallback cb'
+    connectSignalFunPtr obj "application-opened" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@application-opened@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #applicationOpened callback
+@
+-}
+afterScreenApplicationOpened :: (IsScreen a, MonadIO m) => a -> ScreenApplicationOpenedCallback -> m SignalHandlerId
+afterScreenApplicationOpened obj cb = liftIO $ do
+    let cb' = wrap_ScreenApplicationOpenedCallback cb
+    cb'' <- mk_ScreenApplicationOpenedCallback cb'
+    connectSignalFunPtr obj "application-opened" cb'' SignalConnectAfter
+
+
+-- signal Screen::background-changed
+{- |
+Emitted when the background on the root window of /@screen@/ has changed.
+-}
+type ScreenBackgroundChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenBackgroundChangedCallback`@.
+noScreenBackgroundChangedCallback :: Maybe ScreenBackgroundChangedCallback
+noScreenBackgroundChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenBackgroundChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenBackgroundChangedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenBackgroundChangedCallback :: C_ScreenBackgroundChangedCallback -> IO (FunPtr C_ScreenBackgroundChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenBackgroundChanged :: MonadIO m => ScreenBackgroundChangedCallback -> m (GClosure C_ScreenBackgroundChangedCallback)
+genClosure_ScreenBackgroundChanged cb = liftIO $ do
+    let cb' = wrap_ScreenBackgroundChangedCallback cb
+    mk_ScreenBackgroundChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenBackgroundChangedCallback` into a `C_ScreenBackgroundChangedCallback`.
+wrap_ScreenBackgroundChangedCallback ::
+    ScreenBackgroundChangedCallback ->
+    C_ScreenBackgroundChangedCallback
+wrap_ScreenBackgroundChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@background-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #backgroundChanged callback
+@
+-}
+onScreenBackgroundChanged :: (IsScreen a, MonadIO m) => a -> ScreenBackgroundChangedCallback -> m SignalHandlerId
+onScreenBackgroundChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenBackgroundChangedCallback cb
+    cb'' <- mk_ScreenBackgroundChangedCallback cb'
+    connectSignalFunPtr obj "background-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@background-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #backgroundChanged callback
+@
+-}
+afterScreenBackgroundChanged :: (IsScreen a, MonadIO m) => a -> ScreenBackgroundChangedCallback -> m SignalHandlerId
+afterScreenBackgroundChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenBackgroundChangedCallback cb
+    cb'' <- mk_ScreenBackgroundChangedCallback cb'
+    connectSignalFunPtr obj "background-changed" cb'' SignalConnectAfter
+
+
+-- signal Screen::class-group-closed
+{- |
+Emitted when a 'GI.Wnck.Objects.ClassGroup.ClassGroup' is closed on /@screen@/.
+
+/Since: 2.20/
+-}
+type ScreenClassGroupClosedCallback =
+    Wnck.ClassGroup.ClassGroup
+    {- ^ /@classGroup@/: the closed 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenClassGroupClosedCallback`@.
+noScreenClassGroupClosedCallback :: Maybe ScreenClassGroupClosedCallback
+noScreenClassGroupClosedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenClassGroupClosedCallback =
+    Ptr () ->                               -- object
+    Ptr Wnck.ClassGroup.ClassGroup ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenClassGroupClosedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenClassGroupClosedCallback :: C_ScreenClassGroupClosedCallback -> IO (FunPtr C_ScreenClassGroupClosedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenClassGroupClosed :: MonadIO m => ScreenClassGroupClosedCallback -> m (GClosure C_ScreenClassGroupClosedCallback)
+genClosure_ScreenClassGroupClosed cb = liftIO $ do
+    let cb' = wrap_ScreenClassGroupClosedCallback cb
+    mk_ScreenClassGroupClosedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenClassGroupClosedCallback` into a `C_ScreenClassGroupClosedCallback`.
+wrap_ScreenClassGroupClosedCallback ::
+    ScreenClassGroupClosedCallback ->
+    C_ScreenClassGroupClosedCallback
+wrap_ScreenClassGroupClosedCallback _cb _ classGroup _ = do
+    classGroup' <- (newObject Wnck.ClassGroup.ClassGroup) classGroup
+    _cb  classGroup'
+
+
+{- |
+Connect a signal handler for the “@class-group-closed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #classGroupClosed callback
+@
+-}
+onScreenClassGroupClosed :: (IsScreen a, MonadIO m) => a -> ScreenClassGroupClosedCallback -> m SignalHandlerId
+onScreenClassGroupClosed obj cb = liftIO $ do
+    let cb' = wrap_ScreenClassGroupClosedCallback cb
+    cb'' <- mk_ScreenClassGroupClosedCallback cb'
+    connectSignalFunPtr obj "class-group-closed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@class-group-closed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #classGroupClosed callback
+@
+-}
+afterScreenClassGroupClosed :: (IsScreen a, MonadIO m) => a -> ScreenClassGroupClosedCallback -> m SignalHandlerId
+afterScreenClassGroupClosed obj cb = liftIO $ do
+    let cb' = wrap_ScreenClassGroupClosedCallback cb
+    cb'' <- mk_ScreenClassGroupClosedCallback cb'
+    connectSignalFunPtr obj "class-group-closed" cb'' SignalConnectAfter
+
+
+-- signal Screen::class-group-opened
+{- |
+Emitted when a new 'GI.Wnck.Objects.ClassGroup.ClassGroup' is opened on /@screen@/.
+
+/Since: 2.20/
+-}
+type ScreenClassGroupOpenedCallback =
+    Wnck.ClassGroup.ClassGroup
+    {- ^ /@classGroup@/: the opened 'GI.Wnck.Objects.ClassGroup.ClassGroup'. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenClassGroupOpenedCallback`@.
+noScreenClassGroupOpenedCallback :: Maybe ScreenClassGroupOpenedCallback
+noScreenClassGroupOpenedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenClassGroupOpenedCallback =
+    Ptr () ->                               -- object
+    Ptr Wnck.ClassGroup.ClassGroup ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenClassGroupOpenedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenClassGroupOpenedCallback :: C_ScreenClassGroupOpenedCallback -> IO (FunPtr C_ScreenClassGroupOpenedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenClassGroupOpened :: MonadIO m => ScreenClassGroupOpenedCallback -> m (GClosure C_ScreenClassGroupOpenedCallback)
+genClosure_ScreenClassGroupOpened cb = liftIO $ do
+    let cb' = wrap_ScreenClassGroupOpenedCallback cb
+    mk_ScreenClassGroupOpenedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenClassGroupOpenedCallback` into a `C_ScreenClassGroupOpenedCallback`.
+wrap_ScreenClassGroupOpenedCallback ::
+    ScreenClassGroupOpenedCallback ->
+    C_ScreenClassGroupOpenedCallback
+wrap_ScreenClassGroupOpenedCallback _cb _ classGroup _ = do
+    classGroup' <- (newObject Wnck.ClassGroup.ClassGroup) classGroup
+    _cb  classGroup'
+
+
+{- |
+Connect a signal handler for the “@class-group-opened@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #classGroupOpened callback
+@
+-}
+onScreenClassGroupOpened :: (IsScreen a, MonadIO m) => a -> ScreenClassGroupOpenedCallback -> m SignalHandlerId
+onScreenClassGroupOpened obj cb = liftIO $ do
+    let cb' = wrap_ScreenClassGroupOpenedCallback cb
+    cb'' <- mk_ScreenClassGroupOpenedCallback cb'
+    connectSignalFunPtr obj "class-group-opened" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@class-group-opened@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #classGroupOpened callback
+@
+-}
+afterScreenClassGroupOpened :: (IsScreen a, MonadIO m) => a -> ScreenClassGroupOpenedCallback -> m SignalHandlerId
+afterScreenClassGroupOpened obj cb = liftIO $ do
+    let cb' = wrap_ScreenClassGroupOpenedCallback cb
+    cb'' <- mk_ScreenClassGroupOpenedCallback cb'
+    connectSignalFunPtr obj "class-group-opened" cb'' SignalConnectAfter
+
+
+-- signal Screen::showing-desktop-changed
+{- |
+Emitted when \"showing the desktop\" mode of /@screen@/ is toggled.
+
+/Since: 2.20/
+-}
+type ScreenShowingDesktopChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenShowingDesktopChangedCallback`@.
+noScreenShowingDesktopChangedCallback :: Maybe ScreenShowingDesktopChangedCallback
+noScreenShowingDesktopChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenShowingDesktopChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenShowingDesktopChangedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenShowingDesktopChangedCallback :: C_ScreenShowingDesktopChangedCallback -> IO (FunPtr C_ScreenShowingDesktopChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenShowingDesktopChanged :: MonadIO m => ScreenShowingDesktopChangedCallback -> m (GClosure C_ScreenShowingDesktopChangedCallback)
+genClosure_ScreenShowingDesktopChanged cb = liftIO $ do
+    let cb' = wrap_ScreenShowingDesktopChangedCallback cb
+    mk_ScreenShowingDesktopChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenShowingDesktopChangedCallback` into a `C_ScreenShowingDesktopChangedCallback`.
+wrap_ScreenShowingDesktopChangedCallback ::
+    ScreenShowingDesktopChangedCallback ->
+    C_ScreenShowingDesktopChangedCallback
+wrap_ScreenShowingDesktopChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@showing-desktop-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #showingDesktopChanged callback
+@
+-}
+onScreenShowingDesktopChanged :: (IsScreen a, MonadIO m) => a -> ScreenShowingDesktopChangedCallback -> m SignalHandlerId
+onScreenShowingDesktopChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenShowingDesktopChangedCallback cb
+    cb'' <- mk_ScreenShowingDesktopChangedCallback cb'
+    connectSignalFunPtr obj "showing-desktop-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@showing-desktop-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #showingDesktopChanged callback
+@
+-}
+afterScreenShowingDesktopChanged :: (IsScreen a, MonadIO m) => a -> ScreenShowingDesktopChangedCallback -> m SignalHandlerId
+afterScreenShowingDesktopChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenShowingDesktopChangedCallback cb
+    cb'' <- mk_ScreenShowingDesktopChangedCallback cb'
+    connectSignalFunPtr obj "showing-desktop-changed" cb'' SignalConnectAfter
+
+
+-- signal Screen::viewports-changed
+{- |
+Emitted when a viewport position has changed in a 'GI.Wnck.Objects.Workspace.Workspace' of
+/@screen@/ or when a 'GI.Wnck.Objects.Workspace.Workspace' of /@screen@/ gets or loses its viewport.
+
+/Since: 2.20/
+-}
+type ScreenViewportsChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenViewportsChangedCallback`@.
+noScreenViewportsChangedCallback :: Maybe ScreenViewportsChangedCallback
+noScreenViewportsChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenViewportsChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenViewportsChangedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenViewportsChangedCallback :: C_ScreenViewportsChangedCallback -> IO (FunPtr C_ScreenViewportsChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenViewportsChanged :: MonadIO m => ScreenViewportsChangedCallback -> m (GClosure C_ScreenViewportsChangedCallback)
+genClosure_ScreenViewportsChanged cb = liftIO $ do
+    let cb' = wrap_ScreenViewportsChangedCallback cb
+    mk_ScreenViewportsChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenViewportsChangedCallback` into a `C_ScreenViewportsChangedCallback`.
+wrap_ScreenViewportsChangedCallback ::
+    ScreenViewportsChangedCallback ->
+    C_ScreenViewportsChangedCallback
+wrap_ScreenViewportsChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@viewports-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #viewportsChanged callback
+@
+-}
+onScreenViewportsChanged :: (IsScreen a, MonadIO m) => a -> ScreenViewportsChangedCallback -> m SignalHandlerId
+onScreenViewportsChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenViewportsChangedCallback cb
+    cb'' <- mk_ScreenViewportsChangedCallback cb'
+    connectSignalFunPtr obj "viewports-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@viewports-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #viewportsChanged callback
+@
+-}
+afterScreenViewportsChanged :: (IsScreen a, MonadIO m) => a -> ScreenViewportsChangedCallback -> m SignalHandlerId
+afterScreenViewportsChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenViewportsChangedCallback cb
+    cb'' <- mk_ScreenViewportsChangedCallback cb'
+    connectSignalFunPtr obj "viewports-changed" cb'' SignalConnectAfter
+
+
+-- signal Screen::window-closed
+{- |
+Emitted when a 'GI.Wnck.Objects.Window.Window' is closed on /@screen@/.
+-}
+type ScreenWindowClosedCallback =
+    Wnck.Window.Window
+    {- ^ /@window@/: the closed 'GI.Wnck.Objects.Window.Window'. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWindowClosedCallback`@.
+noScreenWindowClosedCallback :: Maybe ScreenWindowClosedCallback
+noScreenWindowClosedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenWindowClosedCallback =
+    Ptr () ->                               -- object
+    Ptr Wnck.Window.Window ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenWindowClosedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenWindowClosedCallback :: C_ScreenWindowClosedCallback -> IO (FunPtr C_ScreenWindowClosedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenWindowClosed :: MonadIO m => ScreenWindowClosedCallback -> m (GClosure C_ScreenWindowClosedCallback)
+genClosure_ScreenWindowClosed cb = liftIO $ do
+    let cb' = wrap_ScreenWindowClosedCallback cb
+    mk_ScreenWindowClosedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenWindowClosedCallback` into a `C_ScreenWindowClosedCallback`.
+wrap_ScreenWindowClosedCallback ::
+    ScreenWindowClosedCallback ->
+    C_ScreenWindowClosedCallback
+wrap_ScreenWindowClosedCallback _cb _ window _ = do
+    window' <- (newObject Wnck.Window.Window) window
+    _cb  window'
+
+
+{- |
+Connect a signal handler for the “@window-closed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #windowClosed callback
+@
+-}
+onScreenWindowClosed :: (IsScreen a, MonadIO m) => a -> ScreenWindowClosedCallback -> m SignalHandlerId
+onScreenWindowClosed obj cb = liftIO $ do
+    let cb' = wrap_ScreenWindowClosedCallback cb
+    cb'' <- mk_ScreenWindowClosedCallback cb'
+    connectSignalFunPtr obj "window-closed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@window-closed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #windowClosed callback
+@
+-}
+afterScreenWindowClosed :: (IsScreen a, MonadIO m) => a -> ScreenWindowClosedCallback -> m SignalHandlerId
+afterScreenWindowClosed obj cb = liftIO $ do
+    let cb' = wrap_ScreenWindowClosedCallback cb
+    cb'' <- mk_ScreenWindowClosedCallback cb'
+    connectSignalFunPtr obj "window-closed" cb'' SignalConnectAfter
+
+
+-- signal Screen::window-manager-changed
+{- |
+Emitted when the window manager on /@screen@/ has changed.
+
+/Since: 2.20/
+-}
+type ScreenWindowManagerChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWindowManagerChangedCallback`@.
+noScreenWindowManagerChangedCallback :: Maybe ScreenWindowManagerChangedCallback
+noScreenWindowManagerChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenWindowManagerChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenWindowManagerChangedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenWindowManagerChangedCallback :: C_ScreenWindowManagerChangedCallback -> IO (FunPtr C_ScreenWindowManagerChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenWindowManagerChanged :: MonadIO m => ScreenWindowManagerChangedCallback -> m (GClosure C_ScreenWindowManagerChangedCallback)
+genClosure_ScreenWindowManagerChanged cb = liftIO $ do
+    let cb' = wrap_ScreenWindowManagerChangedCallback cb
+    mk_ScreenWindowManagerChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenWindowManagerChangedCallback` into a `C_ScreenWindowManagerChangedCallback`.
+wrap_ScreenWindowManagerChangedCallback ::
+    ScreenWindowManagerChangedCallback ->
+    C_ScreenWindowManagerChangedCallback
+wrap_ScreenWindowManagerChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@window-manager-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #windowManagerChanged callback
+@
+-}
+onScreenWindowManagerChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowManagerChangedCallback -> m SignalHandlerId
+onScreenWindowManagerChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenWindowManagerChangedCallback cb
+    cb'' <- mk_ScreenWindowManagerChangedCallback cb'
+    connectSignalFunPtr obj "window-manager-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@window-manager-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #windowManagerChanged callback
+@
+-}
+afterScreenWindowManagerChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowManagerChangedCallback -> m SignalHandlerId
+afterScreenWindowManagerChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenWindowManagerChangedCallback cb
+    cb'' <- mk_ScreenWindowManagerChangedCallback cb'
+    connectSignalFunPtr obj "window-manager-changed" cb'' SignalConnectAfter
+
+
+-- signal Screen::window-opened
+{- |
+Emitted when a new 'GI.Wnck.Objects.Window.Window' is opened on /@screen@/.
+-}
+type ScreenWindowOpenedCallback =
+    Wnck.Window.Window
+    {- ^ /@window@/: the opened 'GI.Wnck.Objects.Window.Window'. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWindowOpenedCallback`@.
+noScreenWindowOpenedCallback :: Maybe ScreenWindowOpenedCallback
+noScreenWindowOpenedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenWindowOpenedCallback =
+    Ptr () ->                               -- object
+    Ptr Wnck.Window.Window ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenWindowOpenedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenWindowOpenedCallback :: C_ScreenWindowOpenedCallback -> IO (FunPtr C_ScreenWindowOpenedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenWindowOpened :: MonadIO m => ScreenWindowOpenedCallback -> m (GClosure C_ScreenWindowOpenedCallback)
+genClosure_ScreenWindowOpened cb = liftIO $ do
+    let cb' = wrap_ScreenWindowOpenedCallback cb
+    mk_ScreenWindowOpenedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenWindowOpenedCallback` into a `C_ScreenWindowOpenedCallback`.
+wrap_ScreenWindowOpenedCallback ::
+    ScreenWindowOpenedCallback ->
+    C_ScreenWindowOpenedCallback
+wrap_ScreenWindowOpenedCallback _cb _ window _ = do
+    window' <- (newObject Wnck.Window.Window) window
+    _cb  window'
+
+
+{- |
+Connect a signal handler for the “@window-opened@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #windowOpened callback
+@
+-}
+onScreenWindowOpened :: (IsScreen a, MonadIO m) => a -> ScreenWindowOpenedCallback -> m SignalHandlerId
+onScreenWindowOpened obj cb = liftIO $ do
+    let cb' = wrap_ScreenWindowOpenedCallback cb
+    cb'' <- mk_ScreenWindowOpenedCallback cb'
+    connectSignalFunPtr obj "window-opened" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@window-opened@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #windowOpened callback
+@
+-}
+afterScreenWindowOpened :: (IsScreen a, MonadIO m) => a -> ScreenWindowOpenedCallback -> m SignalHandlerId
+afterScreenWindowOpened obj cb = liftIO $ do
+    let cb' = wrap_ScreenWindowOpenedCallback cb
+    cb'' <- mk_ScreenWindowOpenedCallback cb'
+    connectSignalFunPtr obj "window-opened" cb'' SignalConnectAfter
+
+
+-- signal Screen::window-stacking-changed
+{- |
+Emitted when the stacking order of 'GI.Wnck.Objects.Window.Window' on /@screen@/ has changed.
+-}
+type ScreenWindowStackingChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWindowStackingChangedCallback`@.
+noScreenWindowStackingChangedCallback :: Maybe ScreenWindowStackingChangedCallback
+noScreenWindowStackingChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenWindowStackingChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenWindowStackingChangedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenWindowStackingChangedCallback :: C_ScreenWindowStackingChangedCallback -> IO (FunPtr C_ScreenWindowStackingChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenWindowStackingChanged :: MonadIO m => ScreenWindowStackingChangedCallback -> m (GClosure C_ScreenWindowStackingChangedCallback)
+genClosure_ScreenWindowStackingChanged cb = liftIO $ do
+    let cb' = wrap_ScreenWindowStackingChangedCallback cb
+    mk_ScreenWindowStackingChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenWindowStackingChangedCallback` into a `C_ScreenWindowStackingChangedCallback`.
+wrap_ScreenWindowStackingChangedCallback ::
+    ScreenWindowStackingChangedCallback ->
+    C_ScreenWindowStackingChangedCallback
+wrap_ScreenWindowStackingChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@window-stacking-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #windowStackingChanged callback
+@
+-}
+onScreenWindowStackingChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowStackingChangedCallback -> m SignalHandlerId
+onScreenWindowStackingChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenWindowStackingChangedCallback cb
+    cb'' <- mk_ScreenWindowStackingChangedCallback cb'
+    connectSignalFunPtr obj "window-stacking-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@window-stacking-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #windowStackingChanged callback
+@
+-}
+afterScreenWindowStackingChanged :: (IsScreen a, MonadIO m) => a -> ScreenWindowStackingChangedCallback -> m SignalHandlerId
+afterScreenWindowStackingChanged obj cb = liftIO $ do
+    let cb' = wrap_ScreenWindowStackingChangedCallback cb
+    cb'' <- mk_ScreenWindowStackingChangedCallback cb'
+    connectSignalFunPtr obj "window-stacking-changed" cb'' SignalConnectAfter
+
+
+-- signal Screen::workspace-created
+{- |
+Emitted when a 'GI.Wnck.Objects.Workspace.Workspace' is created on /@screen@/.
+-}
+type ScreenWorkspaceCreatedCallback =
+    Wnck.Workspace.Workspace
+    {- ^ /@space@/: the workspace that has been created. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWorkspaceCreatedCallback`@.
+noScreenWorkspaceCreatedCallback :: Maybe ScreenWorkspaceCreatedCallback
+noScreenWorkspaceCreatedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenWorkspaceCreatedCallback =
+    Ptr () ->                               -- object
+    Ptr Wnck.Workspace.Workspace ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenWorkspaceCreatedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenWorkspaceCreatedCallback :: C_ScreenWorkspaceCreatedCallback -> IO (FunPtr C_ScreenWorkspaceCreatedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenWorkspaceCreated :: MonadIO m => ScreenWorkspaceCreatedCallback -> m (GClosure C_ScreenWorkspaceCreatedCallback)
+genClosure_ScreenWorkspaceCreated cb = liftIO $ do
+    let cb' = wrap_ScreenWorkspaceCreatedCallback cb
+    mk_ScreenWorkspaceCreatedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenWorkspaceCreatedCallback` into a `C_ScreenWorkspaceCreatedCallback`.
+wrap_ScreenWorkspaceCreatedCallback ::
+    ScreenWorkspaceCreatedCallback ->
+    C_ScreenWorkspaceCreatedCallback
+wrap_ScreenWorkspaceCreatedCallback _cb _ space _ = do
+    space' <- (newObject Wnck.Workspace.Workspace) space
+    _cb  space'
+
+
+{- |
+Connect a signal handler for the “@workspace-created@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #workspaceCreated callback
+@
+-}
+onScreenWorkspaceCreated :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceCreatedCallback -> m SignalHandlerId
+onScreenWorkspaceCreated obj cb = liftIO $ do
+    let cb' = wrap_ScreenWorkspaceCreatedCallback cb
+    cb'' <- mk_ScreenWorkspaceCreatedCallback cb'
+    connectSignalFunPtr obj "workspace-created" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@workspace-created@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #workspaceCreated callback
+@
+-}
+afterScreenWorkspaceCreated :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceCreatedCallback -> m SignalHandlerId
+afterScreenWorkspaceCreated obj cb = liftIO $ do
+    let cb' = wrap_ScreenWorkspaceCreatedCallback cb
+    cb'' <- mk_ScreenWorkspaceCreatedCallback cb'
+    connectSignalFunPtr obj "workspace-created" cb'' SignalConnectAfter
+
+
+-- signal Screen::workspace-destroyed
+{- |
+Emitted when a 'GI.Wnck.Objects.Workspace.Workspace' is destroyed on /@screen@/.
+-}
+type ScreenWorkspaceDestroyedCallback =
+    Wnck.Workspace.Workspace
+    {- ^ /@space@/: the workspace that has been destroyed. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `ScreenWorkspaceDestroyedCallback`@.
+noScreenWorkspaceDestroyedCallback :: Maybe ScreenWorkspaceDestroyedCallback
+noScreenWorkspaceDestroyedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_ScreenWorkspaceDestroyedCallback =
+    Ptr () ->                               -- object
+    Ptr Wnck.Workspace.Workspace ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_ScreenWorkspaceDestroyedCallback`.
+foreign import ccall "wrapper"
+    mk_ScreenWorkspaceDestroyedCallback :: C_ScreenWorkspaceDestroyedCallback -> IO (FunPtr C_ScreenWorkspaceDestroyedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_ScreenWorkspaceDestroyed :: MonadIO m => ScreenWorkspaceDestroyedCallback -> m (GClosure C_ScreenWorkspaceDestroyedCallback)
+genClosure_ScreenWorkspaceDestroyed cb = liftIO $ do
+    let cb' = wrap_ScreenWorkspaceDestroyedCallback cb
+    mk_ScreenWorkspaceDestroyedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `ScreenWorkspaceDestroyedCallback` into a `C_ScreenWorkspaceDestroyedCallback`.
+wrap_ScreenWorkspaceDestroyedCallback ::
+    ScreenWorkspaceDestroyedCallback ->
+    C_ScreenWorkspaceDestroyedCallback
+wrap_ScreenWorkspaceDestroyedCallback _cb _ space _ = do
+    space' <- (newObject Wnck.Workspace.Workspace) space
+    _cb  space'
+
+
+{- |
+Connect a signal handler for the “@workspace-destroyed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' screen #workspaceDestroyed callback
+@
+-}
+onScreenWorkspaceDestroyed :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceDestroyedCallback -> m SignalHandlerId
+onScreenWorkspaceDestroyed obj cb = liftIO $ do
+    let cb' = wrap_ScreenWorkspaceDestroyedCallback cb
+    cb'' <- mk_ScreenWorkspaceDestroyedCallback cb'
+    connectSignalFunPtr obj "workspace-destroyed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@workspace-destroyed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' screen #workspaceDestroyed callback
+@
+-}
+afterScreenWorkspaceDestroyed :: (IsScreen a, MonadIO m) => a -> ScreenWorkspaceDestroyedCallback -> m SignalHandlerId
+afterScreenWorkspaceDestroyed obj cb = liftIO $ do
+    let cb' = wrap_ScreenWorkspaceDestroyedCallback cb
+    cb'' <- mk_ScreenWorkspaceDestroyedCallback cb'
+    connectSignalFunPtr obj "workspace-destroyed" cb'' SignalConnectAfter
+
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList Screen
+type instance O.AttributeList Screen = ScreenAttributeList
+type ScreenAttributeList = ('[ ] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+#endif
+
+#if ENABLE_OVERLOADING
+data ScreenActiveWindowChangedSignalInfo
+instance SignalInfo ScreenActiveWindowChangedSignalInfo where
+    type HaskellCallbackType ScreenActiveWindowChangedSignalInfo = ScreenActiveWindowChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenActiveWindowChangedCallback cb
+        cb'' <- mk_ScreenActiveWindowChangedCallback cb'
+        connectSignalFunPtr obj "active-window-changed" cb'' connectMode
+
+data ScreenActiveWorkspaceChangedSignalInfo
+instance SignalInfo ScreenActiveWorkspaceChangedSignalInfo where
+    type HaskellCallbackType ScreenActiveWorkspaceChangedSignalInfo = ScreenActiveWorkspaceChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenActiveWorkspaceChangedCallback cb
+        cb'' <- mk_ScreenActiveWorkspaceChangedCallback cb'
+        connectSignalFunPtr obj "active-workspace-changed" cb'' connectMode
+
+data ScreenApplicationClosedSignalInfo
+instance SignalInfo ScreenApplicationClosedSignalInfo where
+    type HaskellCallbackType ScreenApplicationClosedSignalInfo = ScreenApplicationClosedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenApplicationClosedCallback cb
+        cb'' <- mk_ScreenApplicationClosedCallback cb'
+        connectSignalFunPtr obj "application-closed" cb'' connectMode
+
+data ScreenApplicationOpenedSignalInfo
+instance SignalInfo ScreenApplicationOpenedSignalInfo where
+    type HaskellCallbackType ScreenApplicationOpenedSignalInfo = ScreenApplicationOpenedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenApplicationOpenedCallback cb
+        cb'' <- mk_ScreenApplicationOpenedCallback cb'
+        connectSignalFunPtr obj "application-opened" cb'' connectMode
+
+data ScreenBackgroundChangedSignalInfo
+instance SignalInfo ScreenBackgroundChangedSignalInfo where
+    type HaskellCallbackType ScreenBackgroundChangedSignalInfo = ScreenBackgroundChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenBackgroundChangedCallback cb
+        cb'' <- mk_ScreenBackgroundChangedCallback cb'
+        connectSignalFunPtr obj "background-changed" cb'' connectMode
+
+data ScreenClassGroupClosedSignalInfo
+instance SignalInfo ScreenClassGroupClosedSignalInfo where
+    type HaskellCallbackType ScreenClassGroupClosedSignalInfo = ScreenClassGroupClosedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenClassGroupClosedCallback cb
+        cb'' <- mk_ScreenClassGroupClosedCallback cb'
+        connectSignalFunPtr obj "class-group-closed" cb'' connectMode
+
+data ScreenClassGroupOpenedSignalInfo
+instance SignalInfo ScreenClassGroupOpenedSignalInfo where
+    type HaskellCallbackType ScreenClassGroupOpenedSignalInfo = ScreenClassGroupOpenedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenClassGroupOpenedCallback cb
+        cb'' <- mk_ScreenClassGroupOpenedCallback cb'
+        connectSignalFunPtr obj "class-group-opened" cb'' connectMode
+
+data ScreenShowingDesktopChangedSignalInfo
+instance SignalInfo ScreenShowingDesktopChangedSignalInfo where
+    type HaskellCallbackType ScreenShowingDesktopChangedSignalInfo = ScreenShowingDesktopChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenShowingDesktopChangedCallback cb
+        cb'' <- mk_ScreenShowingDesktopChangedCallback cb'
+        connectSignalFunPtr obj "showing-desktop-changed" cb'' connectMode
+
+data ScreenViewportsChangedSignalInfo
+instance SignalInfo ScreenViewportsChangedSignalInfo where
+    type HaskellCallbackType ScreenViewportsChangedSignalInfo = ScreenViewportsChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenViewportsChangedCallback cb
+        cb'' <- mk_ScreenViewportsChangedCallback cb'
+        connectSignalFunPtr obj "viewports-changed" cb'' connectMode
+
+data ScreenWindowClosedSignalInfo
+instance SignalInfo ScreenWindowClosedSignalInfo where
+    type HaskellCallbackType ScreenWindowClosedSignalInfo = ScreenWindowClosedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenWindowClosedCallback cb
+        cb'' <- mk_ScreenWindowClosedCallback cb'
+        connectSignalFunPtr obj "window-closed" cb'' connectMode
+
+data ScreenWindowManagerChangedSignalInfo
+instance SignalInfo ScreenWindowManagerChangedSignalInfo where
+    type HaskellCallbackType ScreenWindowManagerChangedSignalInfo = ScreenWindowManagerChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenWindowManagerChangedCallback cb
+        cb'' <- mk_ScreenWindowManagerChangedCallback cb'
+        connectSignalFunPtr obj "window-manager-changed" cb'' connectMode
+
+data ScreenWindowOpenedSignalInfo
+instance SignalInfo ScreenWindowOpenedSignalInfo where
+    type HaskellCallbackType ScreenWindowOpenedSignalInfo = ScreenWindowOpenedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenWindowOpenedCallback cb
+        cb'' <- mk_ScreenWindowOpenedCallback cb'
+        connectSignalFunPtr obj "window-opened" cb'' connectMode
+
+data ScreenWindowStackingChangedSignalInfo
+instance SignalInfo ScreenWindowStackingChangedSignalInfo where
+    type HaskellCallbackType ScreenWindowStackingChangedSignalInfo = ScreenWindowStackingChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenWindowStackingChangedCallback cb
+        cb'' <- mk_ScreenWindowStackingChangedCallback cb'
+        connectSignalFunPtr obj "window-stacking-changed" cb'' connectMode
+
+data ScreenWorkspaceCreatedSignalInfo
+instance SignalInfo ScreenWorkspaceCreatedSignalInfo where
+    type HaskellCallbackType ScreenWorkspaceCreatedSignalInfo = ScreenWorkspaceCreatedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenWorkspaceCreatedCallback cb
+        cb'' <- mk_ScreenWorkspaceCreatedCallback cb'
+        connectSignalFunPtr obj "workspace-created" cb'' connectMode
+
+data ScreenWorkspaceDestroyedSignalInfo
+instance SignalInfo ScreenWorkspaceDestroyedSignalInfo where
+    type HaskellCallbackType ScreenWorkspaceDestroyedSignalInfo = ScreenWorkspaceDestroyedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_ScreenWorkspaceDestroyedCallback cb
+        cb'' <- mk_ScreenWorkspaceDestroyedCallback cb'
+        connectSignalFunPtr obj "workspace-destroyed" cb'' connectMode
+
+type instance O.SignalList Screen = ScreenSignalList
+type ScreenSignalList = ('[ '("activeWindowChanged", ScreenActiveWindowChangedSignalInfo), '("activeWorkspaceChanged", ScreenActiveWorkspaceChangedSignalInfo), '("applicationClosed", ScreenApplicationClosedSignalInfo), '("applicationOpened", ScreenApplicationOpenedSignalInfo), '("backgroundChanged", ScreenBackgroundChangedSignalInfo), '("classGroupClosed", ScreenClassGroupClosedSignalInfo), '("classGroupOpened", ScreenClassGroupOpenedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("showingDesktopChanged", ScreenShowingDesktopChangedSignalInfo), '("viewportsChanged", ScreenViewportsChangedSignalInfo), '("windowClosed", ScreenWindowClosedSignalInfo), '("windowManagerChanged", ScreenWindowManagerChangedSignalInfo), '("windowOpened", ScreenWindowOpenedSignalInfo), '("windowStackingChanged", ScreenWindowStackingChangedSignalInfo), '("workspaceCreated", ScreenWorkspaceCreatedSignalInfo), '("workspaceDestroyed", ScreenWorkspaceDestroyedSignalInfo)] :: [(Symbol, *)])
+
+#endif
+
+-- method Screen::calc_workspace_layout
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num_workspaces", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of #WnckWorkspace on @screen, or -1 to let\nwnck_screen_calc_workspace_layout() find this number.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "space_index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the index of a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "layout", argType = TInterface (Name {namespace = "Wnck", name = "WorkspaceLayout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the layout of #WnckWorkspace with additional\ninformation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_calc_workspace_layout" wnck_screen_calc_workspace_layout :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    Int32 ->                                -- num_workspaces : TBasicType TInt
+    Int32 ->                                -- space_index : TBasicType TInt
+    Ptr Wnck.WorkspaceLayout.WorkspaceLayout -> -- layout : TInterface (Name {namespace = "Wnck", name = "WorkspaceLayout"})
+    IO ()
+
+{-# DEPRECATED screenCalcWorkspaceLayout ["(Since version 2.20)"] #-}
+{- |
+Calculates the layout of 'GI.Wnck.Objects.Workspace.Workspace', with additional information like
+the row and column of the 'GI.Wnck.Objects.Workspace.Workspace' with index /@spaceIndex@/.
+
+/Since: 2.12/
+-}
+screenCalcWorkspaceLayout ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> Int32
+    {- ^ /@numWorkspaces@/: the number of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/, or -1 to let
+'GI.Wnck.Objects.Screen.screenCalcWorkspaceLayout' find this number. -}
+    -> Int32
+    {- ^ /@spaceIndex@/: the index of a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> Wnck.WorkspaceLayout.WorkspaceLayout
+    {- ^ /@layout@/: return location for the layout of 'GI.Wnck.Objects.Workspace.Workspace' with additional
+information. -}
+    -> m ()
+screenCalcWorkspaceLayout screen numWorkspaces spaceIndex layout = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    layout' <- unsafeManagedPtrGetPtr layout
+    wnck_screen_calc_workspace_layout screen' numWorkspaces spaceIndex layout'
+    touchManagedPtr screen
+    touchManagedPtr layout
+    return ()
+
+#if ENABLE_OVERLOADING
+data ScreenCalcWorkspaceLayoutMethodInfo
+instance (signature ~ (Int32 -> Int32 -> Wnck.WorkspaceLayout.WorkspaceLayout -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenCalcWorkspaceLayoutMethodInfo a signature where
+    overloadedMethod _ = screenCalcWorkspaceLayout
+
+#endif
+
+-- method Screen::change_workspace_count
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of #WnckWorkspace to request.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_change_workspace_count" wnck_screen_change_workspace_count :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    Int32 ->                                -- count : TBasicType TInt
+    IO ()
+
+{- |
+Asks the window manager to change the number of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/.
+
+/Since: 2.2/
+-}
+screenChangeWorkspaceCount ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> Int32
+    {- ^ /@count@/: the number of 'GI.Wnck.Objects.Workspace.Workspace' to request. -}
+    -> m ()
+screenChangeWorkspaceCount screen count = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    wnck_screen_change_workspace_count screen' count
+    touchManagedPtr screen
+    return ()
+
+#if ENABLE_OVERLOADING
+data ScreenChangeWorkspaceCountMethodInfo
+instance (signature ~ (Int32 -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenChangeWorkspaceCountMethodInfo a signature where
+    overloadedMethod _ = screenChangeWorkspaceCount
+
+#endif
+
+-- method Screen::force_update
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_force_update" wnck_screen_force_update :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO ()
+
+{- |
+Synchronously and immediately updates the list of 'GI.Wnck.Objects.Window.Window' on /@screen@/.
+This bypasses the standard update mechanism, where the list of 'GI.Wnck.Objects.Window.Window'
+is updated in the idle loop.
+
+This is usually a bad idea for both performance and correctness reasons (to
+get things right, you need to write model-view code that tracks changes, not
+get a static list of open windows). However, this function can be useful for
+small applications that just do something and then exit.
+-}
+screenForceUpdate ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m ()
+screenForceUpdate screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    wnck_screen_force_update screen'
+    touchManagedPtr screen
+    return ()
+
+#if ENABLE_OVERLOADING
+data ScreenForceUpdateMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenForceUpdateMethodInfo a signature where
+    overloadedMethod _ = screenForceUpdate
+
+#endif
+
+-- method Screen::get_active_window
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Window"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_active_window" wnck_screen_get_active_window :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO (Ptr Wnck.Window.Window)
+
+{- |
+Gets the active 'GI.Wnck.Objects.Window.Window' on /@screen@/. May return 'Nothing' sometimes, since
+not all window managers guarantee that a window is always active.
+-}
+screenGetActiveWindow ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m (Maybe Wnck.Window.Window)
+    {- ^ __Returns:__ the active 'GI.Wnck.Objects.Window.Window' on /@screen@/, or 'Nothing'.
+The returned 'GI.Wnck.Objects.Window.Window' is owned by libwnck and must not be referenced or
+unreferenced. -}
+screenGetActiveWindow screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_active_window screen'
+    maybeResult <- convertIfNonNull result $ \result' -> do
+        result'' <- (newObject Wnck.Window.Window) result'
+        return result''
+    touchManagedPtr screen
+    return maybeResult
+
+#if ENABLE_OVERLOADING
+data ScreenGetActiveWindowMethodInfo
+instance (signature ~ (m (Maybe Wnck.Window.Window)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetActiveWindowMethodInfo a signature where
+    overloadedMethod _ = screenGetActiveWindow
+
+#endif
+
+-- method Screen::get_active_workspace
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Workspace"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_active_workspace" wnck_screen_get_active_workspace :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO (Ptr Wnck.Workspace.Workspace)
+
+{- |
+Gets the active 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/. May return 'Nothing' sometimes,
+if libwnck is in a weird state due to the asynchronous nature of the
+interaction with the window manager.
+-}
+screenGetActiveWorkspace ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m (Maybe Wnck.Workspace.Workspace)
+    {- ^ __Returns:__ the active 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/, or
+'Nothing'. The returned 'GI.Wnck.Objects.Workspace.Workspace' is owned by libwnck and must not be
+referenced or unreferenced. -}
+screenGetActiveWorkspace screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_active_workspace screen'
+    maybeResult <- convertIfNonNull result $ \result' -> do
+        result'' <- (newObject Wnck.Workspace.Workspace) result'
+        return result''
+    touchManagedPtr screen
+    return maybeResult
+
+#if ENABLE_OVERLOADING
+data ScreenGetActiveWorkspaceMethodInfo
+instance (signature ~ (m (Maybe Wnck.Workspace.Workspace)), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetActiveWorkspaceMethodInfo a signature where
+    overloadedMethod _ = screenGetActiveWorkspace
+
+#endif
+
+-- method Screen::get_background_pixmap
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TULong)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_background_pixmap" wnck_screen_get_background_pixmap :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO CULong
+
+{- |
+Gets the X window ID of the background pixmap of /@screen@/.
+-}
+screenGetBackgroundPixmap ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m CULong
+    {- ^ __Returns:__ the X window ID of the background pixmap of /@screen@/. -}
+screenGetBackgroundPixmap screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_background_pixmap screen'
+    touchManagedPtr screen
+    return result
+
+#if ENABLE_OVERLOADING
+data ScreenGetBackgroundPixmapMethodInfo
+instance (signature ~ (m CULong), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetBackgroundPixmapMethodInfo a signature where
+    overloadedMethod _ = screenGetBackgroundPixmap
+
+#endif
+
+-- method Screen::get_height
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_height" wnck_screen_get_height :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO Int32
+
+{- |
+Gets the height of /@screen@/.
+-}
+screenGetHeight ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m Int32
+    {- ^ __Returns:__ the height of /@screen@/. -}
+screenGetHeight screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_height screen'
+    touchManagedPtr screen
+    return result
+
+#if ENABLE_OVERLOADING
+data ScreenGetHeightMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetHeightMethodInfo a signature where
+    overloadedMethod _ = screenGetHeight
+
+#endif
+
+-- method Screen::get_number
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_number" wnck_screen_get_number :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO Int32
+
+{- |
+Gets the index of /@screen@/ on the display to which it belongs. The first
+'GI.Wnck.Objects.Screen.Screen' has an index of 0.
+
+/Since: 2.20/
+-}
+screenGetNumber ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m Int32
+    {- ^ __Returns:__ the index of /@space@/ on /@screen@/, or -1 on errors. -}
+screenGetNumber screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_number screen'
+    touchManagedPtr screen
+    return result
+
+#if ENABLE_OVERLOADING
+data ScreenGetNumberMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetNumberMethodInfo a signature where
+    overloadedMethod _ = screenGetNumber
+
+#endif
+
+-- method Screen::get_previously_active_window
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Window"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_previously_active_window" wnck_screen_get_previously_active_window :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO (Ptr Wnck.Window.Window)
+
+{- |
+Gets the previously active 'GI.Wnck.Objects.Window.Window' on /@screen@/. May return 'Nothing'
+sometimes, since not all window managers guarantee that a window is always
+active.
+
+/Since: 2.8/
+-}
+screenGetPreviouslyActiveWindow ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m Wnck.Window.Window
+    {- ^ __Returns:__ the previously active 'GI.Wnck.Objects.Window.Window' on /@screen@/,
+or 'Nothing'. The returned 'GI.Wnck.Objects.Window.Window' is owned by libwnck and must not be
+referenced or unreferenced. -}
+screenGetPreviouslyActiveWindow screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_previously_active_window screen'
+    checkUnexpectedReturnNULL "screenGetPreviouslyActiveWindow" result
+    result' <- (newObject Wnck.Window.Window) result
+    touchManagedPtr screen
+    return result'
+
+#if ENABLE_OVERLOADING
+data ScreenGetPreviouslyActiveWindowMethodInfo
+instance (signature ~ (m Wnck.Window.Window), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetPreviouslyActiveWindowMethodInfo a signature where
+    overloadedMethod _ = screenGetPreviouslyActiveWindow
+
+#endif
+
+-- method Screen::get_showing_desktop
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_showing_desktop" wnck_screen_get_showing_desktop :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO CInt
+
+{- |
+Gets whether /@screen@/ is in the \"showing the desktop\" mode. This mode is
+changed when a 'GI.Wnck.Objects.Screen.Screen'::@/showing-desktop-changed/@ signal gets emitted.
+
+/Since: 2.2/
+-}
+screenGetShowingDesktop ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is fullscreen, 'False' otherwise. -}
+screenGetShowingDesktop screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_showing_desktop screen'
+    let result' = (/= 0) result
+    touchManagedPtr screen
+    return result'
+
+#if ENABLE_OVERLOADING
+data ScreenGetShowingDesktopMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetShowingDesktopMethodInfo a signature where
+    overloadedMethod _ = screenGetShowingDesktop
+
+#endif
+
+-- method Screen::get_width
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_width" wnck_screen_get_width :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO Int32
+
+{- |
+Gets the width of /@screen@/.
+-}
+screenGetWidth ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m Int32
+    {- ^ __Returns:__ the width of /@screen@/. -}
+screenGetWidth screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_width screen'
+    touchManagedPtr screen
+    return result
+
+#if ENABLE_OVERLOADING
+data ScreenGetWidthMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWidthMethodInfo a signature where
+    overloadedMethod _ = screenGetWidth
+
+#endif
+
+-- method Screen::get_window_manager_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_window_manager_name" wnck_screen_get_window_manager_name :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO CString
+
+{- |
+Gets the name of the window manager.
+
+/Since: 2.20/
+-}
+screenGetWindowManagerName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m T.Text
+    {- ^ __Returns:__ the name of the window manager, or 'Nothing' if the window manager
+does not comply with the \<ulink
+url=\"http:\/\/standards.freedesktop.org\/wm-spec\/wm-spec-latest.html\">EWMH\<\/ulink>
+specification. -}
+screenGetWindowManagerName screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_window_manager_name screen'
+    checkUnexpectedReturnNULL "screenGetWindowManagerName" result
+    result' <- cstringToText result
+    touchManagedPtr screen
+    return result'
+
+#if ENABLE_OVERLOADING
+data ScreenGetWindowManagerNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWindowManagerNameMethodInfo a signature where
+    overloadedMethod _ = screenGetWindowManagerName
+
+#endif
+
+-- method Screen::get_windows
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TGList (TInterface (Name {namespace = "Wnck", name = "Window"})))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_windows" wnck_screen_get_windows :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO (Ptr (GList (Ptr Wnck.Window.Window)))
+
+{- |
+Gets the list of 'GI.Wnck.Objects.Window.Window' on /@screen@/. The list is not in a defined
+order, but should be \"stable\" (windows should not be reordered in it).
+However, the stability of the list is established by the window manager, so
+don\'t blame libwnck if it breaks down.
+-}
+screenGetWindows ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m [Wnck.Window.Window]
+    {- ^ __Returns:__ the list of
+'GI.Wnck.Objects.Window.Window' on /@screen@/, or 'Nothing' if there is no window on /@screen@/. The list
+should not be modified nor freed, as it is owned by /@screen@/. -}
+screenGetWindows screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_windows screen'
+    result' <- unpackGList result
+    result'' <- mapM (newObject Wnck.Window.Window) result'
+    touchManagedPtr screen
+    return result''
+
+#if ENABLE_OVERLOADING
+data ScreenGetWindowsMethodInfo
+instance (signature ~ (m [Wnck.Window.Window]), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWindowsMethodInfo a signature where
+    overloadedMethod _ = screenGetWindows
+
+#endif
+
+-- method Screen::get_windows_stacked
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TGList (TInterface (Name {namespace = "Wnck", name = "Window"})))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_windows_stacked" wnck_screen_get_windows_stacked :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO (Ptr (GList (Ptr Wnck.Window.Window)))
+
+{- |
+Gets the list of 'GI.Wnck.Objects.Window.Window' on /@screen@/ in bottom-to-top order.
+-}
+screenGetWindowsStacked ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m [Wnck.Window.Window]
+    {- ^ __Returns:__ the list of
+'GI.Wnck.Objects.Window.Window' in stacking order on /@screen@/, or 'Nothing' if there is no window on
+/@screen@/. The list should not be modified nor freed, as it is owned by
+/@screen@/. -}
+screenGetWindowsStacked screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_windows_stacked screen'
+    result' <- unpackGList result
+    result'' <- mapM (newObject Wnck.Window.Window) result'
+    touchManagedPtr screen
+    return result''
+
+#if ENABLE_OVERLOADING
+data ScreenGetWindowsStackedMethodInfo
+instance (signature ~ (m [Wnck.Window.Window]), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWindowsStackedMethodInfo a signature where
+    overloadedMethod _ = screenGetWindowsStacked
+
+#endif
+
+-- method Screen::get_workspace
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "workspace", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a workspace index, starting from 0.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Workspace"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_workspace" wnck_screen_get_workspace :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    Int32 ->                                -- workspace : TBasicType TInt
+    IO (Ptr Wnck.Workspace.Workspace)
+
+{- |
+Gets the 'GI.Wnck.Objects.Workspace.Workspace' numbered /@workspace@/ on /@screen@/.
+-}
+screenGetWorkspace ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> Int32
+    {- ^ /@workspace@/: a workspace index, starting from 0. -}
+    -> m Wnck.Workspace.Workspace
+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Workspace.Workspace' numbered /@workspace@/ on
+/@screen@/, or 'Nothing' if no such workspace exists. The returned 'GI.Wnck.Objects.Workspace.Workspace'
+is owned by libwnck and must not be referenced or unreferenced. -}
+screenGetWorkspace screen workspace = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_workspace screen' workspace
+    checkUnexpectedReturnNULL "screenGetWorkspace" result
+    result' <- (newObject Wnck.Workspace.Workspace) result
+    touchManagedPtr screen
+    return result'
+
+#if ENABLE_OVERLOADING
+data ScreenGetWorkspaceMethodInfo
+instance (signature ~ (Int32 -> m Wnck.Workspace.Workspace), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWorkspaceMethodInfo a signature where
+    overloadedMethod _ = screenGetWorkspace
+
+#endif
+
+-- method Screen::get_workspace_count
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_workspace_count" wnck_screen_get_workspace_count :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO Int32
+
+{- |
+Gets the number of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/.
+-}
+screenGetWorkspaceCount ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m Int32
+    {- ^ __Returns:__ the number of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/. -}
+screenGetWorkspaceCount screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_workspace_count screen'
+    touchManagedPtr screen
+    return result
+
+#if ENABLE_OVERLOADING
+data ScreenGetWorkspaceCountMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWorkspaceCountMethodInfo a signature where
+    overloadedMethod _ = screenGetWorkspaceCount
+
+#endif
+
+-- method Screen::get_workspaces
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TGList (TInterface (Name {namespace = "Wnck", name = "Workspace"})))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_workspaces" wnck_screen_get_workspaces :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    IO (Ptr (GList (Ptr Wnck.Workspace.Workspace)))
+
+{- |
+Gets the list of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/. The list is ordered: the
+first element in the list is the first 'GI.Wnck.Objects.Workspace.Workspace', etc..
+
+/Since: 2.20/
+-}
+screenGetWorkspaces ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> m [Wnck.Workspace.Workspace]
+    {- ^ __Returns:__ the list of
+'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/. The list should not be modified nor freed, as it
+is owned by /@screen@/. -}
+screenGetWorkspaces screen = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_get_workspaces screen'
+    result' <- unpackGList result
+    result'' <- mapM (newObject Wnck.Workspace.Workspace) result'
+    touchManagedPtr screen
+    return result''
+
+#if ENABLE_OVERLOADING
+data ScreenGetWorkspacesMethodInfo
+instance (signature ~ (m [Wnck.Workspace.Workspace]), MonadIO m, IsScreen a) => O.MethodInfo ScreenGetWorkspacesMethodInfo a signature where
+    overloadedMethod _ = screenGetWorkspaces
+
+#endif
+
+-- method Screen::move_viewport
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X offset in pixels of viewport.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y offset in pixels of viewport.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_move_viewport" wnck_screen_move_viewport :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    Int32 ->                                -- x : TBasicType TInt
+    Int32 ->                                -- y : TBasicType TInt
+    IO ()
+
+{- |
+Asks the window manager to move the viewport of the current 'GI.Wnck.Objects.Workspace.Workspace'
+on /@screen@/.
+
+/Since: 2.4/
+-}
+screenMoveViewport ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> Int32
+    {- ^ /@x@/: X offset in pixels of viewport. -}
+    -> Int32
+    {- ^ /@y@/: Y offset in pixels of viewport. -}
+    -> m ()
+screenMoveViewport screen x y = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    wnck_screen_move_viewport screen' x y
+    touchManagedPtr screen
+    return ()
+
+#if ENABLE_OVERLOADING
+data ScreenMoveViewportMethodInfo
+instance (signature ~ (Int32 -> Int32 -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenMoveViewportMethodInfo a signature where
+    overloadedMethod _ = screenMoveViewport
+
+#endif
+
+-- method Screen::net_wm_supports
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "atom", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a property atom.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_net_wm_supports" wnck_screen_net_wm_supports :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    CString ->                              -- atom : TBasicType TUTF8
+    IO CInt
+
+{- |
+Gets whether the window manager for /@screen@/ supports a certain hint from
+the \<ulink
+url=\"http:\/\/standards.freedesktop.org\/wm-spec\/wm-spec-latest.html\">Extended
+Window Manager Hints specification\<\/ulink> (EWMH).
+
+When using this function, keep in mind that the window manager can change
+over time; so you should not use this function in a way that impacts
+persistent application state. A common bug is that your application can
+start up before the window manager does when the user logs in, and before
+the window manager starts 'GI.Wnck.Objects.Screen.screenNetWmSupports' will return 'False'
+for every property.
+
+See also @/gdk_x11_screen_supports_net_wm_hint()/@ in GDK.
+-}
+screenNetWmSupports ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> T.Text
+    {- ^ /@atom@/: a property atom. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if the window manager for /@screen@/ supports the /@atom@/
+hint, 'False' otherwise. -}
+screenNetWmSupports screen atom = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    atom' <- textToCString atom
+    result <- wnck_screen_net_wm_supports screen' atom'
+    let result' = (/= 0) result
+    touchManagedPtr screen
+    freeMem atom'
+    return result'
+
+#if ENABLE_OVERLOADING
+data ScreenNetWmSupportsMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m, IsScreen a) => O.MethodInfo ScreenNetWmSupportsMethodInfo a signature where
+    overloadedMethod _ = screenNetWmSupports
+
+#endif
+
+-- method Screen::release_workspace_layout
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "current_token", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the token obtained through\nwnck_screen_try_set_workspace_layout().", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_release_workspace_layout" wnck_screen_release_workspace_layout :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    Int32 ->                                -- current_token : TBasicType TInt
+    IO ()
+
+{- |
+Releases the ownership of the layout of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/.
+/@currentToken@/ is used to verify that the caller is the owner of the layout.
+If the verification fails, nothing happens.
+-}
+screenReleaseWorkspaceLayout ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> Int32
+    {- ^ /@currentToken@/: the token obtained through
+'GI.Wnck.Objects.Screen.screenTrySetWorkspaceLayout'. -}
+    -> m ()
+screenReleaseWorkspaceLayout screen currentToken = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    wnck_screen_release_workspace_layout screen' currentToken
+    touchManagedPtr screen
+    return ()
+
+#if ENABLE_OVERLOADING
+data ScreenReleaseWorkspaceLayoutMethodInfo
+instance (signature ~ (Int32 -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenReleaseWorkspaceLayoutMethodInfo a signature where
+    overloadedMethod _ = screenReleaseWorkspaceLayout
+
+#endif
+
+-- method Screen::toggle_showing_desktop
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to activate the \"showing the desktop\" mode on @screen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_toggle_showing_desktop" wnck_screen_toggle_showing_desktop :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    CInt ->                                 -- show : TBasicType TBoolean
+    IO ()
+
+{- |
+Asks the window manager to set the \"showing the desktop\" mode on /@screen@/
+according to /@show@/.
+
+/Since: 2.2/
+-}
+screenToggleShowingDesktop ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> Bool
+    {- ^ /@show@/: whether to activate the \"showing the desktop\" mode on /@screen@/. -}
+    -> m ()
+screenToggleShowingDesktop screen show_ = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    let show_' = (fromIntegral . fromEnum) show_
+    wnck_screen_toggle_showing_desktop screen' show_'
+    touchManagedPtr screen
+    return ()
+
+#if ENABLE_OVERLOADING
+data ScreenToggleShowingDesktopMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, IsScreen a) => O.MethodInfo ScreenToggleShowingDesktopMethodInfo a signature where
+    overloadedMethod _ = screenToggleShowingDesktop
+
+#endif
+
+-- method Screen::try_set_workspace_layout
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "screen", argType = TInterface (Name {namespace = "Wnck", name = "Screen"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckScreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "current_token", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a token. Use 0 if you do not called\nwnck_screen_try_set_workspace_layout() before, or if you did not keep the\nold token.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rows", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of rows to use for the #WnckWorkspace layout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "columns", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of columns to use for the #WnckWorkspace layout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_try_set_workspace_layout" wnck_screen_try_set_workspace_layout :: 
+    Ptr Screen ->                           -- screen : TInterface (Name {namespace = "Wnck", name = "Screen"})
+    Int32 ->                                -- current_token : TBasicType TInt
+    Int32 ->                                -- rows : TBasicType TInt
+    Int32 ->                                -- columns : TBasicType TInt
+    IO Int32
+
+{- |
+Tries to modify the layout of 'GI.Wnck.Objects.Workspace.Workspace' on /@screen@/. To do this, tries
+to acquire ownership of the layout. If the current process is the owner of
+the layout, /@currentToken@/ is used to determine if the caller is the owner
+(there might be more than one part of the same process trying to set the
+layout). Since no more than one application should set this property of
+/@screen@/ at a time, setting the layout is not guaranteed to work.
+
+If /@rows@/ is 0, the actual number of rows will be determined based on
+/@columns@/ and the number of 'GI.Wnck.Objects.Workspace.Workspace'. If /@columns@/ is 0, the actual
+number of columns will be determined based on /@rows@/ and the number of
+'GI.Wnck.Objects.Workspace.Workspace'. /@rows@/ and /@columns@/ must not be 0 at the same time.
+
+You have to release the ownership of the layout with
+'GI.Wnck.Objects.Screen.screenReleaseWorkspaceLayout' when you do not need it anymore.
+-}
+screenTrySetWorkspaceLayout ::
+    (B.CallStack.HasCallStack, MonadIO m, IsScreen a) =>
+    a
+    {- ^ /@screen@/: a 'GI.Wnck.Objects.Screen.Screen'. -}
+    -> Int32
+    {- ^ /@currentToken@/: a token. Use 0 if you do not called
+'GI.Wnck.Objects.Screen.screenTrySetWorkspaceLayout' before, or if you did not keep the
+old token. -}
+    -> Int32
+    {- ^ /@rows@/: the number of rows to use for the 'GI.Wnck.Objects.Workspace.Workspace' layout. -}
+    -> Int32
+    {- ^ /@columns@/: the number of columns to use for the 'GI.Wnck.Objects.Workspace.Workspace' layout. -}
+    -> m Int32
+    {- ^ __Returns:__ a token to use for future calls to
+'GI.Wnck.Objects.Screen.screenTrySetWorkspaceLayout' and to
+'GI.Wnck.Objects.Screen.screenReleaseWorkspaceLayout', or 0 if the layout could not be set. -}
+screenTrySetWorkspaceLayout screen currentToken rows columns = liftIO $ do
+    screen' <- unsafeManagedPtrCastPtr screen
+    result <- wnck_screen_try_set_workspace_layout screen' currentToken rows columns
+    touchManagedPtr screen
+    return result
+
+#if ENABLE_OVERLOADING
+data ScreenTrySetWorkspaceLayoutMethodInfo
+instance (signature ~ (Int32 -> Int32 -> Int32 -> m Int32), MonadIO m, IsScreen a) => O.MethodInfo ScreenTrySetWorkspaceLayoutMethodInfo a signature where
+    overloadedMethod _ = screenTrySetWorkspaceLayout
+
+#endif
+
+-- method Screen::free_workspace_layout
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "layout", argType = TInterface (Name {namespace = "Wnck", name = "WorkspaceLayout"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspaceLayout.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_free_workspace_layout" wnck_screen_free_workspace_layout :: 
+    Ptr Wnck.WorkspaceLayout.WorkspaceLayout -> -- layout : TInterface (Name {namespace = "Wnck", name = "WorkspaceLayout"})
+    IO ()
+
+{-# DEPRECATED screenFreeWorkspaceLayout ["(Since version 2.20)"] #-}
+{- |
+Frees the content of /@layout@/. This does not free /@layout@/ itself, so you
+might want to free /@layout@/ yourself after calling this.
+
+/Since: 2.12/
+-}
+screenFreeWorkspaceLayout ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    Wnck.WorkspaceLayout.WorkspaceLayout
+    {- ^ /@layout@/: a 'GI.Wnck.Structs.WorkspaceLayout.WorkspaceLayout'. -}
+    -> m ()
+screenFreeWorkspaceLayout layout = liftIO $ do
+    layout' <- unsafeManagedPtrGetPtr layout
+    wnck_screen_free_workspace_layout layout'
+    touchManagedPtr layout
+    return ()
+
+#if ENABLE_OVERLOADING
+#endif
+
+-- method Screen::get
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "index", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "screen number, starting from 0.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Screen"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get" wnck_screen_get :: 
+    Int32 ->                                -- index : TBasicType TInt
+    IO (Ptr Screen)
+
+{- |
+Gets the 'GI.Wnck.Objects.Screen.Screen' for a given screen on the default display.
+-}
+screenGet ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    Int32
+    {- ^ /@index@/: screen number, starting from 0. -}
+    -> m Screen
+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Screen.Screen' for screen /@index@/, or 'Nothing'
+if no such screen exists. The returned 'GI.Wnck.Objects.Screen.Screen' is owned by libwnck and
+must not be referenced or unreferenced. -}
+screenGet index = liftIO $ do
+    result <- wnck_screen_get index
+    checkUnexpectedReturnNULL "screenGet" result
+    result' <- (newObject Screen) result
+    return result'
+
+#if ENABLE_OVERLOADING
+#endif
+
+-- method Screen::get_default
+-- method type : MemberFunction
+-- Args : []
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Screen"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_default" wnck_screen_get_default :: 
+    IO (Ptr Screen)
+
+{- |
+Gets the default 'GI.Wnck.Objects.Screen.Screen' on the default display.
+-}
+screenGetDefault ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    m (Maybe Screen)
+    {- ^ __Returns:__ the default 'GI.Wnck.Objects.Screen.Screen'. The returned
+'GI.Wnck.Objects.Screen.Screen' is owned by libwnck and must not be referenced or unreferenced. This
+can return 'Nothing' if not on X11. -}
+screenGetDefault  = liftIO $ do
+    result <- wnck_screen_get_default
+    maybeResult <- convertIfNonNull result $ \result' -> do
+        result'' <- (newObject Screen) result'
+        return result''
+    return maybeResult
+
+#if ENABLE_OVERLOADING
+#endif
+
+-- method Screen::get_for_root
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "root_window_id", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an X window ID.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Screen"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_screen_get_for_root" wnck_screen_get_for_root :: 
+    CULong ->                               -- root_window_id : TBasicType TULong
+    IO (Ptr Screen)
+
+{- |
+Gets the 'GI.Wnck.Objects.Screen.Screen' for the root window at /@rootWindowId@/, or
+'Nothing' if no 'GI.Wnck.Objects.Screen.Screen' exists for this root window.
+
+This function does not work if 'GI.Wnck.Objects.Screen.screenGet' was not called for the
+sought 'GI.Wnck.Objects.Screen.Screen' before, and returns 'Nothing'.
+-}
+screenGetForRoot ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    CULong
+    {- ^ /@rootWindowId@/: an X window ID. -}
+    -> m Screen
+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Screen.Screen' for the root window at
+/@rootWindowId@/, or 'Nothing'. The returned 'GI.Wnck.Objects.Screen.Screen' is owned by libwnck and
+must not be referenced or unreferenced. -}
+screenGetForRoot rootWindowId = liftIO $ do
+    result <- wnck_screen_get_for_root rootWindowId
+    checkUnexpectedReturnNULL "screenGetForRoot" result
+    result' <- (newObject Screen) result
+    return result'
+
+#if ENABLE_OVERLOADING
+#endif
+
+
diff --git a/GI/Wnck/Objects/Screen.hs-boot b/GI/Wnck/Objects/Screen.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Screen.hs-boot
@@ -0,0 +1,140 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Objects.Screen where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype Screen = Screen (ManagedPtr Screen)
+instance GObject Screen where
+class (GObject o, O.IsDescendantOf Screen o) => IsScreen o
+instance (GObject o, O.IsDescendantOf Screen o) => IsScreen o
+instance O.HasParentTypes Screen
+#if ENABLE_OVERLOADING
+data ScreenActiveWindowChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenActiveWorkspaceChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenApplicationClosedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenApplicationOpenedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenBackgroundChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenClassGroupClosedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenClassGroupOpenedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenShowingDesktopChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenViewportsChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenWindowClosedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenWindowManagerChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenWindowOpenedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenWindowStackingChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenWorkspaceCreatedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenWorkspaceDestroyedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenCalcWorkspaceLayoutMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenChangeWorkspaceCountMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenForceUpdateMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetActiveWindowMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetActiveWorkspaceMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetBackgroundPixmapMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetHeightMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetNumberMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetPreviouslyActiveWindowMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetShowingDesktopMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetWidthMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetWindowManagerNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetWindowsMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetWindowsStackedMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetWorkspaceMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetWorkspaceCountMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenGetWorkspacesMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenMoveViewportMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenNetWmSupportsMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenReleaseWorkspaceLayoutMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenToggleShowingDesktopMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data ScreenTrySetWorkspaceLayoutMethodInfo
+#endif
diff --git a/GI/Wnck/Objects/Selector.hs b/GI/Wnck/Objects/Selector.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Selector.hs
@@ -0,0 +1,480 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+The 'GI.Wnck.Objects.Selector.Selector' struct contains only private fields and should not be
+directly accessed.
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Objects.Selector
+    ( 
+
+-- * Exported types
+    Selector(..)                            ,
+    IsSelector                              ,
+    toSelector                              ,
+    noSelector                              ,
+
+
+ -- * Methods
+-- ** new #method:new#
+
+    selectorNew                             ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
+import qualified GI.GObject.Objects.Object as GObject.Object
+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
+import qualified GI.Gtk.Objects.Container as Gtk.Container
+import qualified GI.Gtk.Objects.MenuBar as Gtk.MenuBar
+import qualified GI.Gtk.Objects.MenuShell as Gtk.MenuShell
+import qualified GI.Gtk.Objects.Widget as Gtk.Widget
+
+-- | Memory-managed wrapper type.
+newtype Selector = Selector (ManagedPtr Selector)
+foreign import ccall "wnck_selector_get_type"
+    c_wnck_selector_get_type :: IO GType
+
+instance GObject Selector where
+    gobjectType = c_wnck_selector_get_type
+    
+
+-- | Type class for types which can be safely cast to `Selector`, for instance with `toSelector`.
+class (GObject o, O.IsDescendantOf Selector o) => IsSelector o
+instance (GObject o, O.IsDescendantOf Selector o) => IsSelector o
+
+instance O.HasParentTypes Selector
+type instance O.ParentTypes Selector = '[Gtk.MenuBar.MenuBar, Gtk.MenuShell.MenuShell, Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]
+
+-- | Cast to `Selector`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
+toSelector :: (MonadIO m, IsSelector o) => o -> m Selector
+toSelector = liftIO . unsafeCastTo Selector
+
+-- | A convenience alias for `Nothing` :: `Maybe` `Selector`.
+noSelector :: Maybe Selector
+noSelector = Nothing
+
+#if ENABLE_OVERLOADING
+type family ResolveSelectorMethod (t :: Symbol) (o :: *) :: * where
+    ResolveSelectorMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
+    ResolveSelectorMethod "activateItem" o = Gtk.MenuShell.MenuShellActivateItemMethodInfo
+    ResolveSelectorMethod "add" o = Gtk.Container.ContainerAddMethodInfo
+    ResolveSelectorMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
+    ResolveSelectorMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
+    ResolveSelectorMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
+    ResolveSelectorMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
+    ResolveSelectorMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
+    ResolveSelectorMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
+    ResolveSelectorMethod "append" o = Gtk.MenuShell.MenuShellAppendMethodInfo
+    ResolveSelectorMethod "bindModel" o = Gtk.MenuShell.MenuShellBindModelMethodInfo
+    ResolveSelectorMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
+    ResolveSelectorMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
+    ResolveSelectorMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
+    ResolveSelectorMethod "cancel" o = Gtk.MenuShell.MenuShellCancelMethodInfo
+    ResolveSelectorMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
+    ResolveSelectorMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
+    ResolveSelectorMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
+    ResolveSelectorMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
+    ResolveSelectorMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
+    ResolveSelectorMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
+    ResolveSelectorMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
+    ResolveSelectorMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
+    ResolveSelectorMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
+    ResolveSelectorMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
+    ResolveSelectorMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
+    ResolveSelectorMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
+    ResolveSelectorMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
+    ResolveSelectorMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
+    ResolveSelectorMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
+    ResolveSelectorMethod "deactivate" o = Gtk.MenuShell.MenuShellDeactivateMethodInfo
+    ResolveSelectorMethod "deselect" o = Gtk.MenuShell.MenuShellDeselectMethodInfo
+    ResolveSelectorMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
+    ResolveSelectorMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
+    ResolveSelectorMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
+    ResolveSelectorMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
+    ResolveSelectorMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
+    ResolveSelectorMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
+    ResolveSelectorMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
+    ResolveSelectorMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
+    ResolveSelectorMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
+    ResolveSelectorMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
+    ResolveSelectorMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
+    ResolveSelectorMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
+    ResolveSelectorMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
+    ResolveSelectorMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
+    ResolveSelectorMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
+    ResolveSelectorMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
+    ResolveSelectorMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
+    ResolveSelectorMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
+    ResolveSelectorMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
+    ResolveSelectorMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
+    ResolveSelectorMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
+    ResolveSelectorMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
+    ResolveSelectorMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
+    ResolveSelectorMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
+    ResolveSelectorMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
+    ResolveSelectorMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
+    ResolveSelectorMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
+    ResolveSelectorMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
+    ResolveSelectorMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
+    ResolveSelectorMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
+    ResolveSelectorMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
+    ResolveSelectorMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
+    ResolveSelectorMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
+    ResolveSelectorMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
+    ResolveSelectorMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
+    ResolveSelectorMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
+    ResolveSelectorMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
+    ResolveSelectorMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
+    ResolveSelectorMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
+    ResolveSelectorMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
+    ResolveSelectorMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
+    ResolveSelectorMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
+    ResolveSelectorMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
+    ResolveSelectorMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
+    ResolveSelectorMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
+    ResolveSelectorMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
+    ResolveSelectorMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
+    ResolveSelectorMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
+    ResolveSelectorMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
+    ResolveSelectorMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
+    ResolveSelectorMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
+    ResolveSelectorMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
+    ResolveSelectorMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
+    ResolveSelectorMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
+    ResolveSelectorMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
+    ResolveSelectorMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
+    ResolveSelectorMethod "insert" o = Gtk.MenuShell.MenuShellInsertMethodInfo
+    ResolveSelectorMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
+    ResolveSelectorMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
+    ResolveSelectorMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
+    ResolveSelectorMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
+    ResolveSelectorMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
+    ResolveSelectorMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
+    ResolveSelectorMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
+    ResolveSelectorMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
+    ResolveSelectorMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
+    ResolveSelectorMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
+    ResolveSelectorMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
+    ResolveSelectorMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
+    ResolveSelectorMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
+    ResolveSelectorMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
+    ResolveSelectorMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
+    ResolveSelectorMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
+    ResolveSelectorMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
+    ResolveSelectorMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
+    ResolveSelectorMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
+    ResolveSelectorMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
+    ResolveSelectorMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
+    ResolveSelectorMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
+    ResolveSelectorMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
+    ResolveSelectorMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
+    ResolveSelectorMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
+    ResolveSelectorMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
+    ResolveSelectorMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
+    ResolveSelectorMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
+    ResolveSelectorMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
+    ResolveSelectorMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
+    ResolveSelectorMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
+    ResolveSelectorMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
+    ResolveSelectorMethod "prepend" o = Gtk.MenuShell.MenuShellPrependMethodInfo
+    ResolveSelectorMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
+    ResolveSelectorMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
+    ResolveSelectorMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
+    ResolveSelectorMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
+    ResolveSelectorMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
+    ResolveSelectorMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
+    ResolveSelectorMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
+    ResolveSelectorMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
+    ResolveSelectorMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
+    ResolveSelectorMethod "ref" o = GObject.Object.ObjectRefMethodInfo
+    ResolveSelectorMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
+    ResolveSelectorMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
+    ResolveSelectorMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
+    ResolveSelectorMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
+    ResolveSelectorMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
+    ResolveSelectorMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
+    ResolveSelectorMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
+    ResolveSelectorMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
+    ResolveSelectorMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
+    ResolveSelectorMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
+    ResolveSelectorMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
+    ResolveSelectorMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
+    ResolveSelectorMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
+    ResolveSelectorMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
+    ResolveSelectorMethod "selectFirst" o = Gtk.MenuShell.MenuShellSelectFirstMethodInfo
+    ResolveSelectorMethod "selectItem" o = Gtk.MenuShell.MenuShellSelectItemMethodInfo
+    ResolveSelectorMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
+    ResolveSelectorMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
+    ResolveSelectorMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
+    ResolveSelectorMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
+    ResolveSelectorMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
+    ResolveSelectorMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
+    ResolveSelectorMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
+    ResolveSelectorMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
+    ResolveSelectorMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
+    ResolveSelectorMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
+    ResolveSelectorMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
+    ResolveSelectorMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
+    ResolveSelectorMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
+    ResolveSelectorMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
+    ResolveSelectorMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
+    ResolveSelectorMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
+    ResolveSelectorMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
+    ResolveSelectorMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
+    ResolveSelectorMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
+    ResolveSelectorMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
+    ResolveSelectorMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
+    ResolveSelectorMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
+    ResolveSelectorMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
+    ResolveSelectorMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
+    ResolveSelectorMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
+    ResolveSelectorMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
+    ResolveSelectorMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
+    ResolveSelectorMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
+    ResolveSelectorMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
+    ResolveSelectorMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
+    ResolveSelectorMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
+    ResolveSelectorMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
+    ResolveSelectorMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
+    ResolveSelectorMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
+    ResolveSelectorMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
+    ResolveSelectorMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
+    ResolveSelectorMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
+    ResolveSelectorMethod "getChildPackDirection" o = Gtk.MenuBar.MenuBarGetChildPackDirectionMethodInfo
+    ResolveSelectorMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
+    ResolveSelectorMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
+    ResolveSelectorMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
+    ResolveSelectorMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
+    ResolveSelectorMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
+    ResolveSelectorMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
+    ResolveSelectorMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
+    ResolveSelectorMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
+    ResolveSelectorMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
+    ResolveSelectorMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
+    ResolveSelectorMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
+    ResolveSelectorMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
+    ResolveSelectorMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
+    ResolveSelectorMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
+    ResolveSelectorMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
+    ResolveSelectorMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
+    ResolveSelectorMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
+    ResolveSelectorMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
+    ResolveSelectorMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
+    ResolveSelectorMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
+    ResolveSelectorMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
+    ResolveSelectorMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
+    ResolveSelectorMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
+    ResolveSelectorMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
+    ResolveSelectorMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
+    ResolveSelectorMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
+    ResolveSelectorMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
+    ResolveSelectorMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
+    ResolveSelectorMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
+    ResolveSelectorMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
+    ResolveSelectorMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
+    ResolveSelectorMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
+    ResolveSelectorMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
+    ResolveSelectorMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
+    ResolveSelectorMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
+    ResolveSelectorMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
+    ResolveSelectorMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
+    ResolveSelectorMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
+    ResolveSelectorMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
+    ResolveSelectorMethod "getPackDirection" o = Gtk.MenuBar.MenuBarGetPackDirectionMethodInfo
+    ResolveSelectorMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
+    ResolveSelectorMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
+    ResolveSelectorMethod "getParentShell" o = Gtk.MenuShell.MenuShellGetParentShellMethodInfo
+    ResolveSelectorMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
+    ResolveSelectorMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
+    ResolveSelectorMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
+    ResolveSelectorMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
+    ResolveSelectorMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
+    ResolveSelectorMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
+    ResolveSelectorMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
+    ResolveSelectorMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
+    ResolveSelectorMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
+    ResolveSelectorMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
+    ResolveSelectorMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
+    ResolveSelectorMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
+    ResolveSelectorMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
+    ResolveSelectorMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
+    ResolveSelectorMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
+    ResolveSelectorMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
+    ResolveSelectorMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
+    ResolveSelectorMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
+    ResolveSelectorMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
+    ResolveSelectorMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
+    ResolveSelectorMethod "getSelectedItem" o = Gtk.MenuShell.MenuShellGetSelectedItemMethodInfo
+    ResolveSelectorMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
+    ResolveSelectorMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
+    ResolveSelectorMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
+    ResolveSelectorMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
+    ResolveSelectorMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
+    ResolveSelectorMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
+    ResolveSelectorMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
+    ResolveSelectorMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
+    ResolveSelectorMethod "getTakeFocus" o = Gtk.MenuShell.MenuShellGetTakeFocusMethodInfo
+    ResolveSelectorMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
+    ResolveSelectorMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
+    ResolveSelectorMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
+    ResolveSelectorMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
+    ResolveSelectorMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
+    ResolveSelectorMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
+    ResolveSelectorMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
+    ResolveSelectorMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
+    ResolveSelectorMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
+    ResolveSelectorMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
+    ResolveSelectorMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
+    ResolveSelectorMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
+    ResolveSelectorMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
+    ResolveSelectorMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
+    ResolveSelectorMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
+    ResolveSelectorMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
+    ResolveSelectorMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
+    ResolveSelectorMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
+    ResolveSelectorMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
+    ResolveSelectorMethod "setChildPackDirection" o = Gtk.MenuBar.MenuBarSetChildPackDirectionMethodInfo
+    ResolveSelectorMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
+    ResolveSelectorMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
+    ResolveSelectorMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
+    ResolveSelectorMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
+    ResolveSelectorMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
+    ResolveSelectorMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
+    ResolveSelectorMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
+    ResolveSelectorMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
+    ResolveSelectorMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
+    ResolveSelectorMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
+    ResolveSelectorMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
+    ResolveSelectorMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
+    ResolveSelectorMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
+    ResolveSelectorMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
+    ResolveSelectorMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
+    ResolveSelectorMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
+    ResolveSelectorMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
+    ResolveSelectorMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
+    ResolveSelectorMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
+    ResolveSelectorMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
+    ResolveSelectorMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
+    ResolveSelectorMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
+    ResolveSelectorMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
+    ResolveSelectorMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
+    ResolveSelectorMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
+    ResolveSelectorMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
+    ResolveSelectorMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
+    ResolveSelectorMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
+    ResolveSelectorMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
+    ResolveSelectorMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
+    ResolveSelectorMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
+    ResolveSelectorMethod "setPackDirection" o = Gtk.MenuBar.MenuBarSetPackDirectionMethodInfo
+    ResolveSelectorMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
+    ResolveSelectorMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
+    ResolveSelectorMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
+    ResolveSelectorMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
+    ResolveSelectorMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
+    ResolveSelectorMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
+    ResolveSelectorMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
+    ResolveSelectorMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
+    ResolveSelectorMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
+    ResolveSelectorMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
+    ResolveSelectorMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
+    ResolveSelectorMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
+    ResolveSelectorMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
+    ResolveSelectorMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
+    ResolveSelectorMethod "setTakeFocus" o = Gtk.MenuShell.MenuShellSetTakeFocusMethodInfo
+    ResolveSelectorMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
+    ResolveSelectorMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
+    ResolveSelectorMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
+    ResolveSelectorMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
+    ResolveSelectorMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
+    ResolveSelectorMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
+    ResolveSelectorMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
+    ResolveSelectorMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
+    ResolveSelectorMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
+    ResolveSelectorMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolveSelectorMethod t Selector, O.MethodInfo info Selector p) => OL.IsLabel t (Selector -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList Selector
+type instance O.AttributeList Selector = SelectorAttributeList
+type SelectorAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("childPackDirection", Gtk.MenuBar.MenuBarChildPackDirectionPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("packDirection", Gtk.MenuBar.MenuBarPackDirectionPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("takeFocus", Gtk.MenuShell.MenuShellTakeFocusPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+#endif
+
+#if ENABLE_OVERLOADING
+type instance O.SignalList Selector = SelectorSignalList
+type SelectorSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("activateCurrent", Gtk.MenuShell.MenuShellActivateCurrentSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("cancel", Gtk.MenuShell.MenuShellCancelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("cycleFocus", Gtk.MenuShell.MenuShellCycleFocusSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deactivate", Gtk.MenuShell.MenuShellDeactivateSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("insert", Gtk.MenuShell.MenuShellInsertSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveCurrent", Gtk.MenuShell.MenuShellMoveCurrentSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveSelected", Gtk.MenuShell.MenuShellMoveSelectedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionDone", Gtk.MenuShell.MenuShellSelectionDoneSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])
+
+#endif
+
+-- method Selector::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Selector"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_selector_new" wnck_selector_new :: 
+    IO (Ptr Selector)
+
+{- |
+Creates a new 'GI.Wnck.Objects.Selector.Selector'. The 'GI.Wnck.Objects.Selector.Selector' will list 'GI.Wnck.Objects.Window.Window' of the
+'GI.Wnck.Objects.Screen.Screen' it is on.
+
+/Since: 2.10/
+-}
+selectorNew ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    m Selector
+    {- ^ __Returns:__ a newly created 'GI.Wnck.Objects.Selector.Selector'. -}
+selectorNew  = liftIO $ do
+    result <- wnck_selector_new
+    checkUnexpectedReturnNULL "selectorNew" result
+    result' <- (newObject Selector) result
+    return result'
+
+#if ENABLE_OVERLOADING
+#endif
+
+
diff --git a/GI/Wnck/Objects/Selector.hs-boot b/GI/Wnck/Objects/Selector.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Selector.hs-boot
@@ -0,0 +1,29 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Objects.Selector where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype Selector = Selector (ManagedPtr Selector)
+instance GObject Selector where
+class (GObject o, O.IsDescendantOf Selector o) => IsSelector o
+instance (GObject o, O.IsDescendantOf Selector o) => IsSelector o
+instance O.HasParentTypes Selector
diff --git a/GI/Wnck/Objects/Tasklist.hs b/GI/Wnck/Objects/Tasklist.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Tasklist.hs
@@ -0,0 +1,1141 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+The 'GI.Wnck.Objects.Tasklist.Tasklist' struct contains only private fields and should not be
+directly accessed.
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Objects.Tasklist
+    ( 
+
+-- * Exported types
+    Tasklist(..)                            ,
+    IsTasklist                              ,
+    toTasklist                              ,
+    noTasklist                              ,
+
+
+ -- * Methods
+-- ** getScrollEnabled #method:getScrollEnabled#
+
+#if ENABLE_OVERLOADING
+    TasklistGetScrollEnabledMethodInfo      ,
+#endif
+    tasklistGetScrollEnabled                ,
+
+
+-- ** getSizeHintList #method:getSizeHintList#
+
+#if ENABLE_OVERLOADING
+    TasklistGetSizeHintListMethodInfo       ,
+#endif
+    tasklistGetSizeHintList                 ,
+
+
+-- ** new #method:new#
+
+    tasklistNew                             ,
+
+
+-- ** setButtonRelief #method:setButtonRelief#
+
+#if ENABLE_OVERLOADING
+    TasklistSetButtonReliefMethodInfo       ,
+#endif
+    tasklistSetButtonRelief                 ,
+
+
+-- ** setGrouping #method:setGrouping#
+
+#if ENABLE_OVERLOADING
+    TasklistSetGroupingMethodInfo           ,
+#endif
+    tasklistSetGrouping                     ,
+
+
+-- ** setGroupingLimit #method:setGroupingLimit#
+
+#if ENABLE_OVERLOADING
+    TasklistSetGroupingLimitMethodInfo      ,
+#endif
+    tasklistSetGroupingLimit                ,
+
+
+-- ** setIncludeAllWorkspaces #method:setIncludeAllWorkspaces#
+
+#if ENABLE_OVERLOADING
+    TasklistSetIncludeAllWorkspacesMethodInfo,
+#endif
+    tasklistSetIncludeAllWorkspaces         ,
+
+
+-- ** setMiddleClickClose #method:setMiddleClickClose#
+
+#if ENABLE_OVERLOADING
+    TasklistSetMiddleClickCloseMethodInfo   ,
+#endif
+    tasklistSetMiddleClickClose             ,
+
+
+-- ** setOrientation #method:setOrientation#
+
+#if ENABLE_OVERLOADING
+    TasklistSetOrientationMethodInfo        ,
+#endif
+    tasklistSetOrientation                  ,
+
+
+-- ** setScrollEnabled #method:setScrollEnabled#
+
+#if ENABLE_OVERLOADING
+    TasklistSetScrollEnabledMethodInfo      ,
+#endif
+    tasklistSetScrollEnabled                ,
+
+
+-- ** setSwitchWorkspaceOnUnminimize #method:setSwitchWorkspaceOnUnminimize#
+
+#if ENABLE_OVERLOADING
+    TasklistSetSwitchWorkspaceOnUnminimizeMethodInfo,
+#endif
+    tasklistSetSwitchWorkspaceOnUnminimize  ,
+
+
+
+
+ -- * Signals
+-- ** taskEnterNotify #signal:taskEnterNotify#
+
+    C_TasklistTaskEnterNotifyCallback       ,
+    TasklistTaskEnterNotifyCallback         ,
+#if ENABLE_OVERLOADING
+    TasklistTaskEnterNotifySignalInfo       ,
+#endif
+    afterTasklistTaskEnterNotify            ,
+    genClosure_TasklistTaskEnterNotify      ,
+    mk_TasklistTaskEnterNotifyCallback      ,
+    noTasklistTaskEnterNotifyCallback       ,
+    onTasklistTaskEnterNotify               ,
+    wrap_TasklistTaskEnterNotifyCallback    ,
+
+
+-- ** taskLeaveNotify #signal:taskLeaveNotify#
+
+    C_TasklistTaskLeaveNotifyCallback       ,
+    TasklistTaskLeaveNotifyCallback         ,
+#if ENABLE_OVERLOADING
+    TasklistTaskLeaveNotifySignalInfo       ,
+#endif
+    afterTasklistTaskLeaveNotify            ,
+    genClosure_TasklistTaskLeaveNotify      ,
+    mk_TasklistTaskLeaveNotifyCallback      ,
+    noTasklistTaskLeaveNotifyCallback       ,
+    onTasklistTaskLeaveNotify               ,
+    wrap_TasklistTaskLeaveNotifyCallback    ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+import qualified GI.Atk.Interfaces.ImplementorIface as Atk.ImplementorIface
+import qualified GI.GObject.Objects.Object as GObject.Object
+import qualified GI.Gtk.Enums as Gtk.Enums
+import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
+import qualified GI.Gtk.Objects.Container as Gtk.Container
+import qualified GI.Gtk.Objects.Widget as Gtk.Widget
+import {-# SOURCE #-} qualified GI.Wnck.Enums as Wnck.Enums
+
+-- | Memory-managed wrapper type.
+newtype Tasklist = Tasklist (ManagedPtr Tasklist)
+foreign import ccall "wnck_tasklist_get_type"
+    c_wnck_tasklist_get_type :: IO GType
+
+instance GObject Tasklist where
+    gobjectType = c_wnck_tasklist_get_type
+    
+
+-- | Type class for types which can be safely cast to `Tasklist`, for instance with `toTasklist`.
+class (GObject o, O.IsDescendantOf Tasklist o) => IsTasklist o
+instance (GObject o, O.IsDescendantOf Tasklist o) => IsTasklist o
+
+instance O.HasParentTypes Tasklist
+type instance O.ParentTypes Tasklist = '[Gtk.Container.Container, Gtk.Widget.Widget, GObject.Object.Object, Atk.ImplementorIface.ImplementorIface, Gtk.Buildable.Buildable]
+
+-- | Cast to `Tasklist`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
+toTasklist :: (MonadIO m, IsTasklist o) => o -> m Tasklist
+toTasklist = liftIO . unsafeCastTo Tasklist
+
+-- | A convenience alias for `Nothing` :: `Maybe` `Tasklist`.
+noTasklist :: Maybe Tasklist
+noTasklist = Nothing
+
+#if ENABLE_OVERLOADING
+type family ResolveTasklistMethod (t :: Symbol) (o :: *) :: * where
+    ResolveTasklistMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
+    ResolveTasklistMethod "add" o = Gtk.Container.ContainerAddMethodInfo
+    ResolveTasklistMethod "addAccelerator" o = Gtk.Widget.WidgetAddAcceleratorMethodInfo
+    ResolveTasklistMethod "addChild" o = Gtk.Buildable.BuildableAddChildMethodInfo
+    ResolveTasklistMethod "addDeviceEvents" o = Gtk.Widget.WidgetAddDeviceEventsMethodInfo
+    ResolveTasklistMethod "addEvents" o = Gtk.Widget.WidgetAddEventsMethodInfo
+    ResolveTasklistMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
+    ResolveTasklistMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
+    ResolveTasklistMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
+    ResolveTasklistMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
+    ResolveTasklistMethod "canActivateAccel" o = Gtk.Widget.WidgetCanActivateAccelMethodInfo
+    ResolveTasklistMethod "checkResize" o = Gtk.Container.ContainerCheckResizeMethodInfo
+    ResolveTasklistMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
+    ResolveTasklistMethod "childGetProperty" o = Gtk.Container.ContainerChildGetPropertyMethodInfo
+    ResolveTasklistMethod "childNotify" o = Gtk.Container.ContainerChildNotifyMethodInfo
+    ResolveTasklistMethod "childNotifyByPspec" o = Gtk.Container.ContainerChildNotifyByPspecMethodInfo
+    ResolveTasklistMethod "childSetProperty" o = Gtk.Container.ContainerChildSetPropertyMethodInfo
+    ResolveTasklistMethod "childType" o = Gtk.Container.ContainerChildTypeMethodInfo
+    ResolveTasklistMethod "classPath" o = Gtk.Widget.WidgetClassPathMethodInfo
+    ResolveTasklistMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
+    ResolveTasklistMethod "constructChild" o = Gtk.Buildable.BuildableConstructChildMethodInfo
+    ResolveTasklistMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
+    ResolveTasklistMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
+    ResolveTasklistMethod "customFinished" o = Gtk.Buildable.BuildableCustomFinishedMethodInfo
+    ResolveTasklistMethod "customTagEnd" o = Gtk.Buildable.BuildableCustomTagEndMethodInfo
+    ResolveTasklistMethod "customTagStart" o = Gtk.Buildable.BuildableCustomTagStartMethodInfo
+    ResolveTasklistMethod "destroy" o = Gtk.Widget.WidgetDestroyMethodInfo
+    ResolveTasklistMethod "destroyed" o = Gtk.Widget.WidgetDestroyedMethodInfo
+    ResolveTasklistMethod "deviceIsShadowed" o = Gtk.Widget.WidgetDeviceIsShadowedMethodInfo
+    ResolveTasklistMethod "dragBegin" o = Gtk.Widget.WidgetDragBeginMethodInfo
+    ResolveTasklistMethod "dragBeginWithCoordinates" o = Gtk.Widget.WidgetDragBeginWithCoordinatesMethodInfo
+    ResolveTasklistMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
+    ResolveTasklistMethod "dragDestAddImageTargets" o = Gtk.Widget.WidgetDragDestAddImageTargetsMethodInfo
+    ResolveTasklistMethod "dragDestAddTextTargets" o = Gtk.Widget.WidgetDragDestAddTextTargetsMethodInfo
+    ResolveTasklistMethod "dragDestAddUriTargets" o = Gtk.Widget.WidgetDragDestAddUriTargetsMethodInfo
+    ResolveTasklistMethod "dragDestFindTarget" o = Gtk.Widget.WidgetDragDestFindTargetMethodInfo
+    ResolveTasklistMethod "dragDestGetTargetList" o = Gtk.Widget.WidgetDragDestGetTargetListMethodInfo
+    ResolveTasklistMethod "dragDestGetTrackMotion" o = Gtk.Widget.WidgetDragDestGetTrackMotionMethodInfo
+    ResolveTasklistMethod "dragDestSet" o = Gtk.Widget.WidgetDragDestSetMethodInfo
+    ResolveTasklistMethod "dragDestSetProxy" o = Gtk.Widget.WidgetDragDestSetProxyMethodInfo
+    ResolveTasklistMethod "dragDestSetTargetList" o = Gtk.Widget.WidgetDragDestSetTargetListMethodInfo
+    ResolveTasklistMethod "dragDestSetTrackMotion" o = Gtk.Widget.WidgetDragDestSetTrackMotionMethodInfo
+    ResolveTasklistMethod "dragDestUnset" o = Gtk.Widget.WidgetDragDestUnsetMethodInfo
+    ResolveTasklistMethod "dragGetData" o = Gtk.Widget.WidgetDragGetDataMethodInfo
+    ResolveTasklistMethod "dragHighlight" o = Gtk.Widget.WidgetDragHighlightMethodInfo
+    ResolveTasklistMethod "dragSourceAddImageTargets" o = Gtk.Widget.WidgetDragSourceAddImageTargetsMethodInfo
+    ResolveTasklistMethod "dragSourceAddTextTargets" o = Gtk.Widget.WidgetDragSourceAddTextTargetsMethodInfo
+    ResolveTasklistMethod "dragSourceAddUriTargets" o = Gtk.Widget.WidgetDragSourceAddUriTargetsMethodInfo
+    ResolveTasklistMethod "dragSourceGetTargetList" o = Gtk.Widget.WidgetDragSourceGetTargetListMethodInfo
+    ResolveTasklistMethod "dragSourceSet" o = Gtk.Widget.WidgetDragSourceSetMethodInfo
+    ResolveTasklistMethod "dragSourceSetIconGicon" o = Gtk.Widget.WidgetDragSourceSetIconGiconMethodInfo
+    ResolveTasklistMethod "dragSourceSetIconName" o = Gtk.Widget.WidgetDragSourceSetIconNameMethodInfo
+    ResolveTasklistMethod "dragSourceSetIconPixbuf" o = Gtk.Widget.WidgetDragSourceSetIconPixbufMethodInfo
+    ResolveTasklistMethod "dragSourceSetIconStock" o = Gtk.Widget.WidgetDragSourceSetIconStockMethodInfo
+    ResolveTasklistMethod "dragSourceSetTargetList" o = Gtk.Widget.WidgetDragSourceSetTargetListMethodInfo
+    ResolveTasklistMethod "dragSourceUnset" o = Gtk.Widget.WidgetDragSourceUnsetMethodInfo
+    ResolveTasklistMethod "dragUnhighlight" o = Gtk.Widget.WidgetDragUnhighlightMethodInfo
+    ResolveTasklistMethod "draw" o = Gtk.Widget.WidgetDrawMethodInfo
+    ResolveTasklistMethod "ensureStyle" o = Gtk.Widget.WidgetEnsureStyleMethodInfo
+    ResolveTasklistMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
+    ResolveTasklistMethod "event" o = Gtk.Widget.WidgetEventMethodInfo
+    ResolveTasklistMethod "forall" o = Gtk.Container.ContainerForallMethodInfo
+    ResolveTasklistMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
+    ResolveTasklistMethod "foreach" o = Gtk.Container.ContainerForeachMethodInfo
+    ResolveTasklistMethod "freezeChildNotify" o = Gtk.Widget.WidgetFreezeChildNotifyMethodInfo
+    ResolveTasklistMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
+    ResolveTasklistMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
+    ResolveTasklistMethod "grabAdd" o = Gtk.Widget.WidgetGrabAddMethodInfo
+    ResolveTasklistMethod "grabDefault" o = Gtk.Widget.WidgetGrabDefaultMethodInfo
+    ResolveTasklistMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
+    ResolveTasklistMethod "grabRemove" o = Gtk.Widget.WidgetGrabRemoveMethodInfo
+    ResolveTasklistMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
+    ResolveTasklistMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
+    ResolveTasklistMethod "hasGrab" o = Gtk.Widget.WidgetHasGrabMethodInfo
+    ResolveTasklistMethod "hasRcStyle" o = Gtk.Widget.WidgetHasRcStyleMethodInfo
+    ResolveTasklistMethod "hasScreen" o = Gtk.Widget.WidgetHasScreenMethodInfo
+    ResolveTasklistMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
+    ResolveTasklistMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
+    ResolveTasklistMethod "hideOnDelete" o = Gtk.Widget.WidgetHideOnDeleteMethodInfo
+    ResolveTasklistMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
+    ResolveTasklistMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
+    ResolveTasklistMethod "inputShapeCombineRegion" o = Gtk.Widget.WidgetInputShapeCombineRegionMethodInfo
+    ResolveTasklistMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
+    ResolveTasklistMethod "intersect" o = Gtk.Widget.WidgetIntersectMethodInfo
+    ResolveTasklistMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
+    ResolveTasklistMethod "isComposited" o = Gtk.Widget.WidgetIsCompositedMethodInfo
+    ResolveTasklistMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
+    ResolveTasklistMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
+    ResolveTasklistMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
+    ResolveTasklistMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
+    ResolveTasklistMethod "isToplevel" o = Gtk.Widget.WidgetIsToplevelMethodInfo
+    ResolveTasklistMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
+    ResolveTasklistMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
+    ResolveTasklistMethod "listAccelClosures" o = Gtk.Widget.WidgetListAccelClosuresMethodInfo
+    ResolveTasklistMethod "listActionPrefixes" o = Gtk.Widget.WidgetListActionPrefixesMethodInfo
+    ResolveTasklistMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
+    ResolveTasklistMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
+    ResolveTasklistMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
+    ResolveTasklistMethod "modifyBase" o = Gtk.Widget.WidgetModifyBaseMethodInfo
+    ResolveTasklistMethod "modifyBg" o = Gtk.Widget.WidgetModifyBgMethodInfo
+    ResolveTasklistMethod "modifyCursor" o = Gtk.Widget.WidgetModifyCursorMethodInfo
+    ResolveTasklistMethod "modifyFg" o = Gtk.Widget.WidgetModifyFgMethodInfo
+    ResolveTasklistMethod "modifyFont" o = Gtk.Widget.WidgetModifyFontMethodInfo
+    ResolveTasklistMethod "modifyStyle" o = Gtk.Widget.WidgetModifyStyleMethodInfo
+    ResolveTasklistMethod "modifyText" o = Gtk.Widget.WidgetModifyTextMethodInfo
+    ResolveTasklistMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
+    ResolveTasklistMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
+    ResolveTasklistMethod "overrideBackgroundColor" o = Gtk.Widget.WidgetOverrideBackgroundColorMethodInfo
+    ResolveTasklistMethod "overrideColor" o = Gtk.Widget.WidgetOverrideColorMethodInfo
+    ResolveTasklistMethod "overrideCursor" o = Gtk.Widget.WidgetOverrideCursorMethodInfo
+    ResolveTasklistMethod "overrideFont" o = Gtk.Widget.WidgetOverrideFontMethodInfo
+    ResolveTasklistMethod "overrideSymbolicColor" o = Gtk.Widget.WidgetOverrideSymbolicColorMethodInfo
+    ResolveTasklistMethod "parserFinished" o = Gtk.Buildable.BuildableParserFinishedMethodInfo
+    ResolveTasklistMethod "path" o = Gtk.Widget.WidgetPathMethodInfo
+    ResolveTasklistMethod "propagateDraw" o = Gtk.Container.ContainerPropagateDrawMethodInfo
+    ResolveTasklistMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
+    ResolveTasklistMethod "queueComputeExpand" o = Gtk.Widget.WidgetQueueComputeExpandMethodInfo
+    ResolveTasklistMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
+    ResolveTasklistMethod "queueDrawArea" o = Gtk.Widget.WidgetQueueDrawAreaMethodInfo
+    ResolveTasklistMethod "queueDrawRegion" o = Gtk.Widget.WidgetQueueDrawRegionMethodInfo
+    ResolveTasklistMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
+    ResolveTasklistMethod "queueResizeNoRedraw" o = Gtk.Widget.WidgetQueueResizeNoRedrawMethodInfo
+    ResolveTasklistMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
+    ResolveTasklistMethod "ref" o = GObject.Object.ObjectRefMethodInfo
+    ResolveTasklistMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
+    ResolveTasklistMethod "regionIntersect" o = Gtk.Widget.WidgetRegionIntersectMethodInfo
+    ResolveTasklistMethod "registerWindow" o = Gtk.Widget.WidgetRegisterWindowMethodInfo
+    ResolveTasklistMethod "remove" o = Gtk.Container.ContainerRemoveMethodInfo
+    ResolveTasklistMethod "removeAccelerator" o = Gtk.Widget.WidgetRemoveAcceleratorMethodInfo
+    ResolveTasklistMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
+    ResolveTasklistMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
+    ResolveTasklistMethod "renderIcon" o = Gtk.Widget.WidgetRenderIconMethodInfo
+    ResolveTasklistMethod "renderIconPixbuf" o = Gtk.Widget.WidgetRenderIconPixbufMethodInfo
+    ResolveTasklistMethod "reparent" o = Gtk.Widget.WidgetReparentMethodInfo
+    ResolveTasklistMethod "resetRcStyles" o = Gtk.Widget.WidgetResetRcStylesMethodInfo
+    ResolveTasklistMethod "resetStyle" o = Gtk.Widget.WidgetResetStyleMethodInfo
+    ResolveTasklistMethod "resizeChildren" o = Gtk.Container.ContainerResizeChildrenMethodInfo
+    ResolveTasklistMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
+    ResolveTasklistMethod "sendExpose" o = Gtk.Widget.WidgetSendExposeMethodInfo
+    ResolveTasklistMethod "sendFocusChange" o = Gtk.Widget.WidgetSendFocusChangeMethodInfo
+    ResolveTasklistMethod "shapeCombineRegion" o = Gtk.Widget.WidgetShapeCombineRegionMethodInfo
+    ResolveTasklistMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
+    ResolveTasklistMethod "showAll" o = Gtk.Widget.WidgetShowAllMethodInfo
+    ResolveTasklistMethod "showNow" o = Gtk.Widget.WidgetShowNowMethodInfo
+    ResolveTasklistMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
+    ResolveTasklistMethod "sizeAllocateWithBaseline" o = Gtk.Widget.WidgetSizeAllocateWithBaselineMethodInfo
+    ResolveTasklistMethod "sizeRequest" o = Gtk.Widget.WidgetSizeRequestMethodInfo
+    ResolveTasklistMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
+    ResolveTasklistMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
+    ResolveTasklistMethod "styleAttach" o = Gtk.Widget.WidgetStyleAttachMethodInfo
+    ResolveTasklistMethod "styleGetProperty" o = Gtk.Widget.WidgetStyleGetPropertyMethodInfo
+    ResolveTasklistMethod "thawChildNotify" o = Gtk.Widget.WidgetThawChildNotifyMethodInfo
+    ResolveTasklistMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
+    ResolveTasklistMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
+    ResolveTasklistMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
+    ResolveTasklistMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
+    ResolveTasklistMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
+    ResolveTasklistMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
+    ResolveTasklistMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
+    ResolveTasklistMethod "unregisterWindow" o = Gtk.Widget.WidgetUnregisterWindowMethodInfo
+    ResolveTasklistMethod "unsetFocusChain" o = Gtk.Container.ContainerUnsetFocusChainMethodInfo
+    ResolveTasklistMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
+    ResolveTasklistMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
+    ResolveTasklistMethod "getAccessible" o = Gtk.Widget.WidgetGetAccessibleMethodInfo
+    ResolveTasklistMethod "getActionGroup" o = Gtk.Widget.WidgetGetActionGroupMethodInfo
+    ResolveTasklistMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
+    ResolveTasklistMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
+    ResolveTasklistMethod "getAllocatedSize" o = Gtk.Widget.WidgetGetAllocatedSizeMethodInfo
+    ResolveTasklistMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
+    ResolveTasklistMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
+    ResolveTasklistMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
+    ResolveTasklistMethod "getAppPaintable" o = Gtk.Widget.WidgetGetAppPaintableMethodInfo
+    ResolveTasklistMethod "getBorderWidth" o = Gtk.Container.ContainerGetBorderWidthMethodInfo
+    ResolveTasklistMethod "getCanDefault" o = Gtk.Widget.WidgetGetCanDefaultMethodInfo
+    ResolveTasklistMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
+    ResolveTasklistMethod "getChildRequisition" o = Gtk.Widget.WidgetGetChildRequisitionMethodInfo
+    ResolveTasklistMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
+    ResolveTasklistMethod "getChildren" o = Gtk.Container.ContainerGetChildrenMethodInfo
+    ResolveTasklistMethod "getClip" o = Gtk.Widget.WidgetGetClipMethodInfo
+    ResolveTasklistMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
+    ResolveTasklistMethod "getCompositeName" o = Gtk.Widget.WidgetGetCompositeNameMethodInfo
+    ResolveTasklistMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
+    ResolveTasklistMethod "getDeviceEnabled" o = Gtk.Widget.WidgetGetDeviceEnabledMethodInfo
+    ResolveTasklistMethod "getDeviceEvents" o = Gtk.Widget.WidgetGetDeviceEventsMethodInfo
+    ResolveTasklistMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
+    ResolveTasklistMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
+    ResolveTasklistMethod "getDoubleBuffered" o = Gtk.Widget.WidgetGetDoubleBufferedMethodInfo
+    ResolveTasklistMethod "getEvents" o = Gtk.Widget.WidgetGetEventsMethodInfo
+    ResolveTasklistMethod "getFocusChain" o = Gtk.Container.ContainerGetFocusChainMethodInfo
+    ResolveTasklistMethod "getFocusChild" o = Gtk.Container.ContainerGetFocusChildMethodInfo
+    ResolveTasklistMethod "getFocusHadjustment" o = Gtk.Container.ContainerGetFocusHadjustmentMethodInfo
+    ResolveTasklistMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
+    ResolveTasklistMethod "getFocusVadjustment" o = Gtk.Container.ContainerGetFocusVadjustmentMethodInfo
+    ResolveTasklistMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
+    ResolveTasklistMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
+    ResolveTasklistMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
+    ResolveTasklistMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
+    ResolveTasklistMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
+    ResolveTasklistMethod "getHasWindow" o = Gtk.Widget.WidgetGetHasWindowMethodInfo
+    ResolveTasklistMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
+    ResolveTasklistMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
+    ResolveTasklistMethod "getInternalChild" o = Gtk.Buildable.BuildableGetInternalChildMethodInfo
+    ResolveTasklistMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
+    ResolveTasklistMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
+    ResolveTasklistMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
+    ResolveTasklistMethod "getMarginLeft" o = Gtk.Widget.WidgetGetMarginLeftMethodInfo
+    ResolveTasklistMethod "getMarginRight" o = Gtk.Widget.WidgetGetMarginRightMethodInfo
+    ResolveTasklistMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
+    ResolveTasklistMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
+    ResolveTasklistMethod "getModifierMask" o = Gtk.Widget.WidgetGetModifierMaskMethodInfo
+    ResolveTasklistMethod "getModifierStyle" o = Gtk.Widget.WidgetGetModifierStyleMethodInfo
+    ResolveTasklistMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
+    ResolveTasklistMethod "getNoShowAll" o = Gtk.Widget.WidgetGetNoShowAllMethodInfo
+    ResolveTasklistMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
+    ResolveTasklistMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
+    ResolveTasklistMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
+    ResolveTasklistMethod "getParentWindow" o = Gtk.Widget.WidgetGetParentWindowMethodInfo
+    ResolveTasklistMethod "getPath" o = Gtk.Widget.WidgetGetPathMethodInfo
+    ResolveTasklistMethod "getPathForChild" o = Gtk.Container.ContainerGetPathForChildMethodInfo
+    ResolveTasklistMethod "getPointer" o = Gtk.Widget.WidgetGetPointerMethodInfo
+    ResolveTasklistMethod "getPreferredHeight" o = Gtk.Widget.WidgetGetPreferredHeightMethodInfo
+    ResolveTasklistMethod "getPreferredHeightAndBaselineForWidth" o = Gtk.Widget.WidgetGetPreferredHeightAndBaselineForWidthMethodInfo
+    ResolveTasklistMethod "getPreferredHeightForWidth" o = Gtk.Widget.WidgetGetPreferredHeightForWidthMethodInfo
+    ResolveTasklistMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
+    ResolveTasklistMethod "getPreferredWidth" o = Gtk.Widget.WidgetGetPreferredWidthMethodInfo
+    ResolveTasklistMethod "getPreferredWidthForHeight" o = Gtk.Widget.WidgetGetPreferredWidthForHeightMethodInfo
+    ResolveTasklistMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
+    ResolveTasklistMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
+    ResolveTasklistMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
+    ResolveTasklistMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
+    ResolveTasklistMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
+    ResolveTasklistMethod "getRequisition" o = Gtk.Widget.WidgetGetRequisitionMethodInfo
+    ResolveTasklistMethod "getResizeMode" o = Gtk.Container.ContainerGetResizeModeMethodInfo
+    ResolveTasklistMethod "getRootWindow" o = Gtk.Widget.WidgetGetRootWindowMethodInfo
+    ResolveTasklistMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
+    ResolveTasklistMethod "getScreen" o = Gtk.Widget.WidgetGetScreenMethodInfo
+    ResolveTasklistMethod "getScrollEnabled" o = TasklistGetScrollEnabledMethodInfo
+    ResolveTasklistMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
+    ResolveTasklistMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
+    ResolveTasklistMethod "getSizeHintList" o = TasklistGetSizeHintListMethodInfo
+    ResolveTasklistMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
+    ResolveTasklistMethod "getState" o = Gtk.Widget.WidgetGetStateMethodInfo
+    ResolveTasklistMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
+    ResolveTasklistMethod "getStyle" o = Gtk.Widget.WidgetGetStyleMethodInfo
+    ResolveTasklistMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
+    ResolveTasklistMethod "getSupportMultidevice" o = Gtk.Widget.WidgetGetSupportMultideviceMethodInfo
+    ResolveTasklistMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
+    ResolveTasklistMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
+    ResolveTasklistMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
+    ResolveTasklistMethod "getTooltipWindow" o = Gtk.Widget.WidgetGetTooltipWindowMethodInfo
+    ResolveTasklistMethod "getToplevel" o = Gtk.Widget.WidgetGetToplevelMethodInfo
+    ResolveTasklistMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
+    ResolveTasklistMethod "getValignWithBaseline" o = Gtk.Widget.WidgetGetValignWithBaselineMethodInfo
+    ResolveTasklistMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
+    ResolveTasklistMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
+    ResolveTasklistMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
+    ResolveTasklistMethod "getVisual" o = Gtk.Widget.WidgetGetVisualMethodInfo
+    ResolveTasklistMethod "getWindow" o = Gtk.Widget.WidgetGetWindowMethodInfo
+    ResolveTasklistMethod "setAccelPath" o = Gtk.Widget.WidgetSetAccelPathMethodInfo
+    ResolveTasklistMethod "setAllocation" o = Gtk.Widget.WidgetSetAllocationMethodInfo
+    ResolveTasklistMethod "setAppPaintable" o = Gtk.Widget.WidgetSetAppPaintableMethodInfo
+    ResolveTasklistMethod "setBorderWidth" o = Gtk.Container.ContainerSetBorderWidthMethodInfo
+    ResolveTasklistMethod "setBuildableProperty" o = Gtk.Buildable.BuildableSetBuildablePropertyMethodInfo
+    ResolveTasklistMethod "setButtonRelief" o = TasklistSetButtonReliefMethodInfo
+    ResolveTasklistMethod "setCanDefault" o = Gtk.Widget.WidgetSetCanDefaultMethodInfo
+    ResolveTasklistMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
+    ResolveTasklistMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
+    ResolveTasklistMethod "setClip" o = Gtk.Widget.WidgetSetClipMethodInfo
+    ResolveTasklistMethod "setCompositeName" o = Gtk.Widget.WidgetSetCompositeNameMethodInfo
+    ResolveTasklistMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
+    ResolveTasklistMethod "setDeviceEnabled" o = Gtk.Widget.WidgetSetDeviceEnabledMethodInfo
+    ResolveTasklistMethod "setDeviceEvents" o = Gtk.Widget.WidgetSetDeviceEventsMethodInfo
+    ResolveTasklistMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
+    ResolveTasklistMethod "setDoubleBuffered" o = Gtk.Widget.WidgetSetDoubleBufferedMethodInfo
+    ResolveTasklistMethod "setEvents" o = Gtk.Widget.WidgetSetEventsMethodInfo
+    ResolveTasklistMethod "setFocusChain" o = Gtk.Container.ContainerSetFocusChainMethodInfo
+    ResolveTasklistMethod "setFocusChild" o = Gtk.Container.ContainerSetFocusChildMethodInfo
+    ResolveTasklistMethod "setFocusHadjustment" o = Gtk.Container.ContainerSetFocusHadjustmentMethodInfo
+    ResolveTasklistMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
+    ResolveTasklistMethod "setFocusVadjustment" o = Gtk.Container.ContainerSetFocusVadjustmentMethodInfo
+    ResolveTasklistMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
+    ResolveTasklistMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
+    ResolveTasklistMethod "setGrouping" o = TasklistSetGroupingMethodInfo
+    ResolveTasklistMethod "setGroupingLimit" o = TasklistSetGroupingLimitMethodInfo
+    ResolveTasklistMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
+    ResolveTasklistMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
+    ResolveTasklistMethod "setHasWindow" o = Gtk.Widget.WidgetSetHasWindowMethodInfo
+    ResolveTasklistMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
+    ResolveTasklistMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
+    ResolveTasklistMethod "setIncludeAllWorkspaces" o = TasklistSetIncludeAllWorkspacesMethodInfo
+    ResolveTasklistMethod "setMapped" o = Gtk.Widget.WidgetSetMappedMethodInfo
+    ResolveTasklistMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
+    ResolveTasklistMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
+    ResolveTasklistMethod "setMarginLeft" o = Gtk.Widget.WidgetSetMarginLeftMethodInfo
+    ResolveTasklistMethod "setMarginRight" o = Gtk.Widget.WidgetSetMarginRightMethodInfo
+    ResolveTasklistMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
+    ResolveTasklistMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
+    ResolveTasklistMethod "setMiddleClickClose" o = TasklistSetMiddleClickCloseMethodInfo
+    ResolveTasklistMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
+    ResolveTasklistMethod "setNoShowAll" o = Gtk.Widget.WidgetSetNoShowAllMethodInfo
+    ResolveTasklistMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
+    ResolveTasklistMethod "setOrientation" o = TasklistSetOrientationMethodInfo
+    ResolveTasklistMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
+    ResolveTasklistMethod "setParentWindow" o = Gtk.Widget.WidgetSetParentWindowMethodInfo
+    ResolveTasklistMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
+    ResolveTasklistMethod "setRealized" o = Gtk.Widget.WidgetSetRealizedMethodInfo
+    ResolveTasklistMethod "setReallocateRedraws" o = Gtk.Container.ContainerSetReallocateRedrawsMethodInfo
+    ResolveTasklistMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
+    ResolveTasklistMethod "setRedrawOnAllocate" o = Gtk.Widget.WidgetSetRedrawOnAllocateMethodInfo
+    ResolveTasklistMethod "setResizeMode" o = Gtk.Container.ContainerSetResizeModeMethodInfo
+    ResolveTasklistMethod "setScrollEnabled" o = TasklistSetScrollEnabledMethodInfo
+    ResolveTasklistMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
+    ResolveTasklistMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
+    ResolveTasklistMethod "setState" o = Gtk.Widget.WidgetSetStateMethodInfo
+    ResolveTasklistMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
+    ResolveTasklistMethod "setStyle" o = Gtk.Widget.WidgetSetStyleMethodInfo
+    ResolveTasklistMethod "setSupportMultidevice" o = Gtk.Widget.WidgetSetSupportMultideviceMethodInfo
+    ResolveTasklistMethod "setSwitchWorkspaceOnUnminimize" o = TasklistSetSwitchWorkspaceOnUnminimizeMethodInfo
+    ResolveTasklistMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
+    ResolveTasklistMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
+    ResolveTasklistMethod "setTooltipWindow" o = Gtk.Widget.WidgetSetTooltipWindowMethodInfo
+    ResolveTasklistMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
+    ResolveTasklistMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
+    ResolveTasklistMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
+    ResolveTasklistMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
+    ResolveTasklistMethod "setVisual" o = Gtk.Widget.WidgetSetVisualMethodInfo
+    ResolveTasklistMethod "setWindow" o = Gtk.Widget.WidgetSetWindowMethodInfo
+    ResolveTasklistMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolveTasklistMethod t Tasklist, O.MethodInfo info Tasklist p) => OL.IsLabel t (Tasklist -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+-- signal Tasklist::task-enter-notify
+{- |
+Emitted when the task is entered.
+-}
+type TasklistTaskEnterNotifyCallback =
+    Ptr ()
+    {- ^ /@windows@/: the 'GI.GLib.Structs.List.List' with all the 'GI.Wnck.Objects.Window.Window' belonging to the task. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `TasklistTaskEnterNotifyCallback`@.
+noTasklistTaskEnterNotifyCallback :: Maybe TasklistTaskEnterNotifyCallback
+noTasklistTaskEnterNotifyCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_TasklistTaskEnterNotifyCallback =
+    Ptr () ->                               -- object
+    Ptr () ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_TasklistTaskEnterNotifyCallback`.
+foreign import ccall "wrapper"
+    mk_TasklistTaskEnterNotifyCallback :: C_TasklistTaskEnterNotifyCallback -> IO (FunPtr C_TasklistTaskEnterNotifyCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_TasklistTaskEnterNotify :: MonadIO m => TasklistTaskEnterNotifyCallback -> m (GClosure C_TasklistTaskEnterNotifyCallback)
+genClosure_TasklistTaskEnterNotify cb = liftIO $ do
+    let cb' = wrap_TasklistTaskEnterNotifyCallback cb
+    mk_TasklistTaskEnterNotifyCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `TasklistTaskEnterNotifyCallback` into a `C_TasklistTaskEnterNotifyCallback`.
+wrap_TasklistTaskEnterNotifyCallback ::
+    TasklistTaskEnterNotifyCallback ->
+    C_TasklistTaskEnterNotifyCallback
+wrap_TasklistTaskEnterNotifyCallback _cb _ windows _ = do
+    _cb  windows
+
+
+{- |
+Connect a signal handler for the “@task-enter-notify@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' tasklist #taskEnterNotify callback
+@
+-}
+onTasklistTaskEnterNotify :: (IsTasklist a, MonadIO m) => a -> TasklistTaskEnterNotifyCallback -> m SignalHandlerId
+onTasklistTaskEnterNotify obj cb = liftIO $ do
+    let cb' = wrap_TasklistTaskEnterNotifyCallback cb
+    cb'' <- mk_TasklistTaskEnterNotifyCallback cb'
+    connectSignalFunPtr obj "task-enter-notify" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@task-enter-notify@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' tasklist #taskEnterNotify callback
+@
+-}
+afterTasklistTaskEnterNotify :: (IsTasklist a, MonadIO m) => a -> TasklistTaskEnterNotifyCallback -> m SignalHandlerId
+afterTasklistTaskEnterNotify obj cb = liftIO $ do
+    let cb' = wrap_TasklistTaskEnterNotifyCallback cb
+    cb'' <- mk_TasklistTaskEnterNotifyCallback cb'
+    connectSignalFunPtr obj "task-enter-notify" cb'' SignalConnectAfter
+
+
+-- signal Tasklist::task-leave-notify
+{- |
+Emitted when the task is entered.
+-}
+type TasklistTaskLeaveNotifyCallback =
+    Ptr ()
+    {- ^ /@windows@/: the 'GI.GLib.Structs.List.List' with all the 'GI.Wnck.Objects.Window.Window' belonging to the task. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `TasklistTaskLeaveNotifyCallback`@.
+noTasklistTaskLeaveNotifyCallback :: Maybe TasklistTaskLeaveNotifyCallback
+noTasklistTaskLeaveNotifyCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_TasklistTaskLeaveNotifyCallback =
+    Ptr () ->                               -- object
+    Ptr () ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_TasklistTaskLeaveNotifyCallback`.
+foreign import ccall "wrapper"
+    mk_TasklistTaskLeaveNotifyCallback :: C_TasklistTaskLeaveNotifyCallback -> IO (FunPtr C_TasklistTaskLeaveNotifyCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_TasklistTaskLeaveNotify :: MonadIO m => TasklistTaskLeaveNotifyCallback -> m (GClosure C_TasklistTaskLeaveNotifyCallback)
+genClosure_TasklistTaskLeaveNotify cb = liftIO $ do
+    let cb' = wrap_TasklistTaskLeaveNotifyCallback cb
+    mk_TasklistTaskLeaveNotifyCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `TasklistTaskLeaveNotifyCallback` into a `C_TasklistTaskLeaveNotifyCallback`.
+wrap_TasklistTaskLeaveNotifyCallback ::
+    TasklistTaskLeaveNotifyCallback ->
+    C_TasklistTaskLeaveNotifyCallback
+wrap_TasklistTaskLeaveNotifyCallback _cb _ windows _ = do
+    _cb  windows
+
+
+{- |
+Connect a signal handler for the “@task-leave-notify@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' tasklist #taskLeaveNotify callback
+@
+-}
+onTasklistTaskLeaveNotify :: (IsTasklist a, MonadIO m) => a -> TasklistTaskLeaveNotifyCallback -> m SignalHandlerId
+onTasklistTaskLeaveNotify obj cb = liftIO $ do
+    let cb' = wrap_TasklistTaskLeaveNotifyCallback cb
+    cb'' <- mk_TasklistTaskLeaveNotifyCallback cb'
+    connectSignalFunPtr obj "task-leave-notify" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@task-leave-notify@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' tasklist #taskLeaveNotify callback
+@
+-}
+afterTasklistTaskLeaveNotify :: (IsTasklist a, MonadIO m) => a -> TasklistTaskLeaveNotifyCallback -> m SignalHandlerId
+afterTasklistTaskLeaveNotify obj cb = liftIO $ do
+    let cb' = wrap_TasklistTaskLeaveNotifyCallback cb
+    cb'' <- mk_TasklistTaskLeaveNotifyCallback cb'
+    connectSignalFunPtr obj "task-leave-notify" cb'' SignalConnectAfter
+
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList Tasklist
+type instance O.AttributeList Tasklist = TasklistAttributeList
+type TasklistAttributeList = ('[ '("appPaintable", Gtk.Widget.WidgetAppPaintablePropertyInfo), '("borderWidth", Gtk.Container.ContainerBorderWidthPropertyInfo), '("canDefault", Gtk.Widget.WidgetCanDefaultPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("child", Gtk.Container.ContainerChildPropertyInfo), '("compositeChild", Gtk.Widget.WidgetCompositeChildPropertyInfo), '("doubleBuffered", Gtk.Widget.WidgetDoubleBufferedPropertyInfo), '("events", Gtk.Widget.WidgetEventsPropertyInfo), '("expand", Gtk.Widget.WidgetExpandPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("isFocus", Gtk.Widget.WidgetIsFocusPropertyInfo), '("margin", Gtk.Widget.WidgetMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginLeft", Gtk.Widget.WidgetMarginLeftPropertyInfo), '("marginRight", Gtk.Widget.WidgetMarginRightPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("noShowAll", Gtk.Widget.WidgetNoShowAllPropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("resizeMode", Gtk.Container.ContainerResizeModePropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("style", Gtk.Widget.WidgetStylePropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("window", Gtk.Widget.WidgetWindowPropertyInfo)] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+#endif
+
+#if ENABLE_OVERLOADING
+data TasklistTaskEnterNotifySignalInfo
+instance SignalInfo TasklistTaskEnterNotifySignalInfo where
+    type HaskellCallbackType TasklistTaskEnterNotifySignalInfo = TasklistTaskEnterNotifyCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_TasklistTaskEnterNotifyCallback cb
+        cb'' <- mk_TasklistTaskEnterNotifyCallback cb'
+        connectSignalFunPtr obj "task-enter-notify" cb'' connectMode
+
+data TasklistTaskLeaveNotifySignalInfo
+instance SignalInfo TasklistTaskLeaveNotifySignalInfo where
+    type HaskellCallbackType TasklistTaskLeaveNotifySignalInfo = TasklistTaskLeaveNotifyCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_TasklistTaskLeaveNotifyCallback cb
+        cb'' <- mk_TasklistTaskLeaveNotifyCallback cb'
+        connectSignalFunPtr obj "task-leave-notify" cb'' connectMode
+
+type instance O.SignalList Tasklist = TasklistSignalList
+type TasklistSignalList = ('[ '("accelClosuresChanged", Gtk.Widget.WidgetAccelClosuresChangedSignalInfo), '("add", Gtk.Container.ContainerAddSignalInfo), '("buttonPressEvent", Gtk.Widget.WidgetButtonPressEventSignalInfo), '("buttonReleaseEvent", Gtk.Widget.WidgetButtonReleaseEventSignalInfo), '("canActivateAccel", Gtk.Widget.WidgetCanActivateAccelSignalInfo), '("checkResize", Gtk.Container.ContainerCheckResizeSignalInfo), '("childNotify", Gtk.Widget.WidgetChildNotifySignalInfo), '("compositedChanged", Gtk.Widget.WidgetCompositedChangedSignalInfo), '("configureEvent", Gtk.Widget.WidgetConfigureEventSignalInfo), '("damageEvent", Gtk.Widget.WidgetDamageEventSignalInfo), '("deleteEvent", Gtk.Widget.WidgetDeleteEventSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("destroyEvent", Gtk.Widget.WidgetDestroyEventSignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("dragBegin", Gtk.Widget.WidgetDragBeginSignalInfo), '("dragDataDelete", Gtk.Widget.WidgetDragDataDeleteSignalInfo), '("dragDataGet", Gtk.Widget.WidgetDragDataGetSignalInfo), '("dragDataReceived", Gtk.Widget.WidgetDragDataReceivedSignalInfo), '("dragDrop", Gtk.Widget.WidgetDragDropSignalInfo), '("dragEnd", Gtk.Widget.WidgetDragEndSignalInfo), '("dragFailed", Gtk.Widget.WidgetDragFailedSignalInfo), '("dragLeave", Gtk.Widget.WidgetDragLeaveSignalInfo), '("dragMotion", Gtk.Widget.WidgetDragMotionSignalInfo), '("draw", Gtk.Widget.WidgetDrawSignalInfo), '("enterNotifyEvent", Gtk.Widget.WidgetEnterNotifyEventSignalInfo), '("event", Gtk.Widget.WidgetEventSignalInfo), '("eventAfter", Gtk.Widget.WidgetEventAfterSignalInfo), '("focus", Gtk.Widget.WidgetFocusSignalInfo), '("focusInEvent", Gtk.Widget.WidgetFocusInEventSignalInfo), '("focusOutEvent", Gtk.Widget.WidgetFocusOutEventSignalInfo), '("grabBrokenEvent", Gtk.Widget.WidgetGrabBrokenEventSignalInfo), '("grabFocus", Gtk.Widget.WidgetGrabFocusSignalInfo), '("grabNotify", Gtk.Widget.WidgetGrabNotifySignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("hierarchyChanged", Gtk.Widget.WidgetHierarchyChangedSignalInfo), '("keyPressEvent", Gtk.Widget.WidgetKeyPressEventSignalInfo), '("keyReleaseEvent", Gtk.Widget.WidgetKeyReleaseEventSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("leaveNotifyEvent", Gtk.Widget.WidgetLeaveNotifyEventSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mapEvent", Gtk.Widget.WidgetMapEventSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("motionNotifyEvent", Gtk.Widget.WidgetMotionNotifyEventSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("parentSet", Gtk.Widget.WidgetParentSetSignalInfo), '("popupMenu", Gtk.Widget.WidgetPopupMenuSignalInfo), '("propertyNotifyEvent", Gtk.Widget.WidgetPropertyNotifyEventSignalInfo), '("proximityInEvent", Gtk.Widget.WidgetProximityInEventSignalInfo), '("proximityOutEvent", Gtk.Widget.WidgetProximityOutEventSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("remove", Gtk.Container.ContainerRemoveSignalInfo), '("screenChanged", Gtk.Widget.WidgetScreenChangedSignalInfo), '("scrollEvent", Gtk.Widget.WidgetScrollEventSignalInfo), '("selectionClearEvent", Gtk.Widget.WidgetSelectionClearEventSignalInfo), '("selectionGet", Gtk.Widget.WidgetSelectionGetSignalInfo), '("selectionNotifyEvent", Gtk.Widget.WidgetSelectionNotifyEventSignalInfo), '("selectionReceived", Gtk.Widget.WidgetSelectionReceivedSignalInfo), '("selectionRequestEvent", Gtk.Widget.WidgetSelectionRequestEventSignalInfo), '("setFocusChild", Gtk.Container.ContainerSetFocusChildSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showHelp", Gtk.Widget.WidgetShowHelpSignalInfo), '("sizeAllocate", Gtk.Widget.WidgetSizeAllocateSignalInfo), '("stateChanged", Gtk.Widget.WidgetStateChangedSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("styleSet", Gtk.Widget.WidgetStyleSetSignalInfo), '("styleUpdated", Gtk.Widget.WidgetStyleUpdatedSignalInfo), '("taskEnterNotify", TasklistTaskEnterNotifySignalInfo), '("taskLeaveNotify", TasklistTaskLeaveNotifySignalInfo), '("touchEvent", Gtk.Widget.WidgetTouchEventSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unmapEvent", Gtk.Widget.WidgetUnmapEventSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo), '("visibilityNotifyEvent", Gtk.Widget.WidgetVisibilityNotifyEventSignalInfo), '("windowStateEvent", Gtk.Widget.WidgetWindowStateEventSignalInfo)] :: [(Symbol, *)])
+
+#endif
+
+-- method Tasklist::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Tasklist"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_tasklist_new" wnck_tasklist_new :: 
+    IO (Ptr Tasklist)
+
+{- |
+Creates a new 'GI.Wnck.Objects.Tasklist.Tasklist'. The 'GI.Wnck.Objects.Tasklist.Tasklist' will list 'GI.Wnck.Objects.Window.Window' of the
+'GI.Wnck.Objects.Screen.Screen' it is on.
+-}
+tasklistNew ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    m Tasklist
+    {- ^ __Returns:__ a newly created 'GI.Wnck.Objects.Tasklist.Tasklist'. -}
+tasklistNew  = liftIO $ do
+    result <- wnck_tasklist_new
+    checkUnexpectedReturnNULL "tasklistNew" result
+    result' <- (newObject Tasklist) result
+    return result'
+
+#if ENABLE_OVERLOADING
+#endif
+
+-- method Tasklist::get_scroll_enabled
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "tasklist", argType = TInterface (Name {namespace = "Wnck", name = "Tasklist"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckTasklist.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_tasklist_get_scroll_enabled" wnck_tasklist_get_scroll_enabled :: 
+    Ptr Tasklist ->                         -- tasklist : TInterface (Name {namespace = "Wnck", name = "Tasklist"})
+    IO CInt
+
+{- |
+Gets the scroll behavior of the /@tasklist@/.
+
+/Since: 3.24.0/
+-}
+tasklistGetScrollEnabled ::
+    (B.CallStack.HasCallStack, MonadIO m, IsTasklist a) =>
+    a
+    {- ^ /@tasklist@/: a 'GI.Wnck.Objects.Tasklist.Tasklist'. -}
+    -> m Bool
+tasklistGetScrollEnabled tasklist = liftIO $ do
+    tasklist' <- unsafeManagedPtrCastPtr tasklist
+    result <- wnck_tasklist_get_scroll_enabled tasklist'
+    let result' = (/= 0) result
+    touchManagedPtr tasklist
+    return result'
+
+#if ENABLE_OVERLOADING
+data TasklistGetScrollEnabledMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsTasklist a) => O.MethodInfo TasklistGetScrollEnabledMethodInfo a signature where
+    overloadedMethod _ = tasklistGetScrollEnabled
+
+#endif
+
+-- method Tasklist::get_size_hint_list
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "tasklist", argType = TInterface (Name {namespace = "Wnck", name = "Tasklist"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckTasklist.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_elements", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for the number of elements in the array\nreturned by this function. This number should always be pair.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_tasklist_get_size_hint_list" wnck_tasklist_get_size_hint_list :: 
+    Ptr Tasklist ->                         -- tasklist : TInterface (Name {namespace = "Wnck", name = "Tasklist"})
+    Int32 ->                                -- n_elements : TBasicType TInt
+    IO Int32
+
+{- |
+Since a 'GI.Wnck.Objects.Tasklist.Tasklist' does not have a fixed size ('GI.Wnck.Objects.Window.Window' can be grouped
+when needed, for example), the standard size request mechanism in GTK+ is
+not enough to announce what sizes can be used by /@tasklist@/. The size hints
+mechanism is a solution for this. See @/panel_applet_set_size_hints()/@ for more
+information.
+-}
+tasklistGetSizeHintList ::
+    (B.CallStack.HasCallStack, MonadIO m, IsTasklist a) =>
+    a
+    {- ^ /@tasklist@/: a 'GI.Wnck.Objects.Tasklist.Tasklist'. -}
+    -> Int32
+    {- ^ /@nElements@/: return location for the number of elements in the array
+returned by this function. This number should always be pair. -}
+    -> m Int32
+    {- ^ __Returns:__ a list of size hints that can be used to allocate an
+appropriate size for /@tasklist@/. -}
+tasklistGetSizeHintList tasklist nElements = liftIO $ do
+    tasklist' <- unsafeManagedPtrCastPtr tasklist
+    result <- wnck_tasklist_get_size_hint_list tasklist' nElements
+    touchManagedPtr tasklist
+    return result
+
+#if ENABLE_OVERLOADING
+data TasklistGetSizeHintListMethodInfo
+instance (signature ~ (Int32 -> m Int32), MonadIO m, IsTasklist a) => O.MethodInfo TasklistGetSizeHintListMethodInfo a signature where
+    overloadedMethod _ = tasklistGetSizeHintList
+
+#endif
+
+-- method Tasklist::set_button_relief
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "tasklist", argType = TInterface (Name {namespace = "Wnck", name = "Tasklist"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckTasklist.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "relief", argType = TInterface (Name {namespace = "Gtk", name = "ReliefStyle"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a relief type.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_tasklist_set_button_relief" wnck_tasklist_set_button_relief :: 
+    Ptr Tasklist ->                         -- tasklist : TInterface (Name {namespace = "Wnck", name = "Tasklist"})
+    CUInt ->                                -- relief : TInterface (Name {namespace = "Gtk", name = "ReliefStyle"})
+    IO ()
+
+{- |
+Sets the relief type of the buttons in /@tasklist@/ to /@relief@/. The main use of
+this function is proper integration of 'GI.Wnck.Objects.Tasklist.Tasklist' in panels with
+non-system backgrounds.
+
+/Since: 2.12/
+-}
+tasklistSetButtonRelief ::
+    (B.CallStack.HasCallStack, MonadIO m, IsTasklist a) =>
+    a
+    {- ^ /@tasklist@/: a 'GI.Wnck.Objects.Tasklist.Tasklist'. -}
+    -> Gtk.Enums.ReliefStyle
+    {- ^ /@relief@/: a relief type. -}
+    -> m ()
+tasklistSetButtonRelief tasklist relief = liftIO $ do
+    tasklist' <- unsafeManagedPtrCastPtr tasklist
+    let relief' = (fromIntegral . fromEnum) relief
+    wnck_tasklist_set_button_relief tasklist' relief'
+    touchManagedPtr tasklist
+    return ()
+
+#if ENABLE_OVERLOADING
+data TasklistSetButtonReliefMethodInfo
+instance (signature ~ (Gtk.Enums.ReliefStyle -> m ()), MonadIO m, IsTasklist a) => O.MethodInfo TasklistSetButtonReliefMethodInfo a signature where
+    overloadedMethod _ = tasklistSetButtonRelief
+
+#endif
+
+-- method Tasklist::set_grouping
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "tasklist", argType = TInterface (Name {namespace = "Wnck", name = "Tasklist"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckTasklist.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "grouping", argType = TInterface (Name {namespace = "Wnck", name = "TasklistGroupingType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a grouping policy.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_tasklist_set_grouping" wnck_tasklist_set_grouping :: 
+    Ptr Tasklist ->                         -- tasklist : TInterface (Name {namespace = "Wnck", name = "Tasklist"})
+    CUInt ->                                -- grouping : TInterface (Name {namespace = "Wnck", name = "TasklistGroupingType"})
+    IO ()
+
+{- |
+Sets the grouping policy for /@tasklist@/ to /@grouping@/.
+-}
+tasklistSetGrouping ::
+    (B.CallStack.HasCallStack, MonadIO m, IsTasklist a) =>
+    a
+    {- ^ /@tasklist@/: a 'GI.Wnck.Objects.Tasklist.Tasklist'. -}
+    -> Wnck.Enums.TasklistGroupingType
+    {- ^ /@grouping@/: a grouping policy. -}
+    -> m ()
+tasklistSetGrouping tasklist grouping = liftIO $ do
+    tasklist' <- unsafeManagedPtrCastPtr tasklist
+    let grouping' = (fromIntegral . fromEnum) grouping
+    wnck_tasklist_set_grouping tasklist' grouping'
+    touchManagedPtr tasklist
+    return ()
+
+#if ENABLE_OVERLOADING
+data TasklistSetGroupingMethodInfo
+instance (signature ~ (Wnck.Enums.TasklistGroupingType -> m ()), MonadIO m, IsTasklist a) => O.MethodInfo TasklistSetGroupingMethodInfo a signature where
+    overloadedMethod _ = tasklistSetGrouping
+
+#endif
+
+-- method Tasklist::set_grouping_limit
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "tasklist", argType = TInterface (Name {namespace = "Wnck", name = "Tasklist"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckTasklist.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "limit", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a size in pixels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_tasklist_set_grouping_limit" wnck_tasklist_set_grouping_limit :: 
+    Ptr Tasklist ->                         -- tasklist : TInterface (Name {namespace = "Wnck", name = "Tasklist"})
+    Int32 ->                                -- limit : TBasicType TInt
+    IO ()
+
+{- |
+Sets the maximum size of buttons in /@tasklist@/ before /@tasklist@/ tries to
+group 'GI.Wnck.Objects.Window.Window' in the same 'GI.Wnck.Objects.Application.Application' in only one button. This
+limit is valid only when the grouping policy of /@tasklist@/ is
+'GI.Wnck.Enums.TasklistGroupingTypeAutoGroup'.
+-}
+tasklistSetGroupingLimit ::
+    (B.CallStack.HasCallStack, MonadIO m, IsTasklist a) =>
+    a
+    {- ^ /@tasklist@/: a 'GI.Wnck.Objects.Tasklist.Tasklist'. -}
+    -> Int32
+    {- ^ /@limit@/: a size in pixels. -}
+    -> m ()
+tasklistSetGroupingLimit tasklist limit = liftIO $ do
+    tasklist' <- unsafeManagedPtrCastPtr tasklist
+    wnck_tasklist_set_grouping_limit tasklist' limit
+    touchManagedPtr tasklist
+    return ()
+
+#if ENABLE_OVERLOADING
+data TasklistSetGroupingLimitMethodInfo
+instance (signature ~ (Int32 -> m ()), MonadIO m, IsTasklist a) => O.MethodInfo TasklistSetGroupingLimitMethodInfo a signature where
+    overloadedMethod _ = tasklistSetGroupingLimit
+
+#endif
+
+-- method Tasklist::set_include_all_workspaces
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "tasklist", argType = TInterface (Name {namespace = "Wnck", name = "Tasklist"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckTasklist.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "include_all_workspaces", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to display #WnckWindow from all\n#WnckWorkspace in @tasklist.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_tasklist_set_include_all_workspaces" wnck_tasklist_set_include_all_workspaces :: 
+    Ptr Tasklist ->                         -- tasklist : TInterface (Name {namespace = "Wnck", name = "Tasklist"})
+    CInt ->                                 -- include_all_workspaces : TBasicType TBoolean
+    IO ()
+
+{- |
+Sets /@tasklist@/ to display 'GI.Wnck.Objects.Window.Window' from all 'GI.Wnck.Objects.Workspace.Workspace' or not,
+according to /@includeAllWorkspaces@/.
+
+Note that if the active 'GI.Wnck.Objects.Workspace.Workspace' has a viewport and if
+/@includeAllWorkspaces@/ is 'False', then only the 'GI.Wnck.Objects.Window.Window' visible in the
+viewport are displayed in /@tasklist@/. The rationale for this is that the
+viewport is generally used to implement workspace-like behavior. A
+side-effect of this is that, when using multiple 'GI.Wnck.Objects.Workspace.Workspace' with
+viewport, it is not possible to show all 'GI.Wnck.Objects.Window.Window' from a 'GI.Wnck.Objects.Workspace.Workspace'
+(even those that are not visible in the viewport) in /@tasklist@/ without
+showing all 'GI.Wnck.Objects.Window.Window' from all 'GI.Wnck.Objects.Workspace.Workspace'.
+-}
+tasklistSetIncludeAllWorkspaces ::
+    (B.CallStack.HasCallStack, MonadIO m, IsTasklist a) =>
+    a
+    {- ^ /@tasklist@/: a 'GI.Wnck.Objects.Tasklist.Tasklist'. -}
+    -> Bool
+    {- ^ /@includeAllWorkspaces@/: whether to display 'GI.Wnck.Objects.Window.Window' from all
+'GI.Wnck.Objects.Workspace.Workspace' in /@tasklist@/. -}
+    -> m ()
+tasklistSetIncludeAllWorkspaces tasklist includeAllWorkspaces = liftIO $ do
+    tasklist' <- unsafeManagedPtrCastPtr tasklist
+    let includeAllWorkspaces' = (fromIntegral . fromEnum) includeAllWorkspaces
+    wnck_tasklist_set_include_all_workspaces tasklist' includeAllWorkspaces'
+    touchManagedPtr tasklist
+    return ()
+
+#if ENABLE_OVERLOADING
+data TasklistSetIncludeAllWorkspacesMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, IsTasklist a) => O.MethodInfo TasklistSetIncludeAllWorkspacesMethodInfo a signature where
+    overloadedMethod _ = tasklistSetIncludeAllWorkspaces
+
+#endif
+
+-- method Tasklist::set_middle_click_close
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "tasklist", argType = TInterface (Name {namespace = "Wnck", name = "Tasklist"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckTasklist.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "middle_click_close", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to close windows with middle click on\nbutton.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_tasklist_set_middle_click_close" wnck_tasklist_set_middle_click_close :: 
+    Ptr Tasklist ->                         -- tasklist : TInterface (Name {namespace = "Wnck", name = "Tasklist"})
+    CInt ->                                 -- middle_click_close : TBasicType TBoolean
+    IO ()
+
+{- |
+Sets /@tasklist@/ to close windows with mouse middle click on button,
+according to /@middleClickClose@/.
+
+/Since: 3.4.6/
+-}
+tasklistSetMiddleClickClose ::
+    (B.CallStack.HasCallStack, MonadIO m, IsTasklist a) =>
+    a
+    {- ^ /@tasklist@/: a 'GI.Wnck.Objects.Tasklist.Tasklist'. -}
+    -> Bool
+    {- ^ /@middleClickClose@/: whether to close windows with middle click on
+button. -}
+    -> m ()
+tasklistSetMiddleClickClose tasklist middleClickClose = liftIO $ do
+    tasklist' <- unsafeManagedPtrCastPtr tasklist
+    let middleClickClose' = (fromIntegral . fromEnum) middleClickClose
+    wnck_tasklist_set_middle_click_close tasklist' middleClickClose'
+    touchManagedPtr tasklist
+    return ()
+
+#if ENABLE_OVERLOADING
+data TasklistSetMiddleClickCloseMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, IsTasklist a) => O.MethodInfo TasklistSetMiddleClickCloseMethodInfo a signature where
+    overloadedMethod _ = tasklistSetMiddleClickClose
+
+#endif
+
+-- method Tasklist::set_orientation
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "tasklist", argType = TInterface (Name {namespace = "Wnck", name = "Tasklist"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckTasklist.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "orient", argType = TInterface (Name {namespace = "Gtk", name = "Orientation"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a GtkOrientation.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_tasklist_set_orientation" wnck_tasklist_set_orientation :: 
+    Ptr Tasklist ->                         -- tasklist : TInterface (Name {namespace = "Wnck", name = "Tasklist"})
+    CUInt ->                                -- orient : TInterface (Name {namespace = "Gtk", name = "Orientation"})
+    IO ()
+
+{- |
+Set the orientation of the /@tasklist@/ to match /@orient@/.
+This function can be used to integrate a 'GI.Wnck.Objects.Tasklist.Tasklist' in vertical panels.
+
+/Since: 3.4.6/
+-}
+tasklistSetOrientation ::
+    (B.CallStack.HasCallStack, MonadIO m, IsTasklist a) =>
+    a
+    {- ^ /@tasklist@/: a 'GI.Wnck.Objects.Tasklist.Tasklist'. -}
+    -> Gtk.Enums.Orientation
+    {- ^ /@orient@/: a GtkOrientation. -}
+    -> m ()
+tasklistSetOrientation tasklist orient = liftIO $ do
+    tasklist' <- unsafeManagedPtrCastPtr tasklist
+    let orient' = (fromIntegral . fromEnum) orient
+    wnck_tasklist_set_orientation tasklist' orient'
+    touchManagedPtr tasklist
+    return ()
+
+#if ENABLE_OVERLOADING
+data TasklistSetOrientationMethodInfo
+instance (signature ~ (Gtk.Enums.Orientation -> m ()), MonadIO m, IsTasklist a) => O.MethodInfo TasklistSetOrientationMethodInfo a signature where
+    overloadedMethod _ = tasklistSetOrientation
+
+#endif
+
+-- method Tasklist::set_scroll_enabled
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "tasklist", argType = TInterface (Name {namespace = "Wnck", name = "Tasklist"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckTasklist.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scroll_enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a boolean.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_tasklist_set_scroll_enabled" wnck_tasklist_set_scroll_enabled :: 
+    Ptr Tasklist ->                         -- tasklist : TInterface (Name {namespace = "Wnck", name = "Tasklist"})
+    CInt ->                                 -- scroll_enabled : TBasicType TBoolean
+    IO ()
+
+{- |
+Sets the scroll behavior of the /@tasklist@/. When set to 'True', a scroll
+event over the tasklist will change the current window accordingly.
+
+/Since: 3.24.0/
+-}
+tasklistSetScrollEnabled ::
+    (B.CallStack.HasCallStack, MonadIO m, IsTasklist a) =>
+    a
+    {- ^ /@tasklist@/: a 'GI.Wnck.Objects.Tasklist.Tasklist'. -}
+    -> Bool
+    {- ^ /@scrollEnabled@/: a boolean. -}
+    -> m ()
+tasklistSetScrollEnabled tasklist scrollEnabled = liftIO $ do
+    tasklist' <- unsafeManagedPtrCastPtr tasklist
+    let scrollEnabled' = (fromIntegral . fromEnum) scrollEnabled
+    wnck_tasklist_set_scroll_enabled tasklist' scrollEnabled'
+    touchManagedPtr tasklist
+    return ()
+
+#if ENABLE_OVERLOADING
+data TasklistSetScrollEnabledMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, IsTasklist a) => O.MethodInfo TasklistSetScrollEnabledMethodInfo a signature where
+    overloadedMethod _ = tasklistSetScrollEnabled
+
+#endif
+
+-- method Tasklist::set_switch_workspace_on_unminimize
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "tasklist", argType = TInterface (Name {namespace = "Wnck", name = "Tasklist"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckTasklist.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "switch_workspace_on_unminimize", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to activate the #WnckWorkspace a\n#WnckWindow is on when unminimizing it.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_tasklist_set_switch_workspace_on_unminimize" wnck_tasklist_set_switch_workspace_on_unminimize :: 
+    Ptr Tasklist ->                         -- tasklist : TInterface (Name {namespace = "Wnck", name = "Tasklist"})
+    CInt ->                                 -- switch_workspace_on_unminimize : TBasicType TBoolean
+    IO ()
+
+{- |
+Sets /@tasklist@/ to activate or not the 'GI.Wnck.Objects.Workspace.Workspace' a 'GI.Wnck.Objects.Window.Window' is on
+when unminimizing it, according to /@switchWorkspaceOnUnminimize@/.
+
+FIXME: does it still work?
+-}
+tasklistSetSwitchWorkspaceOnUnminimize ::
+    (B.CallStack.HasCallStack, MonadIO m, IsTasklist a) =>
+    a
+    {- ^ /@tasklist@/: a 'GI.Wnck.Objects.Tasklist.Tasklist'. -}
+    -> Bool
+    {- ^ /@switchWorkspaceOnUnminimize@/: whether to activate the 'GI.Wnck.Objects.Workspace.Workspace' a
+'GI.Wnck.Objects.Window.Window' is on when unminimizing it. -}
+    -> m ()
+tasklistSetSwitchWorkspaceOnUnminimize tasklist switchWorkspaceOnUnminimize = liftIO $ do
+    tasklist' <- unsafeManagedPtrCastPtr tasklist
+    let switchWorkspaceOnUnminimize' = (fromIntegral . fromEnum) switchWorkspaceOnUnminimize
+    wnck_tasklist_set_switch_workspace_on_unminimize tasklist' switchWorkspaceOnUnminimize'
+    touchManagedPtr tasklist
+    return ()
+
+#if ENABLE_OVERLOADING
+data TasklistSetSwitchWorkspaceOnUnminimizeMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, IsTasklist a) => O.MethodInfo TasklistSetSwitchWorkspaceOnUnminimizeMethodInfo a signature where
+    overloadedMethod _ = tasklistSetSwitchWorkspaceOnUnminimize
+
+#endif
+
+
diff --git a/GI/Wnck/Objects/Tasklist.hs-boot b/GI/Wnck/Objects/Tasklist.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Tasklist.hs-boot
@@ -0,0 +1,65 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Objects.Tasklist where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype Tasklist = Tasklist (ManagedPtr Tasklist)
+instance GObject Tasklist where
+class (GObject o, O.IsDescendantOf Tasklist o) => IsTasklist o
+instance (GObject o, O.IsDescendantOf Tasklist o) => IsTasklist o
+instance O.HasParentTypes Tasklist
+#if ENABLE_OVERLOADING
+data TasklistTaskEnterNotifySignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data TasklistTaskLeaveNotifySignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data TasklistGetScrollEnabledMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data TasklistGetSizeHintListMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data TasklistSetButtonReliefMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data TasklistSetGroupingMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data TasklistSetGroupingLimitMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data TasklistSetIncludeAllWorkspacesMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data TasklistSetMiddleClickCloseMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data TasklistSetOrientationMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data TasklistSetScrollEnabledMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data TasklistSetSwitchWorkspaceOnUnminimizeMethodInfo
+#endif
diff --git a/GI/Wnck/Objects/Window.hs b/GI/Wnck/Objects/Window.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Window.hs
@@ -0,0 +1,4675 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+The 'GI.Wnck.Objects.Window.Window' struct contains only private fields and should not be
+directly accessed.
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Objects.Window
+    ( 
+
+-- * Exported types
+    Window(..)                              ,
+    IsWindow                                ,
+    toWindow                                ,
+    noWindow                                ,
+
+
+ -- * Methods
+-- ** activate #method:activate#
+
+#if ENABLE_OVERLOADING
+    WindowActivateMethodInfo                ,
+#endif
+    windowActivate                          ,
+
+
+-- ** activateTransient #method:activateTransient#
+
+#if ENABLE_OVERLOADING
+    WindowActivateTransientMethodInfo       ,
+#endif
+    windowActivateTransient                 ,
+
+
+-- ** close #method:close#
+
+#if ENABLE_OVERLOADING
+    WindowCloseMethodInfo                   ,
+#endif
+    windowClose                             ,
+
+
+-- ** get #method:get#
+
+    windowGet                               ,
+
+
+-- ** getActions #method:getActions#
+
+#if ENABLE_OVERLOADING
+    WindowGetActionsMethodInfo              ,
+#endif
+    windowGetActions                        ,
+
+
+-- ** getApplication #method:getApplication#
+
+#if ENABLE_OVERLOADING
+    WindowGetApplicationMethodInfo          ,
+#endif
+    windowGetApplication                    ,
+
+
+-- ** getClassGroup #method:getClassGroup#
+
+#if ENABLE_OVERLOADING
+    WindowGetClassGroupMethodInfo           ,
+#endif
+    windowGetClassGroup                     ,
+
+
+-- ** getClassGroupName #method:getClassGroupName#
+
+#if ENABLE_OVERLOADING
+    WindowGetClassGroupNameMethodInfo       ,
+#endif
+    windowGetClassGroupName                 ,
+
+
+-- ** getClassInstanceName #method:getClassInstanceName#
+
+#if ENABLE_OVERLOADING
+    WindowGetClassInstanceNameMethodInfo    ,
+#endif
+    windowGetClassInstanceName              ,
+
+
+-- ** getClientWindowGeometry #method:getClientWindowGeometry#
+
+#if ENABLE_OVERLOADING
+    WindowGetClientWindowGeometryMethodInfo ,
+#endif
+    windowGetClientWindowGeometry           ,
+
+
+-- ** getGeometry #method:getGeometry#
+
+#if ENABLE_OVERLOADING
+    WindowGetGeometryMethodInfo             ,
+#endif
+    windowGetGeometry                       ,
+
+
+-- ** getGroupLeader #method:getGroupLeader#
+
+#if ENABLE_OVERLOADING
+    WindowGetGroupLeaderMethodInfo          ,
+#endif
+    windowGetGroupLeader                    ,
+
+
+-- ** getIcon #method:getIcon#
+
+#if ENABLE_OVERLOADING
+    WindowGetIconMethodInfo                 ,
+#endif
+    windowGetIcon                           ,
+
+
+-- ** getIconIsFallback #method:getIconIsFallback#
+
+#if ENABLE_OVERLOADING
+    WindowGetIconIsFallbackMethodInfo       ,
+#endif
+    windowGetIconIsFallback                 ,
+
+
+-- ** getIconName #method:getIconName#
+
+#if ENABLE_OVERLOADING
+    WindowGetIconNameMethodInfo             ,
+#endif
+    windowGetIconName                       ,
+
+
+-- ** getMiniIcon #method:getMiniIcon#
+
+#if ENABLE_OVERLOADING
+    WindowGetMiniIconMethodInfo             ,
+#endif
+    windowGetMiniIcon                       ,
+
+
+-- ** getName #method:getName#
+
+#if ENABLE_OVERLOADING
+    WindowGetNameMethodInfo                 ,
+#endif
+    windowGetName                           ,
+
+
+-- ** getPid #method:getPid#
+
+#if ENABLE_OVERLOADING
+    WindowGetPidMethodInfo                  ,
+#endif
+    windowGetPid                            ,
+
+
+-- ** getRole #method:getRole#
+
+#if ENABLE_OVERLOADING
+    WindowGetRoleMethodInfo                 ,
+#endif
+    windowGetRole                           ,
+
+
+-- ** getScreen #method:getScreen#
+
+#if ENABLE_OVERLOADING
+    WindowGetScreenMethodInfo               ,
+#endif
+    windowGetScreen                         ,
+
+
+-- ** getSessionId #method:getSessionId#
+
+#if ENABLE_OVERLOADING
+    WindowGetSessionIdMethodInfo            ,
+#endif
+    windowGetSessionId                      ,
+
+
+-- ** getSessionIdUtf8 #method:getSessionIdUtf8#
+
+#if ENABLE_OVERLOADING
+    WindowGetSessionIdUtf8MethodInfo        ,
+#endif
+    windowGetSessionIdUtf8                  ,
+
+
+-- ** getSortOrder #method:getSortOrder#
+
+#if ENABLE_OVERLOADING
+    WindowGetSortOrderMethodInfo            ,
+#endif
+    windowGetSortOrder                      ,
+
+
+-- ** getState #method:getState#
+
+#if ENABLE_OVERLOADING
+    WindowGetStateMethodInfo                ,
+#endif
+    windowGetState                          ,
+
+
+-- ** getTransient #method:getTransient#
+
+#if ENABLE_OVERLOADING
+    WindowGetTransientMethodInfo            ,
+#endif
+    windowGetTransient                      ,
+
+
+-- ** getWindowType #method:getWindowType#
+
+#if ENABLE_OVERLOADING
+    WindowGetWindowTypeMethodInfo           ,
+#endif
+    windowGetWindowType                     ,
+
+
+-- ** getWorkspace #method:getWorkspace#
+
+#if ENABLE_OVERLOADING
+    WindowGetWorkspaceMethodInfo            ,
+#endif
+    windowGetWorkspace                      ,
+
+
+-- ** getXid #method:getXid#
+
+#if ENABLE_OVERLOADING
+    WindowGetXidMethodInfo                  ,
+#endif
+    windowGetXid                            ,
+
+
+-- ** hasIconName #method:hasIconName#
+
+#if ENABLE_OVERLOADING
+    WindowHasIconNameMethodInfo             ,
+#endif
+    windowHasIconName                       ,
+
+
+-- ** hasName #method:hasName#
+
+#if ENABLE_OVERLOADING
+    WindowHasNameMethodInfo                 ,
+#endif
+    windowHasName                           ,
+
+
+-- ** isAbove #method:isAbove#
+
+#if ENABLE_OVERLOADING
+    WindowIsAboveMethodInfo                 ,
+#endif
+    windowIsAbove                           ,
+
+
+-- ** isActive #method:isActive#
+
+#if ENABLE_OVERLOADING
+    WindowIsActiveMethodInfo                ,
+#endif
+    windowIsActive                          ,
+
+
+-- ** isBelow #method:isBelow#
+
+#if ENABLE_OVERLOADING
+    WindowIsBelowMethodInfo                 ,
+#endif
+    windowIsBelow                           ,
+
+
+-- ** isFullscreen #method:isFullscreen#
+
+#if ENABLE_OVERLOADING
+    WindowIsFullscreenMethodInfo            ,
+#endif
+    windowIsFullscreen                      ,
+
+
+-- ** isInViewport #method:isInViewport#
+
+#if ENABLE_OVERLOADING
+    WindowIsInViewportMethodInfo            ,
+#endif
+    windowIsInViewport                      ,
+
+
+-- ** isMaximized #method:isMaximized#
+
+#if ENABLE_OVERLOADING
+    WindowIsMaximizedMethodInfo             ,
+#endif
+    windowIsMaximized                       ,
+
+
+-- ** isMaximizedHorizontally #method:isMaximizedHorizontally#
+
+#if ENABLE_OVERLOADING
+    WindowIsMaximizedHorizontallyMethodInfo ,
+#endif
+    windowIsMaximizedHorizontally           ,
+
+
+-- ** isMaximizedVertically #method:isMaximizedVertically#
+
+#if ENABLE_OVERLOADING
+    WindowIsMaximizedVerticallyMethodInfo   ,
+#endif
+    windowIsMaximizedVertically             ,
+
+
+-- ** isMinimized #method:isMinimized#
+
+#if ENABLE_OVERLOADING
+    WindowIsMinimizedMethodInfo             ,
+#endif
+    windowIsMinimized                       ,
+
+
+-- ** isMostRecentlyActivated #method:isMostRecentlyActivated#
+
+#if ENABLE_OVERLOADING
+    WindowIsMostRecentlyActivatedMethodInfo ,
+#endif
+    windowIsMostRecentlyActivated           ,
+
+
+-- ** isOnWorkspace #method:isOnWorkspace#
+
+#if ENABLE_OVERLOADING
+    WindowIsOnWorkspaceMethodInfo           ,
+#endif
+    windowIsOnWorkspace                     ,
+
+
+-- ** isPinned #method:isPinned#
+
+#if ENABLE_OVERLOADING
+    WindowIsPinnedMethodInfo                ,
+#endif
+    windowIsPinned                          ,
+
+
+-- ** isShaded #method:isShaded#
+
+#if ENABLE_OVERLOADING
+    WindowIsShadedMethodInfo                ,
+#endif
+    windowIsShaded                          ,
+
+
+-- ** isSkipPager #method:isSkipPager#
+
+#if ENABLE_OVERLOADING
+    WindowIsSkipPagerMethodInfo             ,
+#endif
+    windowIsSkipPager                       ,
+
+
+-- ** isSkipTasklist #method:isSkipTasklist#
+
+#if ENABLE_OVERLOADING
+    WindowIsSkipTasklistMethodInfo          ,
+#endif
+    windowIsSkipTasklist                    ,
+
+
+-- ** isSticky #method:isSticky#
+
+#if ENABLE_OVERLOADING
+    WindowIsStickyMethodInfo                ,
+#endif
+    windowIsSticky                          ,
+
+
+-- ** isVisibleOnWorkspace #method:isVisibleOnWorkspace#
+
+#if ENABLE_OVERLOADING
+    WindowIsVisibleOnWorkspaceMethodInfo    ,
+#endif
+    windowIsVisibleOnWorkspace              ,
+
+
+-- ** keyboardMove #method:keyboardMove#
+
+#if ENABLE_OVERLOADING
+    WindowKeyboardMoveMethodInfo            ,
+#endif
+    windowKeyboardMove                      ,
+
+
+-- ** keyboardSize #method:keyboardSize#
+
+#if ENABLE_OVERLOADING
+    WindowKeyboardSizeMethodInfo            ,
+#endif
+    windowKeyboardSize                      ,
+
+
+-- ** makeAbove #method:makeAbove#
+
+#if ENABLE_OVERLOADING
+    WindowMakeAboveMethodInfo               ,
+#endif
+    windowMakeAbove                         ,
+
+
+-- ** makeBelow #method:makeBelow#
+
+#if ENABLE_OVERLOADING
+    WindowMakeBelowMethodInfo               ,
+#endif
+    windowMakeBelow                         ,
+
+
+-- ** maximize #method:maximize#
+
+#if ENABLE_OVERLOADING
+    WindowMaximizeMethodInfo                ,
+#endif
+    windowMaximize                          ,
+
+
+-- ** maximizeHorizontally #method:maximizeHorizontally#
+
+#if ENABLE_OVERLOADING
+    WindowMaximizeHorizontallyMethodInfo    ,
+#endif
+    windowMaximizeHorizontally              ,
+
+
+-- ** maximizeVertically #method:maximizeVertically#
+
+#if ENABLE_OVERLOADING
+    WindowMaximizeVerticallyMethodInfo      ,
+#endif
+    windowMaximizeVertically                ,
+
+
+-- ** minimize #method:minimize#
+
+#if ENABLE_OVERLOADING
+    WindowMinimizeMethodInfo                ,
+#endif
+    windowMinimize                          ,
+
+
+-- ** moveToWorkspace #method:moveToWorkspace#
+
+#if ENABLE_OVERLOADING
+    WindowMoveToWorkspaceMethodInfo         ,
+#endif
+    windowMoveToWorkspace                   ,
+
+
+-- ** needsAttention #method:needsAttention#
+
+#if ENABLE_OVERLOADING
+    WindowNeedsAttentionMethodInfo          ,
+#endif
+    windowNeedsAttention                    ,
+
+
+-- ** orTransientNeedsAttention #method:orTransientNeedsAttention#
+
+#if ENABLE_OVERLOADING
+    WindowOrTransientNeedsAttentionMethodInfo,
+#endif
+    windowOrTransientNeedsAttention         ,
+
+
+-- ** pin #method:pin#
+
+#if ENABLE_OVERLOADING
+    WindowPinMethodInfo                     ,
+#endif
+    windowPin                               ,
+
+
+-- ** setFullscreen #method:setFullscreen#
+
+#if ENABLE_OVERLOADING
+    WindowSetFullscreenMethodInfo           ,
+#endif
+    windowSetFullscreen                     ,
+
+
+-- ** setGeometry #method:setGeometry#
+
+#if ENABLE_OVERLOADING
+    WindowSetGeometryMethodInfo             ,
+#endif
+    windowSetGeometry                       ,
+
+
+-- ** setIconGeometry #method:setIconGeometry#
+
+#if ENABLE_OVERLOADING
+    WindowSetIconGeometryMethodInfo         ,
+#endif
+    windowSetIconGeometry                   ,
+
+
+-- ** setSkipPager #method:setSkipPager#
+
+#if ENABLE_OVERLOADING
+    WindowSetSkipPagerMethodInfo            ,
+#endif
+    windowSetSkipPager                      ,
+
+
+-- ** setSkipTasklist #method:setSkipTasklist#
+
+#if ENABLE_OVERLOADING
+    WindowSetSkipTasklistMethodInfo         ,
+#endif
+    windowSetSkipTasklist                   ,
+
+
+-- ** setSortOrder #method:setSortOrder#
+
+#if ENABLE_OVERLOADING
+    WindowSetSortOrderMethodInfo            ,
+#endif
+    windowSetSortOrder                      ,
+
+
+-- ** setWindowType #method:setWindowType#
+
+#if ENABLE_OVERLOADING
+    WindowSetWindowTypeMethodInfo           ,
+#endif
+    windowSetWindowType                     ,
+
+
+-- ** shade #method:shade#
+
+#if ENABLE_OVERLOADING
+    WindowShadeMethodInfo                   ,
+#endif
+    windowShade                             ,
+
+
+-- ** stick #method:stick#
+
+#if ENABLE_OVERLOADING
+    WindowStickMethodInfo                   ,
+#endif
+    windowStick                             ,
+
+
+-- ** transientIsMostRecentlyActivated #method:transientIsMostRecentlyActivated#
+
+#if ENABLE_OVERLOADING
+    WindowTransientIsMostRecentlyActivatedMethodInfo,
+#endif
+    windowTransientIsMostRecentlyActivated  ,
+
+
+-- ** unmakeAbove #method:unmakeAbove#
+
+#if ENABLE_OVERLOADING
+    WindowUnmakeAboveMethodInfo             ,
+#endif
+    windowUnmakeAbove                       ,
+
+
+-- ** unmakeBelow #method:unmakeBelow#
+
+#if ENABLE_OVERLOADING
+    WindowUnmakeBelowMethodInfo             ,
+#endif
+    windowUnmakeBelow                       ,
+
+
+-- ** unmaximize #method:unmaximize#
+
+#if ENABLE_OVERLOADING
+    WindowUnmaximizeMethodInfo              ,
+#endif
+    windowUnmaximize                        ,
+
+
+-- ** unmaximizeHorizontally #method:unmaximizeHorizontally#
+
+#if ENABLE_OVERLOADING
+    WindowUnmaximizeHorizontallyMethodInfo  ,
+#endif
+    windowUnmaximizeHorizontally            ,
+
+
+-- ** unmaximizeVertically #method:unmaximizeVertically#
+
+#if ENABLE_OVERLOADING
+    WindowUnmaximizeVerticallyMethodInfo    ,
+#endif
+    windowUnmaximizeVertically              ,
+
+
+-- ** unminimize #method:unminimize#
+
+#if ENABLE_OVERLOADING
+    WindowUnminimizeMethodInfo              ,
+#endif
+    windowUnminimize                        ,
+
+
+-- ** unpin #method:unpin#
+
+#if ENABLE_OVERLOADING
+    WindowUnpinMethodInfo                   ,
+#endif
+    windowUnpin                             ,
+
+
+-- ** unshade #method:unshade#
+
+#if ENABLE_OVERLOADING
+    WindowUnshadeMethodInfo                 ,
+#endif
+    windowUnshade                           ,
+
+
+-- ** unstick #method:unstick#
+
+#if ENABLE_OVERLOADING
+    WindowUnstickMethodInfo                 ,
+#endif
+    windowUnstick                           ,
+
+
+
+
+ -- * Signals
+-- ** actionsChanged #signal:actionsChanged#
+
+    C_WindowActionsChangedCallback          ,
+    WindowActionsChangedCallback            ,
+#if ENABLE_OVERLOADING
+    WindowActionsChangedSignalInfo          ,
+#endif
+    afterWindowActionsChanged               ,
+    genClosure_WindowActionsChanged         ,
+    mk_WindowActionsChangedCallback         ,
+    noWindowActionsChangedCallback          ,
+    onWindowActionsChanged                  ,
+    wrap_WindowActionsChangedCallback       ,
+
+
+-- ** classChanged #signal:classChanged#
+
+    C_WindowClassChangedCallback            ,
+    WindowClassChangedCallback              ,
+#if ENABLE_OVERLOADING
+    WindowClassChangedSignalInfo            ,
+#endif
+    afterWindowClassChanged                 ,
+    genClosure_WindowClassChanged           ,
+    mk_WindowClassChangedCallback           ,
+    noWindowClassChangedCallback            ,
+    onWindowClassChanged                    ,
+    wrap_WindowClassChangedCallback         ,
+
+
+-- ** geometryChanged #signal:geometryChanged#
+
+    C_WindowGeometryChangedCallback         ,
+    WindowGeometryChangedCallback           ,
+#if ENABLE_OVERLOADING
+    WindowGeometryChangedSignalInfo         ,
+#endif
+    afterWindowGeometryChanged              ,
+    genClosure_WindowGeometryChanged        ,
+    mk_WindowGeometryChangedCallback        ,
+    noWindowGeometryChangedCallback         ,
+    onWindowGeometryChanged                 ,
+    wrap_WindowGeometryChangedCallback      ,
+
+
+-- ** iconChanged #signal:iconChanged#
+
+    C_WindowIconChangedCallback             ,
+    WindowIconChangedCallback               ,
+#if ENABLE_OVERLOADING
+    WindowIconChangedSignalInfo             ,
+#endif
+    afterWindowIconChanged                  ,
+    genClosure_WindowIconChanged            ,
+    mk_WindowIconChangedCallback            ,
+    noWindowIconChangedCallback             ,
+    onWindowIconChanged                     ,
+    wrap_WindowIconChangedCallback          ,
+
+
+-- ** nameChanged #signal:nameChanged#
+
+    C_WindowNameChangedCallback             ,
+    WindowNameChangedCallback               ,
+#if ENABLE_OVERLOADING
+    WindowNameChangedSignalInfo             ,
+#endif
+    afterWindowNameChanged                  ,
+    genClosure_WindowNameChanged            ,
+    mk_WindowNameChangedCallback            ,
+    noWindowNameChangedCallback             ,
+    onWindowNameChanged                     ,
+    wrap_WindowNameChangedCallback          ,
+
+
+-- ** roleChanged #signal:roleChanged#
+
+    C_WindowRoleChangedCallback             ,
+    WindowRoleChangedCallback               ,
+#if ENABLE_OVERLOADING
+    WindowRoleChangedSignalInfo             ,
+#endif
+    afterWindowRoleChanged                  ,
+    genClosure_WindowRoleChanged            ,
+    mk_WindowRoleChangedCallback            ,
+    noWindowRoleChangedCallback             ,
+    onWindowRoleChanged                     ,
+    wrap_WindowRoleChangedCallback          ,
+
+
+-- ** stateChanged #signal:stateChanged#
+
+    C_WindowStateChangedCallback            ,
+    WindowStateChangedCallback              ,
+#if ENABLE_OVERLOADING
+    WindowStateChangedSignalInfo            ,
+#endif
+    afterWindowStateChanged                 ,
+    genClosure_WindowStateChanged           ,
+    mk_WindowStateChangedCallback           ,
+    noWindowStateChangedCallback            ,
+    onWindowStateChanged                    ,
+    wrap_WindowStateChangedCallback         ,
+
+
+-- ** typeChanged #signal:typeChanged#
+
+    C_WindowTypeChangedCallback             ,
+    WindowTypeChangedCallback               ,
+#if ENABLE_OVERLOADING
+    WindowTypeChangedSignalInfo             ,
+#endif
+    afterWindowTypeChanged                  ,
+    genClosure_WindowTypeChanged            ,
+    mk_WindowTypeChangedCallback            ,
+    noWindowTypeChangedCallback             ,
+    onWindowTypeChanged                     ,
+    wrap_WindowTypeChangedCallback          ,
+
+
+-- ** workspaceChanged #signal:workspaceChanged#
+
+    C_WindowWorkspaceChangedCallback        ,
+    WindowWorkspaceChangedCallback          ,
+#if ENABLE_OVERLOADING
+    WindowWorkspaceChangedSignalInfo        ,
+#endif
+    afterWindowWorkspaceChanged             ,
+    genClosure_WindowWorkspaceChanged       ,
+    mk_WindowWorkspaceChangedCallback       ,
+    noWindowWorkspaceChangedCallback        ,
+    onWindowWorkspaceChanged                ,
+    wrap_WindowWorkspaceChangedCallback     ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+import qualified GI.GObject.Objects.Object as GObject.Object
+import qualified GI.GdkPixbuf.Objects.Pixbuf as GdkPixbuf.Pixbuf
+import {-# SOURCE #-} qualified GI.Wnck.Enums as Wnck.Enums
+import {-# SOURCE #-} qualified GI.Wnck.Flags as Wnck.Flags
+import {-# SOURCE #-} qualified GI.Wnck.Objects.Application as Wnck.Application
+import {-# SOURCE #-} qualified GI.Wnck.Objects.ClassGroup as Wnck.ClassGroup
+import {-# SOURCE #-} qualified GI.Wnck.Objects.Screen as Wnck.Screen
+import {-# SOURCE #-} qualified GI.Wnck.Objects.Workspace as Wnck.Workspace
+
+-- | Memory-managed wrapper type.
+newtype Window = Window (ManagedPtr Window)
+foreign import ccall "wnck_window_get_type"
+    c_wnck_window_get_type :: IO GType
+
+instance GObject Window where
+    gobjectType = c_wnck_window_get_type
+    
+
+-- | Type class for types which can be safely cast to `Window`, for instance with `toWindow`.
+class (GObject o, O.IsDescendantOf Window o) => IsWindow o
+instance (GObject o, O.IsDescendantOf Window o) => IsWindow o
+
+instance O.HasParentTypes Window
+type instance O.ParentTypes Window = '[GObject.Object.Object]
+
+-- | Cast to `Window`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
+toWindow :: (MonadIO m, IsWindow o) => o -> m Window
+toWindow = liftIO . unsafeCastTo Window
+
+-- | A convenience alias for `Nothing` :: `Maybe` `Window`.
+noWindow :: Maybe Window
+noWindow = Nothing
+
+#if ENABLE_OVERLOADING
+type family ResolveWindowMethod (t :: Symbol) (o :: *) :: * where
+    ResolveWindowMethod "activate" o = WindowActivateMethodInfo
+    ResolveWindowMethod "activateTransient" o = WindowActivateTransientMethodInfo
+    ResolveWindowMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
+    ResolveWindowMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
+    ResolveWindowMethod "close" o = WindowCloseMethodInfo
+    ResolveWindowMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
+    ResolveWindowMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
+    ResolveWindowMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
+    ResolveWindowMethod "hasIconName" o = WindowHasIconNameMethodInfo
+    ResolveWindowMethod "hasName" o = WindowHasNameMethodInfo
+    ResolveWindowMethod "isAbove" o = WindowIsAboveMethodInfo
+    ResolveWindowMethod "isActive" o = WindowIsActiveMethodInfo
+    ResolveWindowMethod "isBelow" o = WindowIsBelowMethodInfo
+    ResolveWindowMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
+    ResolveWindowMethod "isFullscreen" o = WindowIsFullscreenMethodInfo
+    ResolveWindowMethod "isInViewport" o = WindowIsInViewportMethodInfo
+    ResolveWindowMethod "isMaximized" o = WindowIsMaximizedMethodInfo
+    ResolveWindowMethod "isMaximizedHorizontally" o = WindowIsMaximizedHorizontallyMethodInfo
+    ResolveWindowMethod "isMaximizedVertically" o = WindowIsMaximizedVerticallyMethodInfo
+    ResolveWindowMethod "isMinimized" o = WindowIsMinimizedMethodInfo
+    ResolveWindowMethod "isMostRecentlyActivated" o = WindowIsMostRecentlyActivatedMethodInfo
+    ResolveWindowMethod "isOnWorkspace" o = WindowIsOnWorkspaceMethodInfo
+    ResolveWindowMethod "isPinned" o = WindowIsPinnedMethodInfo
+    ResolveWindowMethod "isShaded" o = WindowIsShadedMethodInfo
+    ResolveWindowMethod "isSkipPager" o = WindowIsSkipPagerMethodInfo
+    ResolveWindowMethod "isSkipTasklist" o = WindowIsSkipTasklistMethodInfo
+    ResolveWindowMethod "isSticky" o = WindowIsStickyMethodInfo
+    ResolveWindowMethod "isVisibleOnWorkspace" o = WindowIsVisibleOnWorkspaceMethodInfo
+    ResolveWindowMethod "keyboardMove" o = WindowKeyboardMoveMethodInfo
+    ResolveWindowMethod "keyboardSize" o = WindowKeyboardSizeMethodInfo
+    ResolveWindowMethod "makeAbove" o = WindowMakeAboveMethodInfo
+    ResolveWindowMethod "makeBelow" o = WindowMakeBelowMethodInfo
+    ResolveWindowMethod "maximize" o = WindowMaximizeMethodInfo
+    ResolveWindowMethod "maximizeHorizontally" o = WindowMaximizeHorizontallyMethodInfo
+    ResolveWindowMethod "maximizeVertically" o = WindowMaximizeVerticallyMethodInfo
+    ResolveWindowMethod "minimize" o = WindowMinimizeMethodInfo
+    ResolveWindowMethod "moveToWorkspace" o = WindowMoveToWorkspaceMethodInfo
+    ResolveWindowMethod "needsAttention" o = WindowNeedsAttentionMethodInfo
+    ResolveWindowMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
+    ResolveWindowMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
+    ResolveWindowMethod "orTransientNeedsAttention" o = WindowOrTransientNeedsAttentionMethodInfo
+    ResolveWindowMethod "pin" o = WindowPinMethodInfo
+    ResolveWindowMethod "ref" o = GObject.Object.ObjectRefMethodInfo
+    ResolveWindowMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
+    ResolveWindowMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
+    ResolveWindowMethod "shade" o = WindowShadeMethodInfo
+    ResolveWindowMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
+    ResolveWindowMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
+    ResolveWindowMethod "stick" o = WindowStickMethodInfo
+    ResolveWindowMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
+    ResolveWindowMethod "transientIsMostRecentlyActivated" o = WindowTransientIsMostRecentlyActivatedMethodInfo
+    ResolveWindowMethod "unmakeAbove" o = WindowUnmakeAboveMethodInfo
+    ResolveWindowMethod "unmakeBelow" o = WindowUnmakeBelowMethodInfo
+    ResolveWindowMethod "unmaximize" o = WindowUnmaximizeMethodInfo
+    ResolveWindowMethod "unmaximizeHorizontally" o = WindowUnmaximizeHorizontallyMethodInfo
+    ResolveWindowMethod "unmaximizeVertically" o = WindowUnmaximizeVerticallyMethodInfo
+    ResolveWindowMethod "unminimize" o = WindowUnminimizeMethodInfo
+    ResolveWindowMethod "unpin" o = WindowUnpinMethodInfo
+    ResolveWindowMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
+    ResolveWindowMethod "unshade" o = WindowUnshadeMethodInfo
+    ResolveWindowMethod "unstick" o = WindowUnstickMethodInfo
+    ResolveWindowMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
+    ResolveWindowMethod "getActions" o = WindowGetActionsMethodInfo
+    ResolveWindowMethod "getApplication" o = WindowGetApplicationMethodInfo
+    ResolveWindowMethod "getClassGroup" o = WindowGetClassGroupMethodInfo
+    ResolveWindowMethod "getClassGroupName" o = WindowGetClassGroupNameMethodInfo
+    ResolveWindowMethod "getClassInstanceName" o = WindowGetClassInstanceNameMethodInfo
+    ResolveWindowMethod "getClientWindowGeometry" o = WindowGetClientWindowGeometryMethodInfo
+    ResolveWindowMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
+    ResolveWindowMethod "getGeometry" o = WindowGetGeometryMethodInfo
+    ResolveWindowMethod "getGroupLeader" o = WindowGetGroupLeaderMethodInfo
+    ResolveWindowMethod "getIcon" o = WindowGetIconMethodInfo
+    ResolveWindowMethod "getIconIsFallback" o = WindowGetIconIsFallbackMethodInfo
+    ResolveWindowMethod "getIconName" o = WindowGetIconNameMethodInfo
+    ResolveWindowMethod "getMiniIcon" o = WindowGetMiniIconMethodInfo
+    ResolveWindowMethod "getName" o = WindowGetNameMethodInfo
+    ResolveWindowMethod "getPid" o = WindowGetPidMethodInfo
+    ResolveWindowMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
+    ResolveWindowMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
+    ResolveWindowMethod "getRole" o = WindowGetRoleMethodInfo
+    ResolveWindowMethod "getScreen" o = WindowGetScreenMethodInfo
+    ResolveWindowMethod "getSessionId" o = WindowGetSessionIdMethodInfo
+    ResolveWindowMethod "getSessionIdUtf8" o = WindowGetSessionIdUtf8MethodInfo
+    ResolveWindowMethod "getSortOrder" o = WindowGetSortOrderMethodInfo
+    ResolveWindowMethod "getState" o = WindowGetStateMethodInfo
+    ResolveWindowMethod "getTransient" o = WindowGetTransientMethodInfo
+    ResolveWindowMethod "getWindowType" o = WindowGetWindowTypeMethodInfo
+    ResolveWindowMethod "getWorkspace" o = WindowGetWorkspaceMethodInfo
+    ResolveWindowMethod "getXid" o = WindowGetXidMethodInfo
+    ResolveWindowMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
+    ResolveWindowMethod "setFullscreen" o = WindowSetFullscreenMethodInfo
+    ResolveWindowMethod "setGeometry" o = WindowSetGeometryMethodInfo
+    ResolveWindowMethod "setIconGeometry" o = WindowSetIconGeometryMethodInfo
+    ResolveWindowMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
+    ResolveWindowMethod "setSkipPager" o = WindowSetSkipPagerMethodInfo
+    ResolveWindowMethod "setSkipTasklist" o = WindowSetSkipTasklistMethodInfo
+    ResolveWindowMethod "setSortOrder" o = WindowSetSortOrderMethodInfo
+    ResolveWindowMethod "setWindowType" o = WindowSetWindowTypeMethodInfo
+    ResolveWindowMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolveWindowMethod t Window, O.MethodInfo info Window p) => OL.IsLabel t (Window -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+-- signal Window::actions-changed
+{- |
+Emitted when the actions availabilities for /@window@/ change.
+-}
+type WindowActionsChangedCallback =
+    [Wnck.Flags.WindowActions]
+    {- ^ /@changedMask@/: the bitmask containing bits set for all actions
+availabilities for /@window@/ that have changed. -}
+    -> [Wnck.Flags.WindowActions]
+    {- ^ /@newState@/: the new actions availabilities for /@window@/. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowActionsChangedCallback`@.
+noWindowActionsChangedCallback :: Maybe WindowActionsChangedCallback
+noWindowActionsChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_WindowActionsChangedCallback =
+    Ptr () ->                               -- object
+    CUInt ->
+    CUInt ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_WindowActionsChangedCallback`.
+foreign import ccall "wrapper"
+    mk_WindowActionsChangedCallback :: C_WindowActionsChangedCallback -> IO (FunPtr C_WindowActionsChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_WindowActionsChanged :: MonadIO m => WindowActionsChangedCallback -> m (GClosure C_WindowActionsChangedCallback)
+genClosure_WindowActionsChanged cb = liftIO $ do
+    let cb' = wrap_WindowActionsChangedCallback cb
+    mk_WindowActionsChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `WindowActionsChangedCallback` into a `C_WindowActionsChangedCallback`.
+wrap_WindowActionsChangedCallback ::
+    WindowActionsChangedCallback ->
+    C_WindowActionsChangedCallback
+wrap_WindowActionsChangedCallback _cb _ changedMask newState _ = do
+    let changedMask' = wordToGFlags changedMask
+    let newState' = wordToGFlags newState
+    _cb  changedMask' newState'
+
+
+{- |
+Connect a signal handler for the “@actions-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' window #actionsChanged callback
+@
+-}
+onWindowActionsChanged :: (IsWindow a, MonadIO m) => a -> WindowActionsChangedCallback -> m SignalHandlerId
+onWindowActionsChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowActionsChangedCallback cb
+    cb'' <- mk_WindowActionsChangedCallback cb'
+    connectSignalFunPtr obj "actions-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@actions-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' window #actionsChanged callback
+@
+-}
+afterWindowActionsChanged :: (IsWindow a, MonadIO m) => a -> WindowActionsChangedCallback -> m SignalHandlerId
+afterWindowActionsChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowActionsChangedCallback cb
+    cb'' <- mk_WindowActionsChangedCallback cb'
+    connectSignalFunPtr obj "actions-changed" cb'' SignalConnectAfter
+
+
+-- signal Window::class-changed
+{- |
+Emitted when the class name or instance name of /@window@/ changes.
+-}
+type WindowClassChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowClassChangedCallback`@.
+noWindowClassChangedCallback :: Maybe WindowClassChangedCallback
+noWindowClassChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_WindowClassChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_WindowClassChangedCallback`.
+foreign import ccall "wrapper"
+    mk_WindowClassChangedCallback :: C_WindowClassChangedCallback -> IO (FunPtr C_WindowClassChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_WindowClassChanged :: MonadIO m => WindowClassChangedCallback -> m (GClosure C_WindowClassChangedCallback)
+genClosure_WindowClassChanged cb = liftIO $ do
+    let cb' = wrap_WindowClassChangedCallback cb
+    mk_WindowClassChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `WindowClassChangedCallback` into a `C_WindowClassChangedCallback`.
+wrap_WindowClassChangedCallback ::
+    WindowClassChangedCallback ->
+    C_WindowClassChangedCallback
+wrap_WindowClassChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@class-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' window #classChanged callback
+@
+-}
+onWindowClassChanged :: (IsWindow a, MonadIO m) => a -> WindowClassChangedCallback -> m SignalHandlerId
+onWindowClassChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowClassChangedCallback cb
+    cb'' <- mk_WindowClassChangedCallback cb'
+    connectSignalFunPtr obj "class-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@class-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' window #classChanged callback
+@
+-}
+afterWindowClassChanged :: (IsWindow a, MonadIO m) => a -> WindowClassChangedCallback -> m SignalHandlerId
+afterWindowClassChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowClassChangedCallback cb
+    cb'' <- mk_WindowClassChangedCallback cb'
+    connectSignalFunPtr obj "class-changed" cb'' SignalConnectAfter
+
+
+-- signal Window::geometry-changed
+{- |
+Emitted when the geometry of /@window@/ changes.
+-}
+type WindowGeometryChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowGeometryChangedCallback`@.
+noWindowGeometryChangedCallback :: Maybe WindowGeometryChangedCallback
+noWindowGeometryChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_WindowGeometryChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_WindowGeometryChangedCallback`.
+foreign import ccall "wrapper"
+    mk_WindowGeometryChangedCallback :: C_WindowGeometryChangedCallback -> IO (FunPtr C_WindowGeometryChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_WindowGeometryChanged :: MonadIO m => WindowGeometryChangedCallback -> m (GClosure C_WindowGeometryChangedCallback)
+genClosure_WindowGeometryChanged cb = liftIO $ do
+    let cb' = wrap_WindowGeometryChangedCallback cb
+    mk_WindowGeometryChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `WindowGeometryChangedCallback` into a `C_WindowGeometryChangedCallback`.
+wrap_WindowGeometryChangedCallback ::
+    WindowGeometryChangedCallback ->
+    C_WindowGeometryChangedCallback
+wrap_WindowGeometryChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@geometry-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' window #geometryChanged callback
+@
+-}
+onWindowGeometryChanged :: (IsWindow a, MonadIO m) => a -> WindowGeometryChangedCallback -> m SignalHandlerId
+onWindowGeometryChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowGeometryChangedCallback cb
+    cb'' <- mk_WindowGeometryChangedCallback cb'
+    connectSignalFunPtr obj "geometry-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@geometry-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' window #geometryChanged callback
+@
+-}
+afterWindowGeometryChanged :: (IsWindow a, MonadIO m) => a -> WindowGeometryChangedCallback -> m SignalHandlerId
+afterWindowGeometryChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowGeometryChangedCallback cb
+    cb'' <- mk_WindowGeometryChangedCallback cb'
+    connectSignalFunPtr obj "geometry-changed" cb'' SignalConnectAfter
+
+
+-- signal Window::icon-changed
+{- |
+Emitted when the icon of /@window@/ changes.
+-}
+type WindowIconChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowIconChangedCallback`@.
+noWindowIconChangedCallback :: Maybe WindowIconChangedCallback
+noWindowIconChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_WindowIconChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_WindowIconChangedCallback`.
+foreign import ccall "wrapper"
+    mk_WindowIconChangedCallback :: C_WindowIconChangedCallback -> IO (FunPtr C_WindowIconChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_WindowIconChanged :: MonadIO m => WindowIconChangedCallback -> m (GClosure C_WindowIconChangedCallback)
+genClosure_WindowIconChanged cb = liftIO $ do
+    let cb' = wrap_WindowIconChangedCallback cb
+    mk_WindowIconChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `WindowIconChangedCallback` into a `C_WindowIconChangedCallback`.
+wrap_WindowIconChangedCallback ::
+    WindowIconChangedCallback ->
+    C_WindowIconChangedCallback
+wrap_WindowIconChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@icon-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' window #iconChanged callback
+@
+-}
+onWindowIconChanged :: (IsWindow a, MonadIO m) => a -> WindowIconChangedCallback -> m SignalHandlerId
+onWindowIconChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowIconChangedCallback cb
+    cb'' <- mk_WindowIconChangedCallback cb'
+    connectSignalFunPtr obj "icon-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@icon-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' window #iconChanged callback
+@
+-}
+afterWindowIconChanged :: (IsWindow a, MonadIO m) => a -> WindowIconChangedCallback -> m SignalHandlerId
+afterWindowIconChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowIconChangedCallback cb
+    cb'' <- mk_WindowIconChangedCallback cb'
+    connectSignalFunPtr obj "icon-changed" cb'' SignalConnectAfter
+
+
+-- signal Window::name-changed
+{- |
+Emitted when the name of /@window@/ changes.
+-}
+type WindowNameChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowNameChangedCallback`@.
+noWindowNameChangedCallback :: Maybe WindowNameChangedCallback
+noWindowNameChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_WindowNameChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_WindowNameChangedCallback`.
+foreign import ccall "wrapper"
+    mk_WindowNameChangedCallback :: C_WindowNameChangedCallback -> IO (FunPtr C_WindowNameChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_WindowNameChanged :: MonadIO m => WindowNameChangedCallback -> m (GClosure C_WindowNameChangedCallback)
+genClosure_WindowNameChanged cb = liftIO $ do
+    let cb' = wrap_WindowNameChangedCallback cb
+    mk_WindowNameChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `WindowNameChangedCallback` into a `C_WindowNameChangedCallback`.
+wrap_WindowNameChangedCallback ::
+    WindowNameChangedCallback ->
+    C_WindowNameChangedCallback
+wrap_WindowNameChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@name-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' window #nameChanged callback
+@
+-}
+onWindowNameChanged :: (IsWindow a, MonadIO m) => a -> WindowNameChangedCallback -> m SignalHandlerId
+onWindowNameChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowNameChangedCallback cb
+    cb'' <- mk_WindowNameChangedCallback cb'
+    connectSignalFunPtr obj "name-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@name-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' window #nameChanged callback
+@
+-}
+afterWindowNameChanged :: (IsWindow a, MonadIO m) => a -> WindowNameChangedCallback -> m SignalHandlerId
+afterWindowNameChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowNameChangedCallback cb
+    cb'' <- mk_WindowNameChangedCallback cb'
+    connectSignalFunPtr obj "name-changed" cb'' SignalConnectAfter
+
+
+-- signal Window::role-changed
+{- |
+Emitted when the role of /@window@/ changes.
+-}
+type WindowRoleChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowRoleChangedCallback`@.
+noWindowRoleChangedCallback :: Maybe WindowRoleChangedCallback
+noWindowRoleChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_WindowRoleChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_WindowRoleChangedCallback`.
+foreign import ccall "wrapper"
+    mk_WindowRoleChangedCallback :: C_WindowRoleChangedCallback -> IO (FunPtr C_WindowRoleChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_WindowRoleChanged :: MonadIO m => WindowRoleChangedCallback -> m (GClosure C_WindowRoleChangedCallback)
+genClosure_WindowRoleChanged cb = liftIO $ do
+    let cb' = wrap_WindowRoleChangedCallback cb
+    mk_WindowRoleChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `WindowRoleChangedCallback` into a `C_WindowRoleChangedCallback`.
+wrap_WindowRoleChangedCallback ::
+    WindowRoleChangedCallback ->
+    C_WindowRoleChangedCallback
+wrap_WindowRoleChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@role-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' window #roleChanged callback
+@
+-}
+onWindowRoleChanged :: (IsWindow a, MonadIO m) => a -> WindowRoleChangedCallback -> m SignalHandlerId
+onWindowRoleChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowRoleChangedCallback cb
+    cb'' <- mk_WindowRoleChangedCallback cb'
+    connectSignalFunPtr obj "role-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@role-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' window #roleChanged callback
+@
+-}
+afterWindowRoleChanged :: (IsWindow a, MonadIO m) => a -> WindowRoleChangedCallback -> m SignalHandlerId
+afterWindowRoleChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowRoleChangedCallback cb
+    cb'' <- mk_WindowRoleChangedCallback cb'
+    connectSignalFunPtr obj "role-changed" cb'' SignalConnectAfter
+
+
+-- signal Window::state-changed
+{- |
+Emitted when the state of /@window@/ changes. This can happen when /@window@/ is
+(un)minimized, (un)maximized, (un)sticked, (un)shaded, (un)made above,
+(un)made below, (un)set fullscreen, when it needs attention, etc. See
+'GI.Wnck.Flags.WindowState' for the complete list of states that might have changed.
+-}
+type WindowStateChangedCallback =
+    [Wnck.Flags.WindowState]
+    {- ^ /@changedMask@/: the bitmask containing bits set for all states of /@window@/
+that have changed. -}
+    -> [Wnck.Flags.WindowState]
+    {- ^ /@newState@/: the new state of /@window@/. -}
+    -> IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowStateChangedCallback`@.
+noWindowStateChangedCallback :: Maybe WindowStateChangedCallback
+noWindowStateChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_WindowStateChangedCallback =
+    Ptr () ->                               -- object
+    CUInt ->
+    CUInt ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_WindowStateChangedCallback`.
+foreign import ccall "wrapper"
+    mk_WindowStateChangedCallback :: C_WindowStateChangedCallback -> IO (FunPtr C_WindowStateChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_WindowStateChanged :: MonadIO m => WindowStateChangedCallback -> m (GClosure C_WindowStateChangedCallback)
+genClosure_WindowStateChanged cb = liftIO $ do
+    let cb' = wrap_WindowStateChangedCallback cb
+    mk_WindowStateChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `WindowStateChangedCallback` into a `C_WindowStateChangedCallback`.
+wrap_WindowStateChangedCallback ::
+    WindowStateChangedCallback ->
+    C_WindowStateChangedCallback
+wrap_WindowStateChangedCallback _cb _ changedMask newState _ = do
+    let changedMask' = wordToGFlags changedMask
+    let newState' = wordToGFlags newState
+    _cb  changedMask' newState'
+
+
+{- |
+Connect a signal handler for the “@state-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' window #stateChanged callback
+@
+-}
+onWindowStateChanged :: (IsWindow a, MonadIO m) => a -> WindowStateChangedCallback -> m SignalHandlerId
+onWindowStateChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowStateChangedCallback cb
+    cb'' <- mk_WindowStateChangedCallback cb'
+    connectSignalFunPtr obj "state-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@state-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' window #stateChanged callback
+@
+-}
+afterWindowStateChanged :: (IsWindow a, MonadIO m) => a -> WindowStateChangedCallback -> m SignalHandlerId
+afterWindowStateChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowStateChangedCallback cb
+    cb'' <- mk_WindowStateChangedCallback cb'
+    connectSignalFunPtr obj "state-changed" cb'' SignalConnectAfter
+
+
+-- signal Window::type-changed
+{- |
+Emitted when the EWMH type hint of the window changes.
+
+/Since: 3.20/
+-}
+type WindowTypeChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowTypeChangedCallback`@.
+noWindowTypeChangedCallback :: Maybe WindowTypeChangedCallback
+noWindowTypeChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_WindowTypeChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_WindowTypeChangedCallback`.
+foreign import ccall "wrapper"
+    mk_WindowTypeChangedCallback :: C_WindowTypeChangedCallback -> IO (FunPtr C_WindowTypeChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_WindowTypeChanged :: MonadIO m => WindowTypeChangedCallback -> m (GClosure C_WindowTypeChangedCallback)
+genClosure_WindowTypeChanged cb = liftIO $ do
+    let cb' = wrap_WindowTypeChangedCallback cb
+    mk_WindowTypeChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `WindowTypeChangedCallback` into a `C_WindowTypeChangedCallback`.
+wrap_WindowTypeChangedCallback ::
+    WindowTypeChangedCallback ->
+    C_WindowTypeChangedCallback
+wrap_WindowTypeChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@type-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' window #typeChanged callback
+@
+-}
+onWindowTypeChanged :: (IsWindow a, MonadIO m) => a -> WindowTypeChangedCallback -> m SignalHandlerId
+onWindowTypeChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowTypeChangedCallback cb
+    cb'' <- mk_WindowTypeChangedCallback cb'
+    connectSignalFunPtr obj "type-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@type-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' window #typeChanged callback
+@
+-}
+afterWindowTypeChanged :: (IsWindow a, MonadIO m) => a -> WindowTypeChangedCallback -> m SignalHandlerId
+afterWindowTypeChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowTypeChangedCallback cb
+    cb'' <- mk_WindowTypeChangedCallback cb'
+    connectSignalFunPtr obj "type-changed" cb'' SignalConnectAfter
+
+
+-- signal Window::workspace-changed
+{- |
+Emitted when the current workspace of /@window@/ changes, or if /@window@/ has
+been pinned or unpinned.
+-}
+type WindowWorkspaceChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `WindowWorkspaceChangedCallback`@.
+noWindowWorkspaceChangedCallback :: Maybe WindowWorkspaceChangedCallback
+noWindowWorkspaceChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_WindowWorkspaceChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_WindowWorkspaceChangedCallback`.
+foreign import ccall "wrapper"
+    mk_WindowWorkspaceChangedCallback :: C_WindowWorkspaceChangedCallback -> IO (FunPtr C_WindowWorkspaceChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_WindowWorkspaceChanged :: MonadIO m => WindowWorkspaceChangedCallback -> m (GClosure C_WindowWorkspaceChangedCallback)
+genClosure_WindowWorkspaceChanged cb = liftIO $ do
+    let cb' = wrap_WindowWorkspaceChangedCallback cb
+    mk_WindowWorkspaceChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `WindowWorkspaceChangedCallback` into a `C_WindowWorkspaceChangedCallback`.
+wrap_WindowWorkspaceChangedCallback ::
+    WindowWorkspaceChangedCallback ->
+    C_WindowWorkspaceChangedCallback
+wrap_WindowWorkspaceChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@workspace-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' window #workspaceChanged callback
+@
+-}
+onWindowWorkspaceChanged :: (IsWindow a, MonadIO m) => a -> WindowWorkspaceChangedCallback -> m SignalHandlerId
+onWindowWorkspaceChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowWorkspaceChangedCallback cb
+    cb'' <- mk_WindowWorkspaceChangedCallback cb'
+    connectSignalFunPtr obj "workspace-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@workspace-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' window #workspaceChanged callback
+@
+-}
+afterWindowWorkspaceChanged :: (IsWindow a, MonadIO m) => a -> WindowWorkspaceChangedCallback -> m SignalHandlerId
+afterWindowWorkspaceChanged obj cb = liftIO $ do
+    let cb' = wrap_WindowWorkspaceChangedCallback cb
+    cb'' <- mk_WindowWorkspaceChangedCallback cb'
+    connectSignalFunPtr obj "workspace-changed" cb'' SignalConnectAfter
+
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList Window
+type instance O.AttributeList Window = WindowAttributeList
+type WindowAttributeList = ('[ ] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+#endif
+
+#if ENABLE_OVERLOADING
+data WindowActionsChangedSignalInfo
+instance SignalInfo WindowActionsChangedSignalInfo where
+    type HaskellCallbackType WindowActionsChangedSignalInfo = WindowActionsChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_WindowActionsChangedCallback cb
+        cb'' <- mk_WindowActionsChangedCallback cb'
+        connectSignalFunPtr obj "actions-changed" cb'' connectMode
+
+data WindowClassChangedSignalInfo
+instance SignalInfo WindowClassChangedSignalInfo where
+    type HaskellCallbackType WindowClassChangedSignalInfo = WindowClassChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_WindowClassChangedCallback cb
+        cb'' <- mk_WindowClassChangedCallback cb'
+        connectSignalFunPtr obj "class-changed" cb'' connectMode
+
+data WindowGeometryChangedSignalInfo
+instance SignalInfo WindowGeometryChangedSignalInfo where
+    type HaskellCallbackType WindowGeometryChangedSignalInfo = WindowGeometryChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_WindowGeometryChangedCallback cb
+        cb'' <- mk_WindowGeometryChangedCallback cb'
+        connectSignalFunPtr obj "geometry-changed" cb'' connectMode
+
+data WindowIconChangedSignalInfo
+instance SignalInfo WindowIconChangedSignalInfo where
+    type HaskellCallbackType WindowIconChangedSignalInfo = WindowIconChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_WindowIconChangedCallback cb
+        cb'' <- mk_WindowIconChangedCallback cb'
+        connectSignalFunPtr obj "icon-changed" cb'' connectMode
+
+data WindowNameChangedSignalInfo
+instance SignalInfo WindowNameChangedSignalInfo where
+    type HaskellCallbackType WindowNameChangedSignalInfo = WindowNameChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_WindowNameChangedCallback cb
+        cb'' <- mk_WindowNameChangedCallback cb'
+        connectSignalFunPtr obj "name-changed" cb'' connectMode
+
+data WindowRoleChangedSignalInfo
+instance SignalInfo WindowRoleChangedSignalInfo where
+    type HaskellCallbackType WindowRoleChangedSignalInfo = WindowRoleChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_WindowRoleChangedCallback cb
+        cb'' <- mk_WindowRoleChangedCallback cb'
+        connectSignalFunPtr obj "role-changed" cb'' connectMode
+
+data WindowStateChangedSignalInfo
+instance SignalInfo WindowStateChangedSignalInfo where
+    type HaskellCallbackType WindowStateChangedSignalInfo = WindowStateChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_WindowStateChangedCallback cb
+        cb'' <- mk_WindowStateChangedCallback cb'
+        connectSignalFunPtr obj "state-changed" cb'' connectMode
+
+data WindowTypeChangedSignalInfo
+instance SignalInfo WindowTypeChangedSignalInfo where
+    type HaskellCallbackType WindowTypeChangedSignalInfo = WindowTypeChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_WindowTypeChangedCallback cb
+        cb'' <- mk_WindowTypeChangedCallback cb'
+        connectSignalFunPtr obj "type-changed" cb'' connectMode
+
+data WindowWorkspaceChangedSignalInfo
+instance SignalInfo WindowWorkspaceChangedSignalInfo where
+    type HaskellCallbackType WindowWorkspaceChangedSignalInfo = WindowWorkspaceChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_WindowWorkspaceChangedCallback cb
+        cb'' <- mk_WindowWorkspaceChangedCallback cb'
+        connectSignalFunPtr obj "workspace-changed" cb'' connectMode
+
+type instance O.SignalList Window = WindowSignalList
+type WindowSignalList = ('[ '("actionsChanged", WindowActionsChangedSignalInfo), '("classChanged", WindowClassChangedSignalInfo), '("geometryChanged", WindowGeometryChangedSignalInfo), '("iconChanged", WindowIconChangedSignalInfo), '("nameChanged", WindowNameChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("roleChanged", WindowRoleChangedSignalInfo), '("stateChanged", WindowStateChangedSignalInfo), '("typeChanged", WindowTypeChangedSignalInfo), '("workspaceChanged", WindowWorkspaceChangedSignalInfo)] :: [(Symbol, *)])
+
+#endif
+
+-- method Window::activate
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X server timestamp of the user interaction event that caused\nthis call to occur.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_activate" wnck_window_activate :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Word32 ->                               -- timestamp : TBasicType TUInt32
+    IO ()
+
+{- |
+Asks the window manager to make /@window@/ the active window. The
+window manager may choose to raise /@window@/ along with focusing it, and may
+decide to refuse the request (to not steal the focus if there is a more
+recent user activity, for example).
+
+This function existed before 2.10, but the /@timestamp@/ argument was missing
+in earlier versions.
+
+/Since: 2.10/
+-}
+windowActivate ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> Word32
+    {- ^ /@timestamp@/: the X server timestamp of the user interaction event that caused
+this call to occur. -}
+    -> m ()
+windowActivate window timestamp = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_activate window' timestamp
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowActivateMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowActivateMethodInfo a signature where
+    overloadedMethod _ = windowActivate
+
+#endif
+
+-- method Window::activate_transient
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X server timestamp of the user interaction event that caused\nthis call to occur.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_activate_transient" wnck_window_activate_transient :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Word32 ->                               -- timestamp : TBasicType TUInt32
+    IO ()
+
+{- |
+If /@window@/ has transients, activates the most likely transient
+instead of the window itself. Otherwise activates /@window@/.
+
+FIXME the ideal behavior of this function is probably to activate
+the most recently active window among /@window@/ and its transients.
+This is probably best implemented on the window manager side.
+
+This function existed before 2.10, but the /@timestamp@/ argument was missing
+in earlier versions.
+
+/Since: 2.10/
+-}
+windowActivateTransient ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> Word32
+    {- ^ /@timestamp@/: the X server timestamp of the user interaction event that caused
+this call to occur. -}
+    -> m ()
+windowActivateTransient window timestamp = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_activate_transient window' timestamp
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowActivateTransientMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowActivateTransientMethodInfo a signature where
+    overloadedMethod _ = windowActivateTransient
+
+#endif
+
+-- method Window::close
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X server timestamp of the user interaction event that caused\nthis call to occur.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_close" wnck_window_close :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Word32 ->                               -- timestamp : TBasicType TUInt32
+    IO ()
+
+{- |
+Closes /@window@/.
+
+This function existed before 2.6, but the /@timestamp@/ argument was missing
+in earlier versions.
+
+/Since: 2.6/
+-}
+windowClose ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> Word32
+    {- ^ /@timestamp@/: the X server timestamp of the user interaction event that caused
+this call to occur. -}
+    -> m ()
+windowClose window timestamp = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_close window' timestamp
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowCloseMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowCloseMethodInfo a signature where
+    overloadedMethod _ = windowClose
+
+#endif
+
+-- method Window::get_actions
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "WindowActions"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_actions" wnck_window_get_actions :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CUInt
+
+{- |
+Gets the actions that can be done for /@window@/.
+-}
+windowGetActions ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m [Wnck.Flags.WindowActions]
+    {- ^ __Returns:__ bitmask of actions that can be done for /@window@/. -}
+windowGetActions window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_actions window'
+    let result' = wordToGFlags result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetActionsMethodInfo
+instance (signature ~ (m [Wnck.Flags.WindowActions]), MonadIO m, IsWindow a) => O.MethodInfo WindowGetActionsMethodInfo a signature where
+    overloadedMethod _ = windowGetActions
+
+#endif
+
+-- method Window::get_application
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Application"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_application" wnck_window_get_application :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO (Ptr Wnck.Application.Application)
+
+{- |
+Gets the 'GI.Wnck.Objects.Application.Application' to which /@window@/ belongs.
+-}
+windowGetApplication ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Wnck.Application.Application
+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Application.Application' to which /@window@/ belongs.
+The returned 'GI.Wnck.Objects.Application.Application' is owned by libwnck and must not be referenced
+or unreferenced. -}
+windowGetApplication window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_application window'
+    checkUnexpectedReturnNULL "windowGetApplication" result
+    result' <- (newObject Wnck.Application.Application) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetApplicationMethodInfo
+instance (signature ~ (m Wnck.Application.Application), MonadIO m, IsWindow a) => O.MethodInfo WindowGetApplicationMethodInfo a signature where
+    overloadedMethod _ = windowGetApplication
+
+#endif
+
+-- method Window::get_class_group
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "ClassGroup"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_class_group" wnck_window_get_class_group :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO (Ptr Wnck.ClassGroup.ClassGroup)
+
+{- |
+Gets the 'GI.Wnck.Objects.ClassGroup.ClassGroup' to which /@window@/ belongs.
+
+/Since: 2.2/
+-}
+windowGetClassGroup ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Wnck.ClassGroup.ClassGroup
+    {- ^ __Returns:__ the 'GI.Wnck.Objects.ClassGroup.ClassGroup' to which /@window@/ belongs.
+The returned 'GI.Wnck.Objects.ClassGroup.ClassGroup' is owned by libwnck and must not be referenced
+or unreferenced. -}
+windowGetClassGroup window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_class_group window'
+    checkUnexpectedReturnNULL "windowGetClassGroup" result
+    result' <- (newObject Wnck.ClassGroup.ClassGroup) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetClassGroupMethodInfo
+instance (signature ~ (m Wnck.ClassGroup.ClassGroup), MonadIO m, IsWindow a) => O.MethodInfo WindowGetClassGroupMethodInfo a signature where
+    overloadedMethod _ = windowGetClassGroup
+
+#endif
+
+-- method Window::get_class_group_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_class_group_name" wnck_window_get_class_group_name :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CString
+
+{- |
+Gets the class group name from the \<ulink
+url=\"http:\/\/tronche.com\/gui\/x\/icccm\/sec-4.html&num;WM_CLASS\">WM_CLASS Property\<\/ulink>
+for /@window@/.
+
+The class group name is also the identifier name of the 'GI.Wnck.Objects.ClassGroup.ClassGroup' to
+which /@window@/ belongs.
+-}
+windowGetClassGroupName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m T.Text
+    {- ^ __Returns:__ the class group name for /@window@/, or 'Nothing' if /@window@/ belongs
+to no class group. -}
+windowGetClassGroupName window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_class_group_name window'
+    checkUnexpectedReturnNULL "windowGetClassGroupName" result
+    result' <- cstringToText result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetClassGroupNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetClassGroupNameMethodInfo a signature where
+    overloadedMethod _ = windowGetClassGroupName
+
+#endif
+
+-- method Window::get_class_instance_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_class_instance_name" wnck_window_get_class_instance_name :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CString
+
+{- |
+Gets the class instance name from the \<ulink
+url=\"http:\/\/tronche.com\/gui\/x\/icccm\/sec-4.html&num;WM_CLASS\">WM_CLASS Property\<\/ulink>
+for /@window@/.
+
+The class instance name allows to differentiate windows belonging to the
+same class group, so that they can use different resources.
+-}
+windowGetClassInstanceName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m T.Text
+    {- ^ __Returns:__ the class instance name for /@window@/, or 'Nothing' if /@window@/ has
+no class instance. -}
+windowGetClassInstanceName window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_class_instance_name window'
+    checkUnexpectedReturnNULL "windowGetClassInstanceName" result
+    result' <- cstringToText result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetClassInstanceNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetClassInstanceNameMethodInfo a signature where
+    overloadedMethod _ = windowGetClassInstanceName
+
+#endif
+
+-- method Window::get_client_window_geometry
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for X coordinate in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "yp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for Y coordinate in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "widthp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for width in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "heightp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for height in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_client_window_geometry" wnck_window_get_client_window_geometry :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Ptr Int32 ->                            -- xp : TBasicType TInt
+    Ptr Int32 ->                            -- yp : TBasicType TInt
+    Ptr Int32 ->                            -- widthp : TBasicType TInt
+    Ptr Int32 ->                            -- heightp : TBasicType TInt
+    IO ()
+
+{- |
+Gets the size and position of /@window@/, as last received
+in a ConfigureNotify event (i.e. this call does not round-trip
+to the server, just gets the last size we were notified of).
+The X and Y coordinates are relative to the root window.
+
+The window manager usually adds a frame around windows. If
+you need to know the size of /@window@/ with the frame, use
+'GI.Wnck.Objects.Window.windowGetGeometry'.
+
+/Since: 2.20/
+-}
+windowGetClientWindowGeometry ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ((Int32, Int32, Int32, Int32))
+windowGetClientWindowGeometry window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    xp <- allocMem :: IO (Ptr Int32)
+    yp <- allocMem :: IO (Ptr Int32)
+    widthp <- allocMem :: IO (Ptr Int32)
+    heightp <- allocMem :: IO (Ptr Int32)
+    wnck_window_get_client_window_geometry window' xp yp widthp heightp
+    xp' <- peek xp
+    yp' <- peek yp
+    widthp' <- peek widthp
+    heightp' <- peek heightp
+    touchManagedPtr window
+    freeMem xp
+    freeMem yp
+    freeMem widthp
+    freeMem heightp
+    return (xp', yp', widthp', heightp')
+
+#if ENABLE_OVERLOADING
+data WindowGetClientWindowGeometryMethodInfo
+instance (signature ~ (m ((Int32, Int32, Int32, Int32))), MonadIO m, IsWindow a) => O.MethodInfo WindowGetClientWindowGeometryMethodInfo a signature where
+    overloadedMethod _ = windowGetClientWindowGeometry
+
+#endif
+
+-- method Window::get_geometry
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "xp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for X coordinate in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "yp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for Y coordinate in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "widthp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for width in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "heightp", argType = TBasicType TInt, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "return location for height in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_geometry" wnck_window_get_geometry :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Ptr Int32 ->                            -- xp : TBasicType TInt
+    Ptr Int32 ->                            -- yp : TBasicType TInt
+    Ptr Int32 ->                            -- widthp : TBasicType TInt
+    Ptr Int32 ->                            -- heightp : TBasicType TInt
+    IO ()
+
+{- |
+Gets the size and position of /@window@/, including decorations. This
+function uses the information last received in a ConfigureNotify
+event and adjusts it according to the size of the frame that is
+added by the window manager (this call does not round-trip to the
+server, it just gets the last sizes that were notified). The
+X and Y coordinates are relative to the root window.
+
+If you need to know the actual size of /@window@/ ignoring the frame
+added by the window manager, use 'GI.Wnck.Objects.Window.windowGetClientWindowGeometry'.
+-}
+windowGetGeometry ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ((Int32, Int32, Int32, Int32))
+windowGetGeometry window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    xp <- allocMem :: IO (Ptr Int32)
+    yp <- allocMem :: IO (Ptr Int32)
+    widthp <- allocMem :: IO (Ptr Int32)
+    heightp <- allocMem :: IO (Ptr Int32)
+    wnck_window_get_geometry window' xp yp widthp heightp
+    xp' <- peek xp
+    yp' <- peek yp
+    widthp' <- peek widthp
+    heightp' <- peek heightp
+    touchManagedPtr window
+    freeMem xp
+    freeMem yp
+    freeMem widthp
+    freeMem heightp
+    return (xp', yp', widthp', heightp')
+
+#if ENABLE_OVERLOADING
+data WindowGetGeometryMethodInfo
+instance (signature ~ (m ((Int32, Int32, Int32, Int32))), MonadIO m, IsWindow a) => O.MethodInfo WindowGetGeometryMethodInfo a signature where
+    overloadedMethod _ = windowGetGeometry
+
+#endif
+
+-- method Window::get_group_leader
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TULong)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_group_leader" wnck_window_get_group_leader :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CULong
+
+{- |
+Gets the group leader of the group of windows to which /@window@/ belongs.
+-}
+windowGetGroupLeader ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m CULong
+    {- ^ __Returns:__ the group leader of the group of windows to which /@window@/
+belongs, or the X window ID of /@window@/ if /@window@/ does not belong to any
+group. -}
+windowGetGroupLeader window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_group_leader window'
+    touchManagedPtr window
+    return result
+
+#if ENABLE_OVERLOADING
+data WindowGetGroupLeaderMethodInfo
+instance (signature ~ (m CULong), MonadIO m, IsWindow a) => O.MethodInfo WindowGetGroupLeaderMethodInfo a signature where
+    overloadedMethod _ = windowGetGroupLeader
+
+#endif
+
+-- method Window::get_icon
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_icon" wnck_window_get_icon :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)
+
+{- |
+Gets the icon to be used for /@window@/. If no icon was found, a fallback
+icon is used. 'GI.Wnck.Objects.Window.windowGetIconIsFallback' can be used to tell if the
+icon is the fallback icon.
+-}
+windowGetIcon ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m GdkPixbuf.Pixbuf.Pixbuf
+    {- ^ __Returns:__ the icon for /@window@/. The caller should
+reference the returned \<classname>GdkPixbuf\<\/classname> if it needs to keep
+the icon around. -}
+windowGetIcon window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_icon window'
+    checkUnexpectedReturnNULL "windowGetIcon" result
+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetIconMethodInfo
+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsWindow a) => O.MethodInfo WindowGetIconMethodInfo a signature where
+    overloadedMethod _ = windowGetIcon
+
+#endif
+
+-- method Window::get_icon_is_fallback
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_icon_is_fallback" wnck_window_get_icon_is_fallback :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether a default fallback icon is used for /@window@/ (because none
+was set on /@window@/).
+-}
+windowGetIconIsFallback ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if the icon for /@window@/ is a fallback, 'False' otherwise. -}
+windowGetIconIsFallback window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_icon_is_fallback window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetIconIsFallbackMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowGetIconIsFallbackMethodInfo a signature where
+    overloadedMethod _ = windowGetIconIsFallback
+
+#endif
+
+-- method Window::get_icon_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_icon_name" wnck_window_get_icon_name :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CString
+
+{- |
+Gets the icon name of /@window@/, as it should be displayed for an icon
+(minimized state). Always returns some value, even if /@window@/ has no icon
+name set; use 'GI.Wnck.Objects.Window.windowHasIconName' if you need to know whether the
+returned icon name is \"real\" or not.
+
+Contrast with 'GI.Wnck.Objects.Window.windowGetName', which returns /@window@/\<!-- -->\'s
+title, not its icon title.
+-}
+windowGetIconName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window' -}
+    -> m T.Text
+    {- ^ __Returns:__ the icon name of /@window@/, or a fallback icon name if no icon
+name is available. -}
+windowGetIconName window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_icon_name window'
+    checkUnexpectedReturnNULL "windowGetIconName" result
+    result' <- cstringToText result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetIconNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetIconNameMethodInfo a signature where
+    overloadedMethod _ = windowGetIconName
+
+#endif
+
+-- method Window::get_mini_icon
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "GdkPixbuf", name = "Pixbuf"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_mini_icon" wnck_window_get_mini_icon :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO (Ptr GdkPixbuf.Pixbuf.Pixbuf)
+
+{- |
+Gets the mini-icon to be used for /@window@/. If no mini-icon was found, a
+fallback mini-icon is used. 'GI.Wnck.Objects.Window.windowGetIconIsFallback' can be used
+to tell if the mini-icon is the fallback mini-icon.
+-}
+windowGetMiniIcon ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m GdkPixbuf.Pixbuf.Pixbuf
+    {- ^ __Returns:__ the mini-icon for /@window@/. The caller should
+reference the returned \<classname>GdkPixbuf\<\/classname> if it needs to keep
+the icon around. -}
+windowGetMiniIcon window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_mini_icon window'
+    checkUnexpectedReturnNULL "windowGetMiniIcon" result
+    result' <- (newObject GdkPixbuf.Pixbuf.Pixbuf) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetMiniIconMethodInfo
+instance (signature ~ (m GdkPixbuf.Pixbuf.Pixbuf), MonadIO m, IsWindow a) => O.MethodInfo WindowGetMiniIconMethodInfo a signature where
+    overloadedMethod _ = windowGetMiniIcon
+
+#endif
+
+-- method Window::get_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_name" wnck_window_get_name :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CString
+
+{- |
+Gets the name of /@window@/, as it should be displayed in a pager
+or tasklist. Always returns some value, even if /@window@/ has no name
+set; use 'GI.Wnck.Objects.Window.windowHasName' if you need to know whether the returned
+name is \"real\" or not.
+
+For icons titles, use 'GI.Wnck.Objects.Window.windowGetIconName' instead.
+-}
+windowGetName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m T.Text
+    {- ^ __Returns:__ the name of /@window@/, or a fallback name if no name is
+available. -}
+windowGetName window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_name window'
+    checkUnexpectedReturnNULL "windowGetName" result
+    result' <- cstringToText result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetNameMethodInfo a signature where
+    overloadedMethod _ = windowGetName
+
+#endif
+
+-- method Window::get_pid
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_pid" wnck_window_get_pid :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO Int32
+
+{- |
+Gets the process ID of /@window@/.
+-}
+windowGetPid ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Int32
+    {- ^ __Returns:__ the process ID of /@window@/, or 0 if none is available. -}
+windowGetPid window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_pid window'
+    touchManagedPtr window
+    return result
+
+#if ENABLE_OVERLOADING
+data WindowGetPidMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsWindow a) => O.MethodInfo WindowGetPidMethodInfo a signature where
+    overloadedMethod _ = windowGetPid
+
+#endif
+
+-- method Window::get_role
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_role" wnck_window_get_role :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CString
+
+{- |
+Gets the role for /@window@/.
+The role uniquely identifies a window among all windows that have the same
+client leader window.
+-}
+windowGetRole ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m T.Text
+    {- ^ __Returns:__ role for /@window@/, or 'Nothing' if /@window@/ has no role. -}
+windowGetRole window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_role window'
+    checkUnexpectedReturnNULL "windowGetRole" result
+    result' <- cstringToText result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetRoleMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetRoleMethodInfo a signature where
+    overloadedMethod _ = windowGetRole
+
+#endif
+
+-- method Window::get_screen
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Screen"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_screen" wnck_window_get_screen :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO (Ptr Wnck.Screen.Screen)
+
+{- |
+Gets the 'GI.Wnck.Objects.Screen.Screen' /@window@/ is on.
+-}
+windowGetScreen ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Wnck.Screen.Screen
+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Screen.Screen' /@window@/ is on. The returned
+'GI.Wnck.Objects.Screen.Screen' is owned by libwnck and must not be referenced or unreferenced. -}
+windowGetScreen window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_screen window'
+    checkUnexpectedReturnNULL "windowGetScreen" result
+    result' <- (newObject Wnck.Screen.Screen) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetScreenMethodInfo
+instance (signature ~ (m Wnck.Screen.Screen), MonadIO m, IsWindow a) => O.MethodInfo WindowGetScreenMethodInfo a signature where
+    overloadedMethod _ = windowGetScreen
+
+#endif
+
+-- method Window::get_session_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_session_id" wnck_window_get_session_id :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CString
+
+{- |
+Gets the session ID for /@window@/ in Latin-1 encoding.
+NOTE: this is invalid UTF-8. You can\'t display this
+string in a GTK+ widget without converting to UTF-8.
+See 'GI.Wnck.Objects.Window.windowGetSessionIdUtf8'.
+-}
+windowGetSessionId ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m T.Text
+    {- ^ __Returns:__ the session ID for /@window@/ in Latin-1, or 'Nothing' if /@window@/ has
+no session ID. -}
+windowGetSessionId window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_session_id window'
+    checkUnexpectedReturnNULL "windowGetSessionId" result
+    result' <- cstringToText result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetSessionIdMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetSessionIdMethodInfo a signature where
+    overloadedMethod _ = windowGetSessionId
+
+#endif
+
+-- method Window::get_session_id_utf8
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_session_id_utf8" wnck_window_get_session_id_utf8 :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CString
+
+{- |
+Gets the session ID for /@window@/ in UTF-8 encoding.
+The session ID should be in Latin-1 encoding, so the conversion should work,
+but a broken client could set a session ID that might not be convertable to
+UTF-8.
+-}
+windowGetSessionIdUtf8 ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m T.Text
+    {- ^ __Returns:__ the session ID for /@window@/ in UTF-8, or 'Nothing' if /@window@/ has
+no session ID. -}
+windowGetSessionIdUtf8 window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_session_id_utf8 window'
+    checkUnexpectedReturnNULL "windowGetSessionIdUtf8" result
+    result' <- cstringToText result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetSessionIdUtf8MethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsWindow a) => O.MethodInfo WindowGetSessionIdUtf8MethodInfo a signature where
+    overloadedMethod _ = windowGetSessionIdUtf8
+
+#endif
+
+-- method Window::get_sort_order
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_sort_order" wnck_window_get_sort_order :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO Int32
+
+{- |
+Gets the sort order of /@window@/, used for ordering of /@window@/ in
+'GI.Wnck.Objects.Selector.Selector' and 'GI.Wnck.Objects.Tasklist.Tasklist'. The sort order is an internal state in
+libwnck. The initial value is defined when the window is created.
+
+/Since: 2.10/
+-}
+windowGetSortOrder ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Int32
+    {- ^ __Returns:__ the sort order of /@window@/, or G_MAXINT if none is available. -}
+windowGetSortOrder window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_sort_order window'
+    touchManagedPtr window
+    return result
+
+#if ENABLE_OVERLOADING
+data WindowGetSortOrderMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsWindow a) => O.MethodInfo WindowGetSortOrderMethodInfo a signature where
+    overloadedMethod _ = windowGetSortOrder
+
+#endif
+
+-- method Window::get_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "WindowState"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_state" wnck_window_get_state :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CUInt
+
+{- |
+Gets the state of /@window@/.
+-}
+windowGetState ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m [Wnck.Flags.WindowState]
+    {- ^ __Returns:__ bitmask of active states for /@window@/. -}
+windowGetState window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_state window'
+    let result' = wordToGFlags result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetStateMethodInfo
+instance (signature ~ (m [Wnck.Flags.WindowState]), MonadIO m, IsWindow a) => O.MethodInfo WindowGetStateMethodInfo a signature where
+    overloadedMethod _ = windowGetState
+
+#endif
+
+-- method Window::get_transient
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Window"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_transient" wnck_window_get_transient :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO (Ptr Window)
+
+{- |
+Gets the 'GI.Wnck.Objects.Window.Window' for which /@window@/ is transient.
+
+/Since: 2.12/
+-}
+windowGetTransient ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Window
+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Window.Window' for which /@window@/ is
+transient, or 'Nothing' if /@window@/ is not transient for any 'GI.Wnck.Objects.Window.Window'.
+The returned 'GI.Wnck.Objects.Window.Window' is owned by libwnck and must not be referenced or
+unreferenced. -}
+windowGetTransient window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_transient window'
+    checkUnexpectedReturnNULL "windowGetTransient" result
+    result' <- (newObject Window) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetTransientMethodInfo
+instance (signature ~ (m Window), MonadIO m, IsWindow a) => O.MethodInfo WindowGetTransientMethodInfo a signature where
+    overloadedMethod _ = windowGetTransient
+
+#endif
+
+-- method Window::get_window_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "WindowType"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_window_type" wnck_window_get_window_type :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CUInt
+
+{- |
+Gets the semantic type of /@window@/.
+-}
+windowGetWindowType ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Wnck.Enums.WindowType
+    {- ^ __Returns:__ the semantic type of /@window@/. -}
+windowGetWindowType window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_window_type window'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetWindowTypeMethodInfo
+instance (signature ~ (m Wnck.Enums.WindowType), MonadIO m, IsWindow a) => O.MethodInfo WindowGetWindowTypeMethodInfo a signature where
+    overloadedMethod _ = windowGetWindowType
+
+#endif
+
+-- method Window::get_workspace
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Workspace"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_workspace" wnck_window_get_workspace :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO (Ptr Wnck.Workspace.Workspace)
+
+{- |
+Gets the current workspace /@window@/ is on. If the window is pinned (on all
+workspaces), or not on any workspaces, 'Nothing' may be returned.
+-}
+windowGetWorkspace ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Wnck.Workspace.Workspace
+    {- ^ __Returns:__ the single current workspace /@window@/ is on, or
+'Nothing'. The returned 'GI.Wnck.Objects.Workspace.Workspace' is owned by libwnck and must not be
+referenced or unreferenced. -}
+windowGetWorkspace window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_workspace window'
+    checkUnexpectedReturnNULL "windowGetWorkspace" result
+    result' <- (newObject Wnck.Workspace.Workspace) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowGetWorkspaceMethodInfo
+instance (signature ~ (m Wnck.Workspace.Workspace), MonadIO m, IsWindow a) => O.MethodInfo WindowGetWorkspaceMethodInfo a signature where
+    overloadedMethod _ = windowGetWorkspace
+
+#endif
+
+-- method Window::get_xid
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TULong)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get_xid" wnck_window_get_xid :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CULong
+
+{- |
+Gets the X window ID of /@window@/.
+-}
+windowGetXid ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m CULong
+    {- ^ __Returns:__ the X window ID of /@window@/. -}
+windowGetXid window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_get_xid window'
+    touchManagedPtr window
+    return result
+
+#if ENABLE_OVERLOADING
+data WindowGetXidMethodInfo
+instance (signature ~ (m CULong), MonadIO m, IsWindow a) => O.MethodInfo WindowGetXidMethodInfo a signature where
+    overloadedMethod _ = windowGetXid
+
+#endif
+
+-- method Window::has_icon_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_has_icon_name" wnck_window_has_icon_name :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Checks whether or not /@window@/ has an icon name.
+'GI.Wnck.Objects.Window.windowGetIconName' will always return some value, even if
+/@window@/ has no icon name set; 'GI.Wnck.Objects.Window.windowHasIconName' can
+be used to tell if that icon name is real or not.
+
+(Note that if 'GI.Wnck.Objects.Window.windowHasIconName' returns 'False', but
+'GI.Wnck.Objects.Window.windowHasName' returns 'True', then the name returned by
+'GI.Wnck.Objects.Window.windowGetIconName' is /@window@/\<!-- -->\'s name. Only when both
+methods return 'False' does 'GI.Wnck.Objects.Window.windowGetIconName' return a
+generic fallback name.)
+
+/Since: 2.16/
+-}
+windowHasIconName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window' -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if 'GI.Wnck.Objects.Window.windowGetIconName' returns
+/@window@/\<!-- -->\'s icon name, 'False' if it returns a fallback name. -}
+windowHasIconName window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_has_icon_name window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowHasIconNameMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowHasIconNameMethodInfo a signature where
+    overloadedMethod _ = windowHasIconName
+
+#endif
+
+-- method Window::has_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_has_name" wnck_window_has_name :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Checks whether or not /@window@/ has a name. 'GI.Wnck.Objects.Window.windowGetName'
+will always return some value, even if /@window@/ has no name set;
+'GI.Wnck.Objects.Window.windowHasName' can be used to tell if that name is
+real or not.
+
+For icons titles, use 'GI.Wnck.Objects.Window.windowHasIconName' instead.
+
+/Since: 2.16/
+-}
+windowHasName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if 'GI.Wnck.Objects.Window.windowGetName' returns /@window@/\<!-- -->\'s
+name, 'False' if it returns a fallback name. -}
+windowHasName window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_has_name window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowHasNameMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowHasNameMethodInfo a signature where
+    overloadedMethod _ = windowHasName
+
+#endif
+
+-- method Window::is_above
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_above" wnck_window_is_above :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is above other windows. This state may change
+anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+
+See 'GI.Wnck.Objects.Window.windowMakeAbove' for more details on this state.
+
+/Since: 2.14/
+-}
+windowIsAbove ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is above other windows, 'False' otherwise. -}
+windowIsAbove window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_above window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsAboveMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsAboveMethodInfo a signature where
+    overloadedMethod _ = windowIsAbove
+
+#endif
+
+-- method Window::is_active
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_active" wnck_window_is_active :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is the active window on its 'GI.Wnck.Objects.Screen.Screen'.
+-}
+windowIsActive ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is the active window on its 'GI.Wnck.Objects.Screen.Screen',
+'False' otherwise. -}
+windowIsActive window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_active window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsActiveMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsActiveMethodInfo a signature where
+    overloadedMethod _ = windowIsActive
+
+#endif
+
+-- method Window::is_below
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_below" wnck_window_is_below :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is below other windows. This state may change
+anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+
+See 'GI.Wnck.Objects.Window.windowMakeBelow' for more details on this state.
+
+/Since: 2.20/
+-}
+windowIsBelow ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is below other windows, 'False' otherwise. -}
+windowIsBelow window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_below window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsBelowMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsBelowMethodInfo a signature where
+    overloadedMethod _ = windowIsBelow
+
+#endif
+
+-- method Window::is_fullscreen
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_fullscreen" wnck_window_is_fullscreen :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is fullscreen. Fullscreen state may change
+anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+
+/Since: 2.8/
+-}
+windowIsFullscreen ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is fullscreen, 'False' otherwise. -}
+windowIsFullscreen window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_fullscreen window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsFullscreenMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsFullscreenMethodInfo a signature where
+    overloadedMethod _ = windowIsFullscreen
+
+#endif
+
+-- method Window::is_in_viewport
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "workspace", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_in_viewport" wnck_window_is_in_viewport :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Ptr Wnck.Workspace.Workspace ->         -- workspace : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO CInt
+
+{- |
+Gets 'True' if /@window@/ appears in the current viewport of /@workspace@/.
+
+/Since: 2.4/
+-}
+windowIsInViewport ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> b
+    {- ^ /@workspace@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ appears in current viewport of /@workspace@/,
+'False' otherwise. -}
+windowIsInViewport window workspace = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    workspace' <- unsafeManagedPtrCastPtr workspace
+    result <- wnck_window_is_in_viewport window' workspace'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    touchManagedPtr workspace
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsInViewportMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) => O.MethodInfo WindowIsInViewportMethodInfo a signature where
+    overloadedMethod _ = windowIsInViewport
+
+#endif
+
+-- method Window::is_maximized
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_maximized" wnck_window_is_maximized :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is maximized. Maximization state may change
+anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+
+As for GDK, \"maximized\" means both vertically and horizontally. If /@window@/
+is maximized in only one direction, then /@window@/ is not considered
+maximized.
+-}
+windowIsMaximized ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is maximized in both directions, 'False'
+otherwise. -}
+windowIsMaximized window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_maximized window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsMaximizedMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsMaximizedMethodInfo a signature where
+    overloadedMethod _ = windowIsMaximized
+
+#endif
+
+-- method Window::is_maximized_horizontally
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_maximized_horizontally" wnck_window_is_maximized_horizontally :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is maximized horizontally. Horizontal maximization
+state may change anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+-}
+windowIsMaximizedHorizontally ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is maximized horizontally, 'False' otherwise. -}
+windowIsMaximizedHorizontally window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_maximized_horizontally window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsMaximizedHorizontallyMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsMaximizedHorizontallyMethodInfo a signature where
+    overloadedMethod _ = windowIsMaximizedHorizontally
+
+#endif
+
+-- method Window::is_maximized_vertically
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_maximized_vertically" wnck_window_is_maximized_vertically :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is maximized vertically. vertiVal maximization
+state may change anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+-}
+windowIsMaximizedVertically ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is maximized vertically, 'False' otherwise. -}
+windowIsMaximizedVertically window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_maximized_vertically window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsMaximizedVerticallyMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsMaximizedVerticallyMethodInfo a signature where
+    overloadedMethod _ = windowIsMaximizedVertically
+
+#endif
+
+-- method Window::is_minimized
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_minimized" wnck_window_is_minimized :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is minimized. Minimization state may change anytime
+a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+-}
+windowIsMinimized ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is minimized, 'False' otherwise. -}
+windowIsMinimized window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_minimized window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsMinimizedMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsMinimizedMethodInfo a signature where
+    overloadedMethod _ = windowIsMinimized
+
+#endif
+
+-- method Window::is_most_recently_activated
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_most_recently_activated" wnck_window_is_most_recently_activated :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is the most recently activated window on its
+'GI.Wnck.Objects.Screen.Screen'.
+
+The most recently activated window is identical to the active
+window for click and sloppy focus methods (since a window is always
+active in those cases) but differs slightly for mouse focus since
+there often is no active window.
+
+/Since: 2.8/
+-}
+windowIsMostRecentlyActivated ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ was the most recently activated window on its
+'GI.Wnck.Objects.Screen.Screen', 'False' otherwise. -}
+windowIsMostRecentlyActivated window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_most_recently_activated window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsMostRecentlyActivatedMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsMostRecentlyActivatedMethodInfo a signature where
+    overloadedMethod _ = windowIsMostRecentlyActivated
+
+#endif
+
+-- method Window::is_on_workspace
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "workspace", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_on_workspace" wnck_window_is_on_workspace :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Ptr Wnck.Workspace.Workspace ->         -- workspace : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ appears on /@workspace@/.
+-}
+windowIsOnWorkspace ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> b
+    {- ^ /@workspace@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ appears on /@workspace@/, 'False' otherwise. -}
+windowIsOnWorkspace window workspace = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    workspace' <- unsafeManagedPtrCastPtr workspace
+    result <- wnck_window_is_on_workspace window' workspace'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    touchManagedPtr workspace
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsOnWorkspaceMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) => O.MethodInfo WindowIsOnWorkspaceMethodInfo a signature where
+    overloadedMethod _ = windowIsOnWorkspace
+
+#endif
+
+-- method Window::is_pinned
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_pinned" wnck_window_is_pinned :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is on all workspace. Pinned state may change
+anytime a 'GI.Wnck.Objects.Window.Window'::@/workspace-changed/@ signal gets emitted, but not when
+a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ gets emitted.
+-}
+windowIsPinned ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is on all workspaces, 'False' otherwise. -}
+windowIsPinned window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_pinned window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsPinnedMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsPinnedMethodInfo a signature where
+    overloadedMethod _ = windowIsPinned
+
+#endif
+
+-- method Window::is_shaded
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_shaded" wnck_window_is_shaded :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is shaded. Shade state may change anytime
+a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+-}
+windowIsShaded ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is shaded, 'False' otherwise. -}
+windowIsShaded window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_shaded window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsShadedMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsShadedMethodInfo a signature where
+    overloadedMethod _ = windowIsShaded
+
+#endif
+
+-- method Window::is_skip_pager
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_skip_pager" wnck_window_is_skip_pager :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is included on pagers. This state may change
+anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+-}
+windowIsSkipPager ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is included on pagers, 'False' otherwise. -}
+windowIsSkipPager window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_skip_pager window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsSkipPagerMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsSkipPagerMethodInfo a signature where
+    overloadedMethod _ = windowIsSkipPager
+
+#endif
+
+-- method Window::is_skip_tasklist
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_skip_tasklist" wnck_window_is_skip_tasklist :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is included on tasklists. This state may change
+anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+-}
+windowIsSkipTasklist ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is included on tasklists, 'False' otherwise. -}
+windowIsSkipTasklist window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_skip_tasklist window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsSkipTasklistMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsSkipTasklistMethodInfo a signature where
+    overloadedMethod _ = windowIsSkipTasklist
+
+#endif
+
+-- method Window::is_sticky
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_sticky" wnck_window_is_sticky :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ is sticky. Sticky state may change
+anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+
+Sticky here means \"stuck to the glass\", i.e. does not scroll with the
+viewport. In GDK\/GTK+ (e.g. 'GI.Gdk.Objects.Window.windowStick'\/'GI.Gtk.Objects.Window.windowStick'), sticky
+means \"stuck to the glass\" and \<emphasis>also\<\/emphasis> that the window is
+on all workspaces. But here it only means the viewport aspect of it.
+-}
+windowIsSticky ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ is \"stuck to the glass\", 'False' otherwise. -}
+windowIsSticky window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_is_sticky window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsStickyMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowIsStickyMethodInfo a signature where
+    overloadedMethod _ = windowIsSticky
+
+#endif
+
+-- method Window::is_visible_on_workspace
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "workspace", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_is_visible_on_workspace" wnck_window_is_visible_on_workspace :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Ptr Wnck.Workspace.Workspace ->         -- workspace : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO CInt
+
+{- |
+Like 'GI.Wnck.Objects.Window.windowIsOnWorkspace', but also checks that
+the window is in a visible state (i.e. not minimized or shaded).
+-}
+windowIsVisibleOnWorkspace ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> b
+    {- ^ /@workspace@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ appears on /@workspace@/ in normal state, 'False'
+otherwise. -}
+windowIsVisibleOnWorkspace window workspace = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    workspace' <- unsafeManagedPtrCastPtr workspace
+    result <- wnck_window_is_visible_on_workspace window' workspace'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    touchManagedPtr workspace
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowIsVisibleOnWorkspaceMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) => O.MethodInfo WindowIsVisibleOnWorkspaceMethodInfo a signature where
+    overloadedMethod _ = windowIsVisibleOnWorkspace
+
+#endif
+
+-- method Window::keyboard_move
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_keyboard_move" wnck_window_keyboard_move :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to start moving /@window@/ via the keyboard.
+-}
+windowKeyboardMove ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowKeyboardMove window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_keyboard_move window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowKeyboardMoveMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowKeyboardMoveMethodInfo a signature where
+    overloadedMethod _ = windowKeyboardMove
+
+#endif
+
+-- method Window::keyboard_size
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_keyboard_size" wnck_window_keyboard_size :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to start resizing /@window@/ via the keyboard.
+-}
+windowKeyboardSize ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowKeyboardSize window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_keyboard_size window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowKeyboardSizeMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowKeyboardSizeMethodInfo a signature where
+    overloadedMethod _ = windowKeyboardSize
+
+#endif
+
+-- method Window::make_above
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_make_above" wnck_window_make_above :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to put /@window@/ on top of most windows (/@window@/ will
+not be on top of focused fullscreen windows, of other windows with this
+setting and of dock windows).
+
+/Since: 2.14/
+-}
+windowMakeAbove ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowMakeAbove window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_make_above window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowMakeAboveMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowMakeAboveMethodInfo a signature where
+    overloadedMethod _ = windowMakeAbove
+
+#endif
+
+-- method Window::make_below
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_make_below" wnck_window_make_below :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to put /@window@/ below most windows.
+
+/Since: 2.20/
+-}
+windowMakeBelow ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowMakeBelow window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_make_below window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowMakeBelowMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowMakeBelowMethodInfo a signature where
+    overloadedMethod _ = windowMakeBelow
+
+#endif
+
+-- method Window::maximize
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_maximize" wnck_window_maximize :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to maximize /@window@/.
+-}
+windowMaximize ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowMaximize window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_maximize window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowMaximizeMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowMaximizeMethodInfo a signature where
+    overloadedMethod _ = windowMaximize
+
+#endif
+
+-- method Window::maximize_horizontally
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_maximize_horizontally" wnck_window_maximize_horizontally :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to maximize horizontally /@window@/.
+-}
+windowMaximizeHorizontally ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowMaximizeHorizontally window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_maximize_horizontally window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowMaximizeHorizontallyMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowMaximizeHorizontallyMethodInfo a signature where
+    overloadedMethod _ = windowMaximizeHorizontally
+
+#endif
+
+-- method Window::maximize_vertically
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_maximize_vertically" wnck_window_maximize_vertically :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to maximize vertically /@window@/.
+-}
+windowMaximizeVertically ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowMaximizeVertically window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_maximize_vertically window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowMaximizeVerticallyMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowMaximizeVerticallyMethodInfo a signature where
+    overloadedMethod _ = windowMaximizeVertically
+
+#endif
+
+-- method Window::minimize
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_minimize" wnck_window_minimize :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Minimizes /@window@/.
+-}
+windowMinimize ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowMinimize window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_minimize window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowMinimizeMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowMinimizeMethodInfo a signature where
+    overloadedMethod _ = windowMinimize
+
+#endif
+
+-- method Window::move_to_workspace
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_move_to_workspace" wnck_window_move_to_workspace :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Ptr Wnck.Workspace.Workspace ->         -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO ()
+
+{- |
+Asks the window manager to move /@window@/ to /@space@/. If /@window@/ was pinned, it
+will also result in /@window@/ being visible only on /@space@/.
+-}
+windowMoveToWorkspace ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> b
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m ()
+windowMoveToWorkspace window space = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    space' <- unsafeManagedPtrCastPtr space
+    wnck_window_move_to_workspace window' space'
+    touchManagedPtr window
+    touchManagedPtr space
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowMoveToWorkspaceMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, IsWindow a, Wnck.Workspace.IsWorkspace b) => O.MethodInfo WindowMoveToWorkspaceMethodInfo a signature where
+    overloadedMethod _ = windowMoveToWorkspace
+
+#endif
+
+-- method Window::needs_attention
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_needs_attention" wnck_window_needs_attention :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ needs attention. This state may change anytime
+a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+
+This state depends on flags such as the demands_attention and is_urgent
+hints.
+
+/Since: 2.12/
+-}
+windowNeedsAttention ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ needs attention, 'False' otherwise. -}
+windowNeedsAttention window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_needs_attention window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowNeedsAttentionMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowNeedsAttentionMethodInfo a signature where
+    overloadedMethod _ = windowNeedsAttention
+
+#endif
+
+-- method Window::or_transient_needs_attention
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_or_transient_needs_attention" wnck_window_or_transient_needs_attention :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether /@window@/ or one of its transients needs attention. This state
+may change anytime a 'GI.Wnck.Objects.Window.Window'::@/state-changed/@ signal gets emitted.
+
+/Since: 2.12/
+-}
+windowOrTransientNeedsAttention ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@window@/ or one of its transients needs attention,
+'False' otherwise. -}
+windowOrTransientNeedsAttention window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_or_transient_needs_attention window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowOrTransientNeedsAttentionMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowOrTransientNeedsAttentionMethodInfo a signature where
+    overloadedMethod _ = windowOrTransientNeedsAttention
+
+#endif
+
+-- method Window::pin
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_pin" wnck_window_pin :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to put /@window@/ on all workspaces.
+-}
+windowPin ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowPin window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_pin window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowPinMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowPinMethodInfo a signature where
+    overloadedMethod _ = windowPin
+
+#endif
+
+-- method Window::set_fullscreen
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fullscreen", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to make @window fullscreen.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_set_fullscreen" wnck_window_set_fullscreen :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    CInt ->                                 -- fullscreen : TBasicType TBoolean
+    IO ()
+
+{- |
+Asks the window manager to set the fullscreen state of /@window@/ according to
+/@fullscreen@/.
+
+/Since: 2.8/
+-}
+windowSetFullscreen ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> Bool
+    {- ^ /@fullscreen@/: whether to make /@window@/ fullscreen. -}
+    -> m ()
+windowSetFullscreen window fullscreen = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    let fullscreen' = (fromIntegral . fromEnum) fullscreen
+    wnck_window_set_fullscreen window' fullscreen'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowSetFullscreenMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetFullscreenMethodInfo a signature where
+    overloadedMethod _ = windowSetFullscreen
+
+#endif
+
+-- method Window::set_geometry
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gravity", argType = TInterface (Name {namespace = "Wnck", name = "WindowGravity"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the gravity point to use as a reference for the new position.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "geometry_mask", argType = TInterface (Name {namespace = "Wnck", name = "WindowMoveResizeMask"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a bitmask containing flags for what should be set.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new X coordinate in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new Y coordinate in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new width in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new height in pixels of @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_set_geometry" wnck_window_set_geometry :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    CUInt ->                                -- gravity : TInterface (Name {namespace = "Wnck", name = "WindowGravity"})
+    CUInt ->                                -- geometry_mask : TInterface (Name {namespace = "Wnck", name = "WindowMoveResizeMask"})
+    Int32 ->                                -- x : TBasicType TInt
+    Int32 ->                                -- y : TBasicType TInt
+    Int32 ->                                -- width : TBasicType TInt
+    Int32 ->                                -- height : TBasicType TInt
+    IO ()
+
+{- |
+Sets the size and position of /@window@/. The X and Y coordinates should be
+relative to the root window.
+
+Note that the new size and position apply to /@window@/ with its frame added
+by the window manager. Therefore, using 'GI.Wnck.Objects.Window.windowSetGeometry' with
+the values returned by 'GI.Wnck.Objects.Window.windowGetGeometry' should be a no-op, while
+using 'GI.Wnck.Objects.Window.windowSetGeometry' with the values returned by
+'GI.Wnck.Objects.Window.windowGetClientWindowGeometry' should reduce the size of /@window@/
+and move it.
+
+/Since: 2.16/
+-}
+windowSetGeometry ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> Wnck.Enums.WindowGravity
+    {- ^ /@gravity@/: the gravity point to use as a reference for the new position. -}
+    -> [Wnck.Flags.WindowMoveResizeMask]
+    {- ^ /@geometryMask@/: a bitmask containing flags for what should be set. -}
+    -> Int32
+    {- ^ /@x@/: new X coordinate in pixels of /@window@/. -}
+    -> Int32
+    {- ^ /@y@/: new Y coordinate in pixels of /@window@/. -}
+    -> Int32
+    {- ^ /@width@/: new width in pixels of /@window@/. -}
+    -> Int32
+    {- ^ /@height@/: new height in pixels of /@window@/. -}
+    -> m ()
+windowSetGeometry window gravity geometryMask x y width height = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    let gravity' = (fromIntegral . fromEnum) gravity
+    let geometryMask' = gflagsToWord geometryMask
+    wnck_window_set_geometry window' gravity' geometryMask' x y width height
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowSetGeometryMethodInfo
+instance (signature ~ (Wnck.Enums.WindowGravity -> [Wnck.Flags.WindowMoveResizeMask] -> Int32 -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetGeometryMethodInfo a signature where
+    overloadedMethod _ = windowSetGeometry
+
+#endif
+
+-- method Window::set_icon_geometry
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "x", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "X coordinate in pixels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "y", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Y coordinate in pixels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "width", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "width in pixels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "height", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "height in pixels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_set_icon_geometry" wnck_window_set_icon_geometry :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Int32 ->                                -- x : TBasicType TInt
+    Int32 ->                                -- y : TBasicType TInt
+    Int32 ->                                -- width : TBasicType TInt
+    Int32 ->                                -- height : TBasicType TInt
+    IO ()
+
+{- |
+Sets the icon geometry for /@window@/. A typical use case for this is the
+destination of the minimization animation of /@window@/.
+-}
+windowSetIconGeometry ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> Int32
+    {- ^ /@x@/: X coordinate in pixels. -}
+    -> Int32
+    {- ^ /@y@/: Y coordinate in pixels. -}
+    -> Int32
+    {- ^ /@width@/: width in pixels. -}
+    -> Int32
+    {- ^ /@height@/: height in pixels. -}
+    -> m ()
+windowSetIconGeometry window x y width height = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_set_icon_geometry window' x y width height
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowSetIconGeometryMethodInfo
+instance (signature ~ (Int32 -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetIconGeometryMethodInfo a signature where
+    overloadedMethod _ = windowSetIconGeometry
+
+#endif
+
+-- method Window::set_skip_pager
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "skip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @window should be included on pagers.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_set_skip_pager" wnck_window_set_skip_pager :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    CInt ->                                 -- skip : TBasicType TBoolean
+    IO ()
+
+{- |
+Asks the window manager to make /@window@/ included or not included on pagers.
+-}
+windowSetSkipPager ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> Bool
+    {- ^ /@skip@/: whether /@window@/ should be included on pagers. -}
+    -> m ()
+windowSetSkipPager window skip = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    let skip' = (fromIntegral . fromEnum) skip
+    wnck_window_set_skip_pager window' skip'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowSetSkipPagerMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetSkipPagerMethodInfo a signature where
+    overloadedMethod _ = windowSetSkipPager
+
+#endif
+
+-- method Window::set_skip_tasklist
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "skip", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether @window should be included on tasklists.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_set_skip_tasklist" wnck_window_set_skip_tasklist :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    CInt ->                                 -- skip : TBasicType TBoolean
+    IO ()
+
+{- |
+Asks the window manager to make /@window@/ included or not included on
+tasklists.
+-}
+windowSetSkipTasklist ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> Bool
+    {- ^ /@skip@/: whether /@window@/ should be included on tasklists. -}
+    -> m ()
+windowSetSkipTasklist window skip = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    let skip' = (fromIntegral . fromEnum) skip
+    wnck_window_set_skip_tasklist window' skip'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowSetSkipTasklistMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetSkipTasklistMethodInfo a signature where
+    overloadedMethod _ = windowSetSkipTasklist
+
+#endif
+
+-- method Window::set_sort_order
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "order", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new sort order for @window.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_set_sort_order" wnck_window_set_sort_order :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Int32 ->                                -- order : TBasicType TInt
+    IO ()
+
+{- |
+Sets the sort order of /@window@/. The sort order is used for ordering of
+/@window@/ in 'GI.Wnck.Objects.Selector.Selector' and 'GI.Wnck.Objects.Tasklist.Tasklist'.
+
+/Since: 2.20/
+-}
+windowSetSortOrder ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> Int32
+    {- ^ /@order@/: new sort order for /@window@/. -}
+    -> m ()
+windowSetSortOrder window order = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_set_sort_order window' order
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowSetSortOrderMethodInfo
+instance (signature ~ (Int32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetSortOrderMethodInfo a signature where
+    overloadedMethod _ = windowSetSortOrder
+
+#endif
+
+-- method Window::set_window_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "wintype", argType = TInterface (Name {namespace = "Wnck", name = "WindowType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a semantic type.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_set_window_type" wnck_window_set_window_type :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    CUInt ->                                -- wintype : TInterface (Name {namespace = "Wnck", name = "WindowType"})
+    IO ()
+
+{- |
+Sets the semantic type of /@window@/ to /@wintype@/.
+
+/Since: 2.12/
+-}
+windowSetWindowType ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> Wnck.Enums.WindowType
+    {- ^ /@wintype@/: a semantic type. -}
+    -> m ()
+windowSetWindowType window wintype = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    let wintype' = (fromIntegral . fromEnum) wintype
+    wnck_window_set_window_type window' wintype'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowSetWindowTypeMethodInfo
+instance (signature ~ (Wnck.Enums.WindowType -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowSetWindowTypeMethodInfo a signature where
+    overloadedMethod _ = windowSetWindowType
+
+#endif
+
+-- method Window::shade
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_shade" wnck_window_shade :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to shade /@window@/.
+-}
+windowShade ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowShade window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_shade window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowShadeMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowShadeMethodInfo a signature where
+    overloadedMethod _ = windowShade
+
+#endif
+
+-- method Window::stick
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_stick" wnck_window_stick :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to keep the /@window@/\<!-- -->\'s position fixed on the
+screen, even when the workspace or viewport scrolls.
+-}
+windowStick ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowStick window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_stick window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowStickMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowStickMethodInfo a signature where
+    overloadedMethod _ = windowStick
+
+#endif
+
+-- method Window::transient_is_most_recently_activated
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_transient_is_most_recently_activated" wnck_window_transient_is_most_recently_activated :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO CInt
+
+{- |
+Gets whether one of the transients of /@window@/ is the most
+recently activated window. See
+'GI.Wnck.Objects.Window.windowIsMostRecentlyActivated' for a more complete
+description of what is meant by most recently activated.  This
+function is needed because clicking on a 'GI.Wnck.Objects.Tasklist.Tasklist' once will
+activate a transient instead of /@window@/ itself
+(wnck_window_activate_transient), and clicking again should
+minimize /@window@/ and its transients.  (Not doing this can be
+especially annoying in the case of modal dialogs that don\'t appear
+in the 'GI.Wnck.Objects.Tasklist.Tasklist').
+
+/Since: 2.12/
+-}
+windowTransientIsMostRecentlyActivated ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if one of the transients of /@window@/ is the most recently
+activated window, 'False' otherwise. -}
+windowTransientIsMostRecentlyActivated window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    result <- wnck_window_transient_is_most_recently_activated window'
+    let result' = (/= 0) result
+    touchManagedPtr window
+    return result'
+
+#if ENABLE_OVERLOADING
+data WindowTransientIsMostRecentlyActivatedMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWindow a) => O.MethodInfo WindowTransientIsMostRecentlyActivatedMethodInfo a signature where
+    overloadedMethod _ = windowTransientIsMostRecentlyActivated
+
+#endif
+
+-- method Window::unmake_above
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_unmake_above" wnck_window_unmake_above :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to not put /@window@/ on top of most windows, and to
+put it again in the stack with other windows.
+
+/Since: 2.14/
+-}
+windowUnmakeAbove ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowUnmakeAbove window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_unmake_above window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowUnmakeAboveMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnmakeAboveMethodInfo a signature where
+    overloadedMethod _ = windowUnmakeAbove
+
+#endif
+
+-- method Window::unmake_below
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_unmake_below" wnck_window_unmake_below :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to not put /@window@/ below most windows, and to
+put it again in the stack with other windows.
+
+/Since: 2.20/
+-}
+windowUnmakeBelow ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowUnmakeBelow window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_unmake_below window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowUnmakeBelowMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnmakeBelowMethodInfo a signature where
+    overloadedMethod _ = windowUnmakeBelow
+
+#endif
+
+-- method Window::unmaximize
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_unmaximize" wnck_window_unmaximize :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to unmaximize /@window@/.
+-}
+windowUnmaximize ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowUnmaximize window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_unmaximize window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowUnmaximizeMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnmaximizeMethodInfo a signature where
+    overloadedMethod _ = windowUnmaximize
+
+#endif
+
+-- method Window::unmaximize_horizontally
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_unmaximize_horizontally" wnck_window_unmaximize_horizontally :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to unmaximize horizontally /@window@/.
+-}
+windowUnmaximizeHorizontally ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowUnmaximizeHorizontally window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_unmaximize_horizontally window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowUnmaximizeHorizontallyMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnmaximizeHorizontallyMethodInfo a signature where
+    overloadedMethod _ = windowUnmaximizeHorizontally
+
+#endif
+
+-- method Window::unmaximize_vertically
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_unmaximize_vertically" wnck_window_unmaximize_vertically :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to unmaximize vertically /@window@/.
+-}
+windowUnmaximizeVertically ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowUnmaximizeVertically window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_unmaximize_vertically window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowUnmaximizeVerticallyMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnmaximizeVerticallyMethodInfo a signature where
+    overloadedMethod _ = windowUnmaximizeVertically
+
+#endif
+
+-- method Window::unminimize
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X server timestamp of the user interaction event that caused\nthis call to occur.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_unminimize" wnck_window_unminimize :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    Word32 ->                               -- timestamp : TBasicType TUInt32
+    IO ()
+
+{- |
+Unminimizes /@window@/ by activating it or one of its transients. See
+'GI.Wnck.Objects.Window.windowActivateTransient' for details on how the activation is done.
+-}
+windowUnminimize ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> Word32
+    {- ^ /@timestamp@/: the X server timestamp of the user interaction event that caused
+this call to occur. -}
+    -> m ()
+windowUnminimize window timestamp = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_unminimize window' timestamp
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowUnminimizeMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnminimizeMethodInfo a signature where
+    overloadedMethod _ = windowUnminimize
+
+#endif
+
+-- method Window::unpin
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_unpin" wnck_window_unpin :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to put /@window@/ only in the currently active
+workspace, if /@window@/ was previously pinned. If /@window@/ was not pinned,
+does not change /@window@/\<!-- -->\'s workspace. If the active workspace
+is not known for some reason (it should not happen much), sets
+/@window@/\<!-- -->\'s workspace to the first workspace.
+-}
+windowUnpin ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowUnpin window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_unpin window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowUnpinMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnpinMethodInfo a signature where
+    overloadedMethod _ = windowUnpin
+
+#endif
+
+-- method Window::unshade
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_unshade" wnck_window_unshade :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to unshade /@window@/.
+-}
+windowUnshade ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowUnshade window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_unshade window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowUnshadeMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnshadeMethodInfo a signature where
+    overloadedMethod _ = windowUnshade
+
+#endif
+
+-- method Window::unstick
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "window", argType = TInterface (Name {namespace = "Wnck", name = "Window"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWindow.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_unstick" wnck_window_unstick :: 
+    Ptr Window ->                           -- window : TInterface (Name {namespace = "Wnck", name = "Window"})
+    IO ()
+
+{- |
+Asks the window manager to not have /@window@/\<!-- -->\'s position fixed on the
+screen when the workspace or viewport scrolls.
+-}
+windowUnstick ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWindow a) =>
+    a
+    {- ^ /@window@/: a 'GI.Wnck.Objects.Window.Window'. -}
+    -> m ()
+windowUnstick window = liftIO $ do
+    window' <- unsafeManagedPtrCastPtr window
+    wnck_window_unstick window'
+    touchManagedPtr window
+    return ()
+
+#if ENABLE_OVERLOADING
+data WindowUnstickMethodInfo
+instance (signature ~ (m ()), MonadIO m, IsWindow a) => O.MethodInfo WindowUnstickMethodInfo a signature where
+    overloadedMethod _ = windowUnstick
+
+#endif
+
+-- method Window::get
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "xwindow", argType = TBasicType TULong, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an X window ID.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Window"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_window_get" wnck_window_get :: 
+    CULong ->                               -- xwindow : TBasicType TULong
+    IO (Ptr Window)
+
+{- |
+Gets a preexisting 'GI.Wnck.Objects.Window.Window' for the X window /@xwindow@/. This will not
+create a 'GI.Wnck.Objects.Window.Window' if none exists. The function is robust against bogus
+window IDs.
+-}
+windowGet ::
+    (B.CallStack.HasCallStack, MonadIO m) =>
+    CULong
+    {- ^ /@xwindow@/: an X window ID. -}
+    -> m Window
+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Window.Window' for /@xwindow@/. The returned
+'GI.Wnck.Objects.Window.Window' is owned by libwnck and must not be referenced or unreferenced. -}
+windowGet xwindow = liftIO $ do
+    result <- wnck_window_get xwindow
+    checkUnexpectedReturnNULL "windowGet" result
+    result' <- (newObject Window) result
+    return result'
+
+#if ENABLE_OVERLOADING
+#endif
+
+
diff --git a/GI/Wnck/Objects/Window.hs-boot b/GI/Wnck/Objects/Window.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Window.hs-boot
@@ -0,0 +1,287 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Objects.Window where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype Window = Window (ManagedPtr Window)
+instance GObject Window where
+class (GObject o, O.IsDescendantOf Window o) => IsWindow o
+instance (GObject o, O.IsDescendantOf Window o) => IsWindow o
+instance O.HasParentTypes Window
+#if ENABLE_OVERLOADING
+data WindowActionsChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowClassChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGeometryChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIconChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowNameChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowRoleChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowStateChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowTypeChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowWorkspaceChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowActivateMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowActivateTransientMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowCloseMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetActionsMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetApplicationMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetClassGroupMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetClassGroupNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetClassInstanceNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetClientWindowGeometryMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetGeometryMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetGroupLeaderMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetIconMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetIconIsFallbackMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetIconNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetMiniIconMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetPidMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetRoleMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetScreenMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetSessionIdMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetSessionIdUtf8MethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetSortOrderMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetStateMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetTransientMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetWindowTypeMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetWorkspaceMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowGetXidMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowHasIconNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowHasNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsAboveMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsActiveMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsBelowMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsFullscreenMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsInViewportMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsMaximizedMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsMaximizedHorizontallyMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsMaximizedVerticallyMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsMinimizedMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsMostRecentlyActivatedMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsOnWorkspaceMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsPinnedMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsShadedMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsSkipPagerMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsSkipTasklistMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsStickyMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowIsVisibleOnWorkspaceMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowKeyboardMoveMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowKeyboardSizeMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowMakeAboveMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowMakeBelowMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowMaximizeMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowMaximizeHorizontallyMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowMaximizeVerticallyMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowMinimizeMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowMoveToWorkspaceMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowNeedsAttentionMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowOrTransientNeedsAttentionMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowPinMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowSetFullscreenMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowSetGeometryMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowSetIconGeometryMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowSetSkipPagerMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowSetSkipTasklistMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowSetSortOrderMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowSetWindowTypeMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowShadeMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowStickMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowTransientIsMostRecentlyActivatedMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowUnmakeAboveMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowUnmakeBelowMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowUnmaximizeMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowUnmaximizeHorizontallyMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowUnmaximizeVerticallyMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowUnminimizeMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowUnpinMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowUnshadeMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WindowUnstickMethodInfo
+#endif
diff --git a/GI/Wnck/Objects/Workspace.hs b/GI/Wnck/Objects/Workspace.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Workspace.hs
@@ -0,0 +1,836 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+The 'GI.Wnck.Objects.Workspace.Workspace' struct contains only private fields and should not be
+directly accessed.
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Objects.Workspace
+    ( 
+
+-- * Exported types
+    Workspace(..)                           ,
+    IsWorkspace                             ,
+    toWorkspace                             ,
+    noWorkspace                             ,
+
+
+ -- * Methods
+-- ** activate #method:activate#
+
+#if ENABLE_OVERLOADING
+    WorkspaceActivateMethodInfo             ,
+#endif
+    workspaceActivate                       ,
+
+
+-- ** changeName #method:changeName#
+
+#if ENABLE_OVERLOADING
+    WorkspaceChangeNameMethodInfo           ,
+#endif
+    workspaceChangeName                     ,
+
+
+-- ** getHeight #method:getHeight#
+
+#if ENABLE_OVERLOADING
+    WorkspaceGetHeightMethodInfo            ,
+#endif
+    workspaceGetHeight                      ,
+
+
+-- ** getLayoutColumn #method:getLayoutColumn#
+
+#if ENABLE_OVERLOADING
+    WorkspaceGetLayoutColumnMethodInfo      ,
+#endif
+    workspaceGetLayoutColumn                ,
+
+
+-- ** getLayoutRow #method:getLayoutRow#
+
+#if ENABLE_OVERLOADING
+    WorkspaceGetLayoutRowMethodInfo         ,
+#endif
+    workspaceGetLayoutRow                   ,
+
+
+-- ** getName #method:getName#
+
+#if ENABLE_OVERLOADING
+    WorkspaceGetNameMethodInfo              ,
+#endif
+    workspaceGetName                        ,
+
+
+-- ** getNeighbor #method:getNeighbor#
+
+#if ENABLE_OVERLOADING
+    WorkspaceGetNeighborMethodInfo          ,
+#endif
+    workspaceGetNeighbor                    ,
+
+
+-- ** getNumber #method:getNumber#
+
+#if ENABLE_OVERLOADING
+    WorkspaceGetNumberMethodInfo            ,
+#endif
+    workspaceGetNumber                      ,
+
+
+-- ** getScreen #method:getScreen#
+
+#if ENABLE_OVERLOADING
+    WorkspaceGetScreenMethodInfo            ,
+#endif
+    workspaceGetScreen                      ,
+
+
+-- ** getViewportX #method:getViewportX#
+
+#if ENABLE_OVERLOADING
+    WorkspaceGetViewportXMethodInfo         ,
+#endif
+    workspaceGetViewportX                   ,
+
+
+-- ** getViewportY #method:getViewportY#
+
+#if ENABLE_OVERLOADING
+    WorkspaceGetViewportYMethodInfo         ,
+#endif
+    workspaceGetViewportY                   ,
+
+
+-- ** getWidth #method:getWidth#
+
+#if ENABLE_OVERLOADING
+    WorkspaceGetWidthMethodInfo             ,
+#endif
+    workspaceGetWidth                       ,
+
+
+-- ** isVirtual #method:isVirtual#
+
+#if ENABLE_OVERLOADING
+    WorkspaceIsVirtualMethodInfo            ,
+#endif
+    workspaceIsVirtual                      ,
+
+
+
+
+ -- * Signals
+-- ** nameChanged #signal:nameChanged#
+
+    C_WorkspaceNameChangedCallback          ,
+    WorkspaceNameChangedCallback            ,
+#if ENABLE_OVERLOADING
+    WorkspaceNameChangedSignalInfo          ,
+#endif
+    afterWorkspaceNameChanged               ,
+    genClosure_WorkspaceNameChanged         ,
+    mk_WorkspaceNameChangedCallback         ,
+    noWorkspaceNameChangedCallback          ,
+    onWorkspaceNameChanged                  ,
+    wrap_WorkspaceNameChangedCallback       ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+import qualified GI.GObject.Objects.Object as GObject.Object
+import {-# SOURCE #-} qualified GI.Wnck.Enums as Wnck.Enums
+import {-# SOURCE #-} qualified GI.Wnck.Objects.Screen as Wnck.Screen
+
+-- | Memory-managed wrapper type.
+newtype Workspace = Workspace (ManagedPtr Workspace)
+foreign import ccall "wnck_workspace_get_type"
+    c_wnck_workspace_get_type :: IO GType
+
+instance GObject Workspace where
+    gobjectType = c_wnck_workspace_get_type
+    
+
+-- | Type class for types which can be safely cast to `Workspace`, for instance with `toWorkspace`.
+class (GObject o, O.IsDescendantOf Workspace o) => IsWorkspace o
+instance (GObject o, O.IsDescendantOf Workspace o) => IsWorkspace o
+
+instance O.HasParentTypes Workspace
+type instance O.ParentTypes Workspace = '[GObject.Object.Object]
+
+-- | Cast to `Workspace`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
+toWorkspace :: (MonadIO m, IsWorkspace o) => o -> m Workspace
+toWorkspace = liftIO . unsafeCastTo Workspace
+
+-- | A convenience alias for `Nothing` :: `Maybe` `Workspace`.
+noWorkspace :: Maybe Workspace
+noWorkspace = Nothing
+
+#if ENABLE_OVERLOADING
+type family ResolveWorkspaceMethod (t :: Symbol) (o :: *) :: * where
+    ResolveWorkspaceMethod "activate" o = WorkspaceActivateMethodInfo
+    ResolveWorkspaceMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
+    ResolveWorkspaceMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
+    ResolveWorkspaceMethod "changeName" o = WorkspaceChangeNameMethodInfo
+    ResolveWorkspaceMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
+    ResolveWorkspaceMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
+    ResolveWorkspaceMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
+    ResolveWorkspaceMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
+    ResolveWorkspaceMethod "isVirtual" o = WorkspaceIsVirtualMethodInfo
+    ResolveWorkspaceMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
+    ResolveWorkspaceMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
+    ResolveWorkspaceMethod "ref" o = GObject.Object.ObjectRefMethodInfo
+    ResolveWorkspaceMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
+    ResolveWorkspaceMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
+    ResolveWorkspaceMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
+    ResolveWorkspaceMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
+    ResolveWorkspaceMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
+    ResolveWorkspaceMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
+    ResolveWorkspaceMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
+    ResolveWorkspaceMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
+    ResolveWorkspaceMethod "getHeight" o = WorkspaceGetHeightMethodInfo
+    ResolveWorkspaceMethod "getLayoutColumn" o = WorkspaceGetLayoutColumnMethodInfo
+    ResolveWorkspaceMethod "getLayoutRow" o = WorkspaceGetLayoutRowMethodInfo
+    ResolveWorkspaceMethod "getName" o = WorkspaceGetNameMethodInfo
+    ResolveWorkspaceMethod "getNeighbor" o = WorkspaceGetNeighborMethodInfo
+    ResolveWorkspaceMethod "getNumber" o = WorkspaceGetNumberMethodInfo
+    ResolveWorkspaceMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
+    ResolveWorkspaceMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
+    ResolveWorkspaceMethod "getScreen" o = WorkspaceGetScreenMethodInfo
+    ResolveWorkspaceMethod "getViewportX" o = WorkspaceGetViewportXMethodInfo
+    ResolveWorkspaceMethod "getViewportY" o = WorkspaceGetViewportYMethodInfo
+    ResolveWorkspaceMethod "getWidth" o = WorkspaceGetWidthMethodInfo
+    ResolveWorkspaceMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
+    ResolveWorkspaceMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
+    ResolveWorkspaceMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolveWorkspaceMethod t Workspace, O.MethodInfo info Workspace p) => OL.IsLabel t (Workspace -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+-- signal Workspace::name-changed
+{- |
+Emitted when the name of /@space@/ changes.
+-}
+type WorkspaceNameChangedCallback =
+    IO ()
+
+-- | A convenience synonym for @`Nothing` :: `Maybe` `WorkspaceNameChangedCallback`@.
+noWorkspaceNameChangedCallback :: Maybe WorkspaceNameChangedCallback
+noWorkspaceNameChangedCallback = Nothing
+
+-- | Type for the callback on the (unwrapped) C side.
+type C_WorkspaceNameChangedCallback =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+-- | Generate a function pointer callable from C code, from a `C_WorkspaceNameChangedCallback`.
+foreign import ccall "wrapper"
+    mk_WorkspaceNameChangedCallback :: C_WorkspaceNameChangedCallback -> IO (FunPtr C_WorkspaceNameChangedCallback)
+
+-- | Wrap the callback into a `GClosure`.
+genClosure_WorkspaceNameChanged :: MonadIO m => WorkspaceNameChangedCallback -> m (GClosure C_WorkspaceNameChangedCallback)
+genClosure_WorkspaceNameChanged cb = liftIO $ do
+    let cb' = wrap_WorkspaceNameChangedCallback cb
+    mk_WorkspaceNameChangedCallback cb' >>= B.GClosure.newGClosure
+
+
+-- | Wrap a `WorkspaceNameChangedCallback` into a `C_WorkspaceNameChangedCallback`.
+wrap_WorkspaceNameChangedCallback ::
+    WorkspaceNameChangedCallback ->
+    C_WorkspaceNameChangedCallback
+wrap_WorkspaceNameChangedCallback _cb _ _ = do
+    _cb 
+
+
+{- |
+Connect a signal handler for the “@name-changed@” signal, to be run before the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.on' workspace #nameChanged callback
+@
+-}
+onWorkspaceNameChanged :: (IsWorkspace a, MonadIO m) => a -> WorkspaceNameChangedCallback -> m SignalHandlerId
+onWorkspaceNameChanged obj cb = liftIO $ do
+    let cb' = wrap_WorkspaceNameChangedCallback cb
+    cb'' <- mk_WorkspaceNameChangedCallback cb'
+    connectSignalFunPtr obj "name-changed" cb'' SignalConnectBefore
+
+{- |
+Connect a signal handler for the “@name-changed@” signal, to be run after the default handler.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Signals.after' workspace #nameChanged callback
+@
+-}
+afterWorkspaceNameChanged :: (IsWorkspace a, MonadIO m) => a -> WorkspaceNameChangedCallback -> m SignalHandlerId
+afterWorkspaceNameChanged obj cb = liftIO $ do
+    let cb' = wrap_WorkspaceNameChangedCallback cb
+    cb'' <- mk_WorkspaceNameChangedCallback cb'
+    connectSignalFunPtr obj "name-changed" cb'' SignalConnectAfter
+
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList Workspace
+type instance O.AttributeList Workspace = WorkspaceAttributeList
+type WorkspaceAttributeList = ('[ ] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+#endif
+
+#if ENABLE_OVERLOADING
+data WorkspaceNameChangedSignalInfo
+instance SignalInfo WorkspaceNameChangedSignalInfo where
+    type HaskellCallbackType WorkspaceNameChangedSignalInfo = WorkspaceNameChangedCallback
+    connectSignal _ obj cb connectMode = do
+        let cb' = wrap_WorkspaceNameChangedCallback cb
+        cb'' <- mk_WorkspaceNameChangedCallback cb'
+        connectSignalFunPtr obj "name-changed" cb'' connectMode
+
+type instance O.SignalList Workspace = WorkspaceSignalList
+type WorkspaceSignalList = ('[ '("nameChanged", WorkspaceNameChangedSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+#endif
+
+-- method Workspace::activate
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the X server timestamp of the user interaction event that caused\nthis call to occur.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_activate" wnck_workspace_activate :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    Word32 ->                               -- timestamp : TBasicType TUInt32
+    IO ()
+
+{- |
+Asks the window manager to make /@space@/ the active workspace. The window
+manager may decide to refuse the request (to not steal the focus if there is
+a more recent user activity, for example).
+
+This function existed before 2.10, but the /@timestamp@/ argument was missing
+in earlier versions.
+
+/Since: 2.10/
+-}
+workspaceActivate ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> Word32
+    {- ^ /@timestamp@/: the X server timestamp of the user interaction event that caused
+this call to occur. -}
+    -> m ()
+workspaceActivate space timestamp = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    wnck_workspace_activate space' timestamp
+    touchManagedPtr space
+    return ()
+
+#if ENABLE_OVERLOADING
+data WorkspaceActivateMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceActivateMethodInfo a signature where
+    overloadedMethod _ = workspaceActivate
+
+#endif
+
+-- method Workspace::change_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new name for @space.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Nothing
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_change_name" wnck_workspace_change_name :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    CString ->                              -- name : TBasicType TUTF8
+    IO ()
+
+{- |
+Changes the name of /@space@/.
+
+/Since: 2.2/
+-}
+workspaceChangeName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> T.Text
+    {- ^ /@name@/: new name for /@space@/. -}
+    -> m ()
+workspaceChangeName space name = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    name' <- textToCString name
+    wnck_workspace_change_name space' name'
+    touchManagedPtr space
+    freeMem name'
+    return ()
+
+#if ENABLE_OVERLOADING
+data WorkspaceChangeNameMethodInfo
+instance (signature ~ (T.Text -> m ()), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceChangeNameMethodInfo a signature where
+    overloadedMethod _ = workspaceChangeName
+
+#endif
+
+-- method Workspace::get_height
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_get_height" wnck_workspace_get_height :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO Int32
+
+{- |
+Gets the height of /@space@/.
+
+/Since: 2.4/
+-}
+workspaceGetHeight ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Int32
+    {- ^ __Returns:__ the height of /@space@/. -}
+workspaceGetHeight space = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    result <- wnck_workspace_get_height space'
+    touchManagedPtr space
+    return result
+
+#if ENABLE_OVERLOADING
+data WorkspaceGetHeightMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceGetHeightMethodInfo a signature where
+    overloadedMethod _ = workspaceGetHeight
+
+#endif
+
+-- method Workspace::get_layout_column
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_get_layout_column" wnck_workspace_get_layout_column :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO Int32
+
+{- |
+Gets the column of /@space@/ in the 'GI.Wnck.Objects.Workspace.Workspace' layout. The first column
+has an index of 0 and is always the left column, regardless of the starting
+corner set for the layout and regardless of the default direction of the
+environment (i.e., in both Left-To-Right and Right-To-Left environments).
+
+/Since: 2.20/
+-}
+workspaceGetLayoutColumn ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Int32
+    {- ^ __Returns:__ the column of /@space@/ in the 'GI.Wnck.Objects.Workspace.Workspace' layout, or -1 on
+errors. -}
+workspaceGetLayoutColumn space = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    result <- wnck_workspace_get_layout_column space'
+    touchManagedPtr space
+    return result
+
+#if ENABLE_OVERLOADING
+data WorkspaceGetLayoutColumnMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceGetLayoutColumnMethodInfo a signature where
+    overloadedMethod _ = workspaceGetLayoutColumn
+
+#endif
+
+-- method Workspace::get_layout_row
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_get_layout_row" wnck_workspace_get_layout_row :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO Int32
+
+{- |
+Gets the row of /@space@/ in the 'GI.Wnck.Objects.Workspace.Workspace' layout. The first row has an
+index of 0 and is always the top row, regardless of the starting corner set
+for the layout.
+
+/Since: 2.20/
+-}
+workspaceGetLayoutRow ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Int32
+    {- ^ __Returns:__ the row of /@space@/ in the 'GI.Wnck.Objects.Workspace.Workspace' layout, or -1 on
+errors. -}
+workspaceGetLayoutRow space = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    result <- wnck_workspace_get_layout_row space'
+    touchManagedPtr space
+    return result
+
+#if ENABLE_OVERLOADING
+data WorkspaceGetLayoutRowMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceGetLayoutRowMethodInfo a signature where
+    overloadedMethod _ = workspaceGetLayoutRow
+
+#endif
+
+-- method Workspace::get_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_get_name" wnck_workspace_get_name :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO CString
+
+{- |
+Gets the human-readable name that should be used to refer to /@space@/. If
+the user has not set a special name, a fallback like \"Workspace 3\" will be
+used.
+-}
+workspaceGetName ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m T.Text
+    {- ^ __Returns:__ the name of /@space@/. -}
+workspaceGetName space = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    result <- wnck_workspace_get_name space'
+    checkUnexpectedReturnNULL "workspaceGetName" result
+    result' <- cstringToText result
+    touchManagedPtr space
+    return result'
+
+#if ENABLE_OVERLOADING
+data WorkspaceGetNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceGetNameMethodInfo a signature where
+    overloadedMethod _ = workspaceGetName
+
+#endif
+
+-- method Workspace::get_neighbor
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface (Name {namespace = "Wnck", name = "MotionDirection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "direction in which to search the neighbor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Workspace"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_get_neighbor" wnck_workspace_get_neighbor :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    CInt ->                                 -- direction : TInterface (Name {namespace = "Wnck", name = "MotionDirection"})
+    IO (Ptr Workspace)
+
+{- |
+Gets the neighbor 'GI.Wnck.Objects.Workspace.Workspace' of /@space@/ in the /@direction@/ direction.
+
+/Since: 2.20/
+-}
+workspaceGetNeighbor ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> Wnck.Enums.MotionDirection
+    {- ^ /@direction@/: direction in which to search the neighbor. -}
+    -> m Workspace
+    {- ^ __Returns:__ the neighbor 'GI.Wnck.Objects.Workspace.Workspace' of /@space@/ in the
+/@direction@/ direction, or 'Nothing' if no such neighbor 'GI.Wnck.Objects.Workspace.Workspace' exists.
+The returned 'GI.Wnck.Objects.Workspace.Workspace' is owned by libwnck and must not be referenced
+or unreferenced. -}
+workspaceGetNeighbor space direction = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    let direction' = (fromIntegral . fromEnum) direction
+    result <- wnck_workspace_get_neighbor space' direction'
+    checkUnexpectedReturnNULL "workspaceGetNeighbor" result
+    result' <- (newObject Workspace) result
+    touchManagedPtr space
+    return result'
+
+#if ENABLE_OVERLOADING
+data WorkspaceGetNeighborMethodInfo
+instance (signature ~ (Wnck.Enums.MotionDirection -> m Workspace), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceGetNeighborMethodInfo a signature where
+    overloadedMethod _ = workspaceGetNeighbor
+
+#endif
+
+-- method Workspace::get_number
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_get_number" wnck_workspace_get_number :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO Int32
+
+{- |
+Gets the index of /@space@/ on the 'GI.Wnck.Objects.Screen.Screen' to which it belongs. The
+first workspace has an index of 0.
+-}
+workspaceGetNumber ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Int32
+    {- ^ __Returns:__ the index of /@space@/ on its 'GI.Wnck.Objects.Screen.Screen', or -1 on errors. -}
+workspaceGetNumber space = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    result <- wnck_workspace_get_number space'
+    touchManagedPtr space
+    return result
+
+#if ENABLE_OVERLOADING
+data WorkspaceGetNumberMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceGetNumberMethodInfo a signature where
+    overloadedMethod _ = workspaceGetNumber
+
+#endif
+
+-- method Workspace::get_screen
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TInterface (Name {namespace = "Wnck", name = "Screen"}))
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_get_screen" wnck_workspace_get_screen :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO (Ptr Wnck.Screen.Screen)
+
+{- |
+Gets the 'GI.Wnck.Objects.Screen.Screen' /@space@/ is on.
+-}
+workspaceGetScreen ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Wnck.Screen.Screen
+    {- ^ __Returns:__ the 'GI.Wnck.Objects.Screen.Screen' /@space@/ is on. The returned
+'GI.Wnck.Objects.Screen.Screen' is owned by libwnck and must not be referenced or unreferenced. -}
+workspaceGetScreen space = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    result <- wnck_workspace_get_screen space'
+    checkUnexpectedReturnNULL "workspaceGetScreen" result
+    result' <- (newObject Wnck.Screen.Screen) result
+    touchManagedPtr space
+    return result'
+
+#if ENABLE_OVERLOADING
+data WorkspaceGetScreenMethodInfo
+instance (signature ~ (m Wnck.Screen.Screen), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceGetScreenMethodInfo a signature where
+    overloadedMethod _ = workspaceGetScreen
+
+#endif
+
+-- method Workspace::get_viewport_x
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_get_viewport_x" wnck_workspace_get_viewport_x :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO Int32
+
+{- |
+Gets the X coordinate of the viewport in /@space@/.
+
+/Since: 2.4/
+-}
+workspaceGetViewportX ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Int32
+    {- ^ __Returns:__ the X coordinate of the viewport in /@space@/, or 0 if /@space@/ does not
+contain a viewport. -}
+workspaceGetViewportX space = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    result <- wnck_workspace_get_viewport_x space'
+    touchManagedPtr space
+    return result
+
+#if ENABLE_OVERLOADING
+data WorkspaceGetViewportXMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceGetViewportXMethodInfo a signature where
+    overloadedMethod _ = workspaceGetViewportX
+
+#endif
+
+-- method Workspace::get_viewport_y
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_get_viewport_y" wnck_workspace_get_viewport_y :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO Int32
+
+{- |
+Gets the Y coordinate of the viewport in /@space@/.
+
+/Since: 2.4/
+-}
+workspaceGetViewportY ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Int32
+    {- ^ __Returns:__ the Y coordinate of the viewport in /@space@/, or 0 if /@space@/ does not
+contain a viewport. -}
+workspaceGetViewportY space = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    result <- wnck_workspace_get_viewport_y space'
+    touchManagedPtr space
+    return result
+
+#if ENABLE_OVERLOADING
+data WorkspaceGetViewportYMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceGetViewportYMethodInfo a signature where
+    overloadedMethod _ = workspaceGetViewportY
+
+#endif
+
+-- method Workspace::get_width
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TInt)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_get_width" wnck_workspace_get_width :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO Int32
+
+{- |
+Gets the width of /@space@/.
+
+/Since: 2.4/
+-}
+workspaceGetWidth ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Int32
+    {- ^ __Returns:__ the width of /@space@/. -}
+workspaceGetWidth space = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    result <- wnck_workspace_get_width space'
+    touchManagedPtr space
+    return result
+
+#if ENABLE_OVERLOADING
+data WorkspaceGetWidthMethodInfo
+instance (signature ~ (m Int32), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceGetWidthMethodInfo a signature where
+    overloadedMethod _ = workspaceGetWidth
+
+#endif
+
+-- method Workspace::is_virtual
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "space", argType = TInterface (Name {namespace = "Wnck", name = "Workspace"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WnckWorkspace.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : Just (TBasicType TBoolean)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "wnck_workspace_is_virtual" wnck_workspace_is_virtual :: 
+    Ptr Workspace ->                        -- space : TInterface (Name {namespace = "Wnck", name = "Workspace"})
+    IO CInt
+
+{- |
+Gets whether /@space@/ contains a viewport.
+
+/Since: 2.4/
+-}
+workspaceIsVirtual ::
+    (B.CallStack.HasCallStack, MonadIO m, IsWorkspace a) =>
+    a
+    {- ^ /@space@/: a 'GI.Wnck.Objects.Workspace.Workspace'. -}
+    -> m Bool
+    {- ^ __Returns:__ 'True' if /@space@/ contains a viewport, 'False' otherwise. -}
+workspaceIsVirtual space = liftIO $ do
+    space' <- unsafeManagedPtrCastPtr space
+    result <- wnck_workspace_is_virtual space'
+    let result' = (/= 0) result
+    touchManagedPtr space
+    return result'
+
+#if ENABLE_OVERLOADING
+data WorkspaceIsVirtualMethodInfo
+instance (signature ~ (m Bool), MonadIO m, IsWorkspace a) => O.MethodInfo WorkspaceIsVirtualMethodInfo a signature where
+    overloadedMethod _ = workspaceIsVirtual
+
+#endif
+
+
diff --git a/GI/Wnck/Objects/Workspace.hs-boot b/GI/Wnck/Objects/Workspace.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Objects/Workspace.hs-boot
@@ -0,0 +1,71 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Objects.Workspace where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype Workspace = Workspace (ManagedPtr Workspace)
+instance GObject Workspace where
+class (GObject o, O.IsDescendantOf Workspace o) => IsWorkspace o
+instance (GObject o, O.IsDescendantOf Workspace o) => IsWorkspace o
+instance O.HasParentTypes Workspace
+#if ENABLE_OVERLOADING
+data WorkspaceNameChangedSignalInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceActivateMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceChangeNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceGetHeightMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceGetLayoutColumnMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceGetLayoutRowMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceGetNameMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceGetNeighborMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceGetNumberMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceGetScreenMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceGetViewportXMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceGetViewportYMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceGetWidthMethodInfo
+#endif
+#if ENABLE_OVERLOADING
+data WorkspaceIsVirtualMethodInfo
+#endif
diff --git a/GI/Wnck/Structs.hs b/GI/Wnck/Structs.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Structs.hs
@@ -0,0 +1,43 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Structs
+    (     module GI.Wnck.Structs.ResourceUsage    ,
+    module GI.Wnck.Structs.WorkspaceLayout  ,
+
+
+    ) where
+
+import GI.Wnck.Structs.ResourceUsage
+import GI.Wnck.Structs.WorkspaceLayout
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+
+
diff --git a/GI/Wnck/Structs/ResourceUsage.hs b/GI/Wnck/Structs/ResourceUsage.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Structs/ResourceUsage.hs
@@ -0,0 +1,757 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+The 'GI.Wnck.Structs.ResourceUsage.ResourceUsage' struct contains information about the total resource
+usage of an X client, and the number of resources allocated for each
+resource type.
+
+/Since: 2.6/
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Structs.ResourceUsage
+    ( 
+
+-- * Exported types
+    ResourceUsage(..)                       ,
+    newZeroResourceUsage                    ,
+    noResourceUsage                         ,
+
+
+ -- * Properties
+-- ** nColormapEntries #attr:nColormapEntries#
+{- | number of Colormap resources allocated.
+-}
+    getResourceUsageNColormapEntries        ,
+#if ENABLE_OVERLOADING
+    resourceUsage_nColormapEntries          ,
+#endif
+    setResourceUsageNColormapEntries        ,
+
+
+-- ** nCursors #attr:nCursors#
+{- | number of Cursor resources allocated.
+-}
+    getResourceUsageNCursors                ,
+#if ENABLE_OVERLOADING
+    resourceUsage_nCursors                  ,
+#endif
+    setResourceUsageNCursors                ,
+
+
+-- ** nFonts #attr:nFonts#
+{- | number of Font resources allocated.
+-}
+    getResourceUsageNFonts                  ,
+#if ENABLE_OVERLOADING
+    resourceUsage_nFonts                    ,
+#endif
+    setResourceUsageNFonts                  ,
+
+
+-- ** nGcs #attr:nGcs#
+{- | number of GContext resources allocated.
+-}
+    getResourceUsageNGcs                    ,
+#if ENABLE_OVERLOADING
+    resourceUsage_nGcs                      ,
+#endif
+    setResourceUsageNGcs                    ,
+
+
+-- ** nGlyphsets #attr:nGlyphsets#
+{- | number of Glyphset resources allocated.
+-}
+    getResourceUsageNGlyphsets              ,
+#if ENABLE_OVERLOADING
+    resourceUsage_nGlyphsets                ,
+#endif
+    setResourceUsageNGlyphsets              ,
+
+
+-- ** nOther #attr:nOther#
+{- | number of other resources allocated.
+-}
+    getResourceUsageNOther                  ,
+#if ENABLE_OVERLOADING
+    resourceUsage_nOther                    ,
+#endif
+    setResourceUsageNOther                  ,
+
+
+-- ** nPassiveGrabs #attr:nPassiveGrabs#
+{- | number of PassiveGrab resources allocated.
+-}
+    getResourceUsageNPassiveGrabs           ,
+#if ENABLE_OVERLOADING
+    resourceUsage_nPassiveGrabs             ,
+#endif
+    setResourceUsageNPassiveGrabs           ,
+
+
+-- ** nPictures #attr:nPictures#
+{- | number of Picture resources allocated.
+-}
+    getResourceUsageNPictures               ,
+#if ENABLE_OVERLOADING
+    resourceUsage_nPictures                 ,
+#endif
+    setResourceUsageNPictures               ,
+
+
+-- ** nPixmaps #attr:nPixmaps#
+{- | number of Pixmap resources allocated.
+-}
+    getResourceUsageNPixmaps                ,
+#if ENABLE_OVERLOADING
+    resourceUsage_nPixmaps                  ,
+#endif
+    setResourceUsageNPixmaps                ,
+
+
+-- ** nWindows #attr:nWindows#
+{- | number of Window resources allocated.
+-}
+    getResourceUsageNWindows                ,
+#if ENABLE_OVERLOADING
+    resourceUsage_nWindows                  ,
+#endif
+    setResourceUsageNWindows                ,
+
+
+-- ** pixmapBytes #attr:pixmapBytes#
+{- | number of bytes allocated in the X server for resources of
+type Pixmap.
+-}
+    getResourceUsagePixmapBytes             ,
+#if ENABLE_OVERLOADING
+    resourceUsage_pixmapBytes               ,
+#endif
+    setResourceUsagePixmapBytes             ,
+
+
+-- ** totalBytesEstimate #attr:totalBytesEstimate#
+{- | estimation of the total number of bytes allocated in
+the X server.
+-}
+    getResourceUsageTotalBytesEstimate      ,
+#if ENABLE_OVERLOADING
+    resourceUsage_totalBytesEstimate        ,
+#endif
+    setResourceUsageTotalBytesEstimate      ,
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+
+-- | Memory-managed wrapper type.
+newtype ResourceUsage = ResourceUsage (ManagedPtr ResourceUsage)
+instance WrappedPtr ResourceUsage where
+    wrappedPtrCalloc = callocBytes 112
+    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 112 >=> wrapPtr ResourceUsage)
+    wrappedPtrFree = Just ptr_to_g_free
+
+-- | Construct a `ResourceUsage` struct initialized to zero.
+newZeroResourceUsage :: MonadIO m => m ResourceUsage
+newZeroResourceUsage = liftIO $ wrappedPtrCalloc >>= wrapPtr ResourceUsage
+
+instance tag ~ 'AttrSet => Constructible ResourceUsage tag where
+    new _ attrs = do
+        o <- newZeroResourceUsage
+        GI.Attributes.set o attrs
+        return o
+
+
+-- | A convenience alias for `Nothing` :: `Maybe` `ResourceUsage`.
+noResourceUsage :: Maybe ResourceUsage
+noResourceUsage = Nothing
+
+{- |
+Get the value of the “@total_bytes_estimate@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #totalBytesEstimate
+@
+-}
+getResourceUsageTotalBytesEstimate :: MonadIO m => ResourceUsage -> m CULong
+getResourceUsageTotalBytesEstimate s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CULong
+    return val
+
+{- |
+Set the value of the “@total_bytes_estimate@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #totalBytesEstimate 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsageTotalBytesEstimate :: MonadIO m => ResourceUsage -> CULong -> m ()
+setResourceUsageTotalBytesEstimate s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 0) (val :: CULong)
+
+#if ENABLE_OVERLOADING
+data ResourceUsageTotalBytesEstimateFieldInfo
+instance AttrInfo ResourceUsageTotalBytesEstimateFieldInfo where
+    type AttrAllowedOps ResourceUsageTotalBytesEstimateFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsageTotalBytesEstimateFieldInfo = (~) CULong
+    type AttrBaseTypeConstraint ResourceUsageTotalBytesEstimateFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsageTotalBytesEstimateFieldInfo = CULong
+    type AttrLabel ResourceUsageTotalBytesEstimateFieldInfo = "total_bytes_estimate"
+    type AttrOrigin ResourceUsageTotalBytesEstimateFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsageTotalBytesEstimate
+    attrSet _ = setResourceUsageTotalBytesEstimate
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_totalBytesEstimate :: AttrLabelProxy "totalBytesEstimate"
+resourceUsage_totalBytesEstimate = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@pixmap_bytes@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #pixmapBytes
+@
+-}
+getResourceUsagePixmapBytes :: MonadIO m => ResourceUsage -> m CULong
+getResourceUsagePixmapBytes s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO CULong
+    return val
+
+{- |
+Set the value of the “@pixmap_bytes@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #pixmapBytes 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsagePixmapBytes :: MonadIO m => ResourceUsage -> CULong -> m ()
+setResourceUsagePixmapBytes s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 8) (val :: CULong)
+
+#if ENABLE_OVERLOADING
+data ResourceUsagePixmapBytesFieldInfo
+instance AttrInfo ResourceUsagePixmapBytesFieldInfo where
+    type AttrAllowedOps ResourceUsagePixmapBytesFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsagePixmapBytesFieldInfo = (~) CULong
+    type AttrBaseTypeConstraint ResourceUsagePixmapBytesFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsagePixmapBytesFieldInfo = CULong
+    type AttrLabel ResourceUsagePixmapBytesFieldInfo = "pixmap_bytes"
+    type AttrOrigin ResourceUsagePixmapBytesFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsagePixmapBytes
+    attrSet _ = setResourceUsagePixmapBytes
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_pixmapBytes :: AttrLabelProxy "pixmapBytes"
+resourceUsage_pixmapBytes = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@n_pixmaps@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #nPixmaps
+@
+-}
+getResourceUsageNPixmaps :: MonadIO m => ResourceUsage -> m Word32
+getResourceUsageNPixmaps s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO Word32
+    return val
+
+{- |
+Set the value of the “@n_pixmaps@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #nPixmaps 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsageNPixmaps :: MonadIO m => ResourceUsage -> Word32 -> m ()
+setResourceUsageNPixmaps s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 16) (val :: Word32)
+
+#if ENABLE_OVERLOADING
+data ResourceUsageNPixmapsFieldInfo
+instance AttrInfo ResourceUsageNPixmapsFieldInfo where
+    type AttrAllowedOps ResourceUsageNPixmapsFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsageNPixmapsFieldInfo = (~) Word32
+    type AttrBaseTypeConstraint ResourceUsageNPixmapsFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsageNPixmapsFieldInfo = Word32
+    type AttrLabel ResourceUsageNPixmapsFieldInfo = "n_pixmaps"
+    type AttrOrigin ResourceUsageNPixmapsFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsageNPixmaps
+    attrSet _ = setResourceUsageNPixmaps
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_nPixmaps :: AttrLabelProxy "nPixmaps"
+resourceUsage_nPixmaps = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@n_windows@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #nWindows
+@
+-}
+getResourceUsageNWindows :: MonadIO m => ResourceUsage -> m Word32
+getResourceUsageNWindows s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 20) :: IO Word32
+    return val
+
+{- |
+Set the value of the “@n_windows@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #nWindows 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsageNWindows :: MonadIO m => ResourceUsage -> Word32 -> m ()
+setResourceUsageNWindows s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 20) (val :: Word32)
+
+#if ENABLE_OVERLOADING
+data ResourceUsageNWindowsFieldInfo
+instance AttrInfo ResourceUsageNWindowsFieldInfo where
+    type AttrAllowedOps ResourceUsageNWindowsFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsageNWindowsFieldInfo = (~) Word32
+    type AttrBaseTypeConstraint ResourceUsageNWindowsFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsageNWindowsFieldInfo = Word32
+    type AttrLabel ResourceUsageNWindowsFieldInfo = "n_windows"
+    type AttrOrigin ResourceUsageNWindowsFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsageNWindows
+    attrSet _ = setResourceUsageNWindows
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_nWindows :: AttrLabelProxy "nWindows"
+resourceUsage_nWindows = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@n_gcs@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #nGcs
+@
+-}
+getResourceUsageNGcs :: MonadIO m => ResourceUsage -> m Word32
+getResourceUsageNGcs s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 24) :: IO Word32
+    return val
+
+{- |
+Set the value of the “@n_gcs@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #nGcs 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsageNGcs :: MonadIO m => ResourceUsage -> Word32 -> m ()
+setResourceUsageNGcs s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 24) (val :: Word32)
+
+#if ENABLE_OVERLOADING
+data ResourceUsageNGcsFieldInfo
+instance AttrInfo ResourceUsageNGcsFieldInfo where
+    type AttrAllowedOps ResourceUsageNGcsFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsageNGcsFieldInfo = (~) Word32
+    type AttrBaseTypeConstraint ResourceUsageNGcsFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsageNGcsFieldInfo = Word32
+    type AttrLabel ResourceUsageNGcsFieldInfo = "n_gcs"
+    type AttrOrigin ResourceUsageNGcsFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsageNGcs
+    attrSet _ = setResourceUsageNGcs
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_nGcs :: AttrLabelProxy "nGcs"
+resourceUsage_nGcs = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@n_pictures@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #nPictures
+@
+-}
+getResourceUsageNPictures :: MonadIO m => ResourceUsage -> m Word32
+getResourceUsageNPictures s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 28) :: IO Word32
+    return val
+
+{- |
+Set the value of the “@n_pictures@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #nPictures 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsageNPictures :: MonadIO m => ResourceUsage -> Word32 -> m ()
+setResourceUsageNPictures s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 28) (val :: Word32)
+
+#if ENABLE_OVERLOADING
+data ResourceUsageNPicturesFieldInfo
+instance AttrInfo ResourceUsageNPicturesFieldInfo where
+    type AttrAllowedOps ResourceUsageNPicturesFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsageNPicturesFieldInfo = (~) Word32
+    type AttrBaseTypeConstraint ResourceUsageNPicturesFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsageNPicturesFieldInfo = Word32
+    type AttrLabel ResourceUsageNPicturesFieldInfo = "n_pictures"
+    type AttrOrigin ResourceUsageNPicturesFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsageNPictures
+    attrSet _ = setResourceUsageNPictures
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_nPictures :: AttrLabelProxy "nPictures"
+resourceUsage_nPictures = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@n_glyphsets@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #nGlyphsets
+@
+-}
+getResourceUsageNGlyphsets :: MonadIO m => ResourceUsage -> m Word32
+getResourceUsageNGlyphsets s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 32) :: IO Word32
+    return val
+
+{- |
+Set the value of the “@n_glyphsets@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #nGlyphsets 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsageNGlyphsets :: MonadIO m => ResourceUsage -> Word32 -> m ()
+setResourceUsageNGlyphsets s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 32) (val :: Word32)
+
+#if ENABLE_OVERLOADING
+data ResourceUsageNGlyphsetsFieldInfo
+instance AttrInfo ResourceUsageNGlyphsetsFieldInfo where
+    type AttrAllowedOps ResourceUsageNGlyphsetsFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsageNGlyphsetsFieldInfo = (~) Word32
+    type AttrBaseTypeConstraint ResourceUsageNGlyphsetsFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsageNGlyphsetsFieldInfo = Word32
+    type AttrLabel ResourceUsageNGlyphsetsFieldInfo = "n_glyphsets"
+    type AttrOrigin ResourceUsageNGlyphsetsFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsageNGlyphsets
+    attrSet _ = setResourceUsageNGlyphsets
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_nGlyphsets :: AttrLabelProxy "nGlyphsets"
+resourceUsage_nGlyphsets = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@n_fonts@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #nFonts
+@
+-}
+getResourceUsageNFonts :: MonadIO m => ResourceUsage -> m Word32
+getResourceUsageNFonts s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 36) :: IO Word32
+    return val
+
+{- |
+Set the value of the “@n_fonts@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #nFonts 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsageNFonts :: MonadIO m => ResourceUsage -> Word32 -> m ()
+setResourceUsageNFonts s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 36) (val :: Word32)
+
+#if ENABLE_OVERLOADING
+data ResourceUsageNFontsFieldInfo
+instance AttrInfo ResourceUsageNFontsFieldInfo where
+    type AttrAllowedOps ResourceUsageNFontsFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsageNFontsFieldInfo = (~) Word32
+    type AttrBaseTypeConstraint ResourceUsageNFontsFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsageNFontsFieldInfo = Word32
+    type AttrLabel ResourceUsageNFontsFieldInfo = "n_fonts"
+    type AttrOrigin ResourceUsageNFontsFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsageNFonts
+    attrSet _ = setResourceUsageNFonts
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_nFonts :: AttrLabelProxy "nFonts"
+resourceUsage_nFonts = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@n_colormap_entries@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #nColormapEntries
+@
+-}
+getResourceUsageNColormapEntries :: MonadIO m => ResourceUsage -> m Word32
+getResourceUsageNColormapEntries s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 40) :: IO Word32
+    return val
+
+{- |
+Set the value of the “@n_colormap_entries@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #nColormapEntries 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsageNColormapEntries :: MonadIO m => ResourceUsage -> Word32 -> m ()
+setResourceUsageNColormapEntries s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 40) (val :: Word32)
+
+#if ENABLE_OVERLOADING
+data ResourceUsageNColormapEntriesFieldInfo
+instance AttrInfo ResourceUsageNColormapEntriesFieldInfo where
+    type AttrAllowedOps ResourceUsageNColormapEntriesFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsageNColormapEntriesFieldInfo = (~) Word32
+    type AttrBaseTypeConstraint ResourceUsageNColormapEntriesFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsageNColormapEntriesFieldInfo = Word32
+    type AttrLabel ResourceUsageNColormapEntriesFieldInfo = "n_colormap_entries"
+    type AttrOrigin ResourceUsageNColormapEntriesFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsageNColormapEntries
+    attrSet _ = setResourceUsageNColormapEntries
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_nColormapEntries :: AttrLabelProxy "nColormapEntries"
+resourceUsage_nColormapEntries = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@n_passive_grabs@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #nPassiveGrabs
+@
+-}
+getResourceUsageNPassiveGrabs :: MonadIO m => ResourceUsage -> m Word32
+getResourceUsageNPassiveGrabs s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 44) :: IO Word32
+    return val
+
+{- |
+Set the value of the “@n_passive_grabs@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #nPassiveGrabs 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsageNPassiveGrabs :: MonadIO m => ResourceUsage -> Word32 -> m ()
+setResourceUsageNPassiveGrabs s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 44) (val :: Word32)
+
+#if ENABLE_OVERLOADING
+data ResourceUsageNPassiveGrabsFieldInfo
+instance AttrInfo ResourceUsageNPassiveGrabsFieldInfo where
+    type AttrAllowedOps ResourceUsageNPassiveGrabsFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsageNPassiveGrabsFieldInfo = (~) Word32
+    type AttrBaseTypeConstraint ResourceUsageNPassiveGrabsFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsageNPassiveGrabsFieldInfo = Word32
+    type AttrLabel ResourceUsageNPassiveGrabsFieldInfo = "n_passive_grabs"
+    type AttrOrigin ResourceUsageNPassiveGrabsFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsageNPassiveGrabs
+    attrSet _ = setResourceUsageNPassiveGrabs
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_nPassiveGrabs :: AttrLabelProxy "nPassiveGrabs"
+resourceUsage_nPassiveGrabs = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@n_cursors@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #nCursors
+@
+-}
+getResourceUsageNCursors :: MonadIO m => ResourceUsage -> m Word32
+getResourceUsageNCursors s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 48) :: IO Word32
+    return val
+
+{- |
+Set the value of the “@n_cursors@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #nCursors 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsageNCursors :: MonadIO m => ResourceUsage -> Word32 -> m ()
+setResourceUsageNCursors s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 48) (val :: Word32)
+
+#if ENABLE_OVERLOADING
+data ResourceUsageNCursorsFieldInfo
+instance AttrInfo ResourceUsageNCursorsFieldInfo where
+    type AttrAllowedOps ResourceUsageNCursorsFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsageNCursorsFieldInfo = (~) Word32
+    type AttrBaseTypeConstraint ResourceUsageNCursorsFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsageNCursorsFieldInfo = Word32
+    type AttrLabel ResourceUsageNCursorsFieldInfo = "n_cursors"
+    type AttrOrigin ResourceUsageNCursorsFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsageNCursors
+    attrSet _ = setResourceUsageNCursors
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_nCursors :: AttrLabelProxy "nCursors"
+resourceUsage_nCursors = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@n_other@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' resourceUsage #nOther
+@
+-}
+getResourceUsageNOther :: MonadIO m => ResourceUsage -> m Word32
+getResourceUsageNOther s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 52) :: IO Word32
+    return val
+
+{- |
+Set the value of the “@n_other@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' resourceUsage [ #nOther 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setResourceUsageNOther :: MonadIO m => ResourceUsage -> Word32 -> m ()
+setResourceUsageNOther s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 52) (val :: Word32)
+
+#if ENABLE_OVERLOADING
+data ResourceUsageNOtherFieldInfo
+instance AttrInfo ResourceUsageNOtherFieldInfo where
+    type AttrAllowedOps ResourceUsageNOtherFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint ResourceUsageNOtherFieldInfo = (~) Word32
+    type AttrBaseTypeConstraint ResourceUsageNOtherFieldInfo = (~) ResourceUsage
+    type AttrGetType ResourceUsageNOtherFieldInfo = Word32
+    type AttrLabel ResourceUsageNOtherFieldInfo = "n_other"
+    type AttrOrigin ResourceUsageNOtherFieldInfo = ResourceUsage
+    attrGet _ = getResourceUsageNOther
+    attrSet _ = setResourceUsageNOther
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+resourceUsage_nOther :: AttrLabelProxy "nOther"
+resourceUsage_nOther = AttrLabelProxy
+
+#endif
+
+
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList ResourceUsage
+type instance O.AttributeList ResourceUsage = ResourceUsageAttributeList
+type ResourceUsageAttributeList = ('[ '("totalBytesEstimate", ResourceUsageTotalBytesEstimateFieldInfo), '("pixmapBytes", ResourceUsagePixmapBytesFieldInfo), '("nPixmaps", ResourceUsageNPixmapsFieldInfo), '("nWindows", ResourceUsageNWindowsFieldInfo), '("nGcs", ResourceUsageNGcsFieldInfo), '("nPictures", ResourceUsageNPicturesFieldInfo), '("nGlyphsets", ResourceUsageNGlyphsetsFieldInfo), '("nFonts", ResourceUsageNFontsFieldInfo), '("nColormapEntries", ResourceUsageNColormapEntriesFieldInfo), '("nPassiveGrabs", ResourceUsageNPassiveGrabsFieldInfo), '("nCursors", ResourceUsageNCursorsFieldInfo), '("nOther", ResourceUsageNOtherFieldInfo)] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+type family ResolveResourceUsageMethod (t :: Symbol) (o :: *) :: * where
+    ResolveResourceUsageMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolveResourceUsageMethod t ResourceUsage, O.MethodInfo info ResourceUsage p) => OL.IsLabel t (ResourceUsage -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+
diff --git a/GI/Wnck/Structs/ResourceUsage.hs-boot b/GI/Wnck/Structs/ResourceUsage.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Structs/ResourceUsage.hs-boot
@@ -0,0 +1,26 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Structs.ResourceUsage where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype ResourceUsage = ResourceUsage (ManagedPtr ResourceUsage)
+instance WrappedPtr ResourceUsage where
diff --git a/GI/Wnck/Structs/WorkspaceLayout.hs b/GI/Wnck/Structs/WorkspaceLayout.hs
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Structs/WorkspaceLayout.hs
@@ -0,0 +1,429 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
+
+The 'GI.Wnck.Structs.WorkspaceLayout.WorkspaceLayout' struct contains information about the layout of
+'GI.Wnck.Objects.Workspace.Workspace' on a 'GI.Wnck.Objects.Screen.Screen', and the exact position of a specific
+'GI.Wnck.Objects.Workspace.Workspace'.
+
+/Since: 2.12/
+-}
+
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+
+module GI.Wnck.Structs.WorkspaceLayout
+    ( 
+
+-- * Exported types
+    WorkspaceLayout(..)                     ,
+    newZeroWorkspaceLayout                  ,
+    noWorkspaceLayout                       ,
+
+
+ -- * Properties
+-- ** cols #attr:cols#
+{- | number of columns in the layout grid.
+-}
+    getWorkspaceLayoutCols                  ,
+    setWorkspaceLayoutCols                  ,
+#if ENABLE_OVERLOADING
+    workspaceLayout_cols                    ,
+#endif
+
+
+-- ** currentCol #attr:currentCol#
+{- | column of the specific 'GI.Wnck.Objects.Workspace.Workspace', starting from 0.
+-}
+    getWorkspaceLayoutCurrentCol            ,
+    setWorkspaceLayoutCurrentCol            ,
+#if ENABLE_OVERLOADING
+    workspaceLayout_currentCol              ,
+#endif
+
+
+-- ** currentRow #attr:currentRow#
+{- | row of the specific 'GI.Wnck.Objects.Workspace.Workspace', starting from 0.
+-}
+    getWorkspaceLayoutCurrentRow            ,
+    setWorkspaceLayoutCurrentRow            ,
+#if ENABLE_OVERLOADING
+    workspaceLayout_currentRow              ,
+#endif
+
+
+-- ** grid #attr:grid#
+{- | array of size /@gridArea@/ containing the index (starting from 0) of
+the 'GI.Wnck.Objects.Workspace.Workspace' for each position in the layout grid, or -1 if the
+position does not correspond to any 'GI.Wnck.Objects.Workspace.Workspace'.
+-}
+    getWorkspaceLayoutGrid                  ,
+    setWorkspaceLayoutGrid                  ,
+#if ENABLE_OVERLOADING
+    workspaceLayout_grid                    ,
+#endif
+
+
+-- ** gridArea #attr:gridArea#
+{- | size of the grid containing all 'GI.Wnck.Objects.Workspace.Workspace'. This can be
+bigger than the number of 'GI.Wnck.Objects.Workspace.Workspace' because the grid might not be
+filled.
+-}
+    getWorkspaceLayoutGridArea              ,
+    setWorkspaceLayoutGridArea              ,
+#if ENABLE_OVERLOADING
+    workspaceLayout_gridArea                ,
+#endif
+
+
+-- ** rows #attr:rows#
+{- | number of rows in the layout grid.
+-}
+    getWorkspaceLayoutRows                  ,
+    setWorkspaceLayoutRows                  ,
+#if ENABLE_OVERLOADING
+    workspaceLayout_rows                    ,
+#endif
+
+
+
+
+    ) where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+
+-- | Memory-managed wrapper type.
+newtype WorkspaceLayout = WorkspaceLayout (ManagedPtr WorkspaceLayout)
+instance WrappedPtr WorkspaceLayout where
+    wrappedPtrCalloc = callocBytes 32
+    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 32 >=> wrapPtr WorkspaceLayout)
+    wrappedPtrFree = Just ptr_to_g_free
+
+-- | Construct a `WorkspaceLayout` struct initialized to zero.
+newZeroWorkspaceLayout :: MonadIO m => m WorkspaceLayout
+newZeroWorkspaceLayout = liftIO $ wrappedPtrCalloc >>= wrapPtr WorkspaceLayout
+
+instance tag ~ 'AttrSet => Constructible WorkspaceLayout tag where
+    new _ attrs = do
+        o <- newZeroWorkspaceLayout
+        GI.Attributes.set o attrs
+        return o
+
+
+-- | A convenience alias for `Nothing` :: `Maybe` `WorkspaceLayout`.
+noWorkspaceLayout :: Maybe WorkspaceLayout
+noWorkspaceLayout = Nothing
+
+{- |
+Get the value of the “@rows@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' workspaceLayout #rows
+@
+-}
+getWorkspaceLayoutRows :: MonadIO m => WorkspaceLayout -> m Int32
+getWorkspaceLayoutRows s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO Int32
+    return val
+
+{- |
+Set the value of the “@rows@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' workspaceLayout [ #rows 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setWorkspaceLayoutRows :: MonadIO m => WorkspaceLayout -> Int32 -> m ()
+setWorkspaceLayoutRows s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 0) (val :: Int32)
+
+#if ENABLE_OVERLOADING
+data WorkspaceLayoutRowsFieldInfo
+instance AttrInfo WorkspaceLayoutRowsFieldInfo where
+    type AttrAllowedOps WorkspaceLayoutRowsFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint WorkspaceLayoutRowsFieldInfo = (~) Int32
+    type AttrBaseTypeConstraint WorkspaceLayoutRowsFieldInfo = (~) WorkspaceLayout
+    type AttrGetType WorkspaceLayoutRowsFieldInfo = Int32
+    type AttrLabel WorkspaceLayoutRowsFieldInfo = "rows"
+    type AttrOrigin WorkspaceLayoutRowsFieldInfo = WorkspaceLayout
+    attrGet _ = getWorkspaceLayoutRows
+    attrSet _ = setWorkspaceLayoutRows
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+workspaceLayout_rows :: AttrLabelProxy "rows"
+workspaceLayout_rows = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@cols@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' workspaceLayout #cols
+@
+-}
+getWorkspaceLayoutCols :: MonadIO m => WorkspaceLayout -> m Int32
+getWorkspaceLayoutCols s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 4) :: IO Int32
+    return val
+
+{- |
+Set the value of the “@cols@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' workspaceLayout [ #cols 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setWorkspaceLayoutCols :: MonadIO m => WorkspaceLayout -> Int32 -> m ()
+setWorkspaceLayoutCols s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 4) (val :: Int32)
+
+#if ENABLE_OVERLOADING
+data WorkspaceLayoutColsFieldInfo
+instance AttrInfo WorkspaceLayoutColsFieldInfo where
+    type AttrAllowedOps WorkspaceLayoutColsFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint WorkspaceLayoutColsFieldInfo = (~) Int32
+    type AttrBaseTypeConstraint WorkspaceLayoutColsFieldInfo = (~) WorkspaceLayout
+    type AttrGetType WorkspaceLayoutColsFieldInfo = Int32
+    type AttrLabel WorkspaceLayoutColsFieldInfo = "cols"
+    type AttrOrigin WorkspaceLayoutColsFieldInfo = WorkspaceLayout
+    attrGet _ = getWorkspaceLayoutCols
+    attrSet _ = setWorkspaceLayoutCols
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+workspaceLayout_cols :: AttrLabelProxy "cols"
+workspaceLayout_cols = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@grid@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' workspaceLayout #grid
+@
+-}
+getWorkspaceLayoutGrid :: MonadIO m => WorkspaceLayout -> m Int32
+getWorkspaceLayoutGrid s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO Int32
+    return val
+
+{- |
+Set the value of the “@grid@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' workspaceLayout [ #grid 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setWorkspaceLayoutGrid :: MonadIO m => WorkspaceLayout -> Int32 -> m ()
+setWorkspaceLayoutGrid s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 8) (val :: Int32)
+
+#if ENABLE_OVERLOADING
+data WorkspaceLayoutGridFieldInfo
+instance AttrInfo WorkspaceLayoutGridFieldInfo where
+    type AttrAllowedOps WorkspaceLayoutGridFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint WorkspaceLayoutGridFieldInfo = (~) Int32
+    type AttrBaseTypeConstraint WorkspaceLayoutGridFieldInfo = (~) WorkspaceLayout
+    type AttrGetType WorkspaceLayoutGridFieldInfo = Int32
+    type AttrLabel WorkspaceLayoutGridFieldInfo = "grid"
+    type AttrOrigin WorkspaceLayoutGridFieldInfo = WorkspaceLayout
+    attrGet _ = getWorkspaceLayoutGrid
+    attrSet _ = setWorkspaceLayoutGrid
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+workspaceLayout_grid :: AttrLabelProxy "grid"
+workspaceLayout_grid = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@grid_area@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' workspaceLayout #gridArea
+@
+-}
+getWorkspaceLayoutGridArea :: MonadIO m => WorkspaceLayout -> m Int32
+getWorkspaceLayoutGridArea s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO Int32
+    return val
+
+{- |
+Set the value of the “@grid_area@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' workspaceLayout [ #gridArea 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setWorkspaceLayoutGridArea :: MonadIO m => WorkspaceLayout -> Int32 -> m ()
+setWorkspaceLayoutGridArea s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 16) (val :: Int32)
+
+#if ENABLE_OVERLOADING
+data WorkspaceLayoutGridAreaFieldInfo
+instance AttrInfo WorkspaceLayoutGridAreaFieldInfo where
+    type AttrAllowedOps WorkspaceLayoutGridAreaFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint WorkspaceLayoutGridAreaFieldInfo = (~) Int32
+    type AttrBaseTypeConstraint WorkspaceLayoutGridAreaFieldInfo = (~) WorkspaceLayout
+    type AttrGetType WorkspaceLayoutGridAreaFieldInfo = Int32
+    type AttrLabel WorkspaceLayoutGridAreaFieldInfo = "grid_area"
+    type AttrOrigin WorkspaceLayoutGridAreaFieldInfo = WorkspaceLayout
+    attrGet _ = getWorkspaceLayoutGridArea
+    attrSet _ = setWorkspaceLayoutGridArea
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+workspaceLayout_gridArea :: AttrLabelProxy "gridArea"
+workspaceLayout_gridArea = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@current_row@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' workspaceLayout #currentRow
+@
+-}
+getWorkspaceLayoutCurrentRow :: MonadIO m => WorkspaceLayout -> m Int32
+getWorkspaceLayoutCurrentRow s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 20) :: IO Int32
+    return val
+
+{- |
+Set the value of the “@current_row@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' workspaceLayout [ #currentRow 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setWorkspaceLayoutCurrentRow :: MonadIO m => WorkspaceLayout -> Int32 -> m ()
+setWorkspaceLayoutCurrentRow s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 20) (val :: Int32)
+
+#if ENABLE_OVERLOADING
+data WorkspaceLayoutCurrentRowFieldInfo
+instance AttrInfo WorkspaceLayoutCurrentRowFieldInfo where
+    type AttrAllowedOps WorkspaceLayoutCurrentRowFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint WorkspaceLayoutCurrentRowFieldInfo = (~) Int32
+    type AttrBaseTypeConstraint WorkspaceLayoutCurrentRowFieldInfo = (~) WorkspaceLayout
+    type AttrGetType WorkspaceLayoutCurrentRowFieldInfo = Int32
+    type AttrLabel WorkspaceLayoutCurrentRowFieldInfo = "current_row"
+    type AttrOrigin WorkspaceLayoutCurrentRowFieldInfo = WorkspaceLayout
+    attrGet _ = getWorkspaceLayoutCurrentRow
+    attrSet _ = setWorkspaceLayoutCurrentRow
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+workspaceLayout_currentRow :: AttrLabelProxy "currentRow"
+workspaceLayout_currentRow = AttrLabelProxy
+
+#endif
+
+
+{- |
+Get the value of the “@current_col@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.get' workspaceLayout #currentCol
+@
+-}
+getWorkspaceLayoutCurrentCol :: MonadIO m => WorkspaceLayout -> m Int32
+getWorkspaceLayoutCurrentCol s = liftIO $ withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 24) :: IO Int32
+    return val
+
+{- |
+Set the value of the “@current_col@” field.
+When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
+
+@
+'Data.GI.Base.Attributes.set' workspaceLayout [ #currentCol 'Data.GI.Base.Attributes.:=' value ]
+@
+-}
+setWorkspaceLayoutCurrentCol :: MonadIO m => WorkspaceLayout -> Int32 -> m ()
+setWorkspaceLayoutCurrentCol s val = liftIO $ withManagedPtr s $ \ptr -> do
+    poke (ptr `plusPtr` 24) (val :: Int32)
+
+#if ENABLE_OVERLOADING
+data WorkspaceLayoutCurrentColFieldInfo
+instance AttrInfo WorkspaceLayoutCurrentColFieldInfo where
+    type AttrAllowedOps WorkspaceLayoutCurrentColFieldInfo = '[ 'AttrSet, 'AttrGet]
+    type AttrSetTypeConstraint WorkspaceLayoutCurrentColFieldInfo = (~) Int32
+    type AttrBaseTypeConstraint WorkspaceLayoutCurrentColFieldInfo = (~) WorkspaceLayout
+    type AttrGetType WorkspaceLayoutCurrentColFieldInfo = Int32
+    type AttrLabel WorkspaceLayoutCurrentColFieldInfo = "current_col"
+    type AttrOrigin WorkspaceLayoutCurrentColFieldInfo = WorkspaceLayout
+    attrGet _ = getWorkspaceLayoutCurrentCol
+    attrSet _ = setWorkspaceLayoutCurrentCol
+    attrConstruct = undefined
+    attrClear _ = undefined
+
+workspaceLayout_currentCol :: AttrLabelProxy "currentCol"
+workspaceLayout_currentCol = AttrLabelProxy
+
+#endif
+
+
+
+#if ENABLE_OVERLOADING
+instance O.HasAttributeList WorkspaceLayout
+type instance O.AttributeList WorkspaceLayout = WorkspaceLayoutAttributeList
+type WorkspaceLayoutAttributeList = ('[ '("rows", WorkspaceLayoutRowsFieldInfo), '("cols", WorkspaceLayoutColsFieldInfo), '("grid", WorkspaceLayoutGridFieldInfo), '("gridArea", WorkspaceLayoutGridAreaFieldInfo), '("currentRow", WorkspaceLayoutCurrentRowFieldInfo), '("currentCol", WorkspaceLayoutCurrentColFieldInfo)] :: [(Symbol, *)])
+#endif
+
+#if ENABLE_OVERLOADING
+type family ResolveWorkspaceLayoutMethod (t :: Symbol) (o :: *) :: * where
+    ResolveWorkspaceLayoutMethod l o = O.MethodResolutionFailed l o
+
+instance (info ~ ResolveWorkspaceLayoutMethod t WorkspaceLayout, O.MethodInfo info WorkspaceLayout p) => OL.IsLabel t (WorkspaceLayout -> p) where
+#if MIN_VERSION_base(4,10,0)
+    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#else
+    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
+#endif
+
+#endif
+
+
diff --git a/GI/Wnck/Structs/WorkspaceLayout.hs-boot b/GI/Wnck/Structs/WorkspaceLayout.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Wnck/Structs/WorkspaceLayout.hs-boot
@@ -0,0 +1,26 @@
+#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
+       && !defined(__HADDOCK_VERSION__))
+module GI.Wnck.Structs.WorkspaceLayout where
+
+import Data.GI.Base.ShortPrelude
+import qualified Data.GI.Base.ShortPrelude as SP
+import qualified Data.GI.Base.Overloading as O
+import qualified Prelude as P
+
+import qualified Data.GI.Base.Attributes as GI.Attributes
+import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
+import qualified Data.GI.Base.GClosure as B.GClosure
+import qualified Data.GI.Base.GError as B.GError
+import qualified Data.GI.Base.GVariant as B.GVariant
+import qualified Data.GI.Base.GValue as B.GValue
+import qualified Data.GI.Base.GParamSpec as B.GParamSpec
+import qualified Data.GI.Base.CallStack as B.CallStack
+import qualified Data.GI.Base.Properties as B.Properties
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+import qualified Foreign.Ptr as FP
+import qualified GHC.OverloadedLabels as OL
+
+newtype WorkspaceLayout = WorkspaceLayout (ManagedPtr WorkspaceLayout)
+instance WrappedPtr WorkspaceLayout where
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,3 +1,17 @@
+The gi-wnck library and included works are provided under the terms of the
+GNU Library General Public License (LGPL) version 2.1 with the following
+exception:
+
+Static linking of applications or any other source to the gi-wnck library
+does not constitute a modified or derivative work and does not require
+the author(s) to provide source code for said work, to link against the
+shared gi-wnck libraries, or to link their applications against a
+user-supplied version of gi-wnck. If you link applications to a modified
+version of gi-wnck, then the changes to gi-wnck must be provided under the
+terms of the LGPL.
+
+----------------------------------------------------------------------------
+
                   GNU LESSER GENERAL PUBLIC LICENSE
                        Version 2.1, February 1999
 
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # Documentation
 Autogenerated documentation for this package can be found at
 
-[https://hackage.haskell.org/package/gi-wnck-3.0.1/docs/GI-Wnck.html](https://hackage.haskell.org/package/gi-wnck-3.0.1/docs/GI-Wnck.html)
+[https://hackage.haskell.org/package/gi-wnck-3.0.3/docs/GI-Wnck.html](https://hackage.haskell.org/package/gi-wnck-3.0.3/docs/GI-Wnck.html)
 
 For general documentation on using [haskell-gi](https://github.com/haskell-gi/haskell-gi) based bindings, see [the project page](https://github.com/haskell-gi/haskell-gi) or [the Wiki](https://github.com/haskell-gi/haskell-gi/wiki).
diff --git a/gi-wnck.cabal b/gi-wnck.cabal
--- a/gi-wnck.cabal
+++ b/gi-wnck.cabal
@@ -1,12 +1,12 @@
 name:                 gi-wnck
-version:              3.0.1
+version:              3.0.3
 synopsis:             Wnck bindings
 description:          Bindings for wnck, autogenerated by haskell-gi.
 homepage:             https://github.com/haskell-gi/haskell-gi
 license:              LGPL-2.1
 license-file:         LICENSE
 author:               Will Thompson, Iñaki García Etxebarria and Jonas Platte
-maintainer:           Iñaki García Etxebarria (garetxe@gmail.com)
+maintainer:           Iñaki García Etxebarria (inaki@blueleaf.cc)
 category:             Bindings
 build-type:           Custom
 cabal-version:        1.24
@@ -14,20 +14,20 @@
 extra-source-files: README.md ChangeLog.md stack.yaml Wnck.overrides
 
 custom-setup
-      setup-depends: base >= 4.7 && < 5,
+      setup-depends: base >= 4.9 && < 5,
                      Cabal >= 1.24,
-                     haskell-gi >= 0.21.1 && < 0.22
+                     haskell-gi >= 0.21.0 && < 0.23
 
 library
       default-language: Haskell2010
-      default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts
+      default-extensions: NoImplicitPrelude, ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts, UndecidableSuperClasses
       other-extensions: PatternSynonyms, ViewPatterns
       ghc-options: -fno-warn-unused-imports -fno-warn-warnings-deprecations
 
       pkgconfig-depends: libwnck-3.0
       build-depends: base >= 4.7 && <5,
-                     haskell-gi-base == 0.21.*,
-                     haskell-gi >= 0.21.1 && < 0.22,
+                     haskell-gi-base >= 0.21.0 && < 0.23,
+                     haskell-gi >= 0.21.0 && < 0.23,
                      haskell-gi-overloading < 1.1,
                      gi-gdk == 3.0.*,
                      gi-gdkpixbuf == 2.0.*,
@@ -43,3 +43,23 @@
       -- see https://ghc.haskell.org/trac/ghc/ticket/14382
       if impl(ghc == 8.2.*)
               build-depends: haskell-gi-overloading == 0.0
+
+      exposed-modules: GI.Wnck,
+                       GI.Wnck.Constants,
+                       GI.Wnck.Enums,
+                       GI.Wnck.Flags,
+                       GI.Wnck.Functions,
+                       GI.Wnck.Objects,
+                       GI.Wnck.Objects.ActionMenu,
+                       GI.Wnck.Objects.Application,
+                       GI.Wnck.Objects.ClassGroup,
+                       GI.Wnck.Objects.ImageMenuItem,
+                       GI.Wnck.Objects.Pager,
+                       GI.Wnck.Objects.Screen,
+                       GI.Wnck.Objects.Selector,
+                       GI.Wnck.Objects.Tasklist,
+                       GI.Wnck.Objects.Window,
+                       GI.Wnck.Objects.Workspace,
+                       GI.Wnck.Structs,
+                       GI.Wnck.Structs.ResourceUsage,
+                       GI.Wnck.Structs.WorkspaceLayout
diff --git a/stack.yaml b/stack.yaml
--- a/stack.yaml
+++ b/stack.yaml
@@ -1,3 +1,3 @@
 packages:
 - '.'
-resolver: lts-9.21
+resolver: lts-13.7