// ****************************************************** //
// Generated by scripts\controls.py
// ****************************************************** //
#include "pch.h"

using namespace winrt;
using namespace Windows::Foundation;
using namespace Windows::Media::Playback;
using namespace Windows::UI;
using namespace Microsoft::UI::Xaml;
using namespace Microsoft::UI::Xaml::Controls;
using namespace Microsoft::UI::Xaml::Navigation;
namespace py = pybind11;


template <typename T> static std::wstring default_repr(const T&) {
    std::wstringstream s;
    s << "<" << typeid(T).name() << ">";
    return s.str();
}
template <> static std::wstring default_repr(const IInspectable& _self) { return L"<" + std::wstring{winrt::get_class_name(_self)} + L">"; }

PYBIND11_EMBEDDED_MODULE(_winui_Xaml_Controls, m) {
    py::enum_<MediaPlaybackState>(m, "MediaPlaybackState")
        .value("None", MediaPlaybackState::None)
        .value("Opening", MediaPlaybackState::Opening)
        .value("Buffering", MediaPlaybackState::Buffering)
        .value("Playing", MediaPlaybackState::Playing)
        .value("Paused", MediaPlaybackState::Paused)
    ;

    py::class_<AnchorRequestedEventArgs, ::pywinui::holder<AnchorRequestedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.AnchorRequestedEventArgs")
        .def("__repr__", [](const AnchorRequestedEventArgs& _self) { return default_repr(_self); } )
        .def_property_readonly("Anchor", [](const AnchorRequestedEventArgs& _self) { return (_self.Anchor()); })
        .def_property_readonly("AnchorCandidates", [](const AnchorRequestedEventArgs& _self) { return (_self.AnchorCandidates()); })
    ;
    py::class_<AnimatedIcon, ::pywinui::holder<AnimatedIcon>>(m, "Microsoft.UI.Xaml.Controls.AnimatedIcon")
        .def("__repr__", [](const AnimatedIcon& _self) { return default_repr(_self); } )
    ;
    py::class_<AnimatedIconSource, ::pywinui::holder<AnimatedIconSource>>(m, "Microsoft.UI.Xaml.Controls.AnimatedIconSource")
        .def("__repr__", [](const AnimatedIconSource& _self) { return default_repr(_self); } )
    ;
    py::class_<AnimatedVisualPlayer, ::pywinui::holder<AnimatedVisualPlayer>>(m, "Microsoft.UI.Xaml.Controls.AnimatedVisualPlayer")
        .def("__repr__", [](const AnimatedVisualPlayer& _self) { return default_repr(_self); } )
    ;
    py::class_<AnnotatedScrollBar, ::pywinui::holder<AnnotatedScrollBar>>(m, "Microsoft.UI.Xaml.Controls.AnnotatedScrollBar")
        .def("__repr__", [](const AnnotatedScrollBar& _self) { return default_repr(_self); } )
    ;
    py::class_<AnnotatedScrollBarDetailLabelRequestedEventArgs, ::pywinui::holder<AnnotatedScrollBarDetailLabelRequestedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.AnnotatedScrollBarDetailLabelRequestedEventArgs")
        .def("__repr__", [](const AnnotatedScrollBarDetailLabelRequestedEventArgs& _self) { return default_repr(_self); } )
        .def_property("Content", [](const AnnotatedScrollBarDetailLabelRequestedEventArgs& _self) { return (_self.Content()); }, [](AnnotatedScrollBarDetailLabelRequestedEventArgs& _self, IInspectable v) { return _self.Content(v); })
        .def_property_readonly("ScrollOffset", [](const AnnotatedScrollBarDetailLabelRequestedEventArgs& _self) { return (_self.ScrollOffset()); })
    ;
    py::class_<AnnotatedScrollBarLabel, ::pywinui::holder<AnnotatedScrollBarLabel>>(m, "Microsoft.UI.Xaml.Controls.AnnotatedScrollBarLabel")
        .def("__repr__", [](const AnnotatedScrollBarLabel& _self) { return default_repr(_self); } )
    ;
    py::class_<AnnotatedScrollBarScrollingEventArgs, ::pywinui::holder<AnnotatedScrollBarScrollingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.AnnotatedScrollBarScrollingEventArgs")
        .def("__repr__", [](const AnnotatedScrollBarScrollingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<AppBar, ::pywinui::holder<AppBar>>(m, "Microsoft.UI.Xaml.Controls.AppBar")
        .def("__repr__", [](const AppBar& _self) { return default_repr(_self); } )
        .def_property("Content", [](const AppBar& _self) { return (_self.Content()); }, [](AppBar& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<AppBarButton, ::pywinui::holder<AppBarButton>>(m, "Microsoft.UI.Xaml.Controls.AppBarButton")
        .def("__repr__", [](const AppBarButton& _self) { return default_repr(_self); } )
    ;
    py::class_<AppBarElementContainer, ::pywinui::holder<AppBarElementContainer>>(m, "Microsoft.UI.Xaml.Controls.AppBarElementContainer")
        .def("__repr__", [](const AppBarElementContainer& _self) { return default_repr(_self); } )
        .def_property("Content", [](const AppBarElementContainer& _self) { return (_self.Content()); }, [](AppBarElementContainer& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<AppBarSeparator, ::pywinui::holder<AppBarSeparator>>(m, "Microsoft.UI.Xaml.Controls.AppBarSeparator")
        .def("__repr__", [](const AppBarSeparator& _self) { return default_repr(_self); } )
    ;
    py::class_<AppBarToggleButton, ::pywinui::holder<AppBarToggleButton>>(m, "Microsoft.UI.Xaml.Controls.AppBarToggleButton")
        .def("__repr__", [](const AppBarToggleButton& _self) { return default_repr(_self); } )
        .def_property("Content", [](const AppBarToggleButton& _self) { return (_self.Content()); }, [](AppBarToggleButton& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<AutoSuggestBox, ::pywinui::holder<AutoSuggestBox>>(m, "Microsoft.UI.Xaml.Controls.AutoSuggestBox")
        .def("__repr__", [](const AutoSuggestBox& _self) { return default_repr(_self); } )
    ;
    py::class_<AutoSuggestBoxQuerySubmittedEventArgs, ::pywinui::holder<AutoSuggestBoxQuerySubmittedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.AutoSuggestBoxQuerySubmittedEventArgs")
        .def("__repr__", [](const AutoSuggestBoxQuerySubmittedEventArgs& _self) { return default_repr(_self); } )
        .def_property_readonly("ChosenSuggestion", [](const AutoSuggestBoxQuerySubmittedEventArgs& _self) { return (_self.ChosenSuggestion()); })
        .def_property_readonly("QueryText", [](const AutoSuggestBoxQuerySubmittedEventArgs& _self) { return (_self.QueryText()); })
    ;
    py::class_<AutoSuggestBoxSuggestionChosenEventArgs, ::pywinui::holder<AutoSuggestBoxSuggestionChosenEventArgs>>(m, "Microsoft.UI.Xaml.Controls.AutoSuggestBoxSuggestionChosenEventArgs")
        .def("__repr__", [](const AutoSuggestBoxSuggestionChosenEventArgs& _self) { return default_repr(_self); } )
        .def_property_readonly("SelectedItem", [](const AutoSuggestBoxSuggestionChosenEventArgs& _self) { return (_self.SelectedItem()); })
    ;
    py::class_<AutoSuggestBoxTextChangedEventArgs, ::pywinui::holder<AutoSuggestBoxTextChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.AutoSuggestBoxTextChangedEventArgs")
        .def("__repr__", [](const AutoSuggestBoxTextChangedEventArgs& _self) { return default_repr(_self); } )
        .def("CheckCurrent", [](AutoSuggestBoxTextChangedEventArgs& _self) { return (_self.CheckCurrent()); })
        .def_property_readonly("Reason", [](const AutoSuggestBoxTextChangedEventArgs& _self) { return (_self.Reason()); })
    ;
    py::class_<BitmapIcon, ::pywinui::holder<BitmapIcon>>(m, "Microsoft.UI.Xaml.Controls.BitmapIcon")
        .def("__repr__", [](const BitmapIcon& _self) { return default_repr(_self); } )
    ;
    py::class_<BitmapIconSource, ::pywinui::holder<BitmapIconSource>>(m, "Microsoft.UI.Xaml.Controls.BitmapIconSource")
        .def("__repr__", [](const BitmapIconSource& _self) { return default_repr(_self); } )
    ;
    py::class_<Border, ::pywinui::holder<Border>>(m, "Microsoft.UI.Xaml.Controls.Border")
        .def("__repr__", [](const Border& _self) { return default_repr(_self); } )
    ;
    py::class_<BreadcrumbBar, ::pywinui::holder<BreadcrumbBar>>(m, "Microsoft.UI.Xaml.Controls.BreadcrumbBar")
        .def("__repr__", [](const BreadcrumbBar& _self) { return default_repr(_self); } )
    ;
    py::class_<BreadcrumbBarItem, ::pywinui::holder<BreadcrumbBarItem>>(m, "Microsoft.UI.Xaml.Controls.BreadcrumbBarItem")
        .def("__repr__", [](const BreadcrumbBarItem& _self) { return default_repr(_self); } )
        .def_property("Content", [](const BreadcrumbBarItem& _self) { return (_self.Content()); }, [](BreadcrumbBarItem& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<BreadcrumbBarItemClickedEventArgs, ::pywinui::holder<BreadcrumbBarItemClickedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.BreadcrumbBarItemClickedEventArgs")
        .def("__repr__", [](const BreadcrumbBarItemClickedEventArgs& _self) { return default_repr(_self); } )
        .def_property_readonly("Index", [](const BreadcrumbBarItemClickedEventArgs& _self) { return (_self.Index()); })
        .def_property_readonly("Item", [](const BreadcrumbBarItemClickedEventArgs& _self) { return (_self.Item()); })
    ;
    py::class_<Button, ::pywinui::holder<Button>>(m, "Microsoft.UI.Xaml.Controls.Button")
        .def("__repr__", [](const Button& _self) { return default_repr(_self); } )
        .def_property("Content", [](const Button& _self) { return (_self.Content()); }, [](Button& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<CalendarDatePicker, ::pywinui::holder<CalendarDatePicker>>(m, "Microsoft.UI.Xaml.Controls.CalendarDatePicker")
        .def("__repr__", [](const CalendarDatePicker& _self) { return default_repr(_self); } )
        .def_property("Date", [](const CalendarDatePicker& _self) { return (_self.Date()).try_as<DateTime>(); }, [](CalendarDatePicker& _self, DateTime v) { return _self.Date(v); })
        .def_property("MaxDate", [](const CalendarDatePicker& _self) { return (_self.MaxDate()); }, [](CalendarDatePicker& _self, DateTime v) { return _self.MaxDate(v); })
        .def_property("MinDate", [](const CalendarDatePicker& _self) { return (_self.MinDate()); }, [](CalendarDatePicker& _self, DateTime v) { return _self.MinDate(v); })
        .def("SetDisplayDate", [](CalendarDatePicker& _self, DateTime date) { return (_self.SetDisplayDate(date)); })
    ;
    py::class_<CalendarDatePickerDateChangedEventArgs, ::pywinui::holder<CalendarDatePickerDateChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.CalendarDatePickerDateChangedEventArgs")
        .def("__repr__", [](const CalendarDatePickerDateChangedEventArgs& _self) { return default_repr(_self); } )
        .def_property_readonly("NewDate", [](const CalendarDatePickerDateChangedEventArgs& _self) { return (_self.NewDate()).try_as<DateTime>(); })
        .def_property_readonly("OldDate", [](const CalendarDatePickerDateChangedEventArgs& _self) { return (_self.OldDate()).try_as<DateTime>(); })
    ;
    py::class_<CalendarView, ::pywinui::holder<CalendarView>>(m, "Microsoft.UI.Xaml.Controls.CalendarView")
        .def("__repr__", [](const CalendarView& _self) { return default_repr(_self); } )
    ;
    py::class_<CalendarViewDayItem, ::pywinui::holder<CalendarViewDayItem>>(m, "Microsoft.UI.Xaml.Controls.CalendarViewDayItem")
        .def("__repr__", [](const CalendarViewDayItem& _self) { return default_repr(_self); } )
    ;
    py::class_<CalendarViewDayItemChangingEventArgs, ::pywinui::holder<CalendarViewDayItemChangingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.CalendarViewDayItemChangingEventArgs")
        .def("__repr__", [](const CalendarViewDayItemChangingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<CalendarViewSelectedDatesChangedEventArgs, ::pywinui::holder<CalendarViewSelectedDatesChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.CalendarViewSelectedDatesChangedEventArgs")
        .def("__repr__", [](const CalendarViewSelectedDatesChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<CandidateWindowBoundsChangedEventArgs, ::pywinui::holder<CandidateWindowBoundsChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.CandidateWindowBoundsChangedEventArgs")
        .def("__repr__", [](const CandidateWindowBoundsChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<Canvas, ::pywinui::holder<Canvas>>(m, "Microsoft.UI.Xaml.Controls.Canvas")
        .def("__repr__", [](const Canvas& _self) { return default_repr(_self); } )
    ;
    py::class_<CheckBox, ::pywinui::holder<CheckBox>>(m, "Microsoft.UI.Xaml.Controls.CheckBox")
        .def("__repr__", [](const CheckBox& _self) { return default_repr(_self); } )
        .def_property("Content", [](const CheckBox& _self) { return (_self.Content()); }, [](CheckBox& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<ChoosingGroupHeaderContainerEventArgs, ::pywinui::holder<ChoosingGroupHeaderContainerEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ChoosingGroupHeaderContainerEventArgs")
        .def("__repr__", [](const ChoosingGroupHeaderContainerEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ChoosingItemContainerEventArgs, ::pywinui::holder<ChoosingItemContainerEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ChoosingItemContainerEventArgs")
        .def("__repr__", [](const ChoosingItemContainerEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<CleanUpVirtualizedItemEventArgs, ::pywinui::holder<CleanUpVirtualizedItemEventArgs>>(m, "Microsoft.UI.Xaml.Controls.CleanUpVirtualizedItemEventArgs")
        .def("__repr__", [](const CleanUpVirtualizedItemEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<Color, ::pywinui::holder<Color>>(m, "Windows.UI.Color")
        .def("__repr__", [](const Color& _self) { return default_repr(_self); } )
        .def_property("A", [](const Color& _self) { return (_self.A); }, [](Color& _self, uint8_t v) { _self.A = v; })
        .def_property("R", [](const Color& _self) { return (_self.R); }, [](Color& _self, uint8_t v) { _self.R = v; })
        .def_property("G", [](const Color& _self) { return (_self.G); }, [](Color& _self, uint8_t v) { _self.G = v; })
        .def_property("B", [](const Color& _self) { return (_self.B); }, [](Color& _self, uint8_t v) { _self.B = v; })
    ;
    py::class_<ColorChangedEventArgs, ::pywinui::holder<ColorChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ColorChangedEventArgs")
        .def("__repr__", [](const ColorChangedEventArgs& _self) { return default_repr(_self); } )
        .def_property_readonly("NewColor", [](const ColorChangedEventArgs& _self) { return (_self.NewColor()); })
        .def_property_readonly("OldColor", [](const ColorChangedEventArgs& _self) { return (_self.OldColor()); })
    ;
    py::class_<ColorPicker, ::pywinui::holder<ColorPicker>>(m, "Microsoft.UI.Xaml.Controls.ColorPicker")
        .def("__repr__", [](const ColorPicker& _self) { return default_repr(_self); } )
        .def_property("Color", [](const ColorPicker& _self) { return (_self.Color()); }, [](ColorPicker& _self, Color v) { return _self.Color(v); })
    ;
    py::class_<ColumnDefinition, ::pywinui::holder<ColumnDefinition>>(m, "Microsoft.UI.Xaml.Controls.ColumnDefinition")
        .def("__repr__", [](const ColumnDefinition& _self) { return default_repr(_self); } )
    ;
    py::class_<ColumnDefinitionCollection, ::pywinui::holder<ColumnDefinitionCollection>>(m, "Microsoft.UI.Xaml.Controls.ColumnDefinitionCollection")
        .def("__repr__", [](const ColumnDefinitionCollection& _self) { return default_repr(_self); } )
    ;
    py::class_<ComboBox, ::pywinui::holder<ComboBox>>(m, "Microsoft.UI.Xaml.Controls.ComboBox")
        .def("__repr__", [](const ComboBox& _self) { return default_repr(_self); } )
    ;
    py::class_<ComboBoxItem, ::pywinui::holder<ComboBoxItem>>(m, "Microsoft.UI.Xaml.Controls.ComboBoxItem")
        .def("__repr__", [](const ComboBoxItem& _self) { return default_repr(_self); } )
        .def_property("Content", [](const ComboBoxItem& _self) { return (_self.Content()); }, [](ComboBoxItem& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<ComboBoxTextSubmittedEventArgs, ::pywinui::holder<ComboBoxTextSubmittedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ComboBoxTextSubmittedEventArgs")
        .def("__repr__", [](const ComboBoxTextSubmittedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<CommandBar, ::pywinui::holder<CommandBar>>(m, "Microsoft.UI.Xaml.Controls.CommandBar")
        .def("__repr__", [](const CommandBar& _self) { return default_repr(_self); } )
    ;
    py::class_<CommandBarFlyout, ::pywinui::holder<CommandBarFlyout>>(m, "Microsoft.UI.Xaml.Controls.CommandBarFlyout")
        .def("__repr__", [](const CommandBarFlyout& _self) { return default_repr(_self); } )
    ;
    py::class_<CommandBarOverflowPresenter, ::pywinui::holder<CommandBarOverflowPresenter>>(m, "Microsoft.UI.Xaml.Controls.CommandBarOverflowPresenter")
        .def("__repr__", [](const CommandBarOverflowPresenter& _self) { return default_repr(_self); } )
    ;
    py::class_<ContainerContentChangingEventArgs, ::pywinui::holder<ContainerContentChangingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ContainerContentChangingEventArgs")
        .def("__repr__", [](const ContainerContentChangingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ContentControl, ::pywinui::holder<ContentControl>>(m, "Microsoft.UI.Xaml.Controls.ContentControl")
        .def("__repr__", [](const ContentControl& _self) { return default_repr(_self); } )
        .def_property("Content", [](const ContentControl& _self) { return (_self.Content()); }, [](ContentControl& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<ContentDialog, ::pywinui::holder<ContentDialog>>(m, "Microsoft.UI.Xaml.Controls.ContentDialog")
        .def("__repr__", [](const ContentDialog& _self) { return default_repr(_self); } )
        .def_property("Content", [](const ContentDialog& _self) { return (_self.Content()); }, [](ContentDialog& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<ContentDialogButtonClickDeferral, ::pywinui::holder<ContentDialogButtonClickDeferral>>(m, "Microsoft.UI.Xaml.Controls.ContentDialogButtonClickDeferral")
        .def("__repr__", [](const ContentDialogButtonClickDeferral& _self) { return default_repr(_self); } )
    ;
    py::class_<ContentDialogButtonClickEventArgs, ::pywinui::holder<ContentDialogButtonClickEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ContentDialogButtonClickEventArgs")
        .def("__repr__", [](const ContentDialogButtonClickEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ContentDialogClosedEventArgs, ::pywinui::holder<ContentDialogClosedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ContentDialogClosedEventArgs")
        .def("__repr__", [](const ContentDialogClosedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ContentDialogClosingDeferral, ::pywinui::holder<ContentDialogClosingDeferral>>(m, "Microsoft.UI.Xaml.Controls.ContentDialogClosingDeferral")
        .def("__repr__", [](const ContentDialogClosingDeferral& _self) { return default_repr(_self); } )
    ;
    py::class_<ContentDialogClosingEventArgs, ::pywinui::holder<ContentDialogClosingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ContentDialogClosingEventArgs")
        .def("__repr__", [](const ContentDialogClosingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ContentDialogOpenedEventArgs, ::pywinui::holder<ContentDialogOpenedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ContentDialogOpenedEventArgs")
        .def("__repr__", [](const ContentDialogOpenedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ContentPresenter, ::pywinui::holder<ContentPresenter>>(m, "Microsoft.UI.Xaml.Controls.ContentPresenter")
        .def("__repr__", [](const ContentPresenter& _self) { return default_repr(_self); } )
    ;
    py::class_<ContextMenuEventArgs, ::pywinui::holder<ContextMenuEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ContextMenuEventArgs")
        .def("__repr__", [](const ContextMenuEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<Control, ::pywinui::holder<Control>>(m, "Microsoft.UI.Xaml.Controls.Control")
        .def("__repr__", [](const Control& _self) { return default_repr(_self); } )
    ;
    py::class_<ControlTemplate, ::pywinui::holder<ControlTemplate>>(m, "Microsoft.UI.Xaml.Controls.ControlTemplate")
        .def("__repr__", [](const ControlTemplate& _self) { return default_repr(_self); } )
    ;
    py::class_<CoreWebView2InitializedEventArgs, ::pywinui::holder<CoreWebView2InitializedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.CoreWebView2InitializedEventArgs")
        .def("__repr__", [](const CoreWebView2InitializedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<DataTemplateSelector, ::pywinui::holder<DataTemplateSelector>>(m, "Microsoft.UI.Xaml.Controls.DataTemplateSelector")
        .def("__repr__", [](const DataTemplateSelector& _self) { return default_repr(_self); } )
    ;
    py::class_<DatePickedEventArgs, ::pywinui::holder<DatePickedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.DatePickedEventArgs")
        .def("__repr__", [](const DatePickedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<DatePicker, ::pywinui::holder<DatePicker>>(m, "Microsoft.UI.Xaml.Controls.DatePicker")
        .def("__repr__", [](const DatePicker& _self) { return default_repr(_self); } )
    ;
    py::class_<DatePickerFlyout, ::pywinui::holder<DatePickerFlyout>>(m, "Microsoft.UI.Xaml.Controls.DatePickerFlyout")
        .def("__repr__", [](const DatePickerFlyout& _self) { return default_repr(_self); } )
    ;
    py::class_<DatePickerFlyoutItem, ::pywinui::holder<DatePickerFlyoutItem>>(m, "Microsoft.UI.Xaml.Controls.DatePickerFlyoutItem")
        .def("__repr__", [](const DatePickerFlyoutItem& _self) { return default_repr(_self); } )
    ;
    py::class_<DatePickerFlyoutPresenter, ::pywinui::holder<DatePickerFlyoutPresenter>>(m, "Microsoft.UI.Xaml.Controls.DatePickerFlyoutPresenter")
        .def("__repr__", [](const DatePickerFlyoutPresenter& _self) { return default_repr(_self); } )
    ;
    py::class_<DatePickerSelectedValueChangedEventArgs, ::pywinui::holder<DatePickerSelectedValueChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.DatePickerSelectedValueChangedEventArgs")
        .def("__repr__", [](const DatePickerSelectedValueChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<DatePickerValueChangedEventArgs, ::pywinui::holder<DatePickerValueChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.DatePickerValueChangedEventArgs")
        .def("__repr__", [](const DatePickerValueChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<DragItemsCompletedEventArgs, ::pywinui::holder<DragItemsCompletedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.DragItemsCompletedEventArgs")
        .def("__repr__", [](const DragItemsCompletedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<DragItemsStartingEventArgs, ::pywinui::holder<DragItemsStartingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.DragItemsStartingEventArgs")
        .def("__repr__", [](const DragItemsStartingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<DropDownButton, ::pywinui::holder<DropDownButton>>(m, "Microsoft.UI.Xaml.Controls.DropDownButton")
        .def("__repr__", [](const DropDownButton& _self) { return default_repr(_self); } )
    ;
    py::class_<DynamicOverflowItemsChangingEventArgs, ::pywinui::holder<DynamicOverflowItemsChangingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.DynamicOverflowItemsChangingEventArgs")
        .def("__repr__", [](const DynamicOverflowItemsChangingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<Expander, ::pywinui::holder<Expander>>(m, "Microsoft.UI.Xaml.Controls.Expander")
        .def("__repr__", [](const Expander& _self) { return default_repr(_self); } )
        .def_property("Content", [](const Expander& _self) { return (_self.Content()); }, [](Expander& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<ExpanderCollapsedEventArgs, ::pywinui::holder<ExpanderCollapsedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ExpanderCollapsedEventArgs")
        .def("__repr__", [](const ExpanderCollapsedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ExpanderExpandingEventArgs, ::pywinui::holder<ExpanderExpandingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ExpanderExpandingEventArgs")
        .def("__repr__", [](const ExpanderExpandingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ExpanderTemplateSettings, ::pywinui::holder<ExpanderTemplateSettings>>(m, "Microsoft.UI.Xaml.Controls.ExpanderTemplateSettings")
        .def("__repr__", [](const ExpanderTemplateSettings& _self) { return default_repr(_self); } )
    ;
    py::class_<FlipView, ::pywinui::holder<FlipView>>(m, "Microsoft.UI.Xaml.Controls.FlipView")
        .def("__repr__", [](const FlipView& _self) { return default_repr(_self); } )
    ;
    py::class_<FlipViewItem, ::pywinui::holder<FlipViewItem>>(m, "Microsoft.UI.Xaml.Controls.FlipViewItem")
        .def("__repr__", [](const FlipViewItem& _self) { return default_repr(_self); } )
        .def_property("Content", [](const FlipViewItem& _self) { return (_self.Content()); }, [](FlipViewItem& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<Flyout, ::pywinui::holder<Flyout>>(m, "Microsoft.UI.Xaml.Controls.Flyout")
        .def("__repr__", [](const Flyout& _self) { return default_repr(_self); } )
    ;
    py::class_<FlyoutPresenter, ::pywinui::holder<FlyoutPresenter>>(m, "Microsoft.UI.Xaml.Controls.FlyoutPresenter")
        .def("__repr__", [](const FlyoutPresenter& _self) { return default_repr(_self); } )
        .def_property("Content", [](const FlyoutPresenter& _self) { return (_self.Content()); }, [](FlyoutPresenter& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<FocusDisengagedEventArgs, ::pywinui::holder<FocusDisengagedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.FocusDisengagedEventArgs")
        .def("__repr__", [](const FocusDisengagedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<FocusEngagedEventArgs, ::pywinui::holder<FocusEngagedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.FocusEngagedEventArgs")
        .def("__repr__", [](const FocusEngagedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<FontIcon, ::pywinui::holder<FontIcon>>(m, "Microsoft.UI.Xaml.Controls.FontIcon")
        .def("__repr__", [](const FontIcon& _self) { return default_repr(_self); } )
    ;
    py::class_<FontIconSource, ::pywinui::holder<FontIconSource>>(m, "Microsoft.UI.Xaml.Controls.FontIconSource")
        .def("__repr__", [](const FontIconSource& _self) { return default_repr(_self); } )
    ;
    py::class_<Frame, ::pywinui::holder<Frame>>(m, "Microsoft.UI.Xaml.Controls.Frame")
        .def("__repr__", [](const Frame& _self) { return default_repr(_self); } )
        .def_property("Content", [](const Frame& _self) { return (_self.Content()); }, [](Frame& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<Grid, ::pywinui::holder<Grid>>(m, "Microsoft.UI.Xaml.Controls.Grid")
        .def("__repr__", [](const Grid& _self) { return default_repr(_self); } )
    ;
    py::class_<GridView, ::pywinui::holder<GridView>>(m, "Microsoft.UI.Xaml.Controls.GridView")
        .def("__repr__", [](const GridView& _self) { return default_repr(_self); } )
    ;
    py::class_<GridViewHeaderItem, ::pywinui::holder<GridViewHeaderItem>>(m, "Microsoft.UI.Xaml.Controls.GridViewHeaderItem")
        .def("__repr__", [](const GridViewHeaderItem& _self) { return default_repr(_self); } )
    ;
    py::class_<GridViewItem, ::pywinui::holder<GridViewItem>>(m, "Microsoft.UI.Xaml.Controls.GridViewItem")
        .def("__repr__", [](const GridViewItem& _self) { return default_repr(_self); } )
        .def_property("Content", [](const GridViewItem& _self) { return (_self.Content()); }, [](GridViewItem& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<GroupItem, ::pywinui::holder<GroupItem>>(m, "Microsoft.UI.Xaml.Controls.GroupItem")
        .def("__repr__", [](const GroupItem& _self) { return default_repr(_self); } )
        .def_property("Content", [](const GroupItem& _self) { return (_self.Content()); }, [](GroupItem& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<GroupStyle, ::pywinui::holder<GroupStyle>>(m, "Microsoft.UI.Xaml.Controls.GroupStyle")
        .def("__repr__", [](const GroupStyle& _self) { return default_repr(_self); } )
    ;
    py::class_<GroupStyleSelector, ::pywinui::holder<GroupStyleSelector>>(m, "Microsoft.UI.Xaml.Controls.GroupStyleSelector")
        .def("__repr__", [](const GroupStyleSelector& _self) { return default_repr(_self); } )
    ;
    py::class_<HasValidationErrorsChangedEventArgs, ::pywinui::holder<HasValidationErrorsChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.HasValidationErrorsChangedEventArgs")
        .def("__repr__", [](const HasValidationErrorsChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<Hub, ::pywinui::holder<Hub>>(m, "Microsoft.UI.Xaml.Controls.Hub")
        .def("__repr__", [](const Hub& _self) { return default_repr(_self); } )
    ;
    py::class_<HubSection, ::pywinui::holder<HubSection>>(m, "Microsoft.UI.Xaml.Controls.HubSection")
        .def("__repr__", [](const HubSection& _self) { return default_repr(_self); } )
    ;
    py::class_<HubSectionCollection, ::pywinui::holder<HubSectionCollection>>(m, "Microsoft.UI.Xaml.Controls.HubSectionCollection")
        .def("__repr__", [](const HubSectionCollection& _self) { return default_repr(_self); } )
    ;
    py::class_<HubSectionHeaderClickEventArgs, ::pywinui::holder<HubSectionHeaderClickEventArgs>>(m, "Microsoft.UI.Xaml.Controls.HubSectionHeaderClickEventArgs")
        .def("__repr__", [](const HubSectionHeaderClickEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<HyperlinkButton, ::pywinui::holder<HyperlinkButton>>(m, "Microsoft.UI.Xaml.Controls.HyperlinkButton")
        .def("__repr__", [](const HyperlinkButton& _self) { return default_repr(_self); } )
        .def_property("Content", [](const HyperlinkButton& _self) { return (_self.Content()); }, [](HyperlinkButton& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<IconElement, ::pywinui::holder<IconElement>>(m, "Microsoft.UI.Xaml.Controls.IconElement")
        .def("__repr__", [](const IconElement& _self) { return default_repr(_self); } )
    ;
    py::class_<IconSource, ::pywinui::holder<IconSource>>(m, "Microsoft.UI.Xaml.Controls.IconSource")
        .def("__repr__", [](const IconSource& _self) { return default_repr(_self); } )
    ;
    py::class_<IconSourceElement, ::pywinui::holder<IconSourceElement>>(m, "Microsoft.UI.Xaml.Controls.IconSourceElement")
        .def("__repr__", [](const IconSourceElement& _self) { return default_repr(_self); } )
    ;
    py::class_<Image, ::pywinui::holder<Image>>(m, "Microsoft.UI.Xaml.Controls.Image")
        .def("__repr__", [](const Image& _self) { return default_repr(_self); } )
    ;
    py::class_<ImageIcon, ::pywinui::holder<ImageIcon>>(m, "Microsoft.UI.Xaml.Controls.ImageIcon")
        .def("__repr__", [](const ImageIcon& _self) { return default_repr(_self); } )
    ;
    py::class_<ImageIconSource, ::pywinui::holder<ImageIconSource>>(m, "Microsoft.UI.Xaml.Controls.ImageIconSource")
        .def("__repr__", [](const ImageIconSource& _self) { return default_repr(_self); } )
    ;
    py::class_<InfoBadge, ::pywinui::holder<InfoBadge>>(m, "Microsoft.UI.Xaml.Controls.InfoBadge")
        .def("__repr__", [](const InfoBadge& _self) { return default_repr(_self); } )
    ;
    py::class_<InfoBadgeTemplateSettings, ::pywinui::holder<InfoBadgeTemplateSettings>>(m, "Microsoft.UI.Xaml.Controls.InfoBadgeTemplateSettings")
        .def("__repr__", [](const InfoBadgeTemplateSettings& _self) { return default_repr(_self); } )
    ;
    py::class_<InfoBar, ::pywinui::holder<InfoBar>>(m, "Microsoft.UI.Xaml.Controls.InfoBar")
        .def("__repr__", [](const InfoBar& _self) { return default_repr(_self); } )
    ;
    py::class_<InfoBarClosedEventArgs, ::pywinui::holder<InfoBarClosedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.InfoBarClosedEventArgs")
        .def("__repr__", [](const InfoBarClosedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<InfoBarClosingEventArgs, ::pywinui::holder<InfoBarClosingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.InfoBarClosingEventArgs")
        .def("__repr__", [](const InfoBarClosingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<InfoBarTemplateSettings, ::pywinui::holder<InfoBarTemplateSettings>>(m, "Microsoft.UI.Xaml.Controls.InfoBarTemplateSettings")
        .def("__repr__", [](const InfoBarTemplateSettings& _self) { return default_repr(_self); } )
    ;
    py::class_<IsTextTrimmedChangedEventArgs, ::pywinui::holder<IsTextTrimmedChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.IsTextTrimmedChangedEventArgs")
        .def("__repr__", [](const IsTextTrimmedChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemClickEventArgs, ::pywinui::holder<ItemClickEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ItemClickEventArgs")
        .def("__repr__", [](const ItemClickEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemCollection, ::pywinui::holder<ItemCollection>>(m, "Microsoft.UI.Xaml.Controls.ItemCollection")
        .def("__repr__", [](const ItemCollection& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemCollectionTransition, ::pywinui::holder<ItemCollectionTransition>>(m, "Microsoft.UI.Xaml.Controls.ItemCollectionTransition")
        .def("__repr__", [](const ItemCollectionTransition& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemCollectionTransitionCompletedEventArgs, ::pywinui::holder<ItemCollectionTransitionCompletedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ItemCollectionTransitionCompletedEventArgs")
        .def("__repr__", [](const ItemCollectionTransitionCompletedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemCollectionTransitionProgress, ::pywinui::holder<ItemCollectionTransitionProgress>>(m, "Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProgress")
        .def("__repr__", [](const ItemCollectionTransitionProgress& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemCollectionTransitionProvider, ::pywinui::holder<ItemCollectionTransitionProvider>>(m, "Microsoft.UI.Xaml.Controls.ItemCollectionTransitionProvider")
        .def("__repr__", [](const ItemCollectionTransitionProvider& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemContainer, ::pywinui::holder<ItemContainer>>(m, "Microsoft.UI.Xaml.Controls.ItemContainer")
        .def("__repr__", [](const ItemContainer& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemContainerGenerator, ::pywinui::holder<ItemContainerGenerator>>(m, "Microsoft.UI.Xaml.Controls.ItemContainerGenerator")
        .def("__repr__", [](const ItemContainerGenerator& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsControl, ::pywinui::holder<ItemsControl>>(m, "Microsoft.UI.Xaml.Controls.ItemsControl")
        .def("__repr__", [](const ItemsControl& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsPanelTemplate, ::pywinui::holder<ItemsPanelTemplate>>(m, "Microsoft.UI.Xaml.Controls.ItemsPanelTemplate")
        .def("__repr__", [](const ItemsPanelTemplate& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsPickedEventArgs, ::pywinui::holder<ItemsPickedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ItemsPickedEventArgs")
        .def("__repr__", [](const ItemsPickedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsPresenter, ::pywinui::holder<ItemsPresenter>>(m, "Microsoft.UI.Xaml.Controls.ItemsPresenter")
        .def("__repr__", [](const ItemsPresenter& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsRepeater, ::pywinui::holder<ItemsRepeater>>(m, "Microsoft.UI.Xaml.Controls.ItemsRepeater")
        .def("__repr__", [](const ItemsRepeater& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsRepeaterElementClearingEventArgs, ::pywinui::holder<ItemsRepeaterElementClearingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ItemsRepeaterElementClearingEventArgs")
        .def("__repr__", [](const ItemsRepeaterElementClearingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsRepeaterElementIndexChangedEventArgs, ::pywinui::holder<ItemsRepeaterElementIndexChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ItemsRepeaterElementIndexChangedEventArgs")
        .def("__repr__", [](const ItemsRepeaterElementIndexChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsRepeaterElementPreparedEventArgs, ::pywinui::holder<ItemsRepeaterElementPreparedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ItemsRepeaterElementPreparedEventArgs")
        .def("__repr__", [](const ItemsRepeaterElementPreparedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsRepeaterScrollHost, ::pywinui::holder<ItemsRepeaterScrollHost>>(m, "Microsoft.UI.Xaml.Controls.ItemsRepeaterScrollHost")
        .def("__repr__", [](const ItemsRepeaterScrollHost& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsSourceView, ::pywinui::holder<ItemsSourceView>>(m, "Microsoft.UI.Xaml.Controls.ItemsSourceView")
        .def("__repr__", [](const ItemsSourceView& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsStackPanel, ::pywinui::holder<ItemsStackPanel>>(m, "Microsoft.UI.Xaml.Controls.ItemsStackPanel")
        .def("__repr__", [](const ItemsStackPanel& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsView, ::pywinui::holder<ItemsView>>(m, "Microsoft.UI.Xaml.Controls.ItemsView")
        .def("__repr__", [](const ItemsView& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsViewItemInvokedEventArgs, ::pywinui::holder<ItemsViewItemInvokedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ItemsViewItemInvokedEventArgs")
        .def("__repr__", [](const ItemsViewItemInvokedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsViewSelectionChangedEventArgs, ::pywinui::holder<ItemsViewSelectionChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ItemsViewSelectionChangedEventArgs")
        .def("__repr__", [](const ItemsViewSelectionChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ItemsWrapGrid, ::pywinui::holder<ItemsWrapGrid>>(m, "Microsoft.UI.Xaml.Controls.ItemsWrapGrid")
        .def("__repr__", [](const ItemsWrapGrid& _self) { return default_repr(_self); } )
    ;
    py::class_<Layout, ::pywinui::holder<Layout>>(m, "Microsoft.UI.Xaml.Controls.Layout")
        .def("__repr__", [](const Layout& _self) { return default_repr(_self); } )
    ;
    py::class_<LayoutContext, ::pywinui::holder<LayoutContext>>(m, "Microsoft.UI.Xaml.Controls.LayoutContext")
        .def("__repr__", [](const LayoutContext& _self) { return default_repr(_self); } )
    ;
    py::class_<LinedFlowLayout, ::pywinui::holder<LinedFlowLayout>>(m, "Microsoft.UI.Xaml.Controls.LinedFlowLayout")
        .def("__repr__", [](const LinedFlowLayout& _self) { return default_repr(_self); } )
    ;
    py::class_<LinedFlowLayoutItemCollectionTransitionProvider, ::pywinui::holder<LinedFlowLayoutItemCollectionTransitionProvider>>(m, "Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemCollectionTransitionProvider")
        .def("__repr__", [](const LinedFlowLayoutItemCollectionTransitionProvider& _self) { return default_repr(_self); } )
    ;
    py::class_<LinedFlowLayoutItemsInfoRequestedEventArgs, ::pywinui::holder<LinedFlowLayoutItemsInfoRequestedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.LinedFlowLayoutItemsInfoRequestedEventArgs")
        .def("__repr__", [](const LinedFlowLayoutItemsInfoRequestedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ListBox, ::pywinui::holder<ListBox>>(m, "Microsoft.UI.Xaml.Controls.ListBox")
        .def("__repr__", [](const ListBox& _self) { return default_repr(_self); } )
    ;
    py::class_<ListBoxItem, ::pywinui::holder<ListBoxItem>>(m, "Microsoft.UI.Xaml.Controls.ListBoxItem")
        .def("__repr__", [](const ListBoxItem& _self) { return default_repr(_self); } )
        .def_property("Content", [](const ListBoxItem& _self) { return (_self.Content()); }, [](ListBoxItem& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<ListPickerFlyout, ::pywinui::holder<ListPickerFlyout>>(m, "Microsoft.UI.Xaml.Controls.ListPickerFlyout")
        .def("__repr__", [](const ListPickerFlyout& _self) { return default_repr(_self); } )
    ;
    py::class_<ListPickerFlyoutPresenter, ::pywinui::holder<ListPickerFlyoutPresenter>>(m, "Microsoft.UI.Xaml.Controls.ListPickerFlyoutPresenter")
        .def("__repr__", [](const ListPickerFlyoutPresenter& _self) { return default_repr(_self); } )
    ;
    py::class_<ListView, ::pywinui::holder<ListView>>(m, "Microsoft.UI.Xaml.Controls.ListView")
        .def("__repr__", [](const ListView& _self) { return default_repr(_self); } )
    ;
    py::class_<ListViewBase, ::pywinui::holder<ListViewBase>>(m, "Microsoft.UI.Xaml.Controls.ListViewBase")
        .def("__repr__", [](const ListViewBase& _self) { return default_repr(_self); } )
    ;
    py::class_<ListViewBaseHeaderItem, ::pywinui::holder<ListViewBaseHeaderItem>>(m, "Microsoft.UI.Xaml.Controls.ListViewBaseHeaderItem")
        .def("__repr__", [](const ListViewBaseHeaderItem& _self) { return default_repr(_self); } )
        .def_property("Content", [](const ListViewBaseHeaderItem& _self) { return (_self.Content()); }, [](ListViewBaseHeaderItem& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<ListViewHeaderItem, ::pywinui::holder<ListViewHeaderItem>>(m, "Microsoft.UI.Xaml.Controls.ListViewHeaderItem")
        .def("__repr__", [](const ListViewHeaderItem& _self) { return default_repr(_self); } )
    ;
    py::class_<ListViewItem, ::pywinui::holder<ListViewItem>>(m, "Microsoft.UI.Xaml.Controls.ListViewItem")
        .def("__repr__", [](const ListViewItem& _self) { return default_repr(_self); } )
        .def_property("Content", [](const ListViewItem& _self) { return (_self.Content()); }, [](ListViewItem& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<ListViewPersistenceHelper, ::pywinui::holder<ListViewPersistenceHelper>>(m, "Microsoft.UI.Xaml.Controls.ListViewPersistenceHelper")
        .def("__repr__", [](const ListViewPersistenceHelper& _self) { return default_repr(_self); } )
    ;
    py::class_<MediaPlaybackSession, ::pywinui::holder<MediaPlaybackSession>>(m, "Windows.Media.Playback.MediaPlaybackSession")
        .def("__repr__", [](const MediaPlaybackSession& _self) { return default_repr(_self); } )
        .def_property_readonly("NaturalDuration", [](const MediaPlaybackSession& _self) { return (_self.NaturalDuration()); })
        .def_property_readonly("PlaybackState", [](const MediaPlaybackSession& _self) { return (_self.PlaybackState()); })
        .def_property_readonly("Position", [](const MediaPlaybackSession& _self) { return (_self.Position()); })
    ;
    py::class_<MediaPlayer, ::pywinui::holder<MediaPlayer>>(m, "Windows.Media.Playback.MediaPlayer")
        .def("__repr__", [](const MediaPlayer& _self) { return default_repr(_self); } )
        .def_property_readonly("PlaybackSession", [](const MediaPlayer& _self) { return (_self.PlaybackSession()); })
        .def("Pause", [](MediaPlayer& _self) { return (_self.Pause()); })
        .def("Play", [](MediaPlayer& _self) { return (_self.Play()); })
        .def("StepBackwardOneFrame", [](MediaPlayer& _self) { return (_self.StepBackwardOneFrame()); })
        .def("StepForwardOneFrame", [](MediaPlayer& _self) { return (_self.StepForwardOneFrame()); })
    ;
    py::class_<MediaPlayerElement, ::pywinui::holder<MediaPlayerElement>>(m, "Microsoft.UI.Xaml.Controls.MediaPlayerElement")
        .def("__repr__", [](const MediaPlayerElement& _self) { return default_repr(_self); } )
        .def_property_readonly("MediaPlayer", [](const MediaPlayerElement& _self) { return (_self.MediaPlayer()); })
    ;
    py::class_<MediaPlayerPresenter, ::pywinui::holder<MediaPlayerPresenter>>(m, "Microsoft.UI.Xaml.Controls.MediaPlayerPresenter")
        .def("__repr__", [](const MediaPlayerPresenter& _self) { return default_repr(_self); } )
    ;
    py::class_<MediaTransportControls, ::pywinui::holder<MediaTransportControls>>(m, "Microsoft.UI.Xaml.Controls.MediaTransportControls")
        .def("__repr__", [](const MediaTransportControls& _self) { return default_repr(_self); } )
    ;
    py::class_<MediaTransportControlsHelper, ::pywinui::holder<MediaTransportControlsHelper>>(m, "Microsoft.UI.Xaml.Controls.MediaTransportControlsHelper")
        .def("__repr__", [](const MediaTransportControlsHelper& _self) { return default_repr(_self); } )
    ;
    py::class_<MenuBar, ::pywinui::holder<MenuBar>>(m, "Microsoft.UI.Xaml.Controls.MenuBar")
        .def("__repr__", [](const MenuBar& _self) { return default_repr(_self); } )
    ;
    py::class_<MenuBarItem, ::pywinui::holder<MenuBarItem>>(m, "Microsoft.UI.Xaml.Controls.MenuBarItem")
        .def("__repr__", [](const MenuBarItem& _self) { return default_repr(_self); } )
    ;
    py::class_<MenuBarItemFlyout, ::pywinui::holder<MenuBarItemFlyout>>(m, "Microsoft.UI.Xaml.Controls.MenuBarItemFlyout")
        .def("__repr__", [](const MenuBarItemFlyout& _self) { return default_repr(_self); } )
    ;
    py::class_<MenuFlyout, ::pywinui::holder<MenuFlyout>>(m, "Microsoft.UI.Xaml.Controls.MenuFlyout")
        .def("__repr__", [](const MenuFlyout& _self) { return default_repr(_self); } )
    ;
    py::class_<MenuFlyoutItem, ::pywinui::holder<MenuFlyoutItem>>(m, "Microsoft.UI.Xaml.Controls.MenuFlyoutItem")
        .def("__repr__", [](const MenuFlyoutItem& _self) { return default_repr(_self); } )
    ;
    py::class_<MenuFlyoutItemBase, ::pywinui::holder<MenuFlyoutItemBase>>(m, "Microsoft.UI.Xaml.Controls.MenuFlyoutItemBase")
        .def("__repr__", [](const MenuFlyoutItemBase& _self) { return default_repr(_self); } )
    ;
    py::class_<MenuFlyoutPresenter, ::pywinui::holder<MenuFlyoutPresenter>>(m, "Microsoft.UI.Xaml.Controls.MenuFlyoutPresenter")
        .def("__repr__", [](const MenuFlyoutPresenter& _self) { return default_repr(_self); } )
    ;
    py::class_<MenuFlyoutSeparator, ::pywinui::holder<MenuFlyoutSeparator>>(m, "Microsoft.UI.Xaml.Controls.MenuFlyoutSeparator")
        .def("__repr__", [](const MenuFlyoutSeparator& _self) { return default_repr(_self); } )
    ;
    py::class_<MenuFlyoutSubItem, ::pywinui::holder<MenuFlyoutSubItem>>(m, "Microsoft.UI.Xaml.Controls.MenuFlyoutSubItem")
        .def("__repr__", [](const MenuFlyoutSubItem& _self) { return default_repr(_self); } )
    ;
    py::class_<NavigationView, ::pywinui::holder<NavigationView>>(m, "Microsoft.UI.Xaml.Controls.NavigationView")
        .def("__repr__", [](const NavigationView& _self) { return default_repr(_self); } )
        .def_property("Content", [](const NavigationView& _self) { return (_self.Content()); }, [](NavigationView& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<NavigationViewBackRequestedEventArgs, ::pywinui::holder<NavigationViewBackRequestedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewBackRequestedEventArgs")
        .def("__repr__", [](const NavigationViewBackRequestedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<NavigationViewDisplayModeChangedEventArgs, ::pywinui::holder<NavigationViewDisplayModeChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewDisplayModeChangedEventArgs")
        .def("__repr__", [](const NavigationViewDisplayModeChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<NavigationViewItem, ::pywinui::holder<NavigationViewItem>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewItem")
        .def("__repr__", [](const NavigationViewItem& _self) { return default_repr(_self); } )
    ;
    py::class_<NavigationViewItemBase, ::pywinui::holder<NavigationViewItemBase>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewItemBase")
        .def("__repr__", [](const NavigationViewItemBase& _self) { return default_repr(_self); } )
        .def_property("Content", [](const NavigationViewItemBase& _self) { return (_self.Content()); }, [](NavigationViewItemBase& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<NavigationViewItemCollapsedEventArgs, ::pywinui::holder<NavigationViewItemCollapsedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewItemCollapsedEventArgs")
        .def("__repr__", [](const NavigationViewItemCollapsedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<NavigationViewItemExpandingEventArgs, ::pywinui::holder<NavigationViewItemExpandingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewItemExpandingEventArgs")
        .def("__repr__", [](const NavigationViewItemExpandingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<NavigationViewItemHeader, ::pywinui::holder<NavigationViewItemHeader>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewItemHeader")
        .def("__repr__", [](const NavigationViewItemHeader& _self) { return default_repr(_self); } )
    ;
    py::class_<NavigationViewItemInvokedEventArgs, ::pywinui::holder<NavigationViewItemInvokedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewItemInvokedEventArgs")
        .def("__repr__", [](const NavigationViewItemInvokedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<NavigationViewItemSeparator, ::pywinui::holder<NavigationViewItemSeparator>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewItemSeparator")
        .def("__repr__", [](const NavigationViewItemSeparator& _self) { return default_repr(_self); } )
    ;
    py::class_<NavigationViewPaneClosingEventArgs, ::pywinui::holder<NavigationViewPaneClosingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewPaneClosingEventArgs")
        .def("__repr__", [](const NavigationViewPaneClosingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<NavigationViewSelectionChangedEventArgs, ::pywinui::holder<NavigationViewSelectionChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewSelectionChangedEventArgs")
        .def("__repr__", [](const NavigationViewSelectionChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<NavigationViewTemplateSettings, ::pywinui::holder<NavigationViewTemplateSettings>>(m, "Microsoft.UI.Xaml.Controls.NavigationViewTemplateSettings")
        .def("__repr__", [](const NavigationViewTemplateSettings& _self) { return default_repr(_self); } )
    ;
    py::class_<NonVirtualizingLayout, ::pywinui::holder<NonVirtualizingLayout>>(m, "Microsoft.UI.Xaml.Controls.NonVirtualizingLayout")
        .def("__repr__", [](const NonVirtualizingLayout& _self) { return default_repr(_self); } )
    ;
    py::class_<NonVirtualizingLayoutContext, ::pywinui::holder<NonVirtualizingLayoutContext>>(m, "Microsoft.UI.Xaml.Controls.NonVirtualizingLayoutContext")
        .def("__repr__", [](const NonVirtualizingLayoutContext& _self) { return default_repr(_self); } )
    ;
    py::class_<NumberBox, ::pywinui::holder<NumberBox>>(m, "Microsoft.UI.Xaml.Controls.NumberBox")
        .def("__repr__", [](const NumberBox& _self) { return default_repr(_self); } )
    ;
    py::class_<NumberBoxValueChangedEventArgs, ::pywinui::holder<NumberBoxValueChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.NumberBoxValueChangedEventArgs")
        .def("__repr__", [](const NumberBoxValueChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<Page, ::pywinui::holder<Page>>(m, "Microsoft.UI.Xaml.Controls.Page")
        .def("__repr__", [](const Page& _self) { return default_repr(_self); } )
    ;
    py::class_<Panel, ::pywinui::holder<Panel>>(m, "Microsoft.UI.Xaml.Controls.Panel")
        .def("__repr__", [](const Panel& _self) { return default_repr(_self); } )
    ;
    py::class_<ParallaxView, ::pywinui::holder<ParallaxView>>(m, "Microsoft.UI.Xaml.Controls.ParallaxView")
        .def("__repr__", [](const ParallaxView& _self) { return default_repr(_self); } )
    ;
    py::class_<PasswordBox, ::pywinui::holder<PasswordBox>>(m, "Microsoft.UI.Xaml.Controls.PasswordBox")
        .def("__repr__", [](const PasswordBox& _self) { return default_repr(_self); } )
    ;
    py::class_<PasswordBoxPasswordChangingEventArgs, ::pywinui::holder<PasswordBoxPasswordChangingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.PasswordBoxPasswordChangingEventArgs")
        .def("__repr__", [](const PasswordBoxPasswordChangingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<PathIcon, ::pywinui::holder<PathIcon>>(m, "Microsoft.UI.Xaml.Controls.PathIcon")
        .def("__repr__", [](const PathIcon& _self) { return default_repr(_self); } )
    ;
    py::class_<PathIconSource, ::pywinui::holder<PathIconSource>>(m, "Microsoft.UI.Xaml.Controls.PathIconSource")
        .def("__repr__", [](const PathIconSource& _self) { return default_repr(_self); } )
    ;
    py::class_<PersonPicture, ::pywinui::holder<PersonPicture>>(m, "Microsoft.UI.Xaml.Controls.PersonPicture")
        .def("__repr__", [](const PersonPicture& _self) { return default_repr(_self); } )
    ;
    py::class_<PersonPictureTemplateSettings, ::pywinui::holder<PersonPictureTemplateSettings>>(m, "Microsoft.UI.Xaml.Controls.PersonPictureTemplateSettings")
        .def("__repr__", [](const PersonPictureTemplateSettings& _self) { return default_repr(_self); } )
    ;
    py::class_<PickerConfirmedEventArgs, ::pywinui::holder<PickerConfirmedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.PickerConfirmedEventArgs")
        .def("__repr__", [](const PickerConfirmedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<PickerFlyout, ::pywinui::holder<PickerFlyout>>(m, "Microsoft.UI.Xaml.Controls.PickerFlyout")
        .def("__repr__", [](const PickerFlyout& _self) { return default_repr(_self); } )
    ;
    py::class_<PickerFlyoutPresenter, ::pywinui::holder<PickerFlyoutPresenter>>(m, "Microsoft.UI.Xaml.Controls.PickerFlyoutPresenter")
        .def("__repr__", [](const PickerFlyoutPresenter& _self) { return default_repr(_self); } )
        .def_property("Content", [](const PickerFlyoutPresenter& _self) { return (_self.Content()); }, [](PickerFlyoutPresenter& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<PipsPager, ::pywinui::holder<PipsPager>>(m, "Microsoft.UI.Xaml.Controls.PipsPager")
        .def("__repr__", [](const PipsPager& _self) { return default_repr(_self); } )
    ;
    py::class_<PipsPagerSelectedIndexChangedEventArgs, ::pywinui::holder<PipsPagerSelectedIndexChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.PipsPagerSelectedIndexChangedEventArgs")
        .def("__repr__", [](const PipsPagerSelectedIndexChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<PipsPagerTemplateSettings, ::pywinui::holder<PipsPagerTemplateSettings>>(m, "Microsoft.UI.Xaml.Controls.PipsPagerTemplateSettings")
        .def("__repr__", [](const PipsPagerTemplateSettings& _self) { return default_repr(_self); } )
    ;
    py::class_<Pivot, ::pywinui::holder<Pivot>>(m, "Microsoft.UI.Xaml.Controls.Pivot")
        .def("__repr__", [](const Pivot& _self) { return default_repr(_self); } )
    ;
    py::class_<PivotItem, ::pywinui::holder<PivotItem>>(m, "Microsoft.UI.Xaml.Controls.PivotItem")
        .def("__repr__", [](const PivotItem& _self) { return default_repr(_self); } )
        .def_property("Content", [](const PivotItem& _self) { return (_self.Content()); }, [](PivotItem& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<PivotItemEventArgs, ::pywinui::holder<PivotItemEventArgs>>(m, "Microsoft.UI.Xaml.Controls.PivotItemEventArgs")
        .def("__repr__", [](const PivotItemEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ProgressBar, ::pywinui::holder<ProgressBar>>(m, "Microsoft.UI.Xaml.Controls.ProgressBar")
        .def("__repr__", [](const ProgressBar& _self) { return default_repr(_self); } )
    ;
    py::class_<ProgressBarTemplateSettings, ::pywinui::holder<ProgressBarTemplateSettings>>(m, "Microsoft.UI.Xaml.Controls.ProgressBarTemplateSettings")
        .def("__repr__", [](const ProgressBarTemplateSettings& _self) { return default_repr(_self); } )
    ;
    py::class_<ProgressRing, ::pywinui::holder<ProgressRing>>(m, "Microsoft.UI.Xaml.Controls.ProgressRing")
        .def("__repr__", [](const ProgressRing& _self) { return default_repr(_self); } )
    ;
    py::class_<ProgressRingTemplateSettings, ::pywinui::holder<ProgressRingTemplateSettings>>(m, "Microsoft.UI.Xaml.Controls.ProgressRingTemplateSettings")
        .def("__repr__", [](const ProgressRingTemplateSettings& _self) { return default_repr(_self); } )
    ;
    py::class_<RadioButton, ::pywinui::holder<RadioButton>>(m, "Microsoft.UI.Xaml.Controls.RadioButton")
        .def("__repr__", [](const RadioButton& _self) { return default_repr(_self); } )
        .def_property("Content", [](const RadioButton& _self) { return (_self.Content()); }, [](RadioButton& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<RadioButtons, ::pywinui::holder<RadioButtons>>(m, "Microsoft.UI.Xaml.Controls.RadioButtons")
        .def("__repr__", [](const RadioButtons& _self) { return default_repr(_self); } )
    ;
    py::class_<RadioMenuFlyoutItem, ::pywinui::holder<RadioMenuFlyoutItem>>(m, "Microsoft.UI.Xaml.Controls.RadioMenuFlyoutItem")
        .def("__repr__", [](const RadioMenuFlyoutItem& _self) { return default_repr(_self); } )
    ;
    py::class_<RatingControl, ::pywinui::holder<RatingControl>>(m, "Microsoft.UI.Xaml.Controls.RatingControl")
        .def("__repr__", [](const RatingControl& _self) { return default_repr(_self); } )
    ;
    py::class_<RatingItemFontInfo, ::pywinui::holder<RatingItemFontInfo>>(m, "Microsoft.UI.Xaml.Controls.RatingItemFontInfo")
        .def("__repr__", [](const RatingItemFontInfo& _self) { return default_repr(_self); } )
    ;
    py::class_<RatingItemImageInfo, ::pywinui::holder<RatingItemImageInfo>>(m, "Microsoft.UI.Xaml.Controls.RatingItemImageInfo")
        .def("__repr__", [](const RatingItemImageInfo& _self) { return default_repr(_self); } )
    ;
    py::class_<RatingItemInfo, ::pywinui::holder<RatingItemInfo>>(m, "Microsoft.UI.Xaml.Controls.RatingItemInfo")
        .def("__repr__", [](const RatingItemInfo& _self) { return default_repr(_self); } )
    ;
    py::class_<RefreshContainer, ::pywinui::holder<RefreshContainer>>(m, "Microsoft.UI.Xaml.Controls.RefreshContainer")
        .def("__repr__", [](const RefreshContainer& _self) { return default_repr(_self); } )
        .def_property("Content", [](const RefreshContainer& _self) { return (_self.Content()); }, [](RefreshContainer& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<RefreshInteractionRatioChangedEventArgs, ::pywinui::holder<RefreshInteractionRatioChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.RefreshInteractionRatioChangedEventArgs")
        .def("__repr__", [](const RefreshInteractionRatioChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<RefreshRequestedEventArgs, ::pywinui::holder<RefreshRequestedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.RefreshRequestedEventArgs")
        .def("__repr__", [](const RefreshRequestedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<RefreshStateChangedEventArgs, ::pywinui::holder<RefreshStateChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.RefreshStateChangedEventArgs")
        .def("__repr__", [](const RefreshStateChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<RefreshVisualizer, ::pywinui::holder<RefreshVisualizer>>(m, "Microsoft.UI.Xaml.Controls.RefreshVisualizer")
        .def("__repr__", [](const RefreshVisualizer& _self) { return default_repr(_self); } )
    ;
    py::class_<RelativePanel, ::pywinui::holder<RelativePanel>>(m, "Microsoft.UI.Xaml.Controls.RelativePanel")
        .def("__repr__", [](const RelativePanel& _self) { return default_repr(_self); } )
    ;
    py::class_<RevealListViewItemPresenter, ::pywinui::holder<RevealListViewItemPresenter>>(m, "Microsoft.UI.Xaml.Controls.RevealListViewItemPresenter")
        .def("__repr__", [](const RevealListViewItemPresenter& _self) { return default_repr(_self); } )
    ;
    py::class_<RichEditBox, ::pywinui::holder<RichEditBox>>(m, "Microsoft.UI.Xaml.Controls.RichEditBox")
        .def("__repr__", [](const RichEditBox& _self) { return default_repr(_self); } )
    ;
    py::class_<RichEditBoxSelectionChangingEventArgs, ::pywinui::holder<RichEditBoxSelectionChangingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.RichEditBoxSelectionChangingEventArgs")
        .def("__repr__", [](const RichEditBoxSelectionChangingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<RichEditBoxTextChangingEventArgs, ::pywinui::holder<RichEditBoxTextChangingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.RichEditBoxTextChangingEventArgs")
        .def("__repr__", [](const RichEditBoxTextChangingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<RichTextBlock, ::pywinui::holder<RichTextBlock>>(m, "Microsoft.UI.Xaml.Controls.RichTextBlock")
        .def("__repr__", [](const RichTextBlock& _self) { return default_repr(_self); } )
    ;
    py::class_<RichTextBlockOverflow, ::pywinui::holder<RichTextBlockOverflow>>(m, "Microsoft.UI.Xaml.Controls.RichTextBlockOverflow")
        .def("__repr__", [](const RichTextBlockOverflow& _self) { return default_repr(_self); } )
    ;
    py::class_<RowDefinition, ::pywinui::holder<RowDefinition>>(m, "Microsoft.UI.Xaml.Controls.RowDefinition")
        .def("__repr__", [](const RowDefinition& _self) { return default_repr(_self); } )
    ;
    py::class_<RowDefinitionCollection, ::pywinui::holder<RowDefinitionCollection>>(m, "Microsoft.UI.Xaml.Controls.RowDefinitionCollection")
        .def("__repr__", [](const RowDefinitionCollection& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollContentPresenter, ::pywinui::holder<ScrollContentPresenter>>(m, "Microsoft.UI.Xaml.Controls.ScrollContentPresenter")
        .def("__repr__", [](const ScrollContentPresenter& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollingAnchorRequestedEventArgs, ::pywinui::holder<ScrollingAnchorRequestedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ScrollingAnchorRequestedEventArgs")
        .def("__repr__", [](const ScrollingAnchorRequestedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollingBringingIntoViewEventArgs, ::pywinui::holder<ScrollingBringingIntoViewEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ScrollingBringingIntoViewEventArgs")
        .def("__repr__", [](const ScrollingBringingIntoViewEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollingScrollAnimationStartingEventArgs, ::pywinui::holder<ScrollingScrollAnimationStartingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ScrollingScrollAnimationStartingEventArgs")
        .def("__repr__", [](const ScrollingScrollAnimationStartingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollingScrollCompletedEventArgs, ::pywinui::holder<ScrollingScrollCompletedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ScrollingScrollCompletedEventArgs")
        .def("__repr__", [](const ScrollingScrollCompletedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollingScrollOptions, ::pywinui::holder<ScrollingScrollOptions>>(m, "Microsoft.UI.Xaml.Controls.ScrollingScrollOptions")
        .def("__repr__", [](const ScrollingScrollOptions& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollingZoomAnimationStartingEventArgs, ::pywinui::holder<ScrollingZoomAnimationStartingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ScrollingZoomAnimationStartingEventArgs")
        .def("__repr__", [](const ScrollingZoomAnimationStartingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollingZoomCompletedEventArgs, ::pywinui::holder<ScrollingZoomCompletedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ScrollingZoomCompletedEventArgs")
        .def("__repr__", [](const ScrollingZoomCompletedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollingZoomOptions, ::pywinui::holder<ScrollingZoomOptions>>(m, "Microsoft.UI.Xaml.Controls.ScrollingZoomOptions")
        .def("__repr__", [](const ScrollingZoomOptions& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollView, ::pywinui::holder<ScrollView>>(m, "Microsoft.UI.Xaml.Controls.ScrollView")
        .def("__repr__", [](const ScrollView& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollViewer, ::pywinui::holder<ScrollViewer>>(m, "Microsoft.UI.Xaml.Controls.ScrollViewer")
        .def("__repr__", [](const ScrollViewer& _self) { return default_repr(_self); } )
        .def_property("Content", [](const ScrollViewer& _self) { return (_self.Content()); }, [](ScrollViewer& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<ScrollViewerView, ::pywinui::holder<ScrollViewerView>>(m, "Microsoft.UI.Xaml.Controls.ScrollViewerView")
        .def("__repr__", [](const ScrollViewerView& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollViewerViewChangedEventArgs, ::pywinui::holder<ScrollViewerViewChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ScrollViewerViewChangedEventArgs")
        .def("__repr__", [](const ScrollViewerViewChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ScrollViewerViewChangingEventArgs, ::pywinui::holder<ScrollViewerViewChangingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ScrollViewerViewChangingEventArgs")
        .def("__repr__", [](const ScrollViewerViewChangingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<SectionsInViewChangedEventArgs, ::pywinui::holder<SectionsInViewChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.SectionsInViewChangedEventArgs")
        .def("__repr__", [](const SectionsInViewChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<SelectionChangedEventArgs, ::pywinui::holder<SelectionChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.SelectionChangedEventArgs")
        .def("__repr__", [](const SelectionChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<SemanticZoom, ::pywinui::holder<SemanticZoom>>(m, "Microsoft.UI.Xaml.Controls.SemanticZoom")
        .def("__repr__", [](const SemanticZoom& _self) { return default_repr(_self); } )
    ;
    py::class_<SemanticZoomLocation, ::pywinui::holder<SemanticZoomLocation>>(m, "Microsoft.UI.Xaml.Controls.SemanticZoomLocation")
        .def("__repr__", [](const SemanticZoomLocation& _self) { return default_repr(_self); } )
    ;
    py::class_<SemanticZoomViewChangedEventArgs, ::pywinui::holder<SemanticZoomViewChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.SemanticZoomViewChangedEventArgs")
        .def("__repr__", [](const SemanticZoomViewChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<Slider, ::pywinui::holder<Slider>>(m, "Microsoft.UI.Xaml.Controls.Slider")
        .def("__repr__", [](const Slider& _self) { return default_repr(_self); } )
    ;
    py::class_<SplitButton, ::pywinui::holder<SplitButton>>(m, "Microsoft.UI.Xaml.Controls.SplitButton")
        .def("__repr__", [](const SplitButton& _self) { return default_repr(_self); } )
        .def_property("Content", [](const SplitButton& _self) { return (_self.Content()); }, [](SplitButton& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<SplitButtonClickEventArgs, ::pywinui::holder<SplitButtonClickEventArgs>>(m, "Microsoft.UI.Xaml.Controls.SplitButtonClickEventArgs")
        .def("__repr__", [](const SplitButtonClickEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<SplitView, ::pywinui::holder<SplitView>>(m, "Microsoft.UI.Xaml.Controls.SplitView")
        .def("__repr__", [](const SplitView& _self) { return default_repr(_self); } )
    ;
    py::class_<SplitViewPaneClosingEventArgs, ::pywinui::holder<SplitViewPaneClosingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.SplitViewPaneClosingEventArgs")
        .def("__repr__", [](const SplitViewPaneClosingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<StackLayout, ::pywinui::holder<StackLayout>>(m, "Microsoft.UI.Xaml.Controls.StackLayout")
        .def("__repr__", [](const StackLayout& _self) { return default_repr(_self); } )
    ;
    py::class_<StackPanel, ::pywinui::holder<StackPanel>>(m, "Microsoft.UI.Xaml.Controls.StackPanel")
        .def("__repr__", [](const StackPanel& _self) { return default_repr(_self); } )
    ;
    py::class_<StyleSelector, ::pywinui::holder<StyleSelector>>(m, "Microsoft.UI.Xaml.Controls.StyleSelector")
        .def("__repr__", [](const StyleSelector& _self) { return default_repr(_self); } )
    ;
    py::class_<SwapChainPanel, ::pywinui::holder<SwapChainPanel>>(m, "Microsoft.UI.Xaml.Controls.SwapChainPanel")
        .def("__repr__", [](const SwapChainPanel& _self) { return default_repr(_self); } )
    ;
    py::class_<SwipeControl, ::pywinui::holder<SwipeControl>>(m, "Microsoft.UI.Xaml.Controls.SwipeControl")
        .def("__repr__", [](const SwipeControl& _self) { return default_repr(_self); } )
        .def_property("Content", [](const SwipeControl& _self) { return (_self.Content()); }, [](SwipeControl& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<SwipeItem, ::pywinui::holder<SwipeItem>>(m, "Microsoft.UI.Xaml.Controls.SwipeItem")
        .def("__repr__", [](const SwipeItem& _self) { return default_repr(_self); } )
    ;
    py::class_<SwipeItemInvokedEventArgs, ::pywinui::holder<SwipeItemInvokedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.SwipeItemInvokedEventArgs")
        .def("__repr__", [](const SwipeItemInvokedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<SwipeItems, ::pywinui::holder<SwipeItems>>(m, "Microsoft.UI.Xaml.Controls.SwipeItems")
        .def("__repr__", [](const SwipeItems& _self) { return default_repr(_self); } )
    ;
    py::class_<SymbolIcon, ::pywinui::holder<SymbolIcon>>(m, "Microsoft.UI.Xaml.Controls.SymbolIcon")
        .def("__repr__", [](const SymbolIcon& _self) { return default_repr(_self); } )
    ;
    py::class_<SymbolIconSource, ::pywinui::holder<SymbolIconSource>>(m, "Microsoft.UI.Xaml.Controls.SymbolIconSource")
        .def("__repr__", [](const SymbolIconSource& _self) { return default_repr(_self); } )
    ;
    py::class_<TabView, ::pywinui::holder<TabView>>(m, "Microsoft.UI.Xaml.Controls.TabView")
        .def("__repr__", [](const TabView& _self) { return default_repr(_self); } )
    ;
    py::class_<TabViewItem, ::pywinui::holder<TabViewItem>>(m, "Microsoft.UI.Xaml.Controls.TabViewItem")
        .def("__repr__", [](const TabViewItem& _self) { return default_repr(_self); } )
    ;
    py::class_<TabViewItemTemplateSettings, ::pywinui::holder<TabViewItemTemplateSettings>>(m, "Microsoft.UI.Xaml.Controls.TabViewItemTemplateSettings")
        .def("__repr__", [](const TabViewItemTemplateSettings& _self) { return default_repr(_self); } )
    ;
    py::class_<TabViewTabCloseRequestedEventArgs, ::pywinui::holder<TabViewTabCloseRequestedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TabViewTabCloseRequestedEventArgs")
        .def("__repr__", [](const TabViewTabCloseRequestedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TabViewTabDragCompletedEventArgs, ::pywinui::holder<TabViewTabDragCompletedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TabViewTabDragCompletedEventArgs")
        .def("__repr__", [](const TabViewTabDragCompletedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TabViewTabDragStartingEventArgs, ::pywinui::holder<TabViewTabDragStartingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TabViewTabDragStartingEventArgs")
        .def("__repr__", [](const TabViewTabDragStartingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TabViewTabDroppedOutsideEventArgs, ::pywinui::holder<TabViewTabDroppedOutsideEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TabViewTabDroppedOutsideEventArgs")
        .def("__repr__", [](const TabViewTabDroppedOutsideEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TeachingTip, ::pywinui::holder<TeachingTip>>(m, "Microsoft.UI.Xaml.Controls.TeachingTip")
        .def("__repr__", [](const TeachingTip& _self) { return default_repr(_self); } )
        .def_property("Content", [](const TeachingTip& _self) { return (_self.Content()); }, [](TeachingTip& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<TeachingTipClosedEventArgs, ::pywinui::holder<TeachingTipClosedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TeachingTipClosedEventArgs")
        .def("__repr__", [](const TeachingTipClosedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TeachingTipClosingEventArgs, ::pywinui::holder<TeachingTipClosingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TeachingTipClosingEventArgs")
        .def("__repr__", [](const TeachingTipClosingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TeachingTipTemplateSettings, ::pywinui::holder<TeachingTipTemplateSettings>>(m, "Microsoft.UI.Xaml.Controls.TeachingTipTemplateSettings")
        .def("__repr__", [](const TeachingTipTemplateSettings& _self) { return default_repr(_self); } )
    ;
    py::class_<TextBlock, ::pywinui::holder<TextBlock>>(m, "Microsoft.UI.Xaml.Controls.TextBlock")
        .def("__repr__", [](const TextBlock& _self) { return default_repr(_self); } )
    ;
    py::class_<TextBox, ::pywinui::holder<TextBox>>(m, "Microsoft.UI.Xaml.Controls.TextBox")
        .def("__repr__", [](const TextBox& _self) { return default_repr(_self); } )
    ;
    py::class_<TextBoxBeforeTextChangingEventArgs, ::pywinui::holder<TextBoxBeforeTextChangingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TextBoxBeforeTextChangingEventArgs")
        .def("__repr__", [](const TextBoxBeforeTextChangingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TextBoxSelectionChangingEventArgs, ::pywinui::holder<TextBoxSelectionChangingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TextBoxSelectionChangingEventArgs")
        .def("__repr__", [](const TextBoxSelectionChangingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TextBoxTextChangingEventArgs, ::pywinui::holder<TextBoxTextChangingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TextBoxTextChangingEventArgs")
        .def("__repr__", [](const TextBoxTextChangingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TextChangedEventArgs, ::pywinui::holder<TextChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TextChangedEventArgs")
        .def("__repr__", [](const TextChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TextCommandBarFlyout, ::pywinui::holder<TextCommandBarFlyout>>(m, "Microsoft.UI.Xaml.Controls.TextCommandBarFlyout")
        .def("__repr__", [](const TextCommandBarFlyout& _self) { return default_repr(_self); } )
    ;
    py::class_<TextCompositionChangedEventArgs, ::pywinui::holder<TextCompositionChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TextCompositionChangedEventArgs")
        .def("__repr__", [](const TextCompositionChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TextCompositionEndedEventArgs, ::pywinui::holder<TextCompositionEndedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TextCompositionEndedEventArgs")
        .def("__repr__", [](const TextCompositionEndedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TextCompositionStartedEventArgs, ::pywinui::holder<TextCompositionStartedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TextCompositionStartedEventArgs")
        .def("__repr__", [](const TextCompositionStartedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TextControlCopyingToClipboardEventArgs, ::pywinui::holder<TextControlCopyingToClipboardEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TextControlCopyingToClipboardEventArgs")
        .def("__repr__", [](const TextControlCopyingToClipboardEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TextControlCuttingToClipboardEventArgs, ::pywinui::holder<TextControlCuttingToClipboardEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TextControlCuttingToClipboardEventArgs")
        .def("__repr__", [](const TextControlCuttingToClipboardEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TextControlPasteEventArgs, ::pywinui::holder<TextControlPasteEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TextControlPasteEventArgs")
        .def("__repr__", [](const TextControlPasteEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TimePickedEventArgs, ::pywinui::holder<TimePickedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TimePickedEventArgs")
        .def("__repr__", [](const TimePickedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TimePicker, ::pywinui::holder<TimePicker>>(m, "Microsoft.UI.Xaml.Controls.TimePicker")
        .def("__repr__", [](const TimePicker& _self) { return default_repr(_self); } )
    ;
    py::class_<TimePickerFlyout, ::pywinui::holder<TimePickerFlyout>>(m, "Microsoft.UI.Xaml.Controls.TimePickerFlyout")
        .def("__repr__", [](const TimePickerFlyout& _self) { return default_repr(_self); } )
    ;
    py::class_<TimePickerFlyoutPresenter, ::pywinui::holder<TimePickerFlyoutPresenter>>(m, "Microsoft.UI.Xaml.Controls.TimePickerFlyoutPresenter")
        .def("__repr__", [](const TimePickerFlyoutPresenter& _self) { return default_repr(_self); } )
    ;
    py::class_<TimePickerSelectedValueChangedEventArgs, ::pywinui::holder<TimePickerSelectedValueChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TimePickerSelectedValueChangedEventArgs")
        .def("__repr__", [](const TimePickerSelectedValueChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TimePickerValueChangedEventArgs, ::pywinui::holder<TimePickerValueChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TimePickerValueChangedEventArgs")
        .def("__repr__", [](const TimePickerValueChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ToggleMenuFlyoutItem, ::pywinui::holder<ToggleMenuFlyoutItem>>(m, "Microsoft.UI.Xaml.Controls.ToggleMenuFlyoutItem")
        .def("__repr__", [](const ToggleMenuFlyoutItem& _self) { return default_repr(_self); } )
    ;
    py::class_<ToggleSplitButton, ::pywinui::holder<ToggleSplitButton>>(m, "Microsoft.UI.Xaml.Controls.ToggleSplitButton")
        .def("__repr__", [](const ToggleSplitButton& _self) { return default_repr(_self); } )
    ;
    py::class_<ToggleSplitButtonIsCheckedChangedEventArgs, ::pywinui::holder<ToggleSplitButtonIsCheckedChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.ToggleSplitButtonIsCheckedChangedEventArgs")
        .def("__repr__", [](const ToggleSplitButtonIsCheckedChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<ToggleSwitch, ::pywinui::holder<ToggleSwitch>>(m, "Microsoft.UI.Xaml.Controls.ToggleSwitch")
        .def("__repr__", [](const ToggleSwitch& _self) { return default_repr(_self); } )
    ;
    py::class_<ToolTip, ::pywinui::holder<ToolTip>>(m, "Microsoft.UI.Xaml.Controls.ToolTip")
        .def("__repr__", [](const ToolTip& _self) { return default_repr(_self); } )
        .def_property("Content", [](const ToolTip& _self) { return (_self.Content()); }, [](ToolTip& _self, IInspectable v) { return _self.Content(v); })
    ;
    py::class_<ToolTipService, ::pywinui::holder<ToolTipService>>(m, "Microsoft.UI.Xaml.Controls.ToolTipService")
        .def("__repr__", [](const ToolTipService& _self) { return default_repr(_self); } )
    ;
    py::class_<TreeView, ::pywinui::holder<TreeView>>(m, "Microsoft.UI.Xaml.Controls.TreeView")
        .def("__repr__", [](const TreeView& _self) { return default_repr(_self); } )
    ;
    py::class_<TreeViewCollapsedEventArgs, ::pywinui::holder<TreeViewCollapsedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TreeViewCollapsedEventArgs")
        .def("__repr__", [](const TreeViewCollapsedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TreeViewDragItemsCompletedEventArgs, ::pywinui::holder<TreeViewDragItemsCompletedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TreeViewDragItemsCompletedEventArgs")
        .def("__repr__", [](const TreeViewDragItemsCompletedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TreeViewDragItemsStartingEventArgs, ::pywinui::holder<TreeViewDragItemsStartingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TreeViewDragItemsStartingEventArgs")
        .def("__repr__", [](const TreeViewDragItemsStartingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TreeViewExpandingEventArgs, ::pywinui::holder<TreeViewExpandingEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TreeViewExpandingEventArgs")
        .def("__repr__", [](const TreeViewExpandingEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TreeViewItem, ::pywinui::holder<TreeViewItem>>(m, "Microsoft.UI.Xaml.Controls.TreeViewItem")
        .def("__repr__", [](const TreeViewItem& _self) { return default_repr(_self); } )
    ;
    py::class_<TreeViewItemInvokedEventArgs, ::pywinui::holder<TreeViewItemInvokedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TreeViewItemInvokedEventArgs")
        .def("__repr__", [](const TreeViewItemInvokedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TreeViewItemTemplateSettings, ::pywinui::holder<TreeViewItemTemplateSettings>>(m, "Microsoft.UI.Xaml.Controls.TreeViewItemTemplateSettings")
        .def("__repr__", [](const TreeViewItemTemplateSettings& _self) { return default_repr(_self); } )
    ;
    py::class_<TreeViewList, ::pywinui::holder<TreeViewList>>(m, "Microsoft.UI.Xaml.Controls.TreeViewList")
        .def("__repr__", [](const TreeViewList& _self) { return default_repr(_self); } )
    ;
    py::class_<TreeViewNode, ::pywinui::holder<TreeViewNode>>(m, "Microsoft.UI.Xaml.Controls.TreeViewNode")
        .def("__repr__", [](const TreeViewNode& _self) { return default_repr(_self); } )
    ;
    py::class_<TreeViewSelectionChangedEventArgs, ::pywinui::holder<TreeViewSelectionChangedEventArgs>>(m, "Microsoft.UI.Xaml.Controls.TreeViewSelectionChangedEventArgs")
        .def("__repr__", [](const TreeViewSelectionChangedEventArgs& _self) { return default_repr(_self); } )
    ;
    py::class_<TwoPaneView, ::pywinui::holder<TwoPaneView>>(m, "Microsoft.UI.Xaml.Controls.TwoPaneView")
        .def("__repr__", [](const TwoPaneView& _self) { return default_repr(_self); } )
    ;
    py::class_<UIElementCollection, ::pywinui::holder<UIElementCollection>>(m, "Microsoft.UI.Xaml.Controls.UIElementCollection")
        .def("__repr__", [](const UIElementCollection& _self) { return default_repr(_self); } )
    ;
    py::class_<UniformGridLayout, ::pywinui::holder<UniformGridLayout>>(m, "Microsoft.UI.Xaml.Controls.UniformGridLayout")
        .def("__repr__", [](const UniformGridLayout& _self) { return default_repr(_self); } )
    ;
    py::class_<UserControl, ::pywinui::holder<UserControl>>(m, "Microsoft.UI.Xaml.Controls.UserControl")
        .def("__repr__", [](const UserControl& _self) { return default_repr(_self); } )
    ;
    py::class_<VariableSizedWrapGrid, ::pywinui::holder<VariableSizedWrapGrid>>(m, "Microsoft.UI.Xaml.Controls.VariableSizedWrapGrid")
        .def("__repr__", [](const VariableSizedWrapGrid& _self) { return default_repr(_self); } )
    ;
    py::class_<Viewbox, ::pywinui::holder<Viewbox>>(m, "Microsoft.UI.Xaml.Controls.Viewbox")
        .def("__repr__", [](const Viewbox& _self) { return default_repr(_self); } )
    ;
    py::class_<VirtualizingLayout, ::pywinui::holder<VirtualizingLayout>>(m, "Microsoft.UI.Xaml.Controls.VirtualizingLayout")
        .def("__repr__", [](const VirtualizingLayout& _self) { return default_repr(_self); } )
    ;
    py::class_<VirtualizingLayoutContext, ::pywinui::holder<VirtualizingLayoutContext>>(m, "Microsoft.UI.Xaml.Controls.VirtualizingLayoutContext")
        .def("__repr__", [](const VirtualizingLayoutContext& _self) { return default_repr(_self); } )
    ;
    py::class_<VirtualizingPanel, ::pywinui::holder<VirtualizingPanel>>(m, "Microsoft.UI.Xaml.Controls.VirtualizingPanel")
        .def("__repr__", [](const VirtualizingPanel& _self) { return default_repr(_self); } )
    ;
    py::class_<VirtualizingStackPanel, ::pywinui::holder<VirtualizingStackPanel>>(m, "Microsoft.UI.Xaml.Controls.VirtualizingStackPanel")
        .def("__repr__", [](const VirtualizingStackPanel& _self) { return default_repr(_self); } )
    ;
    py::class_<WebView2, ::pywinui::holder<WebView2>>(m, "Microsoft.UI.Xaml.Controls.WebView2")
        .def("__repr__", [](const WebView2& _self) { return default_repr(_self); } )
    ;
    py::class_<WrapGrid, ::pywinui::holder<WrapGrid>>(m, "Microsoft.UI.Xaml.Controls.WrapGrid")
        .def("__repr__", [](const WrapGrid& _self) { return default_repr(_self); } )
    ;
    py::class_<XamlControlsResources, ::pywinui::holder<XamlControlsResources>>(m, "Microsoft.UI.Xaml.Controls.XamlControlsResources")
        .def("__repr__", [](const XamlControlsResources& _self) { return default_repr(_self); } )
    ;
}
