nearby/internal/platform/implementation/windows/generated/winrt/impl/Microsoft.UI.Input.0.h

// WARNING: Please don't edit this file. It was generated by C++/WinRT
// v2.0.250303.1

#pragma once
#ifndef WINRT_Microsoft_UI_Input_0_H
#define WINRT_Microsoft_UI_Input_0_H
WINRT_EXPORT namespace winrt::Microsoft::UI { struct WindowId; }
WINRT_EXPORT namespace winrt::Microsoft::UI::Content {
  struct ContentIsland;
  struct IContentSiteBridge;
  struct IContentSiteLink;
}
WINRT_EXPORT namespace winrt::Microsoft::UI::Dispatching {
  struct DispatcherQueue;
}
WINRT_EXPORT namespace winrt::Windows::Foundation {
  struct EventRegistrationToken;
  struct Point;
  struct Rect;
  template <typename TSender, typename TResult>
  struct WINRT_IMPL_EMPTY_BASES TypedEventHandler;
}
WINRT_EXPORT namespace winrt::Windows::Foundation::Collections {
  template <typename T>
  struct WINRT_IMPL_EMPTY_BASES IVector;
}
WINRT_EXPORT namespace winrt::Windows::Graphics {
  struct PointInt32;
  struct RectInt32;
}
WINRT_EXPORT namespace winrt::Windows::System {
  enum class VirtualKey : int32_t;
  enum class VirtualKeyModifiers : uint32_t;
}
WINRT_EXPORT namespace winrt::Windows::UI::Core {
  struct CoreCursor;
  enum class CoreVirtualKeyStates : uint32_t;
}
WINRT_EXPORT namespace winrt::Microsoft::UI::Input {
  enum class CrossSlidingState : int32_t {
    Started = 0,
    Dragging = 1,
    Selecting = 2,
    SelectSpeedBumping = 3,
    SpeedBumping = 4,
    Rearranging = 5,
    Completed = 6,
  };
  enum class DraggingState : int32_t {
    Started = 0,
    Continuing = 1,
    Completed = 2,
  };
  enum class FocusNavigationReason : int32_t {
    Programmatic = 0,
    Restore = 1,
    First = 2,
    Last = 3,
    Left = 4,
    Up = 5,
    Right = 6,
    Down = 7,
  };
  enum class FocusNavigationResult : int32_t {
    NotMoved = 0,
    Moved = 1,
    NoFocusableElements = 2,
  };
  enum class GestureSettings : uint32_t {
    None = 0,
    Tap = 0x1,
    DoubleTap = 0x2,
    Hold = 0x4,
    HoldWithMouse = 0x8,
    RightTap = 0x10,
    Drag = 0x20,
    ManipulationTranslateX = 0x40,
    ManipulationTranslateY = 0x80,
    ManipulationTranslateRailsX = 0x100,
    ManipulationTranslateRailsY = 0x200,
    ManipulationRotate = 0x400,
    ManipulationScale = 0x800,
    ManipulationTranslateInertia = 0x1000,
    ManipulationRotateInertia = 0x2000,
    ManipulationScaleInertia = 0x4000,
    CrossSlide = 0x8000,
    ManipulationMultipleFingerPanning = 0x10000,
  };
  enum class HoldingState : int32_t {
    Started = 0,
    Completed = 1,
    Canceled = 2,
  };
  enum class InputActivationState : int32_t {
    None = 0,
    Deactivated = 1,
    Activated = 2,
  };
  enum class InputPointerSourceDeviceKinds : uint32_t {
    None = 0,
    Touch = 0x1,
    Pen = 0x2,
    Mouse = 0x4,
  };
  enum class InputSystemCursorShape : int32_t {
    Arrow = 0,
    Cross = 1,
    Hand = 3,
    Help = 4,
    IBeam = 5,
    SizeAll = 6,
    SizeNortheastSouthwest = 7,
    SizeNorthSouth = 8,
    SizeNorthwestSoutheast = 9,
    SizeWestEast = 10,
    UniversalNo = 11,
    UpArrow = 12,
    Wait = 13,
    Pin = 14,
    Person = 15,
    AppStarting = 16,
  };
  enum class MoveSizeOperation : int32_t {
    Move = 0,
    SizeBottom = 1,
    SizeBottomLeft = 2,
    SizeBottomRight = 3,
    SizeLeft = 4,
    SizeRight = 5,
    SizeTop = 6,
    SizeTopLeft = 7,
    SizeTopRight = 8,
  };
  enum class NonClientRegionKind : int32_t {
    Close = 0,
    Maximize = 1,
    Minimize = 2,
    Icon = 3,
    Caption = 4,
    TopBorder = 5,
    LeftBorder = 6,
    BottomBorder = 7,
    RightBorder = 8,
    Passthrough = 9,
  };
  enum class PointerDeviceType : int32_t {
    Touch = 0,
    Pen = 1,
    Mouse = 2,
    Touchpad = 3,
  };
  enum class PointerUpdateKind : int32_t {
    Other = 0,
    LeftButtonPressed = 1,
    LeftButtonReleased = 2,
    RightButtonPressed = 3,
    RightButtonReleased = 4,
    MiddleButtonPressed = 5,
    MiddleButtonReleased = 6,
    XButton1Pressed = 7,
    XButton1Released = 8,
    XButton2Pressed = 9,
    XButton2Released = 10,
  };
  enum class VirtualKeyStates : uint32_t {
    None = 0,
    Down = 0x1,
    Locked = 0x2,
  };
  struct ICharacterReceivedEventArgs;
  struct IContextMenuKeyEventArgs;
  struct ICrossSlidingEventArgs;
  struct IDraggingEventArgs;
  struct IEnteredMoveSizeEventArgs;
  struct IEnteringMoveSizeEventArgs;
  struct IExitedMoveSizeEventArgs;
  struct IFocusChangedEventArgs;
  struct IFocusNavigationRequest;
  struct IFocusNavigationRequestEventArgs;
  struct IFocusNavigationRequestStatics;
  struct IGestureRecognizer;
  struct IHoldingEventArgs;
  struct IInputActivationListener;
  struct IInputActivationListenerActivationChangedEventArgs;
  struct IInputActivationListenerStatics;
  struct IInputActivationListenerStatics2;
  struct IInputCursor;
  struct IInputCursorFactory;
  struct IInputCursorStatics;
  struct IInputCustomCursor;
  struct IInputCustomCursorFactory;
  struct IInputDesktopNamedResourceCursor;
  struct IInputDesktopNamedResourceCursorStatics;
  struct IInputDesktopResourceCursor;
  struct IInputDesktopResourceCursorStatics;
  struct IInputFocusController;
  struct IInputFocusController2;
  struct IInputFocusControllerStatics;
  struct IInputFocusNavigationHost;
  struct IInputFocusNavigationHostStatics;
  struct IInputFocusNavigationHostStatics2;
  struct IInputKeyboardSource;
  struct IInputKeyboardSource2;
  struct IInputKeyboardSourceStatics;
  struct IInputKeyboardSourceStatics2;
  struct IInputLightDismissAction;
  struct IInputLightDismissActionStatics;
  struct IInputLightDismissEventArgs;
  struct IInputNonClientPointerSource;
  struct IInputNonClientPointerSource2;
  struct IInputNonClientPointerSourceStatics;
  struct IInputObject;
  struct IInputObjectFactory;
  struct IInputPointerSource;
  struct IInputPointerSourceStatics;
  struct IInputPreTranslateKeyboardSource;
  struct IInputPreTranslateKeyboardSourceStatics;
  struct IInputSystemCursor;
  struct IInputSystemCursorStatics;
  struct IKeyEventArgs;
  struct IManipulationCompletedEventArgs;
  struct IManipulationInertiaStartingEventArgs;
  struct IManipulationStartedEventArgs;
  struct IManipulationUpdatedEventArgs;
  struct IMouseWheelParameters;
  struct INonClientCaptionTappedEventArgs;
  struct INonClientPointerEventArgs;
  struct INonClientRegionsChangedEventArgs;
  struct IPointerEventArgs;
  struct IPointerPoint;
  struct IPointerPointProperties;
  struct IPointerPointTransform;
  struct IPointerPredictor;
  struct IPointerPredictorStatics;
  struct IRightTappedEventArgs;
  struct ITappedEventArgs;
  struct IWindowRectChangedEventArgs;
  struct IWindowRectChangingEventArgs;
  struct CharacterReceivedEventArgs;
  struct ContextMenuKeyEventArgs;
  struct CrossSlidingEventArgs;
  struct DraggingEventArgs;
  struct EnteredMoveSizeEventArgs;
  struct EnteringMoveSizeEventArgs;
  struct ExitedMoveSizeEventArgs;
  struct FocusChangedEventArgs;
  struct FocusNavigationRequest;
  struct FocusNavigationRequestEventArgs;
  struct GestureRecognizer;
  struct HoldingEventArgs;
  struct InputActivationListener;
  struct InputActivationListenerActivationChangedEventArgs;
  struct InputCursor;
  struct InputCustomCursor;
  struct InputDesktopNamedResourceCursor;
  struct InputDesktopResourceCursor;
  struct InputFocusController;
  struct InputFocusNavigationHost;
  struct InputKeyboardSource;
  struct InputLightDismissAction;
  struct InputLightDismissEventArgs;
  struct InputNonClientPointerSource;
  struct InputObject;
  struct InputPointerSource;
  struct InputPreTranslateKeyboardSource;
  struct InputSystemCursor;
  struct KeyEventArgs;
  struct ManipulationCompletedEventArgs;
  struct ManipulationInertiaStartingEventArgs;
  struct ManipulationStartedEventArgs;
  struct ManipulationUpdatedEventArgs;
  struct MouseWheelParameters;
  struct NonClientCaptionTappedEventArgs;
  struct NonClientPointerEventArgs;
  struct NonClientRegionsChangedEventArgs;
  struct PointerEventArgs;
  struct PointerPoint;
  struct PointerPointProperties;
  struct PointerPredictor;
  struct RightTappedEventArgs;
  struct TappedEventArgs;
  struct WindowRectChangedEventArgs;
  struct WindowRectChangingEventArgs;
  struct CrossSlideThresholds;
  struct ManipulationDelta;
  struct ManipulationVelocities;
  struct PhysicalKeyStatus;
}
namespace winrt::impl {
template <>
struct category<winrt::Microsoft::UI::Input::ICharacterReceivedEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IContextMenuKeyEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::ICrossSlidingEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IDraggingEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IEnteredMoveSizeEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IEnteringMoveSizeEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IExitedMoveSizeEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IFocusChangedEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IFocusNavigationRequest> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IFocusNavigationRequestEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IFocusNavigationRequestStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IGestureRecognizer> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IHoldingEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputActivationListener> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::
                    IInputActivationListenerActivationChangedEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputActivationListenerStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputActivationListenerStatics2> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputCursor> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputCursorFactory> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputCursorStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputCustomCursor> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputCustomCursorFactory> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputDesktopNamedResourceCursor> {
  using type = interface_category;
};
template <>
struct category<
    winrt::Microsoft::UI::Input::IInputDesktopNamedResourceCursorStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputDesktopResourceCursor> {
  using type = interface_category;
};
template <>
struct category<
    winrt::Microsoft::UI::Input::IInputDesktopResourceCursorStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputFocusController> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputFocusController2> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputFocusControllerStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputFocusNavigationHost> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputFocusNavigationHostStatics> {
  using type = interface_category;
};
template <>
struct category<
    winrt::Microsoft::UI::Input::IInputFocusNavigationHostStatics2> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputKeyboardSource> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputKeyboardSource2> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputKeyboardSourceStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputKeyboardSourceStatics2> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputLightDismissAction> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputLightDismissActionStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputLightDismissEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputNonClientPointerSource> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputNonClientPointerSource2> {
  using type = interface_category;
};
template <>
struct category<
    winrt::Microsoft::UI::Input::IInputNonClientPointerSourceStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputObject> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputObjectFactory> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputPointerSource> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputPointerSourceStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputPreTranslateKeyboardSource> {
  using type = interface_category;
};
template <>
struct category<
    winrt::Microsoft::UI::Input::IInputPreTranslateKeyboardSourceStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputSystemCursor> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IInputSystemCursorStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IKeyEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IManipulationCompletedEventArgs> {
  using type = interface_category;
};
template <>
struct category<
    winrt::Microsoft::UI::Input::IManipulationInertiaStartingEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IManipulationStartedEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IManipulationUpdatedEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IMouseWheelParameters> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::INonClientCaptionTappedEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::INonClientPointerEventArgs> {
  using type = interface_category;
};
template <>
struct category<
    winrt::Microsoft::UI::Input::INonClientRegionsChangedEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IPointerEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IPointerPoint> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IPointerPointProperties> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IPointerPointTransform> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IPointerPredictor> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IPointerPredictorStatics> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IRightTappedEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::ITappedEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IWindowRectChangedEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::IWindowRectChangingEventArgs> {
  using type = interface_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::CharacterReceivedEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::ContextMenuKeyEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::CrossSlidingEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::DraggingEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::EnteredMoveSizeEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::EnteringMoveSizeEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::ExitedMoveSizeEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::FocusChangedEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::FocusNavigationRequest> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::FocusNavigationRequestEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::GestureRecognizer> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::HoldingEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputActivationListener> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::
                    InputActivationListenerActivationChangedEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputCursor> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputCustomCursor> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputDesktopNamedResourceCursor> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputDesktopResourceCursor> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputFocusController> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputFocusNavigationHost> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputKeyboardSource> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputLightDismissAction> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputLightDismissEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputNonClientPointerSource> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputObject> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputPointerSource> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputPreTranslateKeyboardSource> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputSystemCursor> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::KeyEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::ManipulationCompletedEventArgs> {
  using type = class_category;
};
template <>
struct category<
    winrt::Microsoft::UI::Input::ManipulationInertiaStartingEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::ManipulationStartedEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::ManipulationUpdatedEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::MouseWheelParameters> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::NonClientCaptionTappedEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::NonClientPointerEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::NonClientRegionsChangedEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::PointerEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::PointerPoint> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::PointerPointProperties> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::PointerPredictor> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::RightTappedEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::TappedEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::WindowRectChangedEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::WindowRectChangingEventArgs> {
  using type = class_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::CrossSlidingState> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::DraggingState> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::FocusNavigationReason> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::FocusNavigationResult> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::GestureSettings> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::HoldingState> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputActivationState> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputPointerSourceDeviceKinds> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::InputSystemCursorShape> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::MoveSizeOperation> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::NonClientRegionKind> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::PointerDeviceType> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::PointerUpdateKind> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::VirtualKeyStates> {
  using type = enum_category;
};
template <>
struct category<winrt::Microsoft::UI::Input::CrossSlideThresholds> {
  using type = struct_category<float, float, float, float>;
};
template <>
struct category<winrt::Microsoft::UI::Input::ManipulationDelta> {
  using type =
      struct_category<winrt::Windows::Foundation::Point, float, float, float>;
};
template <>
struct category<winrt::Microsoft::UI::Input::ManipulationVelocities> {
  using type = struct_category<winrt::Windows::Foundation::Point, float, float>;
};
template <>
struct category<winrt::Microsoft::UI::Input::PhysicalKeyStatus> {
  using type = struct_category<uint32_t, uint32_t, bool, bool, bool, bool>;
};
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::CharacterReceivedEventArgs> =
        L"Microsoft.UI.Input.CharacterReceivedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::ContextMenuKeyEventArgs> =
        L"Microsoft.UI.Input.ContextMenuKeyEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::CrossSlidingEventArgs> =
        L"Microsoft.UI.Input.CrossSlidingEventArgs";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::DraggingEventArgs> =
    L"Microsoft.UI.Input.DraggingEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::EnteredMoveSizeEventArgs> =
        L"Microsoft.UI.Input.EnteredMoveSizeEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::EnteringMoveSizeEventArgs> =
        L"Microsoft.UI.Input.EnteringMoveSizeEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::ExitedMoveSizeEventArgs> =
        L"Microsoft.UI.Input.ExitedMoveSizeEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::FocusChangedEventArgs> =
        L"Microsoft.UI.Input.FocusChangedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::FocusNavigationRequest> =
        L"Microsoft.UI.Input.FocusNavigationRequest";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::FocusNavigationRequestEventArgs> =
        L"Microsoft.UI.Input.FocusNavigationRequestEventArgs";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::GestureRecognizer> =
    L"Microsoft.UI.Input.GestureRecognizer";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::HoldingEventArgs> =
    L"Microsoft.UI.Input.HoldingEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputActivationListener> =
        L"Microsoft.UI.Input.InputActivationListener";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::
               InputActivationListenerActivationChangedEventArgs> =
        L"Microsoft.UI.Input.InputActivationListenerActivationChangedEventArgs";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::InputCursor> =
    L"Microsoft.UI.Input.InputCursor";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::InputCustomCursor> =
    L"Microsoft.UI.Input.InputCustomCursor";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputDesktopNamedResourceCursor> =
        L"Microsoft.UI.Input.InputDesktopNamedResourceCursor";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputDesktopResourceCursor> =
        L"Microsoft.UI.Input.InputDesktopResourceCursor";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputFocusController> =
        L"Microsoft.UI.Input.InputFocusController";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputFocusNavigationHost> =
        L"Microsoft.UI.Input.InputFocusNavigationHost";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputKeyboardSource> =
        L"Microsoft.UI.Input.InputKeyboardSource";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputLightDismissAction> =
        L"Microsoft.UI.Input.InputLightDismissAction";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputLightDismissEventArgs> =
        L"Microsoft.UI.Input.InputLightDismissEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputNonClientPointerSource> =
        L"Microsoft.UI.Input.InputNonClientPointerSource";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::InputObject> =
    L"Microsoft.UI.Input.InputObject";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::InputPointerSource> =
    L"Microsoft.UI.Input.InputPointerSource";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputPreTranslateKeyboardSource> =
        L"Microsoft.UI.Input.InputPreTranslateKeyboardSource";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::InputSystemCursor> =
    L"Microsoft.UI.Input.InputSystemCursor";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::KeyEventArgs> =
    L"Microsoft.UI.Input.KeyEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::ManipulationCompletedEventArgs> =
        L"Microsoft.UI.Input.ManipulationCompletedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::ManipulationInertiaStartingEventArgs> =
        L"Microsoft.UI.Input.ManipulationInertiaStartingEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::ManipulationStartedEventArgs> =
        L"Microsoft.UI.Input.ManipulationStartedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::ManipulationUpdatedEventArgs> =
        L"Microsoft.UI.Input.ManipulationUpdatedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::MouseWheelParameters> =
        L"Microsoft.UI.Input.MouseWheelParameters";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::NonClientCaptionTappedEventArgs> =
        L"Microsoft.UI.Input.NonClientCaptionTappedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::NonClientPointerEventArgs> =
        L"Microsoft.UI.Input.NonClientPointerEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::NonClientRegionsChangedEventArgs> =
        L"Microsoft.UI.Input.NonClientRegionsChangedEventArgs";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::PointerEventArgs> =
    L"Microsoft.UI.Input.PointerEventArgs";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::PointerPoint> =
    L"Microsoft.UI.Input.PointerPoint";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::PointerPointProperties> =
        L"Microsoft.UI.Input.PointerPointProperties";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::PointerPredictor> =
    L"Microsoft.UI.Input.PointerPredictor";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::RightTappedEventArgs> =
        L"Microsoft.UI.Input.RightTappedEventArgs";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::TappedEventArgs> =
    L"Microsoft.UI.Input.TappedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::WindowRectChangedEventArgs> =
        L"Microsoft.UI.Input.WindowRectChangedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::WindowRectChangingEventArgs> =
        L"Microsoft.UI.Input.WindowRectChangingEventArgs";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::CrossSlidingState> =
    L"Microsoft.UI.Input.CrossSlidingState";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::DraggingState> =
    L"Microsoft.UI.Input.DraggingState";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::FocusNavigationReason> =
        L"Microsoft.UI.Input.FocusNavigationReason";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::FocusNavigationResult> =
        L"Microsoft.UI.Input.FocusNavigationResult";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::GestureSettings> =
    L"Microsoft.UI.Input.GestureSettings";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::HoldingState> =
    L"Microsoft.UI.Input.HoldingState";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputActivationState> =
        L"Microsoft.UI.Input.InputActivationState";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputPointerSourceDeviceKinds> =
        L"Microsoft.UI.Input.InputPointerSourceDeviceKinds";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::InputSystemCursorShape> =
        L"Microsoft.UI.Input.InputSystemCursorShape";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::MoveSizeOperation> =
    L"Microsoft.UI.Input.MoveSizeOperation";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::NonClientRegionKind> =
        L"Microsoft.UI.Input.NonClientRegionKind";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::PointerDeviceType> =
    L"Microsoft.UI.Input.PointerDeviceType";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::PointerUpdateKind> =
    L"Microsoft.UI.Input.PointerUpdateKind";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::VirtualKeyStates> =
    L"Microsoft.UI.Input.VirtualKeyStates";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::CrossSlideThresholds> =
        L"Microsoft.UI.Input.CrossSlideThresholds";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::ManipulationDelta> =
    L"Microsoft.UI.Input.ManipulationDelta";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::ManipulationVelocities> =
        L"Microsoft.UI.Input.ManipulationVelocities";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::PhysicalKeyStatus> =
    L"Microsoft.UI.Input.PhysicalKeyStatus";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::ICharacterReceivedEventArgs> =
        L"Microsoft.UI.Input.ICharacterReceivedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IContextMenuKeyEventArgs> =
        L"Microsoft.UI.Input.IContextMenuKeyEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::ICrossSlidingEventArgs> =
        L"Microsoft.UI.Input.ICrossSlidingEventArgs";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::IDraggingEventArgs> =
    L"Microsoft.UI.Input.IDraggingEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IEnteredMoveSizeEventArgs> =
        L"Microsoft.UI.Input.IEnteredMoveSizeEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IEnteringMoveSizeEventArgs> =
        L"Microsoft.UI.Input.IEnteringMoveSizeEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IExitedMoveSizeEventArgs> =
        L"Microsoft.UI.Input.IExitedMoveSizeEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IFocusChangedEventArgs> =
        L"Microsoft.UI.Input.IFocusChangedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IFocusNavigationRequest> =
        L"Microsoft.UI.Input.IFocusNavigationRequest";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IFocusNavigationRequestEventArgs> =
        L"Microsoft.UI.Input.IFocusNavigationRequestEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IFocusNavigationRequestStatics> =
        L"Microsoft.UI.Input.IFocusNavigationRequestStatics";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::IGestureRecognizer> =
    L"Microsoft.UI.Input.IGestureRecognizer";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::IHoldingEventArgs> =
    L"Microsoft.UI.Input.IHoldingEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputActivationListener> =
        L"Microsoft.UI.Input.IInputActivationListener";
template <>
inline constexpr auto& name_v<
    winrt::Microsoft::UI::Input::
        IInputActivationListenerActivationChangedEventArgs> =
    L"Microsoft.UI.Input.IInputActivationListenerActivationChangedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputActivationListenerStatics> =
        L"Microsoft.UI.Input.IInputActivationListenerStatics";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputActivationListenerStatics2> =
        L"Microsoft.UI.Input.IInputActivationListenerStatics2";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::IInputCursor> =
    L"Microsoft.UI.Input.IInputCursor";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputCursorFactory> =
        L"Microsoft.UI.Input.IInputCursorFactory";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputCursorStatics> =
        L"Microsoft.UI.Input.IInputCursorStatics";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::IInputCustomCursor> =
    L"Microsoft.UI.Input.IInputCustomCursor";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputCustomCursorFactory> =
        L"Microsoft.UI.Input.IInputCustomCursorFactory";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputDesktopNamedResourceCursor> =
        L"Microsoft.UI.Input.IInputDesktopNamedResourceCursor";
template <>
inline constexpr auto& name_v<
    winrt::Microsoft::UI::Input::IInputDesktopNamedResourceCursorStatics> =
    L"Microsoft.UI.Input.IInputDesktopNamedResourceCursorStatics";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputDesktopResourceCursor> =
        L"Microsoft.UI.Input.IInputDesktopResourceCursor";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputDesktopResourceCursorStatics> =
        L"Microsoft.UI.Input.IInputDesktopResourceCursorStatics";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputFocusController> =
        L"Microsoft.UI.Input.IInputFocusController";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputFocusController2> =
        L"Microsoft.UI.Input.IInputFocusController2";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputFocusControllerStatics> =
        L"Microsoft.UI.Input.IInputFocusControllerStatics";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputFocusNavigationHost> =
        L"Microsoft.UI.Input.IInputFocusNavigationHost";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputFocusNavigationHostStatics> =
        L"Microsoft.UI.Input.IInputFocusNavigationHostStatics";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputFocusNavigationHostStatics2> =
        L"Microsoft.UI.Input.IInputFocusNavigationHostStatics2";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputKeyboardSource> =
        L"Microsoft.UI.Input.IInputKeyboardSource";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputKeyboardSource2> =
        L"Microsoft.UI.Input.IInputKeyboardSource2";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputKeyboardSourceStatics> =
        L"Microsoft.UI.Input.IInputKeyboardSourceStatics";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputKeyboardSourceStatics2> =
        L"Microsoft.UI.Input.IInputKeyboardSourceStatics2";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputLightDismissAction> =
        L"Microsoft.UI.Input.IInputLightDismissAction";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputLightDismissActionStatics> =
        L"Microsoft.UI.Input.IInputLightDismissActionStatics";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputLightDismissEventArgs> =
        L"Microsoft.UI.Input.IInputLightDismissEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputNonClientPointerSource> =
        L"Microsoft.UI.Input.IInputNonClientPointerSource";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputNonClientPointerSource2> =
        L"Microsoft.UI.Input.IInputNonClientPointerSource2";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputNonClientPointerSourceStatics> =
        L"Microsoft.UI.Input.IInputNonClientPointerSourceStatics";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::IInputObject> =
    L"Microsoft.UI.Input.IInputObject";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputObjectFactory> =
        L"Microsoft.UI.Input.IInputObjectFactory";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputPointerSource> =
        L"Microsoft.UI.Input.IInputPointerSource";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputPointerSourceStatics> =
        L"Microsoft.UI.Input.IInputPointerSourceStatics";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputPreTranslateKeyboardSource> =
        L"Microsoft.UI.Input.IInputPreTranslateKeyboardSource";
template <>
inline constexpr auto& name_v<
    winrt::Microsoft::UI::Input::IInputPreTranslateKeyboardSourceStatics> =
    L"Microsoft.UI.Input.IInputPreTranslateKeyboardSourceStatics";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::IInputSystemCursor> =
    L"Microsoft.UI.Input.IInputSystemCursor";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IInputSystemCursorStatics> =
        L"Microsoft.UI.Input.IInputSystemCursorStatics";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::IKeyEventArgs> =
    L"Microsoft.UI.Input.IKeyEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IManipulationCompletedEventArgs> =
        L"Microsoft.UI.Input.IManipulationCompletedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IManipulationInertiaStartingEventArgs> =
        L"Microsoft.UI.Input.IManipulationInertiaStartingEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IManipulationStartedEventArgs> =
        L"Microsoft.UI.Input.IManipulationStartedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IManipulationUpdatedEventArgs> =
        L"Microsoft.UI.Input.IManipulationUpdatedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IMouseWheelParameters> =
        L"Microsoft.UI.Input.IMouseWheelParameters";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::INonClientCaptionTappedEventArgs> =
        L"Microsoft.UI.Input.INonClientCaptionTappedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::INonClientPointerEventArgs> =
        L"Microsoft.UI.Input.INonClientPointerEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::INonClientRegionsChangedEventArgs> =
        L"Microsoft.UI.Input.INonClientRegionsChangedEventArgs";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::IPointerEventArgs> =
    L"Microsoft.UI.Input.IPointerEventArgs";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::IPointerPoint> =
    L"Microsoft.UI.Input.IPointerPoint";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IPointerPointProperties> =
        L"Microsoft.UI.Input.IPointerPointProperties";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IPointerPointTransform> =
        L"Microsoft.UI.Input.IPointerPointTransform";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::IPointerPredictor> =
    L"Microsoft.UI.Input.IPointerPredictor";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IPointerPredictorStatics> =
        L"Microsoft.UI.Input.IPointerPredictorStatics";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IRightTappedEventArgs> =
        L"Microsoft.UI.Input.IRightTappedEventArgs";
template <>
inline constexpr auto& name_v<winrt::Microsoft::UI::Input::ITappedEventArgs> =
    L"Microsoft.UI.Input.ITappedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IWindowRectChangedEventArgs> =
        L"Microsoft.UI.Input.IWindowRectChangedEventArgs";
template <>
inline constexpr auto&
    name_v<winrt::Microsoft::UI::Input::IWindowRectChangingEventArgs> =
        L"Microsoft.UI.Input.IWindowRectChangingEventArgs";
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::ICharacterReceivedEventArgs>{
        0x36122718,
        0x9263,
        0x592B,
        {0x8D, 0x87, 0x8F, 0x86, 0x54, 0x3F, 0xFC,
         0x95}};  // 36122718-9263-592B-8D87-8F86543FFC95
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IContextMenuKeyEventArgs>{
        0xF6025762,
        0x9426,
        0x541A,
        {0xB6, 0x47, 0x03, 0x7A, 0xBD, 0xBE, 0xCE,
         0xFC}};  // F6025762-9426-541A-B647-037ABDBECEFC
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::ICrossSlidingEventArgs>{
        0x7679641F,
        0xBA9F,
        0x543C,
        {0xA7, 0xC8, 0x62, 0x29, 0xA9, 0x8F, 0x89,
         0xEF}};  // 7679641F-BA9F-543C-A7C8-6229A98F89EF
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IDraggingEventArgs>{
    0x3EFB1B75,
    0x3D3B,
    0x550E,
    {0x96, 0x3D, 0x08, 0x28, 0xCA, 0x76, 0x12,
     0x8A}};  // 3EFB1B75-3D3B-550E-963D-0828CA76128A
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IEnteredMoveSizeEventArgs>{
        0x698D28FE,
        0xD325,
        0x59E0,
        {0x98, 0x34, 0xB1, 0x0F, 0xC2, 0xF7, 0xBA,
         0x67}};  // 698D28FE-D325-59E0-9834-B10FC2F7BA67
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IEnteringMoveSizeEventArgs>{
        0x47C083B2,
        0x402B,
        0x51EC,
        {0x88, 0x36, 0xD4, 0x86, 0x79, 0xFE, 0xA6,
         0x95}};  // 47C083B2-402B-51EC-8836-D48679FEA695
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IExitedMoveSizeEventArgs>{
        0xDF12A46E,
        0xDAEE,
        0x5DAC,
        {0xA6, 0x78, 0xD7, 0xD5, 0xE4, 0xD0, 0x89,
         0x3A}};  // DF12A46E-DAEE-5DAC-A678-D7D5E4D0893A
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IFocusChangedEventArgs>{
        0xA039B115,
        0xDBDF,
        0x594C,
        {0x9B, 0x86, 0xDA, 0x6A, 0xA0, 0x5C, 0x9F,
         0xA2}};  // A039B115-DBDF-594C-9B86-DA6AA05C9FA2
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IFocusNavigationRequest>{
        0x6D84BB83,
        0x9C84,
        0x5112,
        {0x85, 0xE9, 0x89, 0x19, 0xAC, 0xF9, 0x72,
         0x62}};  // 6D84BB83-9C84-5112-85E9-8919ACF97262
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IFocusNavigationRequestEventArgs>{
        0x35A63426,
        0xE271,
        0x59F9,
        {0xA2, 0x31, 0x0D, 0x19, 0x03, 0x14, 0xB4,
         0x15}};  // 35A63426-E271-59F9-A231-0D190314B415
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IFocusNavigationRequestStatics>{
        0x8C4D2ED8,
        0x3A63,
        0x519E,
        {0xA8, 0x27, 0xF5, 0x7E, 0x26, 0x3B, 0xD1,
         0xFF}};  // 8C4D2ED8-3A63-519E-A827-F57E263BD1FF
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IGestureRecognizer>{
    0xCDA89AFC,
    0x6BD0,
    0x595C,
    {0xBA, 0x37, 0x54, 0x5F, 0xCE, 0x5B, 0xF0,
     0x16}};  // CDA89AFC-6BD0-595C-BA37-545FCE5BF016
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IHoldingEventArgs>{
    0x8E449E85,
    0xD223,
    0x533C,
    {0xB0, 0xB2, 0xBF, 0x7C, 0x6D, 0x10, 0xC2,
     0xDB}};  // 8E449E85-D223-533C-B0B2-BF7C6D10C2DB
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputActivationListener>{
        0x3B818627,
        0x6CE7,
        0x5E0D,
        {0xA0, 0xF5, 0x66, 0x84, 0xFD, 0x1A, 0xEC,
         0x78}};  // 3B818627-6CE7-5E0D-A0F5-6684FD1AEC78
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::
               IInputActivationListenerActivationChangedEventArgs>{
        0x7978526B,
        0x00B6,
        0x5303,
        {0x8F, 0x7D, 0x55, 0xBE, 0xF3, 0x6D, 0xA7,
         0x86}};  // 7978526B-00B6-5303-8F7D-55BEF36DA786
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputActivationListenerStatics>{
        0xC4249843,
        0xF053,
        0x5C99,
        {0x9D, 0x51, 0x72, 0x0A, 0xDE, 0x94, 0x22,
         0x4D}};  // C4249843-F053-5C99-9D51-720ADE94224D
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputActivationListenerStatics2>{
        0x7EA26120,
        0x9636,
        0x5292,
        {0xA7, 0xB1, 0x56, 0x54, 0x4A, 0xC5, 0x1A,
         0x22}};  // 7EA26120-9636-5292-A7B1-56544AC51A22
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IInputCursor>{
    0x359B15F9,
    0x19C2,
    0x5714,
    {0x84, 0x32, 0x75, 0x17, 0x68, 0x26, 0x40,
     0x6B}};  // 359B15F9-19C2-5714-8432-75176826406B
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IInputCursorFactory>{
    0x2F47647B,
    0x4BE0,
    0x53E9,
    {0xBE, 0x7E, 0xC3, 0x8D, 0x54, 0x59, 0xDB,
     0x6B}};  // 2F47647B-4BE0-53E9-BE7E-C38D5459DB6B
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IInputCursorStatics>{
    0x92F6A552,
    0x099F,
    0x55FB,
    {0x8C, 0x31, 0xE4, 0x50, 0x28, 0x4C, 0x96,
     0x43}};  // 92F6A552-099F-55FB-8C31-E450284C9643
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IInputCustomCursor>{
    0x5486F042,
    0x7E1A,
    0x5DC8,
    {0x80, 0x41, 0xE4, 0x7B, 0x60, 0x9A, 0x5B,
     0xA1}};  // 5486F042-7E1A-5DC8-8041-E47B609A5BA1
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputCustomCursorFactory>{
        0x6F402882,
        0x66E0,
        0x57D3,
        {0x89, 0xD0, 0xAA, 0x5E, 0x2F, 0xF9, 0x17,
         0xBC}};  // 6F402882-66E0-57D3-89D0-AA5E2FF917BC
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputDesktopNamedResourceCursor>{
        0xF40EA93B,
        0x0ED7,
        0x5B3A,
        {0xBF, 0xE2, 0x14, 0xE2, 0xB5, 0xAD, 0x88,
         0xA3}};  // F40EA93B-0ED7-5B3A-BFE2-14E2B5AD88A3
template <>
inline constexpr guid guid_v<
    winrt::Microsoft::UI::Input::IInputDesktopNamedResourceCursorStatics>{
    0xE8B6D5AA,
    0x898B,
    0x5E69,
    {0xB0, 0x1F, 0x38, 0x3A, 0x09, 0x43, 0xE3,
     0xE4}};  // E8B6D5AA-898B-5E69-B01F-383A0943E3E4
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputDesktopResourceCursor>{
        0x1DF2777F,
        0x7C90,
        0x58FC,
        {0xA7, 0xA3, 0xD5, 0x73, 0x6C, 0x65, 0x10,
         0xFD}};  // 1DF2777F-7C90-58FC-A7A3-D5736C6510FD
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputDesktopResourceCursorStatics>{
        0xF440DC37,
        0xA0B6,
        0x56EB,
        {0xBC, 0xEC, 0xB0, 0x24, 0xF2, 0x23, 0x3D,
         0x47}};  // F440DC37-A0B6-56EB-BCEC-B024F2233D47
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputFocusController>{
        0x8DFDC26C,
        0x8B8D,
        0x515D,
        {0x8D, 0xDD, 0x46, 0x85, 0xB3, 0xA5, 0x40,
         0xE9}};  // 8DFDC26C-8B8D-515D-8DDD-4685B3A540E9
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputFocusController2>{
        0x5165077C,
        0xCD4B,
        0x501D,
        {0xB3, 0x86, 0xB5, 0x06, 0x82, 0x36, 0x01,
         0x85}};  // 5165077C-CD4B-501D-B386-B50682360185
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputFocusControllerStatics>{
        0xAEB311DA,
        0xDA9B,
        0x5A1B,
        {0x92, 0xF4, 0x83, 0xDD, 0xDE, 0x93, 0x3E,
         0x00}};  // AEB311DA-DA9B-5A1B-92F4-83DDDE933E00
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputFocusNavigationHost>{
        0x53C2A147,
        0x932C,
        0x5486,
        {0xA9, 0xC6, 0xF6, 0xC5, 0xA9, 0xC6, 0x59,
         0x56}};  // 53C2A147-932C-5486-A9C6-F6C5A9C65956
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputFocusNavigationHostStatics>{
        0xC9C62CD1,
        0x73DB,
        0x5AA9,
        {0xB8, 0x9D, 0x14, 0x35, 0x09, 0xDB, 0x8F,
         0x37}};  // C9C62CD1-73DB-5AA9-B89D-143509DB8F37
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputFocusNavigationHostStatics2>{
        0x82505F60,
        0xEF7B,
        0x55D8,
        {0x83, 0x62, 0x8C, 0xC2, 0x84, 0x02, 0x66,
         0xA1}};  // 82505F60-EF7B-55D8-8362-8CC2840266A1
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IInputKeyboardSource>{
    0xED61B906,
    0x16AD,
    0x5DF7,
    {0xA5, 0x50, 0x5E, 0x6F, 0x7D, 0x22, 0x29,
     0xF7}};  // ED61B906-16AD-5DF7-A550-5E6F7D2229F7
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputKeyboardSource2>{
        0x79D1C9B6,
        0xB3C9,
        0x5EC2,
        {0x8A, 0x5B, 0x70, 0x70, 0x88, 0x78, 0x7F,
         0x78}};  // 79D1C9B6-B3C9-5EC2-8A5B-707088787F78
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputKeyboardSourceStatics>{
        0xF4E1563D,
        0x8C2E,
        0x5BCD,
        {0xB7, 0x84, 0x47, 0xAD, 0xEA, 0xA3, 0xCD,
         0x7E}};  // F4E1563D-8C2E-5BCD-B784-47ADEAA3CD7E
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputKeyboardSourceStatics2>{
        0x8857518C,
        0x2899,
        0x5F11,
        {0x9B, 0x64, 0x0A, 0xD8, 0x32, 0x34, 0x82,
         0x4B}};  // 8857518C-2899-5F11-9B64-0AD83234824B
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputLightDismissAction>{
        0xE8A39502,
        0xA860,
        0x502F,
        {0x8C, 0x10, 0x36, 0x46, 0xD4, 0x3A, 0xEC,
         0xF1}};  // E8A39502-A860-502F-8C10-3646D43AECF1
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputLightDismissActionStatics>{
        0xED9B8DEF,
        0x6496,
        0x5169,
        {0x98, 0x4D, 0xD4, 0x4B, 0x4E, 0x69, 0x06,
         0x23}};  // ED9B8DEF-6496-5169-984D-D44B4E690623
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputLightDismissEventArgs>{
        0x078660EE,
        0x07CA,
        0x5808,
        {0xB9, 0x82, 0xE6, 0xE8, 0x99, 0xCF, 0x09,
         0x8C}};  // 078660EE-07CA-5808-B982-E6E899CF098C
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputNonClientPointerSource>{
        0x471732B4,
        0x3D07,
        0x5104,
        {0xB1, 0x92, 0xEB, 0xAC, 0xF7, 0x1E, 0x86,
         0xDF}};  // 471732B4-3D07-5104-B192-EBACF71E86DF
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputNonClientPointerSource2>{
        0xDD2B10C4,
        0x7DE6,
        0x5C1D,
        {0xB4, 0x38, 0x06, 0xDD, 0xC9, 0x94, 0x05,
         0x8F}};  // DD2B10C4-7DE6-5C1D-B438-06DDC994058F
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputNonClientPointerSourceStatics>{
        0x7D0B775C,
        0x1903,
        0x5DC7,
        {0xBD, 0x2F, 0x7A, 0x4B, 0x31, 0xF0, 0xCF,
         0xF2}};  // 7D0B775C-1903-5DC7-BD2F-7A4B31F0CFF2
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IInputObject>{
    0x42EDBC88,
    0xD386,
    0x544D,
    {0xB1, 0xB8, 0x68, 0x61, 0x7F, 0xE6, 0x82,
     0x82}};  // 42EDBC88-D386-544D-B1B8-68617FE68282
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IInputObjectFactory>{
    0xF7786BC2,
    0xB0B8,
    0x5961,
    {0x9A, 0x57, 0xAE, 0x19, 0x9D, 0x45, 0x21,
     0x06}};  // F7786BC2-B0B8-5961-9A57-AE199D452106
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IInputPointerSource>{
    0x6A6C2764,
    0xC3F4,
    0x5BE5,
    {0x84, 0x47, 0xC9, 0xA9, 0x87, 0x66, 0xC2,
     0x40}};  // 6A6C2764-C3F4-5BE5-8447-C9A98766C240
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputPointerSourceStatics>{
        0xE8A19FD1,
        0xA914,
        0x533F,
        {0x9B, 0x0F, 0x6B, 0xF0, 0x06, 0x5E, 0x67,
         0x81}};  // E8A19FD1-A914-533F-9B0F-6BF0065E6781
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputPreTranslateKeyboardSource>{
        0x2F327FEB,
        0xB7E7,
        0x5E37,
        {0xA0, 0xCC, 0x37, 0xDC, 0xAB, 0xE7, 0x65,
         0x88}};  // 2F327FEB-B7E7-5E37-A0CC-37DCABE76588
template <>
inline constexpr guid guid_v<
    winrt::Microsoft::UI::Input::IInputPreTranslateKeyboardSourceStatics>{
    0x23D584D2,
    0xAF8C,
    0x5A8A,
    {0x80, 0x6F, 0x2B, 0xA9, 0xC5, 0xB1, 0xA5,
     0xEC}};  // 23D584D2-AF8C-5A8A-806F-2BA9C5B1A5EC
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IInputSystemCursor>{
    0x59F538E7,
    0xC500,
    0x59AB,
    {0x8B, 0x54, 0x0B, 0xC6, 0x10, 0x0F, 0xD4,
     0x9E}};  // 59F538E7-C500-59AB-8B54-0BC6100FD49E
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IInputSystemCursorStatics>{
        0xD3860BB6,
        0x698A,
        0x5814,
        {0xAE, 0xDD, 0xC2, 0xFA, 0x8B, 0xBA, 0x5A,
         0x02}};  // D3860BB6-698A-5814-AEDD-C2FA8BBA5A02
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IKeyEventArgs>{
    0x40D5BB74,
    0x977E,
    0x5194,
    {0x80, 0x39, 0x9F, 0x6C, 0x44, 0x42, 0x7B,
     0xBB}};  // 40D5BB74-977E-5194-8039-9F6C44427BBB
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IManipulationCompletedEventArgs>{
        0x0E0249D4,
        0x46E4,
        0x5559,
        {0xAE, 0xE3, 0xFA, 0x45, 0xCE, 0x2A, 0x7F,
         0x56}};  // 0E0249D4-46E4-5559-AEE3-FA45CE2A7F56
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IManipulationInertiaStartingEventArgs>{
        0xACF9EF71,
        0x6E15,
        0x56AB,
        {0x92, 0x60, 0xF0, 0xD3, 0xCE, 0x5F, 0x66,
         0xE8}};  // ACF9EF71-6E15-56AB-9260-F0D3CE5F66E8
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IManipulationStartedEventArgs>{
        0x4A616613,
        0xEEF1,
        0x5F1B,
        {0xA7, 0x68, 0x07, 0x75, 0x47, 0x8D, 0x49,
         0xD4}};  // 4A616613-EEF1-5F1B-A768-0775478D49D4
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IManipulationUpdatedEventArgs>{
        0x406E1961,
        0x0C98,
        0x5FC0,
        {0xB3, 0xD8, 0x11, 0x64, 0x92, 0xEF, 0x00,
         0x53}};  // 406E1961-0C98-5FC0-B3D8-116492EF0053
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IMouseWheelParameters>{
        0x6D98BE40,
        0x1D56,
        0x51D1,
        {0xAA, 0x0D, 0xF3, 0x25, 0x43, 0x9C, 0xD0,
         0x09}};  // 6D98BE40-1D56-51D1-AA0D-F325439CD009
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::INonClientCaptionTappedEventArgs>{
        0x3D173531,
        0x991F,
        0x5753,
        {0xB7, 0xE0, 0x14, 0xA1, 0x21, 0xC3, 0xCD,
         0x2D}};  // 3D173531-991F-5753-B7E0-14A121C3CD2D
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::INonClientPointerEventArgs>{
        0xA5B44AEC,
        0xB797,
        0x505A,
        {0xA1, 0x29, 0xAE, 0x4E, 0x52, 0x71, 0xC7,
         0x3C}};  // A5B44AEC-B797-505A-A129-AE4E5271C73C
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::INonClientRegionsChangedEventArgs>{
        0xFE97EE95,
        0x1824,
        0x51B2,
        {0xB8, 0xEB, 0x10, 0xFF, 0x06, 0x65, 0xCE,
         0x23}};  // FE97EE95-1824-51B2-B8EB-10FF0665CE23
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IPointerEventArgs>{
    0x865B188C,
    0x2ED5,
    0x5DF8,
    {0x82, 0x9F, 0xAC, 0x07, 0x01, 0xD5, 0xC5,
     0x1A}};  // 865B188C-2ED5-5DF8-829F-AC0701D5C51A
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IPointerPoint>{
    0x0D430EE6,
    0x252C,
    0x59A4,
    {0xB2, 0xA2, 0xD4, 0x42, 0x64, 0xDC, 0x6A,
     0x40}};  // 0D430EE6-252C-59A4-B2A2-D44264DC6A40
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IPointerPointProperties>{
        0xD760ED77,
        0x4B10,
        0x57A5,
        {0xB3, 0xCC, 0xD9, 0xBF, 0x34, 0x13, 0xE9,
         0x96}};  // D760ED77-4B10-57A5-B3CC-D9BF3413E996
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IPointerPointTransform>{
        0xDB4791BC,
        0x994D,
        0x54C7,
        {0x92, 0xEF, 0x66, 0xEA, 0x1D, 0xE9, 0xB4,
         0x3C}};  // DB4791BC-994D-54C7-92EF-66EA1DE9B43C
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::IPointerPredictor>{
    0x12C100EC,
    0x2100,
    0x565F,
    {0xA6, 0x0C, 0xF1, 0x18, 0x7F, 0x43, 0x88,
     0x28}};  // 12C100EC-2100-565F-A60C-F1187F438828
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IPointerPredictorStatics>{
        0x78A8EF30,
        0x3E5C,
        0x55CD,
        {0x8F, 0x85, 0x65, 0xAC, 0x09, 0xB1, 0xA9,
         0x87}};  // 78A8EF30-3E5C-55CD-8F85-65AC09B1A987
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IRightTappedEventArgs>{
        0x8FF73B39,
        0x887E,
        0x50A4,
        {0x85, 0x00, 0x77, 0x95, 0x30, 0x39, 0xDC,
         0xB4}};  // 8FF73B39-887E-50A4-8500-77953039DCB4
template <>
inline constexpr guid guid_v<winrt::Microsoft::UI::Input::ITappedEventArgs>{
    0xC3A01BB5,
    0x6076,
    0x5E0F,
    {0x87, 0x1A, 0x9D, 0x94, 0xA6, 0xA8, 0xF8,
     0x2B}};  // C3A01BB5-6076-5E0F-871A-9D94A6A8F82B
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IWindowRectChangedEventArgs>{
        0x8A885D28,
        0xD2D9,
        0x5DDA,
        {0x98, 0x48, 0xCD, 0xF2, 0x47, 0x77, 0x10,
         0x37}};  // 8A885D28-D2D9-5DDA-9848-CDF247771037
template <>
inline constexpr guid
    guid_v<winrt::Microsoft::UI::Input::IWindowRectChangingEventArgs>{
        0xDB13ED3C,
        0xDEBC,
        0x5855,
        {0x8D, 0x70, 0x59, 0x36, 0xFD, 0x81, 0x34,
         0x57}};  // DB13ED3C-DEBC-5855-8D70-5936FD813457
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::CharacterReceivedEventArgs> {
  using type = winrt::Microsoft::UI::Input::ICharacterReceivedEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::ContextMenuKeyEventArgs> {
  using type = winrt::Microsoft::UI::Input::IContextMenuKeyEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::CrossSlidingEventArgs> {
  using type = winrt::Microsoft::UI::Input::ICrossSlidingEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::DraggingEventArgs> {
  using type = winrt::Microsoft::UI::Input::IDraggingEventArgs;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::EnteredMoveSizeEventArgs> {
  using type = winrt::Microsoft::UI::Input::IEnteredMoveSizeEventArgs;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::EnteringMoveSizeEventArgs> {
  using type = winrt::Microsoft::UI::Input::IEnteringMoveSizeEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::ExitedMoveSizeEventArgs> {
  using type = winrt::Microsoft::UI::Input::IExitedMoveSizeEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::FocusChangedEventArgs> {
  using type = winrt::Microsoft::UI::Input::IFocusChangedEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::FocusNavigationRequest> {
  using type = winrt::Microsoft::UI::Input::IFocusNavigationRequest;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::FocusNavigationRequestEventArgs> {
  using type = winrt::Microsoft::UI::Input::IFocusNavigationRequestEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::GestureRecognizer> {
  using type = winrt::Microsoft::UI::Input::IGestureRecognizer;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::HoldingEventArgs> {
  using type = winrt::Microsoft::UI::Input::IHoldingEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::InputActivationListener> {
  using type = winrt::Microsoft::UI::Input::IInputActivationListener;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::
        InputActivationListenerActivationChangedEventArgs> {
  using type = winrt::Microsoft::UI::Input::
      IInputActivationListenerActivationChangedEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::InputCursor> {
  using type = winrt::Microsoft::UI::Input::IInputCursor;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::InputCustomCursor> {
  using type = winrt::Microsoft::UI::Input::IInputCustomCursor;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::InputDesktopNamedResourceCursor> {
  using type = winrt::Microsoft::UI::Input::IInputDesktopNamedResourceCursor;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::InputDesktopResourceCursor> {
  using type = winrt::Microsoft::UI::Input::IInputDesktopResourceCursor;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::InputFocusController> {
  using type = winrt::Microsoft::UI::Input::IInputFocusController;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::InputFocusNavigationHost> {
  using type = winrt::Microsoft::UI::Input::IInputFocusNavigationHost;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::InputKeyboardSource> {
  using type = winrt::Microsoft::UI::Input::IInputKeyboardSource;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::InputLightDismissAction> {
  using type = winrt::Microsoft::UI::Input::IInputLightDismissAction;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::InputLightDismissEventArgs> {
  using type = winrt::Microsoft::UI::Input::IInputLightDismissEventArgs;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::InputNonClientPointerSource> {
  using type = winrt::Microsoft::UI::Input::IInputNonClientPointerSource;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::InputObject> {
  using type = winrt::Microsoft::UI::Input::IInputObject;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::InputPointerSource> {
  using type = winrt::Microsoft::UI::Input::IInputPointerSource;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::InputPreTranslateKeyboardSource> {
  using type = winrt::Microsoft::UI::Input::IInputPreTranslateKeyboardSource;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::InputSystemCursor> {
  using type = winrt::Microsoft::UI::Input::IInputSystemCursor;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::KeyEventArgs> {
  using type = winrt::Microsoft::UI::Input::IKeyEventArgs;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::ManipulationCompletedEventArgs> {
  using type = winrt::Microsoft::UI::Input::IManipulationCompletedEventArgs;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::ManipulationInertiaStartingEventArgs> {
  using type =
      winrt::Microsoft::UI::Input::IManipulationInertiaStartingEventArgs;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::ManipulationStartedEventArgs> {
  using type = winrt::Microsoft::UI::Input::IManipulationStartedEventArgs;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::ManipulationUpdatedEventArgs> {
  using type = winrt::Microsoft::UI::Input::IManipulationUpdatedEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::MouseWheelParameters> {
  using type = winrt::Microsoft::UI::Input::IMouseWheelParameters;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::NonClientCaptionTappedEventArgs> {
  using type = winrt::Microsoft::UI::Input::INonClientCaptionTappedEventArgs;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::NonClientPointerEventArgs> {
  using type = winrt::Microsoft::UI::Input::INonClientPointerEventArgs;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::NonClientRegionsChangedEventArgs> {
  using type = winrt::Microsoft::UI::Input::INonClientRegionsChangedEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::PointerEventArgs> {
  using type = winrt::Microsoft::UI::Input::IPointerEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::PointerPoint> {
  using type = winrt::Microsoft::UI::Input::IPointerPoint;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::PointerPointProperties> {
  using type = winrt::Microsoft::UI::Input::IPointerPointProperties;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::PointerPredictor> {
  using type = winrt::Microsoft::UI::Input::IPointerPredictor;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::RightTappedEventArgs> {
  using type = winrt::Microsoft::UI::Input::IRightTappedEventArgs;
};
template <>
struct default_interface<winrt::Microsoft::UI::Input::TappedEventArgs> {
  using type = winrt::Microsoft::UI::Input::ITappedEventArgs;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::WindowRectChangedEventArgs> {
  using type = winrt::Microsoft::UI::Input::IWindowRectChangedEventArgs;
};
template <>
struct default_interface<
    winrt::Microsoft::UI::Input::WindowRectChangingEventArgs> {
  using type = winrt::Microsoft::UI::Input::IWindowRectChangingEventArgs;
};
template <>
struct abi<winrt::Microsoft::UI::Input::ICharacterReceivedEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Handled(bool*) noexcept = 0;
    virtual int32_t __stdcall put_Handled(bool) noexcept = 0;
    virtual int32_t __stdcall get_KeyCode(uint32_t*) noexcept = 0;
    virtual int32_t __stdcall get_KeyStatus(
        struct struct_Microsoft_UI_Input_PhysicalKeyStatus*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IContextMenuKeyEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Handled(bool*) noexcept = 0;
    virtual int32_t __stdcall put_Handled(bool) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::ICrossSlidingEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_CrossSlidingState(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Position(
        winrt::Windows::Foundation::Point*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IDraggingEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_DraggingState(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Position(
        winrt::Windows::Foundation::Point*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IEnteredMoveSizeEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_PointerScreenPoint(
        struct struct_Windows_Graphics_PointInt32*) noexcept = 0;
    virtual int32_t __stdcall get_MoveSizeOperation(int32_t*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IEnteringMoveSizeEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_PointerScreenPoint(
        struct struct_Windows_Graphics_PointInt32*) noexcept = 0;
    virtual int32_t __stdcall get_MoveSizeOperation(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_MoveSizeWindowId(
        struct struct_Microsoft_UI_WindowId*) noexcept = 0;
    virtual int32_t __stdcall put_MoveSizeWindowId(
        struct struct_Microsoft_UI_WindowId) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IExitedMoveSizeEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_PointerScreenPoint(
        struct struct_Windows_Graphics_PointInt32*) noexcept = 0;
    virtual int32_t __stdcall get_MoveSizeOperation(int32_t*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IFocusChangedEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Handled(bool*) noexcept = 0;
    virtual int32_t __stdcall put_Handled(bool) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IFocusNavigationRequest> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_CorrelationId(winrt::guid*) noexcept = 0;
    virtual int32_t __stdcall get_HintRect(void**) noexcept = 0;
    virtual int32_t __stdcall get_Reason(int32_t*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IFocusNavigationRequestEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Request(void**) noexcept = 0;
    virtual int32_t __stdcall get_Result(int32_t*) noexcept = 0;
    virtual int32_t __stdcall put_Result(int32_t) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IFocusNavigationRequestStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall Create(int32_t, void**) noexcept = 0;
    virtual int32_t __stdcall CreateWithHintRect(
        int32_t, winrt::Windows::Foundation::Rect, void**) noexcept = 0;
    virtual int32_t __stdcall CreateWithHintRectAndId(
        int32_t, winrt::Windows::Foundation::Rect, winrt::guid,
        void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IGestureRecognizer> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_AutoProcessInertia(bool*) noexcept = 0;
    virtual int32_t __stdcall put_AutoProcessInertia(bool) noexcept = 0;
    virtual int32_t __stdcall get_CrossSlideExact(bool*) noexcept = 0;
    virtual int32_t __stdcall put_CrossSlideExact(bool) noexcept = 0;
    virtual int32_t __stdcall get_CrossSlideHorizontally(bool*) noexcept = 0;
    virtual int32_t __stdcall put_CrossSlideHorizontally(bool) noexcept = 0;
    virtual int32_t __stdcall get_CrossSlideThresholds(
        struct struct_Microsoft_UI_Input_CrossSlideThresholds*) noexcept = 0;
    virtual int32_t __stdcall put_CrossSlideThresholds(
        struct struct_Microsoft_UI_Input_CrossSlideThresholds) noexcept = 0;
    virtual int32_t __stdcall get_GestureSettings(uint32_t*) noexcept = 0;
    virtual int32_t __stdcall put_GestureSettings(uint32_t) noexcept = 0;
    virtual int32_t __stdcall get_IsActive(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsInertial(bool*) noexcept = 0;
    virtual int32_t __stdcall get_PivotCenter(
        winrt::Windows::Foundation::Point*) noexcept = 0;
    virtual int32_t __stdcall put_PivotCenter(
        winrt::Windows::Foundation::Point) noexcept = 0;
    virtual int32_t __stdcall get_PivotRadius(float*) noexcept = 0;
    virtual int32_t __stdcall put_PivotRadius(float) noexcept = 0;
    virtual int32_t __stdcall get_InertiaExpansionDeceleration(
        float*) noexcept = 0;
    virtual int32_t __stdcall put_InertiaExpansionDeceleration(
        float) noexcept = 0;
    virtual int32_t __stdcall get_InertiaExpansion(float*) noexcept = 0;
    virtual int32_t __stdcall put_InertiaExpansion(float) noexcept = 0;
    virtual int32_t __stdcall get_InertiaRotationAngle(float*) noexcept = 0;
    virtual int32_t __stdcall put_InertiaRotationAngle(float) noexcept = 0;
    virtual int32_t __stdcall get_InertiaRotationDeceleration(
        float*) noexcept = 0;
    virtual int32_t __stdcall put_InertiaRotationDeceleration(
        float) noexcept = 0;
    virtual int32_t __stdcall get_InertiaTranslationDeceleration(
        float*) noexcept = 0;
    virtual int32_t __stdcall put_InertiaTranslationDeceleration(
        float) noexcept = 0;
    virtual int32_t __stdcall get_InertiaTranslationDisplacement(
        float*) noexcept = 0;
    virtual int32_t __stdcall put_InertiaTranslationDisplacement(
        float) noexcept = 0;
    virtual int32_t __stdcall get_ManipulationExact(bool*) noexcept = 0;
    virtual int32_t __stdcall put_ManipulationExact(bool) noexcept = 0;
    virtual int32_t __stdcall get_MouseWheelParameters(void**) noexcept = 0;
    virtual int32_t __stdcall get_ShowGestureFeedback(bool*) noexcept = 0;
    virtual int32_t __stdcall put_ShowGestureFeedback(bool) noexcept = 0;
    virtual int32_t __stdcall CanBeDoubleTap(void*, bool*) noexcept = 0;
    virtual int32_t __stdcall CompleteGesture() noexcept = 0;
    virtual int32_t __stdcall ProcessDownEvent(void*) noexcept = 0;
    virtual int32_t __stdcall ProcessMoveEvents(void*) noexcept = 0;
    virtual int32_t __stdcall ProcessMouseWheelEvent(void*, bool,
                                                     bool) noexcept = 0;
    virtual int32_t __stdcall ProcessInertia() noexcept = 0;
    virtual int32_t __stdcall ProcessUpEvent(void*) noexcept = 0;
    virtual int32_t __stdcall add_Tapped(void*,
                                         winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_Tapped(winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_RightTapped(void*,
                                              winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_RightTapped(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_Holding(void*,
                                          winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_Holding(winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_Dragging(void*,
                                           winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_Dragging(winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_ManipulationStarted(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_ManipulationStarted(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_ManipulationUpdated(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_ManipulationUpdated(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_ManipulationInertiaStarting(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_ManipulationInertiaStarting(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_ManipulationCompleted(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_ManipulationCompleted(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_CrossSliding(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_CrossSliding(
        winrt::event_token) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IHoldingEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_HoldingState(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Position(
        winrt::Windows::Foundation::Point*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputActivationListener> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_State(int32_t*) noexcept = 0;
    virtual int32_t __stdcall add_InputActivationChanged(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_InputActivationChanged(
        winrt::event_token) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::
               IInputActivationListenerActivationChangedEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {};
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputActivationListenerStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetForWindowId(
        struct struct_Microsoft_UI_WindowId, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputActivationListenerStatics2> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetForIsland(void*, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputCursor> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {};
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputCursorFactory> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {};
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputCursorStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall CreateFromCoreCursor(void*, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputCustomCursor> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {};
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputCustomCursorFactory> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {};
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputDesktopNamedResourceCursor> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_ModuleName(void**) noexcept = 0;
    virtual int32_t __stdcall get_ResourceName(void**) noexcept = 0;
  };
};
template <>
struct abi<
    winrt::Microsoft::UI::Input::IInputDesktopNamedResourceCursorStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall Create(void*, void**) noexcept = 0;
    virtual int32_t __stdcall CreateFromModule(void*, void*,
                                               void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputDesktopResourceCursor> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_ModuleName(void**) noexcept = 0;
    virtual int32_t __stdcall get_ResourceId(uint32_t*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputDesktopResourceCursorStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall Create(uint32_t, void**) noexcept = 0;
    virtual int32_t __stdcall CreateFromModule(void*, uint32_t,
                                               void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputFocusController> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_HasFocus(bool*) noexcept = 0;
    virtual int32_t __stdcall TrySetFocus(bool*) noexcept = 0;
    virtual int32_t __stdcall add_GotFocus(void*,
                                           winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_GotFocus(winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_LostFocus(void*,
                                            winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_LostFocus(winrt::event_token) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputFocusController2> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall DepartFocus(void*, int32_t*) noexcept = 0;
    virtual int32_t __stdcall add_NavigateFocusRequested(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_NavigateFocusRequested(
        winrt::event_token) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputFocusControllerStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetForIsland(void*, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputFocusNavigationHost> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_ContainsFocus(bool*) noexcept = 0;
    virtual int32_t __stdcall NavigateFocus(void*, int32_t*) noexcept = 0;
    virtual int32_t __stdcall add_DepartFocusRequested(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_DepartFocusRequested(
        winrt::event_token) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputFocusNavigationHostStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetForSiteBridge(void*, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputFocusNavigationHostStatics2> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetForSiteLink(void*, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputKeyboardSource> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {};
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputKeyboardSource2> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetCurrentKeyState(int32_t,
                                                 uint32_t*) noexcept = 0;
    virtual int32_t __stdcall GetKeyState(int32_t, uint32_t*) noexcept = 0;
    virtual int32_t __stdcall add_CharacterReceived(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_CharacterReceived(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_ContextMenuKey(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_ContextMenuKey(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_KeyDown(void*,
                                          winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_KeyDown(winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_KeyUp(void*,
                                        winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_KeyUp(winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_SystemKeyDown(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_SystemKeyDown(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_SystemKeyUp(void*,
                                              winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_SystemKeyUp(
        winrt::event_token) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputKeyboardSourceStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetKeyStateForCurrentThread(
        int32_t, uint32_t*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputKeyboardSourceStatics2> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetForIsland(void*, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputLightDismissAction> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall add_Dismissed(void*,
                                            winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_Dismissed(winrt::event_token) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputLightDismissActionStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetForWindowId(
        struct struct_Microsoft_UI_WindowId, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputLightDismissEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {};
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputNonClientPointerSource> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_DispatcherQueue(void**) noexcept = 0;
    virtual int32_t __stdcall ClearAllRegionRects() noexcept = 0;
    virtual int32_t __stdcall ClearRegionRects(int32_t) noexcept = 0;
    virtual int32_t __stdcall GetRegionRects(
        int32_t, uint32_t* __resultSize,
        struct struct_Windows_Graphics_RectInt32**) noexcept = 0;
    virtual int32_t __stdcall SetRegionRects(
        int32_t, uint32_t,
        struct struct_Windows_Graphics_RectInt32*) noexcept = 0;
    virtual int32_t __stdcall add_CaptionTapped(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_CaptionTapped(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerEntered(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerEntered(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerExited(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerExited(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerMoved(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerMoved(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerPressed(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerPressed(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerReleased(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerReleased(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_RegionsChanged(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_RegionsChanged(
        winrt::event_token) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputNonClientPointerSource2> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall add_EnteringMoveSize(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_EnteringMoveSize(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_EnteredMoveSize(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_EnteredMoveSize(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_WindowRectChanging(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_WindowRectChanging(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_WindowRectChanged(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_WindowRectChanged(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_ExitedMoveSize(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_ExitedMoveSize(
        winrt::event_token) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputNonClientPointerSourceStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetForWindowId(
        struct struct_Microsoft_UI_WindowId, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputObject> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_DispatcherQueue(void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputObjectFactory> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {};
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputPointerSource> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Cursor(void**) noexcept = 0;
    virtual int32_t __stdcall put_Cursor(void*) noexcept = 0;
    virtual int32_t __stdcall get_DeviceKinds(uint32_t*) noexcept = 0;
    virtual int32_t __stdcall add_PointerCaptureLost(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerCaptureLost(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerEntered(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerEntered(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerExited(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerExited(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerMoved(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerMoved(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerPressed(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerPressed(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerReleased(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerReleased(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerRoutedAway(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerRoutedAway(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerRoutedReleased(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerRoutedReleased(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerRoutedTo(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerRoutedTo(
        winrt::event_token) noexcept = 0;
    virtual int32_t __stdcall add_PointerWheelChanged(
        void*, winrt::event_token*) noexcept = 0;
    virtual int32_t __stdcall remove_PointerWheelChanged(
        winrt::event_token) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputPointerSourceStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetForIsland(void*, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputPreTranslateKeyboardSource> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {};
};
template <>
struct abi<
    winrt::Microsoft::UI::Input::IInputPreTranslateKeyboardSourceStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall GetForIsland(void*, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputSystemCursor> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_CursorShape(int32_t*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IInputSystemCursorStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall Create(int32_t, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IKeyEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Handled(bool*) noexcept = 0;
    virtual int32_t __stdcall put_Handled(bool) noexcept = 0;
    virtual int32_t __stdcall get_KeyStatus(
        struct struct_Microsoft_UI_Input_PhysicalKeyStatus*) noexcept = 0;
    virtual int32_t __stdcall get_Timestamp(uint64_t*) noexcept = 0;
    virtual int32_t __stdcall get_VirtualKey(int32_t*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IManipulationCompletedEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Cumulative(
        struct struct_Microsoft_UI_Input_ManipulationDelta*) noexcept = 0;
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Position(
        winrt::Windows::Foundation::Point*) noexcept = 0;
    virtual int32_t __stdcall get_Velocities(
        struct struct_Microsoft_UI_Input_ManipulationVelocities*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IManipulationInertiaStartingEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Cumulative(
        struct struct_Microsoft_UI_Input_ManipulationDelta*) noexcept = 0;
    virtual int32_t __stdcall get_Delta(
        struct struct_Microsoft_UI_Input_ManipulationDelta*) noexcept = 0;
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Position(
        winrt::Windows::Foundation::Point*) noexcept = 0;
    virtual int32_t __stdcall get_Velocities(
        struct struct_Microsoft_UI_Input_ManipulationVelocities*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IManipulationStartedEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Cumulative(
        struct struct_Microsoft_UI_Input_ManipulationDelta*) noexcept = 0;
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Position(
        winrt::Windows::Foundation::Point*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IManipulationUpdatedEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Cumulative(
        struct struct_Microsoft_UI_Input_ManipulationDelta*) noexcept = 0;
    virtual int32_t __stdcall get_Delta(
        struct struct_Microsoft_UI_Input_ManipulationDelta*) noexcept = 0;
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Position(
        winrt::Windows::Foundation::Point*) noexcept = 0;
    virtual int32_t __stdcall get_Velocities(
        struct struct_Microsoft_UI_Input_ManipulationVelocities*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IMouseWheelParameters> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_CharTranslation(
        winrt::Windows::Foundation::Point*) noexcept = 0;
    virtual int32_t __stdcall put_CharTranslation(
        winrt::Windows::Foundation::Point) noexcept = 0;
    virtual int32_t __stdcall get_DeltaScale(float*) noexcept = 0;
    virtual int32_t __stdcall put_DeltaScale(float) noexcept = 0;
    virtual int32_t __stdcall get_DeltaRotationAngle(float*) noexcept = 0;
    virtual int32_t __stdcall put_DeltaRotationAngle(float) noexcept = 0;
    virtual int32_t __stdcall get_PageTranslation(
        winrt::Windows::Foundation::Point*) noexcept = 0;
    virtual int32_t __stdcall put_PageTranslation(
        winrt::Windows::Foundation::Point) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::INonClientCaptionTappedEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Point(
        winrt::Windows::Foundation::Point*) noexcept = 0;
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::INonClientPointerEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Point(
        winrt::Windows::Foundation::Point*) noexcept = 0;
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_RegionKind(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_IsPointInRegion(bool*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::INonClientRegionsChangedEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_ChangedRegions(uint32_t* __valueSize,
                                                 int32_t**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IPointerEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_CurrentPoint(void**) noexcept = 0;
    virtual int32_t __stdcall get_Handled(bool*) noexcept = 0;
    virtual int32_t __stdcall put_Handled(bool) noexcept = 0;
    virtual int32_t __stdcall get_KeyModifiers(uint32_t*) noexcept = 0;
    virtual int32_t __stdcall GetIntermediatePoints(void**) noexcept = 0;
    virtual int32_t __stdcall GetIntermediateTransformedPoints(
        void*, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IPointerPoint> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_FrameId(uint32_t*) noexcept = 0;
    virtual int32_t __stdcall get_IsInContact(bool*) noexcept = 0;
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_PointerId(uint32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Position(
        winrt::Windows::Foundation::Point*) noexcept = 0;
    virtual int32_t __stdcall get_Properties(void**) noexcept = 0;
    virtual int32_t __stdcall get_Timestamp(uint64_t*) noexcept = 0;
    virtual int32_t __stdcall GetTransformedPoint(void*, void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IPointerPointProperties> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_ContactRect(
        winrt::Windows::Foundation::Rect*) noexcept = 0;
    virtual int32_t __stdcall get_IsBarrelButtonPressed(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsCanceled(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsEraser(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsHorizontalMouseWheel(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsInRange(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsInverted(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsLeftButtonPressed(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsMiddleButtonPressed(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsPrimary(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsRightButtonPressed(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsXButton1Pressed(bool*) noexcept = 0;
    virtual int32_t __stdcall get_IsXButton2Pressed(bool*) noexcept = 0;
    virtual int32_t __stdcall get_MouseWheelDelta(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Orientation(float*) noexcept = 0;
    virtual int32_t __stdcall get_PointerUpdateKind(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Pressure(float*) noexcept = 0;
    virtual int32_t __stdcall get_TouchConfidence(bool*) noexcept = 0;
    virtual int32_t __stdcall get_Twist(float*) noexcept = 0;
    virtual int32_t __stdcall get_XTilt(float*) noexcept = 0;
    virtual int32_t __stdcall get_YTilt(float*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IPointerPointTransform> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_Inverse(void**) noexcept = 0;
    virtual int32_t __stdcall TryTransform(winrt::Windows::Foundation::Point,
                                           winrt::Windows::Foundation::Point*,
                                           bool*) noexcept = 0;
    virtual int32_t __stdcall TryTransformBounds(
        winrt::Windows::Foundation::Rect, winrt::Windows::Foundation::Rect*,
        bool*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IPointerPredictor> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_PredictionTime(int64_t*) noexcept = 0;
    virtual int32_t __stdcall put_PredictionTime(int64_t) noexcept = 0;
    virtual int32_t __stdcall GetPredictedPoints(void*, uint32_t* __resultSize,
                                                 void***) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IPointerPredictorStatics> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall CreateForInputPointerSource(void*,
                                                          void**) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IRightTappedEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Position(
        winrt::Windows::Foundation::Point*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::ITappedEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_PointerDeviceType(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_Position(
        winrt::Windows::Foundation::Point*) noexcept = 0;
    virtual int32_t __stdcall get_TapCount(uint32_t*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IWindowRectChangedEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_PointerScreenPoint(
        struct struct_Windows_Graphics_PointInt32*) noexcept = 0;
    virtual int32_t __stdcall get_MoveSizeOperation(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_OldWindowRect(
        struct struct_Windows_Graphics_RectInt32*) noexcept = 0;
    virtual int32_t __stdcall get_NewWindowRect(
        struct struct_Windows_Graphics_RectInt32*) noexcept = 0;
  };
};
template <>
struct abi<winrt::Microsoft::UI::Input::IWindowRectChangingEventArgs> {
  struct WINRT_IMPL_NOVTABLE type : inspectable_abi {
    virtual int32_t __stdcall get_PointerScreenPoint(
        struct struct_Windows_Graphics_PointInt32*) noexcept = 0;
    virtual int32_t __stdcall get_MoveSizeOperation(int32_t*) noexcept = 0;
    virtual int32_t __stdcall get_OldWindowRect(
        struct struct_Windows_Graphics_RectInt32*) noexcept = 0;
    virtual int32_t __stdcall get_NewWindowRect(
        struct struct_Windows_Graphics_RectInt32*) noexcept = 0;
    virtual int32_t __stdcall put_NewWindowRect(
        struct struct_Windows_Graphics_RectInt32) noexcept = 0;
    virtual int32_t __stdcall get_AllowRectChange(bool*) noexcept = 0;
    virtual int32_t __stdcall put_AllowRectChange(bool) noexcept = 0;
    virtual int32_t __stdcall get_ShowWindow(bool*) noexcept = 0;
    virtual int32_t __stdcall put_ShowWindow(bool) noexcept = 0;
  };
};
template <typename D>
struct consume_Microsoft_UI_Input_ICharacterReceivedEventArgs {
  [[nodiscard]] auto Handled() const;
  auto Handled(bool value) const;
  [[nodiscard]] auto KeyCode() const;
  [[nodiscard]] auto KeyStatus() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::ICharacterReceivedEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_ICharacterReceivedEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IContextMenuKeyEventArgs {
  [[nodiscard]] auto Handled() const;
  auto Handled(bool value) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IContextMenuKeyEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IContextMenuKeyEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_ICrossSlidingEventArgs {
  [[nodiscard]] auto CrossSlidingState() const;
  [[nodiscard]] auto PointerDeviceType() const;
  [[nodiscard]] auto Position() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::ICrossSlidingEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_ICrossSlidingEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IDraggingEventArgs {
  [[nodiscard]] auto DraggingState() const;
  [[nodiscard]] auto PointerDeviceType() const;
  [[nodiscard]] auto Position() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IDraggingEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IDraggingEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IEnteredMoveSizeEventArgs {
  [[nodiscard]] auto PointerScreenPoint() const;
  [[nodiscard]] auto MoveSizeOperation() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IEnteredMoveSizeEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IEnteredMoveSizeEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IEnteringMoveSizeEventArgs {
  [[nodiscard]] auto PointerScreenPoint() const;
  [[nodiscard]] auto MoveSizeOperation() const;
  [[nodiscard]] auto MoveSizeWindowId() const;
  auto MoveSizeWindowId(winrt::Microsoft::UI::WindowId const& value) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IEnteringMoveSizeEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IEnteringMoveSizeEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IExitedMoveSizeEventArgs {
  [[nodiscard]] auto PointerScreenPoint() const;
  [[nodiscard]] auto MoveSizeOperation() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IExitedMoveSizeEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IExitedMoveSizeEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IFocusChangedEventArgs {
  [[nodiscard]] auto Handled() const;
  auto Handled(bool value) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IFocusChangedEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IFocusChangedEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IFocusNavigationRequest {
  [[nodiscard]] auto CorrelationId() const;
  [[nodiscard]] auto HintRect() const;
  [[nodiscard]] auto Reason() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IFocusNavigationRequest> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IFocusNavigationRequest<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IFocusNavigationRequestEventArgs {
  [[nodiscard]] auto Request() const;
  [[nodiscard]] auto Result() const;
  auto Result(
      winrt::Microsoft::UI::Input::FocusNavigationResult const& value) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IFocusNavigationRequestEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IFocusNavigationRequestEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IFocusNavigationRequestStatics {
  auto Create(
      winrt::Microsoft::UI::Input::FocusNavigationReason const& reason) const;
  auto Create(winrt::Microsoft::UI::Input::FocusNavigationReason const& reason,
              winrt::Windows::Foundation::Rect const& hintRect) const;
  auto Create(winrt::Microsoft::UI::Input::FocusNavigationReason const& reason,
              winrt::Windows::Foundation::Rect const& hintRect,
              winrt::guid const& correlationId) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IFocusNavigationRequestStatics> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IFocusNavigationRequestStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IGestureRecognizer {
  [[nodiscard]] auto AutoProcessInertia() const;
  auto AutoProcessInertia(bool value) const;
  [[nodiscard]] auto CrossSlideExact() const;
  auto CrossSlideExact(bool value) const;
  [[nodiscard]] auto CrossSlideHorizontally() const;
  auto CrossSlideHorizontally(bool value) const;
  [[nodiscard]] auto CrossSlideThresholds() const;
  auto CrossSlideThresholds(
      winrt::Microsoft::UI::Input::CrossSlideThresholds const& value) const;
  [[nodiscard]] auto GestureSettings() const;
  auto GestureSettings(
      winrt::Microsoft::UI::Input::GestureSettings const& value) const;
  [[nodiscard]] auto IsActive() const;
  [[nodiscard]] auto IsInertial() const;
  [[nodiscard]] auto PivotCenter() const;
  auto PivotCenter(winrt::Windows::Foundation::Point const& value) const;
  [[nodiscard]] auto PivotRadius() const;
  auto PivotRadius(float value) const;
  [[nodiscard]] auto InertiaExpansionDeceleration() const;
  auto InertiaExpansionDeceleration(float value) const;
  [[nodiscard]] auto InertiaExpansion() const;
  auto InertiaExpansion(float value) const;
  [[nodiscard]] auto InertiaRotationAngle() const;
  auto InertiaRotationAngle(float value) const;
  [[nodiscard]] auto InertiaRotationDeceleration() const;
  auto InertiaRotationDeceleration(float value) const;
  [[nodiscard]] auto InertiaTranslationDeceleration() const;
  auto InertiaTranslationDeceleration(float value) const;
  [[nodiscard]] auto InertiaTranslationDisplacement() const;
  auto InertiaTranslationDisplacement(float value) const;
  [[nodiscard]] auto ManipulationExact() const;
  auto ManipulationExact(bool value) const;
  [[nodiscard]] auto MouseWheelParameters() const;
  [[nodiscard]] auto ShowGestureFeedback() const;
  auto ShowGestureFeedback(bool value) const;
  auto CanBeDoubleTap(
      winrt::Microsoft::UI::Input::PointerPoint const& value) const;
  auto CompleteGesture() const;
  auto ProcessDownEvent(
      winrt::Microsoft::UI::Input::PointerPoint const& value) const;
  auto ProcessMoveEvents(
      param::vector<winrt::Microsoft::UI::Input::PointerPoint> const& value)
      const;
  auto ProcessMouseWheelEvent(
      winrt::Microsoft::UI::Input::PointerPoint const& value,
      bool isShiftKeyDown, bool isControlKeyDown) const;
  auto ProcessInertia() const;
  auto ProcessUpEvent(
      winrt::Microsoft::UI::Input::PointerPoint const& value) const;
  auto Tapped(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::TappedEventArgs> const& handler) const;
  using Tapped_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IGestureRecognizer,
      &impl::abi_t<
          winrt::Microsoft::UI::Input::IGestureRecognizer>::remove_Tapped>;
  [[nodiscard]] auto Tapped(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::TappedEventArgs> const& handler) const;
  auto Tapped(winrt::event_token const& token) const noexcept;
  auto RightTapped(winrt::Windows::Foundation::TypedEventHandler<
                   winrt::Microsoft::UI::Input::GestureRecognizer,
                   winrt::Microsoft::UI::Input::RightTappedEventArgs> const&
                       handler) const;
  using RightTapped_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IGestureRecognizer,
      &impl::abi_t<
          winrt::Microsoft::UI::Input::IGestureRecognizer>::remove_RightTapped>;
  [[nodiscard]] auto RightTapped(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::RightTappedEventArgs> const& handler)
      const;
  auto RightTapped(winrt::event_token const& token) const noexcept;
  auto Holding(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::HoldingEventArgs> const& handler) const;
  using Holding_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IGestureRecognizer,
      &impl::abi_t<
          winrt::Microsoft::UI::Input::IGestureRecognizer>::remove_Holding>;
  [[nodiscard]] auto Holding(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::HoldingEventArgs> const& handler) const;
  auto Holding(winrt::event_token const& token) const noexcept;
  auto Dragging(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::DraggingEventArgs> const& handler) const;
  using Dragging_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IGestureRecognizer,
      &impl::abi_t<
          winrt::Microsoft::UI::Input::IGestureRecognizer>::remove_Dragging>;
  [[nodiscard]] auto Dragging(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::DraggingEventArgs> const& handler) const;
  auto Dragging(winrt::event_token const& token) const noexcept;
  auto ManipulationStarted(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::ManipulationStartedEventArgs> const&
          handler) const;
  using ManipulationStarted_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IGestureRecognizer,
      &impl::abi_t<winrt::Microsoft::UI::Input::IGestureRecognizer>::
          remove_ManipulationStarted>;
  [[nodiscard]] auto ManipulationStarted(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::ManipulationStartedEventArgs> const&
          handler) const;
  auto ManipulationStarted(winrt::event_token const& token) const noexcept;
  auto ManipulationUpdated(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::ManipulationUpdatedEventArgs> const&
          handler) const;
  using ManipulationUpdated_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IGestureRecognizer,
      &impl::abi_t<winrt::Microsoft::UI::Input::IGestureRecognizer>::
          remove_ManipulationUpdated>;
  [[nodiscard]] auto ManipulationUpdated(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::ManipulationUpdatedEventArgs> const&
          handler) const;
  auto ManipulationUpdated(winrt::event_token const& token) const noexcept;
  auto ManipulationInertiaStarting(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::
              ManipulationInertiaStartingEventArgs> const& handler) const;
  using ManipulationInertiaStarting_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IGestureRecognizer,
      &impl::abi_t<winrt::Microsoft::UI::Input::IGestureRecognizer>::
          remove_ManipulationInertiaStarting>;
  [[nodiscard]] auto ManipulationInertiaStarting(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::
              ManipulationInertiaStartingEventArgs> const& handler) const;
  auto ManipulationInertiaStarting(
      winrt::event_token const& token) const noexcept;
  auto ManipulationCompleted(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::ManipulationCompletedEventArgs> const&
          handler) const;
  using ManipulationCompleted_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IGestureRecognizer,
      &impl::abi_t<winrt::Microsoft::UI::Input::IGestureRecognizer>::
          remove_ManipulationCompleted>;
  [[nodiscard]] auto ManipulationCompleted(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::ManipulationCompletedEventArgs> const&
          handler) const;
  auto ManipulationCompleted(winrt::event_token const& token) const noexcept;
  auto CrossSliding(winrt::Windows::Foundation::TypedEventHandler<
                    winrt::Microsoft::UI::Input::GestureRecognizer,
                    winrt::Microsoft::UI::Input::CrossSlidingEventArgs> const&
                        handler) const;
  using CrossSliding_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IGestureRecognizer,
      &impl::abi_t<winrt::Microsoft::UI::Input::IGestureRecognizer>::
          remove_CrossSliding>;
  [[nodiscard]] auto CrossSliding(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::GestureRecognizer,
          winrt::Microsoft::UI::Input::CrossSlidingEventArgs> const& handler)
      const;
  auto CrossSliding(winrt::event_token const& token) const noexcept;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IGestureRecognizer> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IGestureRecognizer<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IHoldingEventArgs {
  [[nodiscard]] auto HoldingState() const;
  [[nodiscard]] auto PointerDeviceType() const;
  [[nodiscard]] auto Position() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IHoldingEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IHoldingEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputActivationListener {
  [[nodiscard]] auto State() const;
  auto InputActivationChanged(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputActivationListener,
          winrt::Microsoft::UI::Input::
              InputActivationListenerActivationChangedEventArgs> const& handler)
      const;
  using InputActivationChanged_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputActivationListener,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputActivationListener>::
          remove_InputActivationChanged>;
  [[nodiscard]] auto InputActivationChanged(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputActivationListener,
          winrt::Microsoft::UI::Input::
              InputActivationListenerActivationChangedEventArgs> const& handler)
      const;
  auto InputActivationChanged(winrt::event_token const& token) const noexcept;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputActivationListener> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputActivationListener<D>;
};
template <typename D>
struct
    consume_Microsoft_UI_Input_IInputActivationListenerActivationChangedEventArgs {
};
template <>
struct consume<winrt::Microsoft::UI::Input::
                   IInputActivationListenerActivationChangedEventArgs> {
  template <typename D>
  using type =
      consume_Microsoft_UI_Input_IInputActivationListenerActivationChangedEventArgs<
          D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputActivationListenerStatics {
  auto GetForWindowId(winrt::Microsoft::UI::WindowId const& windowId) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputActivationListenerStatics> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputActivationListenerStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputActivationListenerStatics2 {
  auto GetForIsland(
      winrt::Microsoft::UI::Content::ContentIsland const& island) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputActivationListenerStatics2> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputActivationListenerStatics2<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputCursor {};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputCursor> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputCursor<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputCursorFactory {};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputCursorFactory> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputCursorFactory<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputCursorStatics {
  auto CreateFromCoreCursor(
      winrt::Windows::UI::Core::CoreCursor const& cursor) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputCursorStatics> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputCursorStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputCustomCursor {};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputCustomCursor> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputCustomCursor<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputCustomCursorFactory {};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputCustomCursorFactory> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputCustomCursorFactory<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputDesktopNamedResourceCursor {
  [[nodiscard]] auto ModuleName() const;
  [[nodiscard]] auto ResourceName() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputDesktopNamedResourceCursor> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputDesktopNamedResourceCursor<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputDesktopNamedResourceCursorStatics {
  auto Create(param::hstring const& resourceName) const;
  auto CreateFromModule(param::hstring const& moduleName,
                        param::hstring const& resourceName) const;
};
template <>
struct consume<
    winrt::Microsoft::UI::Input::IInputDesktopNamedResourceCursorStatics> {
  template <typename D>
  using type =
      consume_Microsoft_UI_Input_IInputDesktopNamedResourceCursorStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputDesktopResourceCursor {
  [[nodiscard]] auto ModuleName() const;
  [[nodiscard]] auto ResourceId() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputDesktopResourceCursor> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputDesktopResourceCursor<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputDesktopResourceCursorStatics {
  auto Create(uint32_t resourceId) const;
  auto CreateFromModule(param::hstring const& moduleName,
                        uint32_t resourceId) const;
};
template <>
struct consume<
    winrt::Microsoft::UI::Input::IInputDesktopResourceCursorStatics> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputDesktopResourceCursorStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputFocusController {
  [[nodiscard]] auto HasFocus() const;
  auto TrySetFocus() const;
  auto GotFocus(winrt::Windows::Foundation::TypedEventHandler<
                winrt::Microsoft::UI::Input::InputFocusController,
                winrt::Microsoft::UI::Input::FocusChangedEventArgs> const&
                    handler) const;
  using GotFocus_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputFocusController,
      &impl::abi_t<
          winrt::Microsoft::UI::Input::IInputFocusController>::remove_GotFocus>;
  [[nodiscard]] auto GotFocus(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputFocusController,
          winrt::Microsoft::UI::Input::FocusChangedEventArgs> const& handler)
      const;
  auto GotFocus(winrt::event_token const& token) const noexcept;
  auto LostFocus(winrt::Windows::Foundation::TypedEventHandler<
                 winrt::Microsoft::UI::Input::InputFocusController,
                 winrt::Microsoft::UI::Input::FocusChangedEventArgs> const&
                     handler) const;
  using LostFocus_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputFocusController,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputFocusController>::
          remove_LostFocus>;
  [[nodiscard]] auto LostFocus(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputFocusController,
          winrt::Microsoft::UI::Input::FocusChangedEventArgs> const& handler)
      const;
  auto LostFocus(winrt::event_token const& token) const noexcept;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputFocusController> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputFocusController<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputFocusController2 {
  auto DepartFocus(
      winrt::Microsoft::UI::Input::FocusNavigationRequest const& request) const;
  auto NavigateFocusRequested(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputFocusController,
          winrt::Microsoft::UI::Input::FocusNavigationRequestEventArgs> const&
          handler) const;
  using NavigateFocusRequested_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputFocusController2,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputFocusController2>::
          remove_NavigateFocusRequested>;
  [[nodiscard]] auto NavigateFocusRequested(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputFocusController,
          winrt::Microsoft::UI::Input::FocusNavigationRequestEventArgs> const&
          handler) const;
  auto NavigateFocusRequested(winrt::event_token const& token) const noexcept;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputFocusController2> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputFocusController2<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputFocusControllerStatics {
  auto GetForIsland(
      winrt::Microsoft::UI::Content::ContentIsland const& island) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputFocusControllerStatics> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputFocusControllerStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputFocusNavigationHost {
  [[nodiscard]] auto ContainsFocus() const;
  auto NavigateFocus(
      winrt::Microsoft::UI::Input::FocusNavigationRequest const& request) const;
  auto DepartFocusRequested(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputFocusNavigationHost,
          winrt::Microsoft::UI::Input::FocusNavigationRequestEventArgs> const&
          handler) const;
  using DepartFocusRequested_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputFocusNavigationHost,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputFocusNavigationHost>::
          remove_DepartFocusRequested>;
  [[nodiscard]] auto DepartFocusRequested(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputFocusNavigationHost,
          winrt::Microsoft::UI::Input::FocusNavigationRequestEventArgs> const&
          handler) const;
  auto DepartFocusRequested(winrt::event_token const& token) const noexcept;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputFocusNavigationHost> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputFocusNavigationHost<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputFocusNavigationHostStatics {
  auto GetForSiteBridge(
      winrt::Microsoft::UI::Content::IContentSiteBridge const& site) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputFocusNavigationHostStatics> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputFocusNavigationHostStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputFocusNavigationHostStatics2 {
  auto GetForSiteLink(winrt::Microsoft::UI::Content::IContentSiteLink const&
                          contentSiteLink) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputFocusNavigationHostStatics2> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputFocusNavigationHostStatics2<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputKeyboardSource {};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputKeyboardSource> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputKeyboardSource<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputKeyboardSource2 {
  auto GetCurrentKeyState(
      winrt::Windows::System::VirtualKey const& virtualKey) const;
  auto GetKeyState(winrt::Windows::System::VirtualKey const& virtualKey) const;
  auto CharacterReceived(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputKeyboardSource,
          winrt::Microsoft::UI::Input::CharacterReceivedEventArgs> const&
          handler) const;
  using CharacterReceived_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputKeyboardSource2,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputKeyboardSource2>::
          remove_CharacterReceived>;
  [[nodiscard]] auto CharacterReceived(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputKeyboardSource,
          winrt::Microsoft::UI::Input::CharacterReceivedEventArgs> const&
          handler) const;
  auto CharacterReceived(winrt::event_token const& token) const noexcept;
  auto ContextMenuKey(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputKeyboardSource,
          winrt::Microsoft::UI::Input::ContextMenuKeyEventArgs> const& handler)
      const;
  using ContextMenuKey_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputKeyboardSource2,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputKeyboardSource2>::
          remove_ContextMenuKey>;
  [[nodiscard]] auto ContextMenuKey(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputKeyboardSource,
          winrt::Microsoft::UI::Input::ContextMenuKeyEventArgs> const& handler)
      const;
  auto ContextMenuKey(winrt::event_token const& token) const noexcept;
  auto KeyDown(winrt::Windows::Foundation::TypedEventHandler<
               winrt::Microsoft::UI::Input::InputKeyboardSource,
               winrt::Microsoft::UI::Input::KeyEventArgs> const& handler) const;
  using KeyDown_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputKeyboardSource2,
      &impl::abi_t<
          winrt::Microsoft::UI::Input::IInputKeyboardSource2>::remove_KeyDown>;
  [[nodiscard]] auto KeyDown(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputKeyboardSource,
          winrt::Microsoft::UI::Input::KeyEventArgs> const& handler) const;
  auto KeyDown(winrt::event_token const& token) const noexcept;
  auto KeyUp(winrt::Windows::Foundation::TypedEventHandler<
             winrt::Microsoft::UI::Input::InputKeyboardSource,
             winrt::Microsoft::UI::Input::KeyEventArgs> const& handler) const;
  using KeyUp_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputKeyboardSource2,
      &impl::abi_t<
          winrt::Microsoft::UI::Input::IInputKeyboardSource2>::remove_KeyUp>;
  [[nodiscard]] auto KeyUp(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputKeyboardSource,
          winrt::Microsoft::UI::Input::KeyEventArgs> const& handler) const;
  auto KeyUp(winrt::event_token const& token) const noexcept;
  auto SystemKeyDown(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputKeyboardSource,
          winrt::Microsoft::UI::Input::KeyEventArgs> const& handler) const;
  using SystemKeyDown_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputKeyboardSource2,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputKeyboardSource2>::
          remove_SystemKeyDown>;
  [[nodiscard]] auto SystemKeyDown(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputKeyboardSource,
          winrt::Microsoft::UI::Input::KeyEventArgs> const& handler) const;
  auto SystemKeyDown(winrt::event_token const& token) const noexcept;
  auto SystemKeyUp(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputKeyboardSource,
          winrt::Microsoft::UI::Input::KeyEventArgs> const& handler) const;
  using SystemKeyUp_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputKeyboardSource2,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputKeyboardSource2>::
          remove_SystemKeyUp>;
  [[nodiscard]] auto SystemKeyUp(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputKeyboardSource,
          winrt::Microsoft::UI::Input::KeyEventArgs> const& handler) const;
  auto SystemKeyUp(winrt::event_token const& token) const noexcept;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputKeyboardSource2> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputKeyboardSource2<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputKeyboardSourceStatics {
  auto GetKeyStateForCurrentThread(
      winrt::Windows::System::VirtualKey const& virtualKey) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputKeyboardSourceStatics> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputKeyboardSourceStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputKeyboardSourceStatics2 {
  auto GetForIsland(
      winrt::Microsoft::UI::Content::ContentIsland const& island) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputKeyboardSourceStatics2> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputKeyboardSourceStatics2<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputLightDismissAction {
  auto Dismissed(winrt::Windows::Foundation::TypedEventHandler<
                 winrt::Microsoft::UI::Input::InputLightDismissAction,
                 winrt::Microsoft::UI::Input::InputLightDismissEventArgs> const&
                     handler) const;
  using Dismissed_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputLightDismissAction,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputLightDismissAction>::
          remove_Dismissed>;
  [[nodiscard]] auto Dismissed(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputLightDismissAction,
          winrt::Microsoft::UI::Input::InputLightDismissEventArgs> const&
          handler) const;
  auto Dismissed(winrt::event_token const& token) const noexcept;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputLightDismissAction> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputLightDismissAction<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputLightDismissActionStatics {
  auto GetForWindowId(winrt::Microsoft::UI::WindowId const& windowId) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputLightDismissActionStatics> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputLightDismissActionStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputLightDismissEventArgs {};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputLightDismissEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputLightDismissEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputNonClientPointerSource {
  [[nodiscard]] auto DispatcherQueue() const;
  auto ClearAllRegionRects() const;
  auto ClearRegionRects(
      winrt::Microsoft::UI::Input::NonClientRegionKind const& region) const;
  auto GetRegionRects(
      winrt::Microsoft::UI::Input::NonClientRegionKind const& region) const;
  auto SetRegionRects(
      winrt::Microsoft::UI::Input::NonClientRegionKind const& region,
      array_view<winrt::Windows::Graphics::RectInt32 const> rects) const;
  auto CaptionTapped(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientCaptionTappedEventArgs> const&
          handler) const;
  using CaptionTapped_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource>::
          remove_CaptionTapped>;
  [[nodiscard]] auto CaptionTapped(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientCaptionTappedEventArgs> const&
          handler) const;
  auto CaptionTapped(winrt::event_token const& token) const noexcept;
  auto PointerEntered(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientPointerEventArgs> const&
          handler) const;
  using PointerEntered_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource>::
          remove_PointerEntered>;
  [[nodiscard]] auto PointerEntered(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientPointerEventArgs> const&
          handler) const;
  auto PointerEntered(winrt::event_token const& token) const noexcept;
  auto PointerExited(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientPointerEventArgs> const&
          handler) const;
  using PointerExited_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource>::
          remove_PointerExited>;
  [[nodiscard]] auto PointerExited(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientPointerEventArgs> const&
          handler) const;
  auto PointerExited(winrt::event_token const& token) const noexcept;
  auto PointerMoved(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientPointerEventArgs> const&
          handler) const;
  using PointerMoved_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource>::
          remove_PointerMoved>;
  [[nodiscard]] auto PointerMoved(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientPointerEventArgs> const&
          handler) const;
  auto PointerMoved(winrt::event_token const& token) const noexcept;
  auto PointerPressed(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientPointerEventArgs> const&
          handler) const;
  using PointerPressed_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource>::
          remove_PointerPressed>;
  [[nodiscard]] auto PointerPressed(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientPointerEventArgs> const&
          handler) const;
  auto PointerPressed(winrt::event_token const& token) const noexcept;
  auto PointerReleased(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientPointerEventArgs> const&
          handler) const;
  using PointerReleased_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource>::
          remove_PointerReleased>;
  [[nodiscard]] auto PointerReleased(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientPointerEventArgs> const&
          handler) const;
  auto PointerReleased(winrt::event_token const& token) const noexcept;
  auto RegionsChanged(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientRegionsChangedEventArgs> const&
          handler) const;
  using RegionsChanged_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource>::
          remove_RegionsChanged>;
  [[nodiscard]] auto RegionsChanged(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::NonClientRegionsChangedEventArgs> const&
          handler) const;
  auto RegionsChanged(winrt::event_token const& token) const noexcept;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputNonClientPointerSource> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputNonClientPointerSource<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputNonClientPointerSource2 {
  auto EnteringMoveSize(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::EnteringMoveSizeEventArgs> const&
          handler) const;
  using EnteringMoveSize_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource2,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource2>::
          remove_EnteringMoveSize>;
  [[nodiscard]] auto EnteringMoveSize(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::EnteringMoveSizeEventArgs> const&
          handler) const;
  auto EnteringMoveSize(winrt::event_token const& token) const noexcept;
  auto EnteredMoveSize(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::EnteredMoveSizeEventArgs> const& handler)
      const;
  using EnteredMoveSize_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource2,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource2>::
          remove_EnteredMoveSize>;
  [[nodiscard]] auto EnteredMoveSize(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::EnteredMoveSizeEventArgs> const& handler)
      const;
  auto EnteredMoveSize(winrt::event_token const& token) const noexcept;
  auto WindowRectChanging(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::WindowRectChangingEventArgs> const&
          handler) const;
  using WindowRectChanging_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource2,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource2>::
          remove_WindowRectChanging>;
  [[nodiscard]] auto WindowRectChanging(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::WindowRectChangingEventArgs> const&
          handler) const;
  auto WindowRectChanging(winrt::event_token const& token) const noexcept;
  auto WindowRectChanged(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::WindowRectChangedEventArgs> const&
          handler) const;
  using WindowRectChanged_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource2,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource2>::
          remove_WindowRectChanged>;
  [[nodiscard]] auto WindowRectChanged(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::WindowRectChangedEventArgs> const&
          handler) const;
  auto WindowRectChanged(winrt::event_token const& token) const noexcept;
  auto ExitedMoveSize(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::ExitedMoveSizeEventArgs> const& handler)
      const;
  using ExitedMoveSize_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputNonClientPointerSource2,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputNonClientPointerSource2>::
          remove_ExitedMoveSize>;
  [[nodiscard]] auto ExitedMoveSize(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputNonClientPointerSource,
          winrt::Microsoft::UI::Input::ExitedMoveSizeEventArgs> const& handler)
      const;
  auto ExitedMoveSize(winrt::event_token const& token) const noexcept;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputNonClientPointerSource2> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputNonClientPointerSource2<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputNonClientPointerSourceStatics {
  auto GetForWindowId(winrt::Microsoft::UI::WindowId const& windowId) const;
};
template <>
struct consume<
    winrt::Microsoft::UI::Input::IInputNonClientPointerSourceStatics> {
  template <typename D>
  using type =
      consume_Microsoft_UI_Input_IInputNonClientPointerSourceStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputObject {
  [[nodiscard]] auto DispatcherQueue() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputObject> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputObject<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputObjectFactory {};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputObjectFactory> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputObjectFactory<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputPointerSource {
  [[nodiscard]] auto Cursor() const;
  auto Cursor(winrt::Microsoft::UI::Input::InputCursor const& value) const;
  [[nodiscard]] auto DeviceKinds() const;
  auto PointerCaptureLost(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  using PointerCaptureLost_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputPointerSource>::
          remove_PointerCaptureLost>;
  [[nodiscard]] auto PointerCaptureLost(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  auto PointerCaptureLost(winrt::event_token const& token) const noexcept;
  auto PointerEntered(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  using PointerEntered_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputPointerSource>::
          remove_PointerEntered>;
  [[nodiscard]] auto PointerEntered(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  auto PointerEntered(winrt::event_token const& token) const noexcept;
  auto PointerExited(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  using PointerExited_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputPointerSource>::
          remove_PointerExited>;
  [[nodiscard]] auto PointerExited(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  auto PointerExited(winrt::event_token const& token) const noexcept;
  auto PointerMoved(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  using PointerMoved_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputPointerSource>::
          remove_PointerMoved>;
  [[nodiscard]] auto PointerMoved(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  auto PointerMoved(winrt::event_token const& token) const noexcept;
  auto PointerPressed(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  using PointerPressed_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputPointerSource>::
          remove_PointerPressed>;
  [[nodiscard]] auto PointerPressed(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  auto PointerPressed(winrt::event_token const& token) const noexcept;
  auto PointerReleased(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  using PointerReleased_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputPointerSource>::
          remove_PointerReleased>;
  [[nodiscard]] auto PointerReleased(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  auto PointerReleased(winrt::event_token const& token) const noexcept;
  auto PointerRoutedAway(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  using PointerRoutedAway_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputPointerSource>::
          remove_PointerRoutedAway>;
  [[nodiscard]] auto PointerRoutedAway(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  auto PointerRoutedAway(winrt::event_token const& token) const noexcept;
  auto PointerRoutedReleased(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  using PointerRoutedReleased_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputPointerSource>::
          remove_PointerRoutedReleased>;
  [[nodiscard]] auto PointerRoutedReleased(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  auto PointerRoutedReleased(winrt::event_token const& token) const noexcept;
  auto PointerRoutedTo(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  using PointerRoutedTo_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputPointerSource>::
          remove_PointerRoutedTo>;
  [[nodiscard]] auto PointerRoutedTo(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  auto PointerRoutedTo(winrt::event_token const& token) const noexcept;
  auto PointerWheelChanged(
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  using PointerWheelChanged_revoker = impl::event_revoker<
      winrt::Microsoft::UI::Input::IInputPointerSource,
      &impl::abi_t<winrt::Microsoft::UI::Input::IInputPointerSource>::
          remove_PointerWheelChanged>;
  [[nodiscard]] auto PointerWheelChanged(
      auto_revoke_t,
      winrt::Windows::Foundation::TypedEventHandler<
          winrt::Microsoft::UI::Input::InputPointerSource,
          winrt::Microsoft::UI::Input::PointerEventArgs> const& handler) const;
  auto PointerWheelChanged(winrt::event_token const& token) const noexcept;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputPointerSource> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputPointerSource<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputPointerSourceStatics {
  auto GetForIsland(
      winrt::Microsoft::UI::Content::ContentIsland const& island) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputPointerSourceStatics> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputPointerSourceStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputPreTranslateKeyboardSource {};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputPreTranslateKeyboardSource> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputPreTranslateKeyboardSource<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputPreTranslateKeyboardSourceStatics {
  auto GetForIsland(
      winrt::Microsoft::UI::Content::ContentIsland const& island) const;
};
template <>
struct consume<
    winrt::Microsoft::UI::Input::IInputPreTranslateKeyboardSourceStatics> {
  template <typename D>
  using type =
      consume_Microsoft_UI_Input_IInputPreTranslateKeyboardSourceStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputSystemCursor {
  [[nodiscard]] auto CursorShape() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputSystemCursor> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputSystemCursor<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IInputSystemCursorStatics {
  auto Create(
      winrt::Microsoft::UI::Input::InputSystemCursorShape const& type) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IInputSystemCursorStatics> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IInputSystemCursorStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IKeyEventArgs {
  [[nodiscard]] auto Handled() const;
  auto Handled(bool value) const;
  [[nodiscard]] auto KeyStatus() const;
  [[nodiscard]] auto Timestamp() const;
  [[nodiscard]] auto VirtualKey() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IKeyEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IKeyEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IManipulationCompletedEventArgs {
  [[nodiscard]] auto Cumulative() const;
  [[nodiscard]] auto PointerDeviceType() const;
  [[nodiscard]] auto Position() const;
  [[nodiscard]] auto Velocities() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IManipulationCompletedEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IManipulationCompletedEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IManipulationInertiaStartingEventArgs {
  [[nodiscard]] auto Cumulative() const;
  [[nodiscard]] auto Delta() const;
  [[nodiscard]] auto PointerDeviceType() const;
  [[nodiscard]] auto Position() const;
  [[nodiscard]] auto Velocities() const;
};
template <>
struct consume<
    winrt::Microsoft::UI::Input::IManipulationInertiaStartingEventArgs> {
  template <typename D>
  using type =
      consume_Microsoft_UI_Input_IManipulationInertiaStartingEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IManipulationStartedEventArgs {
  [[nodiscard]] auto Cumulative() const;
  [[nodiscard]] auto PointerDeviceType() const;
  [[nodiscard]] auto Position() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IManipulationStartedEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IManipulationStartedEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IManipulationUpdatedEventArgs {
  [[nodiscard]] auto Cumulative() const;
  [[nodiscard]] auto Delta() const;
  [[nodiscard]] auto PointerDeviceType() const;
  [[nodiscard]] auto Position() const;
  [[nodiscard]] auto Velocities() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IManipulationUpdatedEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IManipulationUpdatedEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IMouseWheelParameters {
  [[nodiscard]] auto CharTranslation() const;
  auto CharTranslation(winrt::Windows::Foundation::Point const& value) const;
  [[nodiscard]] auto DeltaScale() const;
  auto DeltaScale(float value) const;
  [[nodiscard]] auto DeltaRotationAngle() const;
  auto DeltaRotationAngle(float value) const;
  [[nodiscard]] auto PageTranslation() const;
  auto PageTranslation(winrt::Windows::Foundation::Point const& value) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IMouseWheelParameters> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IMouseWheelParameters<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_INonClientCaptionTappedEventArgs {
  [[nodiscard]] auto Point() const;
  [[nodiscard]] auto PointerDeviceType() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::INonClientCaptionTappedEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_INonClientCaptionTappedEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_INonClientPointerEventArgs {
  [[nodiscard]] auto Point() const;
  [[nodiscard]] auto PointerDeviceType() const;
  [[nodiscard]] auto RegionKind() const;
  [[nodiscard]] auto IsPointInRegion() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::INonClientPointerEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_INonClientPointerEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_INonClientRegionsChangedEventArgs {
  [[nodiscard]] auto ChangedRegions() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::INonClientRegionsChangedEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_INonClientRegionsChangedEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IPointerEventArgs {
  [[nodiscard]] auto CurrentPoint() const;
  [[nodiscard]] auto Handled() const;
  auto Handled(bool value) const;
  [[nodiscard]] auto KeyModifiers() const;
  auto GetIntermediatePoints() const;
  auto GetIntermediateTransformedPoints(
      winrt::Microsoft::UI::Input::IPointerPointTransform const& transform)
      const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IPointerEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IPointerEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IPointerPoint {
  [[nodiscard]] auto FrameId() const;
  [[nodiscard]] auto IsInContact() const;
  [[nodiscard]] auto PointerDeviceType() const;
  [[nodiscard]] auto PointerId() const;
  [[nodiscard]] auto Position() const;
  [[nodiscard]] auto Properties() const;
  [[nodiscard]] auto Timestamp() const;
  auto GetTransformedPoint(
      winrt::Microsoft::UI::Input::IPointerPointTransform const& transform)
      const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IPointerPoint> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IPointerPoint<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IPointerPointProperties {
  [[nodiscard]] auto ContactRect() const;
  [[nodiscard]] auto IsBarrelButtonPressed() const;
  [[nodiscard]] auto IsCanceled() const;
  [[nodiscard]] auto IsEraser() const;
  [[nodiscard]] auto IsHorizontalMouseWheel() const;
  [[nodiscard]] auto IsInRange() const;
  [[nodiscard]] auto IsInverted() const;
  [[nodiscard]] auto IsLeftButtonPressed() const;
  [[nodiscard]] auto IsMiddleButtonPressed() const;
  [[nodiscard]] auto IsPrimary() const;
  [[nodiscard]] auto IsRightButtonPressed() const;
  [[nodiscard]] auto IsXButton1Pressed() const;
  [[nodiscard]] auto IsXButton2Pressed() const;
  [[nodiscard]] auto MouseWheelDelta() const;
  [[nodiscard]] auto Orientation() const;
  [[nodiscard]] auto PointerUpdateKind() const;
  [[nodiscard]] auto Pressure() const;
  [[nodiscard]] auto TouchConfidence() const;
  [[nodiscard]] auto Twist() const;
  [[nodiscard]] auto XTilt() const;
  [[nodiscard]] auto YTilt() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IPointerPointProperties> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IPointerPointProperties<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IPointerPointTransform {
  [[nodiscard]] auto Inverse() const;
  auto TryTransform(winrt::Windows::Foundation::Point const& inPoint,
                    winrt::Windows::Foundation::Point& outPoint) const;
  auto TryTransformBounds(winrt::Windows::Foundation::Rect const& inRect,
                          winrt::Windows::Foundation::Rect& outRect) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IPointerPointTransform> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IPointerPointTransform<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IPointerPredictor {
  [[nodiscard]] auto PredictionTime() const;
  auto PredictionTime(winrt::Windows::Foundation::TimeSpan const& value) const;
  auto GetPredictedPoints(
      winrt::Microsoft::UI::Input::PointerPoint const& point) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IPointerPredictor> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IPointerPredictor<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IPointerPredictorStatics {
  auto CreateForInputPointerSource(
      winrt::Microsoft::UI::Input::InputPointerSource const& inputPointerSource)
      const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IPointerPredictorStatics> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IPointerPredictorStatics<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IRightTappedEventArgs {
  [[nodiscard]] auto PointerDeviceType() const;
  [[nodiscard]] auto Position() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IRightTappedEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IRightTappedEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_ITappedEventArgs {
  [[nodiscard]] auto PointerDeviceType() const;
  [[nodiscard]] auto Position() const;
  [[nodiscard]] auto TapCount() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::ITappedEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_ITappedEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IWindowRectChangedEventArgs {
  [[nodiscard]] auto PointerScreenPoint() const;
  [[nodiscard]] auto MoveSizeOperation() const;
  [[nodiscard]] auto OldWindowRect() const;
  [[nodiscard]] auto NewWindowRect() const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IWindowRectChangedEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IWindowRectChangedEventArgs<D>;
};
template <typename D>
struct consume_Microsoft_UI_Input_IWindowRectChangingEventArgs {
  [[nodiscard]] auto PointerScreenPoint() const;
  [[nodiscard]] auto MoveSizeOperation() const;
  [[nodiscard]] auto OldWindowRect() const;
  [[nodiscard]] auto NewWindowRect() const;
  auto NewWindowRect(winrt::Windows::Graphics::RectInt32 const& value) const;
  [[nodiscard]] auto AllowRectChange() const;
  auto AllowRectChange(bool value) const;
  [[nodiscard]] auto ShowWindow() const;
  auto ShowWindow(bool value) const;
};
template <>
struct consume<winrt::Microsoft::UI::Input::IWindowRectChangingEventArgs> {
  template <typename D>
  using type = consume_Microsoft_UI_Input_IWindowRectChangingEventArgs<D>;
};
struct struct_Microsoft_UI_Input_CrossSlideThresholds {
  float SelectionStart;
  float SpeedBumpStart;
  float SpeedBumpEnd;
  float RearrangeStart;
};
template <>
struct abi<Microsoft::UI::Input::CrossSlideThresholds> {
  using type = struct_Microsoft_UI_Input_CrossSlideThresholds;
};
struct struct_Microsoft_UI_Input_ManipulationDelta {
  winrt::Windows::Foundation::Point Translation;
  float Scale;
  float Rotation;
  float Expansion;
};
template <>
struct abi<Microsoft::UI::Input::ManipulationDelta> {
  using type = struct_Microsoft_UI_Input_ManipulationDelta;
};
struct struct_Microsoft_UI_Input_ManipulationVelocities {
  winrt::Windows::Foundation::Point Linear;
  float Angular;
  float Expansion;
};
template <>
struct abi<Microsoft::UI::Input::ManipulationVelocities> {
  using type = struct_Microsoft_UI_Input_ManipulationVelocities;
};
struct struct_Microsoft_UI_Input_PhysicalKeyStatus {
  uint32_t RepeatCount;
  uint32_t ScanCode;
  bool IsExtendedKey;
  bool IsMenuKeyDown;
  bool WasKeyDown;
  bool IsKeyReleased;
};
template <>
struct abi<Microsoft::UI::Input::PhysicalKeyStatus> {
  using type = struct_Microsoft_UI_Input_PhysicalKeyStatus;
};
}  // namespace winrt::impl
#endif