nativeapi.gen.go

// AUTO-GENERATED. DO NOT EDIT.
// Code generated by ./codegen. DO NOT EDIT.
// Any manual changes WILL BE LOST when this file is regenerated.

package nativeapi

/*
#include "bridge.gen.h"
*/
import "C"
import (
	"runtime/cgo"
	"unsafe"
)

// ClipboardData holds the native ClipboardData value.
type ClipboardData struct {
	Text      *string
	HTML      *string
	Image     *Image
	FilePaths []string
}

func fromCClipboardData(raw C.native_clipboard_data_t) ClipboardData {
	return ClipboardData{
		Text:      optionalStringFromC(raw.text),
		HTML:      optionalStringFromC(raw.html),
		Image:     wrapImage(uint64(C.native_handle_retain(raw.image)), false),
		FilePaths: stringsFromC(raw.file_paths),
	}
}
func toCClipboardData(value ClipboardData) (C.native_clipboard_data_t, func()) {
	var raw C.native_clipboard_data_t
	var cleanup []func()
	var cField0 *C.char
	if value.Text != nil {
		cField0 = C.CString(*value.Text)
		cleanup = append(cleanup, func() { C.free(unsafe.Pointer(cField0)) })
	}
	raw.text = cField0
	var cField1 *C.char
	if value.HTML != nil {
		cField1 = C.CString(*value.HTML)
		cleanup = append(cleanup, func() { C.free(unsafe.Pointer(cField1)) })
	}
	raw.html = cField1
	raw.image = C.native_image_t(value.Image.nativeHandleValue())
	cField3, cField3Cleanup := stringsToC(value.FilePaths)
	cleanup = append(cleanup, func() { cField3Cleanup() })
	raw.file_paths = cField3
	return raw, func() {
		for i := len(cleanup) - 1; i >= 0; i-- {
			cleanup[i]()
		}
	}
}

// ClipboardEventType identifies the active event variant.
type ClipboardEventType int32

const (
	ClipboardEventChanged ClipboardEventType = 0
)

// ClipboardEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type ClipboardEvent struct {
	Type ClipboardEventType
}

func fromCClipboardEvent(raw *C.native_clipboard_event_t) ClipboardEvent {
	value := ClipboardEvent{Type: ClipboardEventType(raw._type)}
	switch value.Type {
	case ClipboardEventChanged:
	}
	return value
}

//export goEvent_native_clipboard_event_t
func goEvent_native_clipboard_event_t(handle C.uintptr_t, event *C.native_clipboard_event_t) {
	cgo.Handle(handle).Value().(func(ClipboardEvent))(fromCClipboardEvent(event))
}

type clipboard struct{}

// Clipboard provides access to the native Clipboard singleton.
// It has no owned handle and does not need to be released.
var Clipboard = clipboard{}

// IsSupported invokes the native IsSupported operation.
func (c clipboard) IsSupported() bool {
	result := C.native_clipboard_is_supported()
	return bool(result)
}

// IsChangeMonitoringSupported invokes the native IsChangeMonitoringSupported operation.
func (c clipboard) IsChangeMonitoringSupported() bool {
	result := C.native_clipboard_is_change_monitoring_supported()
	return bool(result)
}

// Read invokes the native Read operation.
func (c clipboard) Read(callback func(bool, ClipboardData)) {
	var cArg0Fn C.native_clipboard_read_callback_t
	var cArg0Data unsafe.Pointer
	var cArg0Release C.native_release_user_data_t
	if callback != nil {
		cArg0Data = newCallback(callback)
		cArg0Fn = C.native_clipboard_read_callback_t(C.go_get_native_clipboard_read_callback_t())
		cArg0Release = C.native_release_user_data_t(C.go_get_release_callback())
	}
	C.native_clipboard_read(cArg0Fn, cArg0Data, cArg0Release)
}

// ReadText invokes the native ReadText operation.
func (c clipboard) ReadText(callback func(bool, *string)) {
	var cArg0Fn C.native_clipboard_read_text_callback_t
	var cArg0Data unsafe.Pointer
	var cArg0Release C.native_release_user_data_t
	if callback != nil {
		cArg0Data = newCallback(callback)
		cArg0Fn = C.native_clipboard_read_text_callback_t(C.go_get_native_clipboard_read_text_callback_t())
		cArg0Release = C.native_release_user_data_t(C.go_get_release_callback())
	}
	C.native_clipboard_read_text(cArg0Fn, cArg0Data, cArg0Release)
}

// ReadHTML invokes the native ReadHtml operation.
func (c clipboard) ReadHTML(callback func(bool, *string)) {
	var cArg0Fn C.native_clipboard_read_html_callback_t
	var cArg0Data unsafe.Pointer
	var cArg0Release C.native_release_user_data_t
	if callback != nil {
		cArg0Data = newCallback(callback)
		cArg0Fn = C.native_clipboard_read_html_callback_t(C.go_get_native_clipboard_read_html_callback_t())
		cArg0Release = C.native_release_user_data_t(C.go_get_release_callback())
	}
	C.native_clipboard_read_html(cArg0Fn, cArg0Data, cArg0Release)
}

// ReadImage invokes the native ReadImage operation.
func (c clipboard) ReadImage(callback func(bool, *Image)) {
	var cArg0Fn C.native_clipboard_read_image_callback_t
	var cArg0Data unsafe.Pointer
	var cArg0Release C.native_release_user_data_t
	if callback != nil {
		cArg0Data = newCallback(callback)
		cArg0Fn = C.native_clipboard_read_image_callback_t(C.go_get_native_clipboard_read_image_callback_t())
		cArg0Release = C.native_release_user_data_t(C.go_get_release_callback())
	}
	C.native_clipboard_read_image(cArg0Fn, cArg0Data, cArg0Release)
}

// ReadFilePaths invokes the native ReadFilePaths operation.
func (c clipboard) ReadFilePaths(callback func(bool, []string)) {
	var cArg0Fn C.native_clipboard_read_file_paths_callback_t
	var cArg0Data unsafe.Pointer
	var cArg0Release C.native_release_user_data_t
	if callback != nil {
		cArg0Data = newCallback(callback)
		cArg0Fn = C.native_clipboard_read_file_paths_callback_t(C.go_get_native_clipboard_read_file_paths_callback_t())
		cArg0Release = C.native_release_user_data_t(C.go_get_release_callback())
	}
	C.native_clipboard_read_file_paths(cArg0Fn, cArg0Data, cArg0Release)
}

// Write invokes the native Write operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (c clipboard) Write(data ClipboardData) error {
	if !validClipboardOptionalText(data.Text) || !validClipboardOptionalText(data.HTML) || !validClipboardPaths(data.FilePaths) {
		return ErrOperationFailed
	}
	cArg0, cArg0Cleanup := toCClipboardData(data)
	defer cArg0Cleanup()
	result := C.native_clipboard_write(cArg0)
	if !bool(result) {
		return nativeError("Clipboard.Write")
	}
	return nil
}

// WriteText invokes the native WriteText operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (c clipboard) WriteText(text string) error {
	if !validClipboardText(text) {
		return ErrOperationFailed
	}
	cArg0 := C.CString(text)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_clipboard_write_text(cArg0)
	if !bool(result) {
		return nativeError("Clipboard.WriteText")
	}
	return nil
}

// WriteHTML invokes the native WriteHtml operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (c clipboard) WriteHTML(html string) error {
	if !validClipboardText(html) {
		return ErrOperationFailed
	}
	cArg0 := C.CString(html)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_clipboard_write_html(cArg0)
	if !bool(result) {
		return nativeError("Clipboard.WriteHTML")
	}
	return nil
}

// WriteImage invokes the native WriteImage operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (c clipboard) WriteImage(image *Image) error {
	result := C.native_clipboard_write_image(C.native_image_t(image.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Clipboard.WriteImage")
	}
	return nil
}

// WriteFilePaths invokes the native WriteFilePaths operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (c clipboard) WriteFilePaths(filePaths []string) error {
	if !validClipboardPaths(filePaths) {
		return ErrOperationFailed
	}
	cArg0, cArg0Cleanup := stringsToC(filePaths)
	defer cArg0Cleanup()
	result := C.native_clipboard_write_file_paths(cArg0)
	if !bool(result) {
		return nativeError("Clipboard.WriteFilePaths")
	}
	return nil
}

// Clear invokes the native Clear operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (c clipboard) Clear() error {
	result := C.native_clipboard_clear()
	if !bool(result) {
		return nativeError("Clipboard.Clear")
	}
	return nil
}

// IsMonitoring invokes the native IsMonitoring operation.
func (c clipboard) IsMonitoring() bool {
	result := C.native_clipboard_is_monitoring()
	return bool(result)
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (c clipboard) AddListener(callback func(ClipboardEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("Clipboard.AddListener")
	}
	data := newCallback(callback)
	id := C.native_clipboard_add_listener(C.native_clipboard_event_callback_t(C.go_get_native_clipboard_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("Clipboard.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (c clipboard) RemoveListener(id ListenerID) error {
	if !bool(C.native_clipboard_remove_listener(C.native_listener_id_t(id))) {
		return nativeError("Clipboard.RemoveListener")
	}
	return nil
}

// Point holds the native Point value.
type Point struct {
	X float64
	Y float64
}

func fromCPoint(raw C.native_point_t) Point {
	return Point{
		X: float64(raw.x),
		Y: float64(raw.y),
	}
}
func toCPoint(value Point) (C.native_point_t, func()) {
	var raw C.native_point_t
	var cleanup []func()
	raw.x = C.double(value.X)
	raw.y = C.double(value.Y)
	return raw, func() {
		for i := len(cleanup) - 1; i >= 0; i-- {
			cleanup[i]()
		}
	}
}

// Size holds the native Size value.
type Size struct {
	Width  float64
	Height float64
}

func fromCSize(raw C.native_size_t) Size {
	return Size{
		Width:  float64(raw.width),
		Height: float64(raw.height),
	}
}
func toCSize(value Size) (C.native_size_t, func()) {
	var raw C.native_size_t
	var cleanup []func()
	raw.width = C.double(value.Width)
	raw.height = C.double(value.Height)
	return raw, func() {
		for i := len(cleanup) - 1; i >= 0; i-- {
			cleanup[i]()
		}
	}
}

// Rectangle holds the native Rectangle value.
type Rectangle struct {
	X      float64
	Y      float64
	Width  float64
	Height float64
}

func fromCRectangle(raw C.native_rectangle_t) Rectangle {
	return Rectangle{
		X:      float64(raw.x),
		Y:      float64(raw.y),
		Width:  float64(raw.width),
		Height: float64(raw.height),
	}
}
func toCRectangle(value Rectangle) (C.native_rectangle_t, func()) {
	var raw C.native_rectangle_t
	var cleanup []func()
	raw.x = C.double(value.X)
	raw.y = C.double(value.Y)
	raw.width = C.double(value.Width)
	raw.height = C.double(value.Height)
	return raw, func() {
		for i := len(cleanup) - 1; i >= 0; i-- {
			cleanup[i]()
		}
	}
}

// EdgeInsets holds the native EdgeInsets value.
type EdgeInsets struct {
	Top    float64
	Right  float64
	Bottom float64
	Left   float64
}

func fromCEdgeInsets(raw C.native_edge_insets_t) EdgeInsets {
	return EdgeInsets{
		Top:    float64(raw.top),
		Right:  float64(raw.right),
		Bottom: float64(raw.bottom),
		Left:   float64(raw.left),
	}
}
func toCEdgeInsets(value EdgeInsets) (C.native_edge_insets_t, func()) {
	var raw C.native_edge_insets_t
	var cleanup []func()
	raw.top = C.double(value.Top)
	raw.right = C.double(value.Right)
	raw.bottom = C.double(value.Bottom)
	raw.left = C.double(value.Left)
	return raw, func() {
		for i := len(cleanup) - 1; i >= 0; i-- {
			cleanup[i]()
		}
	}
}

// EdgeInsetsAll invokes the native All operation.
func EdgeInsetsAll(value float64) EdgeInsets {
	result := C.native_edge_insets_all(C.double(value))
	return fromCEdgeInsets(result)
}

// EdgeInsetsSymmetric invokes the native Symmetric operation.
func EdgeInsetsSymmetric(vertical, horizontal float64) EdgeInsets {
	result := C.native_edge_insets_symmetric(C.double(vertical), C.double(horizontal))
	return fromCEdgeInsets(result)
}

// Color holds the native Color value.
type Color struct {
	R uint8
	G uint8
	B uint8
	A uint8
}

func fromCColor(raw C.native_color_t) Color {
	return Color{
		R: uint8(raw.r),
		G: uint8(raw.g),
		B: uint8(raw.b),
		A: uint8(raw.a),
	}
}
func toCColor(value Color) (C.native_color_t, func()) {
	var raw C.native_color_t
	var cleanup []func()
	raw.r = C.uchar(value.R)
	raw.g = C.uchar(value.G)
	raw.b = C.uchar(value.B)
	raw.a = C.uchar(value.A)
	return raw, func() {
		for i := len(cleanup) - 1; i >= 0; i-- {
			cleanup[i]()
		}
	}
}

// ColorFromRGBA invokes the native FromRGBA operation.
func ColorFromRGBA(red, green, blue, alpha uint8) Color {
	result := C.native_color_from_rgba(C.uchar(red), C.uchar(green), C.uchar(blue), C.uchar(alpha))
	return fromCColor(result)
}

// ColorFromHex invokes the native FromHex operation.
func ColorFromHex(hex string) Color {
	cArg0 := C.CString(hex)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_color_from_hex(cArg0)
	return fromCColor(result)
}

// ToRGBA invokes the native ToRGBA operation.
func (c Color) ToRGBA() uint32 {
	cSelf, cSelfCleanup := toCColor(c)
	defer cSelfCleanup()
	result := C.native_color_to_rgba(cSelf)
	return uint32(result)
}

// ToARGB invokes the native ToARGB operation.
func (c Color) ToARGB() uint32 {
	cSelf, cSelfCleanup := toCColor(c)
	defer cSelfCleanup()
	result := C.native_color_to_argb(cSelf)
	return uint32(result)
}

// ColorTransparent is the native transparent value.
var ColorTransparent = fromCColor(C.NATIVE_COLOR_TRANSPARENT)

// ColorBlack is the native black value.
var ColorBlack = fromCColor(C.NATIVE_COLOR_BLACK)

// ColorWhite is the native white value.
var ColorWhite = fromCColor(C.NATIVE_COLOR_WHITE)

// ColorRed is the native red value.
var ColorRed = fromCColor(C.NATIVE_COLOR_RED)

// ColorGreen is the native green value.
var ColorGreen = fromCColor(C.NATIVE_COLOR_GREEN)

// ColorBlue is the native blue value.
var ColorBlue = fromCColor(C.NATIVE_COLOR_BLUE)

// ColorYellow is the native yellow value.
var ColorYellow = fromCColor(C.NATIVE_COLOR_YELLOW)

// ColorCyan is the native cyan value.
var ColorCyan = fromCColor(C.NATIVE_COLOR_CYAN)

// ColorMagenta is the native magenta value.
var ColorMagenta = fromCColor(C.NATIVE_COLOR_MAGENTA)

// ModifierKey represents native ModifierKey values.
type ModifierKey int32

const (
	ModifierKeyNone       ModifierKey = 0
	ModifierKeyShift      ModifierKey = 1
	ModifierKeyCtrl       ModifierKey = 2
	ModifierKeyAlt        ModifierKey = 4
	ModifierKeyMeta       ModifierKey = 8
	ModifierKeyFn         ModifierKey = 16
	ModifierKeyCapsLock   ModifierKey = 32
	ModifierKeyNumLock    ModifierKey = 64
	ModifierKeyScrollLock ModifierKey = 128
)

// KeyboardAccelerator holds the native KeyboardAccelerator value.
type KeyboardAccelerator struct {
	Modifiers ModifierKey
	Key       string
}

func fromCKeyboardAccelerator(raw C.native_keyboard_accelerator_t) KeyboardAccelerator {
	return KeyboardAccelerator{
		Modifiers: ModifierKey(raw.modifiers),
		Key:       C.GoString(raw.key),
	}
}
func toCKeyboardAccelerator(value KeyboardAccelerator) (C.native_keyboard_accelerator_t, func()) {
	var raw C.native_keyboard_accelerator_t
	var cleanup []func()
	raw.modifiers = C.native_modifier_key_t(value.Modifiers)
	cField1 := C.CString(value.Key)
	cleanup = append(cleanup, func() { C.free(unsafe.Pointer(cField1)) })
	raw.key = cField1
	return raw, func() {
		for i := len(cleanup) - 1; i >= 0; i-- {
			cleanup[i]()
		}
	}
}

// String invokes the native ToString operation.
func (ka KeyboardAccelerator) String() string {
	cSelf, cSelfCleanup := toCKeyboardAccelerator(ka)
	defer cSelfCleanup()
	result := C.native_keyboard_accelerator_to_string(cSelf)
	defer C.free_c_str(result)
	return C.GoString(result)
}

// IsEmpty invokes the native IsEmpty operation.
func (ka KeyboardAccelerator) IsEmpty() bool {
	cSelf, cSelfCleanup := toCKeyboardAccelerator(ka)
	defer cSelfCleanup()
	result := C.native_keyboard_accelerator_is_empty(cSelf)
	return bool(result)
}

// KeyboardEventType identifies the active event variant.
type KeyboardEventType int32

const (
	KeyboardEventKeyPressed          KeyboardEventType = 0
	KeyboardEventKeyReleased         KeyboardEventType = 1
	KeyboardEventModifierKeysChanged KeyboardEventType = 2
)

// KeyboardEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type KeyboardEvent struct {
	Type         KeyboardEventType
	Keycode      int32
	ModifierKeys uint32
}

func fromCKeyboardEvent(raw *C.native_keyboard_event_t) KeyboardEvent {
	value := KeyboardEvent{Type: KeyboardEventType(raw._type)}
	value.Keycode = int32(raw.keycode)
	switch value.Type {
	case KeyboardEventKeyPressed:
	case KeyboardEventKeyReleased:
	case KeyboardEventModifierKeysChanged:
		value.ModifierKeys = uint32(C.go_native_keyboard_event_t_modifier_keys_changed_ModifierKeys(raw))
	}
	return value
}

//export goEvent_native_keyboard_event_t
func goEvent_native_keyboard_event_t(handle C.uintptr_t, event *C.native_keyboard_event_t) {
	cgo.Handle(handle).Value().(func(KeyboardEvent))(fromCKeyboardEvent(event))
}

// EventDecision owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type EventDecision struct{ *nativeHandle }

func wrapEventDecision(value uint64, borrowed bool) *EventDecision {
	if value == 0 {
		return nil
	}
	return wrapEventDecisionState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapEventDecisionState(state *nativeHandle) *EventDecision {
	return &EventDecision{state}
}
func (ed *EventDecision) nativeHandleValue() uint64 {
	if ed == nil || ed.nativeHandle == nil {
		return 0
	}
	return ed.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (ed *EventDecision) Release() {
	if ed.nativeHandleValue() == 0 || ed.borrowed {
		return
	}
	C.native_event_decision_free(C.native_event_decision_t(ed.value))
	ed.value = 0
}

// Accept invokes the native Accept operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ed *EventDecision) Accept() error {
	result := C.native_event_decision_accept(C.native_event_decision_t(ed.nativeHandleValue()))
	if !bool(result) {
		return nativeError("EventDecision.Accept")
	}
	return nil
}

// Cancel invokes the native Cancel operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ed *EventDecision) Cancel() error {
	result := C.native_event_decision_cancel(C.native_event_decision_t(ed.nativeHandleValue()))
	if !bool(result) {
		return nativeError("EventDecision.Cancel")
	}
	return nil
}

// IsPending invokes the native IsPending operation.
func (ed *EventDecision) IsPending() bool {
	result := C.native_event_decision_is_pending(C.native_event_decision_t(ed.nativeHandleValue()))
	return bool(result)
}

// EventRequest owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type EventRequest struct{ *nativeHandle }

func wrapEventRequest(value uint64, borrowed bool) *EventRequest {
	if value == 0 {
		return nil
	}
	return wrapEventRequestState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapEventRequestState(state *nativeHandle) *EventRequest {
	return &EventRequest{state}
}
func (er *EventRequest) nativeHandleValue() uint64 {
	if er == nil || er.nativeHandle == nil {
		return 0
	}
	return er.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (er *EventRequest) Release() {
	if er.nativeHandleValue() == 0 || er.borrowed {
		return
	}
	C.native_event_request_free(C.native_event_request_t(er.value))
	er.value = 0
}

// IsCancelable invokes the native IsCancelable operation.
func (er *EventRequest) IsCancelable() bool {
	result := C.native_event_request_is_cancelable(C.native_event_request_t(er.nativeHandleValue()))
	return bool(result)
}

// IsCancelled invokes the native IsCancelled operation.
func (er *EventRequest) IsCancelled() bool {
	result := C.native_event_request_is_cancelled(C.native_event_request_t(er.nativeHandleValue()))
	return bool(result)
}

// IsPending invokes the native IsPending operation.
func (er *EventRequest) IsPending() bool {
	result := C.native_event_request_is_pending(C.native_event_request_t(er.nativeHandleValue()))
	return bool(result)
}

// Cancel invokes the native Cancel operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (er *EventRequest) Cancel() error {
	result := C.native_event_request_cancel(C.native_event_request_t(er.nativeHandleValue()))
	if !bool(result) {
		return nativeError("EventRequest.Cancel")
	}
	return nil
}

// Defer invokes the native Defer operation.
// The returned reference is owned; nil means no object is available.
func (er *EventRequest) Defer() *EventDecision {
	result := C.native_event_request_defer(C.native_event_request_t(er.nativeHandleValue()))
	return wrapEventDecision(uint64(result), false)
}

// Placement represents native Placement values.
type Placement int32

const (
	PlacementTop         Placement = 0
	PlacementTopStart    Placement = 1
	PlacementTopEnd      Placement = 2
	PlacementRight       Placement = 3
	PlacementRightStart  Placement = 4
	PlacementRightEnd    Placement = 5
	PlacementBottom      Placement = 6
	PlacementBottomStart Placement = 7
	PlacementBottomEnd   Placement = 8
	PlacementLeft        Placement = 9
	PlacementLeftStart   Placement = 10
	PlacementLeftEnd     Placement = 11
)

// DialogModality represents native DialogModality values.
type DialogModality int32

const (
	DialogModalityNone        DialogModality = 0
	DialogModalityApplication DialogModality = 1
	DialogModalityWindow      DialogModality = 2
)

type accessibilityManager struct{}

// AccessibilityManager provides access to the native AccessibilityManager singleton.
// It has no owned handle and does not need to be released.
var AccessibilityManager = accessibilityManager{}

// Enable invokes the native Enable operation.
func (am accessibilityManager) Enable() {
	C.native_accessibility_manager_enable()
}

// IsEnabled invokes the native IsEnabled operation.
func (am accessibilityManager) IsEnabled() bool {
	result := C.native_accessibility_manager_is_enabled()
	return bool(result)
}

// DisplayID identifies a native object.
type DisplayID uint32

// DisplayOrientation represents native DisplayOrientation values.
type DisplayOrientation int32

const (
	DisplayOrientationPortrait         DisplayOrientation = 0
	DisplayOrientationLandscape        DisplayOrientation = 90
	DisplayOrientationPortraitFlipped  DisplayOrientation = 180
	DisplayOrientationLandscapeFlipped DisplayOrientation = 270
)

// DisplayEventType identifies the active event variant.
type DisplayEventType int32

const (
	DisplayEventAdded   DisplayEventType = 0
	DisplayEventRemoved DisplayEventType = 1
	DisplayEventChanged DisplayEventType = 2
)

// DisplayEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type DisplayEvent struct {
	Type    DisplayEventType
	Display *Display
}

func fromCDisplayEvent(raw *C.native_display_event_t) DisplayEvent {
	value := DisplayEvent{Type: DisplayEventType(raw._type)}
	value.Display = wrapDisplay(uint64(raw.display), true)
	switch value.Type {
	case DisplayEventAdded:
	case DisplayEventRemoved:
	case DisplayEventChanged:
	}
	return value
}

//export goEvent_native_display_event_t
func goEvent_native_display_event_t(handle C.uintptr_t, event *C.native_display_event_t) {
	cgo.Handle(handle).Value().(func(DisplayEvent))(fromCDisplayEvent(event))
}

// Display owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type Display struct{ *nativeHandle }

func wrapDisplay(value uint64, borrowed bool) *Display {
	if value == 0 {
		return nil
	}
	return wrapDisplayState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapDisplayState(state *nativeHandle) *Display {
	return &Display{state}
}
func (d *Display) nativeHandleValue() uint64 {
	if d == nil || d.nativeHandle == nil {
		return 0
	}
	return d.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (d *Display) Release() {
	if d.nativeHandleValue() == 0 || d.borrowed {
		return
	}
	C.native_display_free(C.native_display_t(d.value))
	d.value = 0
}

// NewDisplayFromNative creates an owned Display.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewDisplayFromNative(display unsafe.Pointer) (*Display, error) {
	result := C.native_display_create(display)
	if result == 0 {
		return nil, nativeError("NewDisplayFromNative")
	}
	return wrapDisplay(uint64(result), false), nil
}

// ID invokes the native GetId operation.
func (d *Display) ID() DisplayID {
	result := C.native_display_get_id(C.native_display_t(d.nativeHandleValue()))
	return DisplayID(result)
}

// Name invokes the native GetName operation.
func (d *Display) Name() string {
	result := C.native_display_get_name(C.native_display_t(d.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Position invokes the native GetPosition operation.
func (d *Display) Position() Point {
	result := C.native_display_get_position(C.native_display_t(d.nativeHandleValue()))
	return fromCPoint(result)
}

// Size invokes the native GetSize operation.
func (d *Display) Size() Size {
	result := C.native_display_get_size(C.native_display_t(d.nativeHandleValue()))
	return fromCSize(result)
}

// WorkArea invokes the native GetWorkArea operation.
func (d *Display) WorkArea() Rectangle {
	result := C.native_display_get_work_area(C.native_display_t(d.nativeHandleValue()))
	return fromCRectangle(result)
}

// ScaleFactor invokes the native GetScaleFactor operation.
func (d *Display) ScaleFactor() float64 {
	result := C.native_display_get_scale_factor(C.native_display_t(d.nativeHandleValue()))
	return float64(result)
}

// IsPrimary invokes the native IsPrimary operation.
func (d *Display) IsPrimary() bool {
	result := C.native_display_is_primary(C.native_display_t(d.nativeHandleValue()))
	return bool(result)
}

// Orientation invokes the native GetOrientation operation.
func (d *Display) Orientation() DisplayOrientation {
	result := C.native_display_get_orientation(C.native_display_t(d.nativeHandleValue()))
	return DisplayOrientation(result)
}

// RefreshRate invokes the native GetRefreshRate operation.
func (d *Display) RefreshRate() int32 {
	result := C.native_display_get_refresh_rate(C.native_display_t(d.nativeHandleValue()))
	return int32(result)
}

// BitDepth invokes the native GetBitDepth operation.
func (d *Display) BitDepth() int32 {
	result := C.native_display_get_bit_depth(C.native_display_t(d.nativeHandleValue()))
	return int32(result)
}

// NativeObject returns a borrowed platform pointer.
func (d *Display) NativeObject() unsafe.Pointer {
	return C.native_display_get_native_object(C.native_display_t(d.nativeHandleValue()))
}

type displayManager struct{}

// DisplayManager provides access to the native DisplayManager singleton.
// It has no owned handle and does not need to be released.
var DisplayManager = displayManager{}

// All invokes the native GetAll operation.
func (dm displayManager) All() []*Display {
	result := C.native_display_manager_get_all()
	defer C.native_display_list_release(&result)
	return listDisplayFromC(result, false)
}

// Primary invokes the native GetPrimary operation.
// The returned reference is owned; nil means no object is available.
func (dm displayManager) Primary() *Display {
	result := C.native_display_manager_get_primary()
	return wrapDisplay(uint64(result), false)
}

// CursorPosition invokes the native GetCursorPosition operation.
func (dm displayManager) CursorPosition() Point {
	result := C.native_display_manager_get_cursor_position()
	return fromCPoint(result)
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (dm displayManager) AddListener(callback func(DisplayEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("DisplayManager.AddListener")
	}
	data := newCallback(callback)
	id := C.native_display_manager_add_listener(C.native_display_event_callback_t(C.go_get_native_display_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("DisplayManager.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (dm displayManager) RemoveListener(id ListenerID) error {
	if !bool(C.native_display_manager_remove_listener(C.native_listener_id_t(id))) {
		return nativeError("DisplayManager.RemoveListener")
	}
	return nil
}

// URLOpenErrorCode represents native UrlOpenErrorCode values.
type URLOpenErrorCode int32

const (
	URLOpenErrorCodeNone                        URLOpenErrorCode = 0
	URLOpenErrorCodeInvalidURLEmpty             URLOpenErrorCode = 1
	URLOpenErrorCodeInvalidURLMissingScheme     URLOpenErrorCode = 2
	URLOpenErrorCodeInvalidURLUnsupportedScheme URLOpenErrorCode = 3
	URLOpenErrorCodeUnsupportedPlatform         URLOpenErrorCode = 4
	URLOpenErrorCodeInvocationFailed            URLOpenErrorCode = 5
)

// URLOpenResult holds the native UrlOpenResult value.
type URLOpenResult struct {
	Success      bool
	ErrorCode    URLOpenErrorCode
	ErrorMessage string
}

func fromCURLOpenResult(raw C.native_url_open_result_t) URLOpenResult {
	return URLOpenResult{
		Success:      bool(raw.success),
		ErrorCode:    URLOpenErrorCode(raw.error_code),
		ErrorMessage: C.GoString(raw.error_message),
	}
}
func toCURLOpenResult(value URLOpenResult) (C.native_url_open_result_t, func()) {
	var raw C.native_url_open_result_t
	var cleanup []func()
	raw.success = C.bool(value.Success)
	raw.error_code = C.native_url_open_error_code_t(value.ErrorCode)
	cField2 := C.CString(value.ErrorMessage)
	cleanup = append(cleanup, func() { C.free(unsafe.Pointer(cField2)) })
	raw.error_message = cField2
	return raw, func() {
		for i := len(cleanup) - 1; i >= 0; i-- {
			cleanup[i]()
		}
	}
}

type urlOpener struct{}

// URLOpener provides access to the native URLOpener singleton.
// It has no owned handle and does not need to be released.
var URLOpener = urlOpener{}

// IsSupported invokes the native IsSupported operation.
func (uo urlOpener) IsSupported() bool {
	result := C.native_url_opener_is_supported()
	return bool(result)
}

// CanOpen invokes the native CanOpen operation.
func (uo urlOpener) CanOpen(url string) bool {
	cArg0 := C.CString(url)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_url_opener_can_open(cArg0)
	return bool(result)
}

// Open invokes the native Open operation.
func (uo urlOpener) Open(url string) URLOpenResult {
	cArg0 := C.CString(url)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_url_opener_open(cArg0)
	defer C.native_url_open_result_free(&result)
	return fromCURLOpenResult(result)
}

type appInfo struct{}

// AppInfo provides access to the native AppInfo singleton.
// It has no owned handle and does not need to be released.
var AppInfo = appInfo{}

// Name invokes the native GetName operation.
func (ai appInfo) Name() string {
	result := C.native_app_info_get_name()
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Identifier invokes the native GetIdentifier operation.
func (ai appInfo) Identifier() string {
	result := C.native_app_info_get_identifier()
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Version invokes the native GetVersion operation.
func (ai appInfo) Version() string {
	result := C.native_app_info_get_version()
	defer C.free_c_str(result)
	return C.GoString(result)
}

// BuildNumber invokes the native GetBuildNumber operation.
func (ai appInfo) BuildNumber() string {
	result := C.native_app_info_get_build_number()
	defer C.free_c_str(result)
	return C.GoString(result)
}

type deviceInfo struct{}

// DeviceInfo provides access to the native DeviceInfo singleton.
// It has no owned handle and does not need to be released.
var DeviceInfo = deviceInfo{}

// Name invokes the native GetName operation.
func (di deviceInfo) Name() string {
	result := C.native_device_info_get_name()
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Model invokes the native GetModel operation.
func (di deviceInfo) Model() string {
	result := C.native_device_info_get_model()
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Manufacturer invokes the native GetManufacturer operation.
func (di deviceInfo) Manufacturer() string {
	result := C.native_device_info_get_manufacturer()
	defer C.free_c_str(result)
	return C.GoString(result)
}

// OSName invokes the native GetOsName operation.
func (di deviceInfo) OSName() string {
	result := C.native_device_info_get_os_name()
	defer C.free_c_str(result)
	return C.GoString(result)
}

// OSVersion invokes the native GetOsVersion operation.
func (di deviceInfo) OSVersion() string {
	result := C.native_device_info_get_os_version()
	defer C.free_c_str(result)
	return C.GoString(result)
}

// KernelVersion invokes the native GetKernelVersion operation.
func (di deviceInfo) KernelVersion() string {
	result := C.native_device_info_get_kernel_version()
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Architecture invokes the native GetArchitecture operation.
func (di deviceInfo) Architecture() string {
	result := C.native_device_info_get_architecture()
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Preferences owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type Preferences struct{ *nativeHandle }

func wrapPreferences(value uint64, borrowed bool) *Preferences {
	if value == 0 {
		return nil
	}
	return wrapPreferencesState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapPreferencesState(state *nativeHandle) *Preferences {
	return &Preferences{state}
}
func (p *Preferences) nativeHandleValue() uint64 {
	if p == nil || p.nativeHandle == nil {
		return 0
	}
	return p.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (p *Preferences) Release() {
	if p.nativeHandleValue() == 0 || p.borrowed {
		return
	}
	C.native_preferences_free(C.native_preferences_t(p.value))
	p.value = 0
}

// NewPreferences creates an owned Preferences.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewPreferences() (*Preferences, error) {
	result := C.native_preferences_create()
	if result == 0 {
		return nil, nativeError("NewPreferences")
	}
	return wrapPreferences(uint64(result), false), nil
}

// NewPreferencesWithScope creates an owned Preferences.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewPreferencesWithScope(scope string) (*Preferences, error) {
	cArg0 := C.CString(scope)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_preferences_create_with_scope(cArg0)
	if result == 0 {
		return nil, nativeError("NewPreferencesWithScope")
	}
	return wrapPreferences(uint64(result), false), nil
}

// Set invokes the native Set operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (p *Preferences) Set(key, value string) error {
	cArg0 := C.CString(key)
	defer C.free(unsafe.Pointer(cArg0))
	cArg1 := C.CString(value)
	defer C.free(unsafe.Pointer(cArg1))
	result := C.native_preferences_set(C.native_preferences_t(p.nativeHandleValue()), cArg0, cArg1)
	if !bool(result) {
		return nativeError("Preferences.Set")
	}
	return nil
}

// Get invokes the native Get operation.
func (p *Preferences) Get(key, defaultValue string) string {
	cArg0 := C.CString(key)
	defer C.free(unsafe.Pointer(cArg0))
	cArg1 := C.CString(defaultValue)
	defer C.free(unsafe.Pointer(cArg1))
	result := C.native_preferences_get(C.native_preferences_t(p.nativeHandleValue()), cArg0, cArg1)
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Remove invokes the native Remove operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (p *Preferences) Remove(key string) error {
	cArg0 := C.CString(key)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_preferences_remove(C.native_preferences_t(p.nativeHandleValue()), cArg0)
	if !bool(result) {
		return nativeError("Preferences.Remove")
	}
	return nil
}

// Clear invokes the native Clear operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (p *Preferences) Clear() error {
	result := C.native_preferences_clear(C.native_preferences_t(p.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Preferences.Clear")
	}
	return nil
}

// Contains invokes the native Contains operation.
func (p *Preferences) Contains(key string) bool {
	cArg0 := C.CString(key)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_preferences_contains(C.native_preferences_t(p.nativeHandleValue()), cArg0)
	return bool(result)
}

// Keys invokes the native GetKeys operation.
func (p *Preferences) Keys() []string {
	result := C.native_preferences_get_keys(C.native_preferences_t(p.nativeHandleValue()))
	defer C.native_string_list_free(&result)
	return stringsFromC(result)
}

// Size invokes the native GetSize operation.
func (p *Preferences) Size() uint64 {
	result := C.native_preferences_get_size(C.native_preferences_t(p.nativeHandleValue()))
	return uint64(result)
}

// All invokes the native GetAll operation.
func (p *Preferences) All() map[string]string {
	result := C.native_preferences_get_all(C.native_preferences_t(p.nativeHandleValue()))
	defer C.native_string_map_free(&result)
	return mapFromC(result)
}

// Scope invokes the native GetScope operation.
func (p *Preferences) Scope() string {
	result := C.native_preferences_get_scope(C.native_preferences_t(p.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// SecureStorage owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type SecureStorage struct{ *nativeHandle }

func wrapSecureStorage(value uint64, borrowed bool) *SecureStorage {
	if value == 0 {
		return nil
	}
	return wrapSecureStorageState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapSecureStorageState(state *nativeHandle) *SecureStorage {
	return &SecureStorage{state}
}
func (ss *SecureStorage) nativeHandleValue() uint64 {
	if ss == nil || ss.nativeHandle == nil {
		return 0
	}
	return ss.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (ss *SecureStorage) Release() {
	if ss.nativeHandleValue() == 0 || ss.borrowed {
		return
	}
	C.native_secure_storage_free(C.native_secure_storage_t(ss.value))
	ss.value = 0
}

// NewSecureStorage creates an owned SecureStorage.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewSecureStorage() (*SecureStorage, error) {
	result := C.native_secure_storage_create()
	if result == 0 {
		return nil, nativeError("NewSecureStorage")
	}
	return wrapSecureStorage(uint64(result), false), nil
}

// NewSecureStorageWithScope creates an owned SecureStorage.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewSecureStorageWithScope(scope string) (*SecureStorage, error) {
	cArg0 := C.CString(scope)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_secure_storage_create_with_scope(cArg0)
	if result == 0 {
		return nil, nativeError("NewSecureStorageWithScope")
	}
	return wrapSecureStorage(uint64(result), false), nil
}

// Set invokes the native Set operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ss *SecureStorage) Set(key, value string) error {
	cArg0 := C.CString(key)
	defer C.free(unsafe.Pointer(cArg0))
	cArg1 := C.CString(value)
	defer C.free(unsafe.Pointer(cArg1))
	result := C.native_secure_storage_set(C.native_secure_storage_t(ss.nativeHandleValue()), cArg0, cArg1)
	if !bool(result) {
		return nativeError("SecureStorage.Set")
	}
	return nil
}

// Get invokes the native Get operation.
func (ss *SecureStorage) Get(key, defaultValue string) string {
	cArg0 := C.CString(key)
	defer C.free(unsafe.Pointer(cArg0))
	cArg1 := C.CString(defaultValue)
	defer C.free(unsafe.Pointer(cArg1))
	result := C.native_secure_storage_get(C.native_secure_storage_t(ss.nativeHandleValue()), cArg0, cArg1)
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Remove invokes the native Remove operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ss *SecureStorage) Remove(key string) error {
	cArg0 := C.CString(key)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_secure_storage_remove(C.native_secure_storage_t(ss.nativeHandleValue()), cArg0)
	if !bool(result) {
		return nativeError("SecureStorage.Remove")
	}
	return nil
}

// Clear invokes the native Clear operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ss *SecureStorage) Clear() error {
	result := C.native_secure_storage_clear(C.native_secure_storage_t(ss.nativeHandleValue()))
	if !bool(result) {
		return nativeError("SecureStorage.Clear")
	}
	return nil
}

// Contains invokes the native Contains operation.
func (ss *SecureStorage) Contains(key string) bool {
	cArg0 := C.CString(key)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_secure_storage_contains(C.native_secure_storage_t(ss.nativeHandleValue()), cArg0)
	return bool(result)
}

// Keys invokes the native GetKeys operation.
func (ss *SecureStorage) Keys() []string {
	result := C.native_secure_storage_get_keys(C.native_secure_storage_t(ss.nativeHandleValue()))
	defer C.native_string_list_free(&result)
	return stringsFromC(result)
}

// Size invokes the native GetSize operation.
func (ss *SecureStorage) Size() uint64 {
	result := C.native_secure_storage_get_size(C.native_secure_storage_t(ss.nativeHandleValue()))
	return uint64(result)
}

// All invokes the native GetAll operation.
func (ss *SecureStorage) All() map[string]string {
	result := C.native_secure_storage_get_all(C.native_secure_storage_t(ss.nativeHandleValue()))
	defer C.native_string_map_free(&result)
	return mapFromC(result)
}

// Scope invokes the native GetScope operation.
func (ss *SecureStorage) Scope() string {
	result := C.native_secure_storage_get_scope(C.native_secure_storage_t(ss.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// SecureStorageIsAvailable invokes the native IsAvailable operation.
func SecureStorageIsAvailable() bool {
	result := C.native_secure_storage_is_available()
	return bool(result)
}

// LaunchAtLogin owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type LaunchAtLogin struct{ *nativeHandle }

func wrapLaunchAtLogin(value uint64, borrowed bool) *LaunchAtLogin {
	if value == 0 {
		return nil
	}
	return wrapLaunchAtLoginState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapLaunchAtLoginState(state *nativeHandle) *LaunchAtLogin {
	return &LaunchAtLogin{state}
}
func (lal *LaunchAtLogin) nativeHandleValue() uint64 {
	if lal == nil || lal.nativeHandle == nil {
		return 0
	}
	return lal.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (lal *LaunchAtLogin) Release() {
	if lal.nativeHandleValue() == 0 || lal.borrowed {
		return
	}
	C.native_launch_at_login_free(C.native_launch_at_login_t(lal.value))
	lal.value = 0
}

// NewLaunchAtLogin creates an owned LaunchAtLogin.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewLaunchAtLogin() (*LaunchAtLogin, error) {
	result := C.native_launch_at_login_create()
	if result == 0 {
		return nil, nativeError("NewLaunchAtLogin")
	}
	return wrapLaunchAtLogin(uint64(result), false), nil
}

// NewLaunchAtLoginWithID creates an owned LaunchAtLogin.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewLaunchAtLoginWithID(id string) (*LaunchAtLogin, error) {
	cArg0 := C.CString(id)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_launch_at_login_create_with_id(cArg0)
	if result == 0 {
		return nil, nativeError("NewLaunchAtLoginWithID")
	}
	return wrapLaunchAtLogin(uint64(result), false), nil
}

// NewLaunchAtLoginWithDisplayName creates an owned LaunchAtLogin.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewLaunchAtLoginWithDisplayName(id, displayName string) (*LaunchAtLogin, error) {
	cArg0 := C.CString(id)
	defer C.free(unsafe.Pointer(cArg0))
	cArg1 := C.CString(displayName)
	defer C.free(unsafe.Pointer(cArg1))
	result := C.native_launch_at_login_create_with_id_and_display_name(cArg0, cArg1)
	if result == 0 {
		return nil, nativeError("NewLaunchAtLoginWithDisplayName")
	}
	return wrapLaunchAtLogin(uint64(result), false), nil
}

// LaunchAtLoginIsSupported invokes the native IsSupported operation.
func LaunchAtLoginIsSupported() bool {
	result := C.native_launch_at_login_is_supported()
	return bool(result)
}

// ID invokes the native GetId operation.
func (lal *LaunchAtLogin) ID() string {
	result := C.native_launch_at_login_get_id(C.native_launch_at_login_t(lal.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// DisplayName invokes the native GetDisplayName operation.
func (lal *LaunchAtLogin) DisplayName() string {
	result := C.native_launch_at_login_get_display_name(C.native_launch_at_login_t(lal.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// SetDisplayName invokes the native SetDisplayName operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (lal *LaunchAtLogin) SetDisplayName(displayName string) error {
	cArg0 := C.CString(displayName)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_launch_at_login_set_display_name(C.native_launch_at_login_t(lal.nativeHandleValue()), cArg0)
	if !bool(result) {
		return nativeError("LaunchAtLogin.SetDisplayName")
	}
	return nil
}

// SetProgram invokes the native SetProgram operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (lal *LaunchAtLogin) SetProgram(executablePath string, arguments []string) error {
	cArg0 := C.CString(executablePath)
	defer C.free(unsafe.Pointer(cArg0))
	cArg1, cArg1Cleanup := stringsToC(arguments)
	defer cArg1Cleanup()
	result := C.native_launch_at_login_set_program(C.native_launch_at_login_t(lal.nativeHandleValue()), cArg0, cArg1)
	if !bool(result) {
		return nativeError("LaunchAtLogin.SetProgram")
	}
	return nil
}

// ExecutablePath invokes the native GetExecutablePath operation.
func (lal *LaunchAtLogin) ExecutablePath() string {
	result := C.native_launch_at_login_get_executable_path(C.native_launch_at_login_t(lal.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Arguments invokes the native GetArguments operation.
func (lal *LaunchAtLogin) Arguments() []string {
	result := C.native_launch_at_login_get_arguments(C.native_launch_at_login_t(lal.nativeHandleValue()))
	defer C.native_string_list_free(&result)
	return stringsFromC(result)
}

// Enable invokes the native Enable operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (lal *LaunchAtLogin) Enable() error {
	result := C.native_launch_at_login_enable(C.native_launch_at_login_t(lal.nativeHandleValue()))
	if !bool(result) {
		return nativeError("LaunchAtLogin.Enable")
	}
	return nil
}

// Disable invokes the native Disable operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (lal *LaunchAtLogin) Disable() error {
	result := C.native_launch_at_login_disable(C.native_launch_at_login_t(lal.nativeHandleValue()))
	if !bool(result) {
		return nativeError("LaunchAtLogin.Disable")
	}
	return nil
}

// IsEnabled invokes the native IsEnabled operation.
func (lal *LaunchAtLogin) IsEnabled() bool {
	result := C.native_launch_at_login_is_enabled(C.native_launch_at_login_t(lal.nativeHandleValue()))
	return bool(result)
}

// MessageDialogResult represents native MessageDialogResult values.
type MessageDialogResult int32

const (
	MessageDialogResultNone      MessageDialogResult = 0
	MessageDialogResultPrimary   MessageDialogResult = 1
	MessageDialogResultSecondary MessageDialogResult = 2
	MessageDialogResultClose     MessageDialogResult = 3
)

// MessageDialog owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type MessageDialog struct{ *nativeHandle }

func wrapMessageDialog(value uint64, borrowed bool) *MessageDialog {
	if value == 0 {
		return nil
	}
	return wrapMessageDialogState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapMessageDialogState(state *nativeHandle) *MessageDialog {
	return &MessageDialog{state}
}
func (md *MessageDialog) nativeHandleValue() uint64 {
	if md == nil || md.nativeHandle == nil {
		return 0
	}
	return md.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (md *MessageDialog) Release() {
	if md.nativeHandleValue() == 0 || md.borrowed {
		return
	}
	C.native_message_dialog_free(C.native_message_dialog_t(md.value))
	md.value = 0
}

// NewMessageDialog creates an owned MessageDialog.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewMessageDialog(title, message string) (*MessageDialog, error) {
	cArg0 := C.CString(title)
	defer C.free(unsafe.Pointer(cArg0))
	cArg1 := C.CString(message)
	defer C.free(unsafe.Pointer(cArg1))
	result := C.native_message_dialog_create(cArg0, cArg1)
	if result == 0 {
		return nil, nativeError("NewMessageDialog")
	}
	return wrapMessageDialog(uint64(result), false), nil
}

// MessageDialogIsExtendedSupported invokes the native IsExtendedSupported operation.
func MessageDialogIsExtendedSupported() bool {
	result := C.native_message_dialog_is_extended_supported()
	return bool(result)
}

// SetButtons invokes the native SetButtons operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (md *MessageDialog) SetButtons(primary, secondary, closeValue string) error {
	cArg0 := C.CString(primary)
	defer C.free(unsafe.Pointer(cArg0))
	cArg1 := C.CString(secondary)
	defer C.free(unsafe.Pointer(cArg1))
	cArg2 := C.CString(closeValue)
	defer C.free(unsafe.Pointer(cArg2))
	result := C.native_message_dialog_set_buttons(C.native_message_dialog_t(md.nativeHandleValue()), cArg0, cArg1, cArg2)
	if !bool(result) {
		return nativeError("MessageDialog.SetButtons")
	}
	return nil
}

// SetDefaultButton invokes the native SetDefaultButton operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (md *MessageDialog) SetDefaultButton(button MessageDialogResult) error {
	result := C.native_message_dialog_set_default_button(C.native_message_dialog_t(md.nativeHandleValue()), C.native_message_dialog_result_t(button))
	if !bool(result) {
		return nativeError("MessageDialog.SetDefaultButton")
	}
	return nil
}

// SetParentWindow invokes the native SetParentWindow operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (md *MessageDialog) SetParentWindow(window *Window) error {
	result := C.native_message_dialog_set_parent_window(C.native_message_dialog_t(md.nativeHandleValue()), C.native_window_t(window.nativeHandleValue()))
	if !bool(result) {
		return nativeError("MessageDialog.SetParentWindow")
	}
	return nil
}

// Result invokes the native GetResult operation.
func (md *MessageDialog) Result() MessageDialogResult {
	result := C.native_message_dialog_get_result(C.native_message_dialog_t(md.nativeHandleValue()))
	return MessageDialogResult(result)
}

// IsOpen invokes the native IsOpen operation.
func (md *MessageDialog) IsOpen() bool {
	result := C.native_message_dialog_is_open(C.native_message_dialog_t(md.nativeHandleValue()))
	return bool(result)
}

// SetInputEnabled invokes the native SetInputEnabled operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (md *MessageDialog) SetInputEnabled(enabled bool) error {
	result := C.native_message_dialog_set_input_enabled(C.native_message_dialog_t(md.nativeHandleValue()), C.bool(enabled))
	if !bool(result) {
		return nativeError("MessageDialog.SetInputEnabled")
	}
	return nil
}

// SetInputText invokes the native SetInputText operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (md *MessageDialog) SetInputText(text string) error {
	cArg0 := C.CString(text)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_message_dialog_set_input_text(C.native_message_dialog_t(md.nativeHandleValue()), cArg0)
	if !bool(result) {
		return nativeError("MessageDialog.SetInputText")
	}
	return nil
}

// InputText invokes the native GetInputText operation.
func (md *MessageDialog) InputText() string {
	result := C.native_message_dialog_get_input_text(C.native_message_dialog_t(md.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// SetCheckbox invokes the native SetCheckbox operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (md *MessageDialog) SetCheckbox(label string, checked bool) error {
	cArg0 := C.CString(label)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_message_dialog_set_checkbox(C.native_message_dialog_t(md.nativeHandleValue()), cArg0, C.bool(checked))
	if !bool(result) {
		return nativeError("MessageDialog.SetCheckbox")
	}
	return nil
}

// IsCheckboxChecked invokes the native IsCheckboxChecked operation.
func (md *MessageDialog) IsCheckboxChecked() bool {
	result := C.native_message_dialog_is_checkbox_checked(C.native_message_dialog_t(md.nativeHandleValue()))
	return bool(result)
}

// SetProgress invokes the native SetProgress operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (md *MessageDialog) SetProgress(value float64) error {
	result := C.native_message_dialog_set_progress(C.native_message_dialog_t(md.nativeHandleValue()), C.double(value))
	if !bool(result) {
		return nativeError("MessageDialog.SetProgress")
	}
	return nil
}

// SetTitle invokes the native SetTitle operation.
func (md *MessageDialog) SetTitle(title string) {
	cArg0 := C.CString(title)
	defer C.free(unsafe.Pointer(cArg0))
	C.native_message_dialog_set_title(C.native_message_dialog_t(md.nativeHandleValue()), cArg0)
}

// Title invokes the native GetTitle operation.
func (md *MessageDialog) Title() string {
	result := C.native_message_dialog_get_title(C.native_message_dialog_t(md.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// SetMessage invokes the native SetMessage operation.
func (md *MessageDialog) SetMessage(message string) {
	cArg0 := C.CString(message)
	defer C.free(unsafe.Pointer(cArg0))
	C.native_message_dialog_set_message(C.native_message_dialog_t(md.nativeHandleValue()), cArg0)
}

// Message invokes the native GetMessage operation.
func (md *MessageDialog) Message() string {
	result := C.native_message_dialog_get_message(C.native_message_dialog_t(md.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Modality invokes the native GetModality operation.
func (md *MessageDialog) Modality() DialogModality {
	result := C.native_message_dialog_get_modality(C.native_message_dialog_t(md.nativeHandleValue()))
	return DialogModality(result)
}

// SetModality invokes the native SetModality operation.
func (md *MessageDialog) SetModality(modality DialogModality) {
	C.native_message_dialog_set_modality(C.native_message_dialog_t(md.nativeHandleValue()), C.native_dialog_modality_t(modality))
}

// Open invokes the native Open operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (md *MessageDialog) Open() error {
	result := C.native_message_dialog_open(C.native_message_dialog_t(md.nativeHandleValue()))
	if !bool(result) {
		return nativeError("MessageDialog.Open")
	}
	return nil
}

// Close invokes the native Close operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (md *MessageDialog) Close() error {
	result := C.native_message_dialog_close(C.native_message_dialog_t(md.nativeHandleValue()))
	if !bool(result) {
		return nativeError("MessageDialog.Close")
	}
	return nil
}

// FileDialogMode represents native FileDialogMode values.
type FileDialogMode int32

const (
	FileDialogModeOpenFile     FileDialogMode = 0
	FileDialogModeOpenFiles    FileDialogMode = 1
	FileDialogModeSaveFile     FileDialogMode = 2
	FileDialogModeSelectFolder FileDialogMode = 3
)

// FileDialogResult represents native FileDialogResult values.
type FileDialogResult int32

const (
	FileDialogResultNone      FileDialogResult = 0
	FileDialogResultAccepted  FileDialogResult = 1
	FileDialogResultCancelled FileDialogResult = 2
	FileDialogResultFailed    FileDialogResult = 3
)

// FileDialog owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type FileDialog struct{ *nativeHandle }

func wrapFileDialog(value uint64, borrowed bool) *FileDialog {
	if value == 0 {
		return nil
	}
	return wrapFileDialogState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapFileDialogState(state *nativeHandle) *FileDialog {
	return &FileDialog{state}
}
func (fd *FileDialog) nativeHandleValue() uint64 {
	if fd == nil || fd.nativeHandle == nil {
		return 0
	}
	return fd.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (fd *FileDialog) Release() {
	if fd.nativeHandleValue() == 0 || fd.borrowed {
		return
	}
	C.native_file_dialog_free(C.native_file_dialog_t(fd.value))
	fd.value = 0
}

// NewFileDialog creates an owned FileDialog.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewFileDialog(mode FileDialogMode) (*FileDialog, error) {
	result := C.native_file_dialog_create(C.native_file_dialog_mode_t(mode))
	if result == 0 {
		return nil, nativeError("NewFileDialog")
	}
	return wrapFileDialog(uint64(result), false), nil
}

// FileDialogIsSupported invokes the native IsSupported operation.
func FileDialogIsSupported() bool {
	result := C.native_file_dialog_is_supported()
	return bool(result)
}

// SetParentWindow invokes the native SetParentWindow operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (fd *FileDialog) SetParentWindow(window *Window) error {
	result := C.native_file_dialog_set_parent_window(C.native_file_dialog_t(fd.nativeHandleValue()), C.native_window_t(window.nativeHandleValue()))
	if !bool(result) {
		return nativeError("FileDialog.SetParentWindow")
	}
	return nil
}

// SetFileTypes invokes the native SetFileTypes operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (fd *FileDialog) SetFileTypes(extensions []string) error {
	cArg0, cArg0Cleanup := stringsToC(extensions)
	defer cArg0Cleanup()
	result := C.native_file_dialog_set_file_types(C.native_file_dialog_t(fd.nativeHandleValue()), cArg0)
	if !bool(result) {
		return nativeError("FileDialog.SetFileTypes")
	}
	return nil
}

// SetSuggestedFileName invokes the native SetSuggestedFileName operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (fd *FileDialog) SetSuggestedFileName(name string) error {
	cArg0 := C.CString(name)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_file_dialog_set_suggested_file_name(C.native_file_dialog_t(fd.nativeHandleValue()), cArg0)
	if !bool(result) {
		return nativeError("FileDialog.SetSuggestedFileName")
	}
	return nil
}

// Modality invokes the native GetModality operation.
func (fd *FileDialog) Modality() DialogModality {
	result := C.native_file_dialog_get_modality(C.native_file_dialog_t(fd.nativeHandleValue()))
	return DialogModality(result)
}

// SetModality invokes the native SetModality operation.
func (fd *FileDialog) SetModality(modality DialogModality) {
	C.native_file_dialog_set_modality(C.native_file_dialog_t(fd.nativeHandleValue()), C.native_dialog_modality_t(modality))
}

// Open invokes the native Open operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (fd *FileDialog) Open() error {
	result := C.native_file_dialog_open(C.native_file_dialog_t(fd.nativeHandleValue()))
	if !bool(result) {
		return nativeError("FileDialog.Open")
	}
	return nil
}

// Close invokes the native Close operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (fd *FileDialog) Close() error {
	result := C.native_file_dialog_close(C.native_file_dialog_t(fd.nativeHandleValue()))
	if !bool(result) {
		return nativeError("FileDialog.Close")
	}
	return nil
}

// Result invokes the native GetResult operation.
func (fd *FileDialog) Result() FileDialogResult {
	result := C.native_file_dialog_get_result(C.native_file_dialog_t(fd.nativeHandleValue()))
	return FileDialogResult(result)
}

// Paths invokes the native GetPaths operation.
func (fd *FileDialog) Paths() []string {
	result := C.native_file_dialog_get_paths(C.native_file_dialog_t(fd.nativeHandleValue()))
	defer C.native_string_list_free(&result)
	return stringsFromC(result)
}

// LastError invokes the native GetLastError operation.
func (fd *FileDialog) LastError() string {
	result := C.native_file_dialog_get_last_error(C.native_file_dialog_t(fd.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// NotificationEventType identifies the active event variant.
type NotificationEventType int32

const (
	NotificationEventActivated NotificationEventType = 0
)

// NotificationEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type NotificationEvent struct {
	Type     NotificationEventType
	Argument string
}

func fromCNotificationEvent(raw *C.native_notification_event_t) NotificationEvent {
	value := NotificationEvent{Type: NotificationEventType(raw._type)}
	switch value.Type {
	case NotificationEventActivated:
		value.Argument = C.GoString(C.go_native_notification_event_t_activated_Argument(raw))
	}
	return value
}

//export goEvent_native_notification_event_t
func goEvent_native_notification_event_t(handle C.uintptr_t, event *C.native_notification_event_t) {
	cgo.Handle(handle).Value().(func(NotificationEvent))(fromCNotificationEvent(event))
}

type notificationManager struct{}

// NotificationManager provides access to the native NotificationManager singleton.
// It has no owned handle and does not need to be released.
var NotificationManager = notificationManager{}

// IsSupported invokes the native IsSupported operation.
func (nm notificationManager) IsSupported() bool {
	result := C.native_notification_manager_is_supported()
	return bool(result)
}

// Initialize invokes the native Initialize operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (nm notificationManager) Initialize() error {
	result := C.native_notification_manager_initialize()
	if !bool(result) {
		return nativeError("NotificationManager.Initialize")
	}
	return nil
}

// Shutdown invokes the native Shutdown operation.
func (nm notificationManager) Shutdown() {
	C.native_notification_manager_shutdown()
}

// Show invokes the native Show operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (nm notificationManager) Show(title, message, tag, buttonLabel string) error {
	cArg0 := C.CString(title)
	defer C.free(unsafe.Pointer(cArg0))
	cArg1 := C.CString(message)
	defer C.free(unsafe.Pointer(cArg1))
	cArg2 := C.CString(tag)
	defer C.free(unsafe.Pointer(cArg2))
	cArg3 := C.CString(buttonLabel)
	defer C.free(unsafe.Pointer(cArg3))
	result := C.native_notification_manager_show(cArg0, cArg1, cArg2, cArg3)
	if !bool(result) {
		return nativeError("NotificationManager.Show")
	}
	return nil
}

// Remove invokes the native Remove operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (nm notificationManager) Remove(tag string) error {
	cArg0 := C.CString(tag)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_notification_manager_remove(cArg0)
	if !bool(result) {
		return nativeError("NotificationManager.Remove")
	}
	return nil
}

// LastError invokes the native GetLastError operation.
func (nm notificationManager) LastError() string {
	result := C.native_notification_manager_get_last_error()
	defer C.free_c_str(result)
	return C.GoString(result)
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (nm notificationManager) AddListener(callback func(NotificationEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("NotificationManager.AddListener")
	}
	data := newCallback(callback)
	id := C.native_notification_manager_add_listener(C.native_notification_event_callback_t(C.go_get_native_notification_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("NotificationManager.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (nm notificationManager) RemoveListener(id ListenerID) error {
	if !bool(C.native_notification_manager_remove_listener(C.native_listener_id_t(id))) {
		return nativeError("NotificationManager.RemoveListener")
	}
	return nil
}

// Image owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type Image struct{ *nativeHandle }

func wrapImage(value uint64, borrowed bool) *Image {
	if value == 0 {
		return nil
	}
	return wrapImageState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapImageState(state *nativeHandle) *Image {
	return &Image{state}
}
func (i *Image) nativeHandleValue() uint64 {
	if i == nil || i.nativeHandle == nil {
		return 0
	}
	return i.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (i *Image) Release() {
	if i.nativeHandleValue() == 0 || i.borrowed {
		return
	}
	C.native_image_free(C.native_image_t(i.value))
	i.value = 0
}

// ImageFromFile invokes the native FromFile operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func ImageFromFile(filePath string) (*Image, error) {
	cArg0 := C.CString(filePath)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_image_from_file(cArg0)
	if result == 0 {
		return nil, nativeError("ImageFromFile")
	}
	return wrapImage(uint64(result), false), nil
}

// ImageFromBase64 invokes the native FromBase64 operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func ImageFromBase64(base64Data string) (*Image, error) {
	cArg0 := C.CString(base64Data)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_image_from_base64(cArg0)
	if result == 0 {
		return nil, nativeError("ImageFromBase64")
	}
	return wrapImage(uint64(result), false), nil
}

// Size invokes the native GetSize operation.
func (i *Image) Size() Size {
	result := C.native_image_get_size(C.native_image_t(i.nativeHandleValue()))
	return fromCSize(result)
}

// Format invokes the native GetFormat operation.
func (i *Image) Format() string {
	result := C.native_image_get_format(C.native_image_t(i.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// ToBase64 invokes the native ToBase64 operation.
func (i *Image) ToBase64() string {
	result := C.native_image_to_base64(C.native_image_t(i.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// SaveToFile invokes the native SaveToFile operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (i *Image) SaveToFile(filePath string) error {
	cArg0 := C.CString(filePath)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_image_save_to_file(C.native_image_t(i.nativeHandleValue()), cArg0)
	if !bool(result) {
		return nativeError("Image.SaveToFile")
	}
	return nil
}

// NativeObject returns a borrowed platform pointer.
func (i *Image) NativeObject() unsafe.Pointer {
	return C.native_image_get_native_object(C.native_image_t(i.nativeHandleValue()))
}

// WindowShape owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type WindowShape struct{ *nativeHandle }

func wrapWindowShape(value uint64, borrowed bool) *WindowShape {
	if value == 0 {
		return nil
	}
	return wrapWindowShapeState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapWindowShapeState(state *nativeHandle) *WindowShape {
	return &WindowShape{state}
}
func (ws *WindowShape) nativeHandleValue() uint64 {
	if ws == nil || ws.nativeHandle == nil {
		return 0
	}
	return ws.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (ws *WindowShape) Release() {
	if ws.nativeHandleValue() == 0 || ws.borrowed {
		return
	}
	C.native_window_shape_free(C.native_window_shape_t(ws.value))
	ws.value = 0
}

// NewWindowShape creates an owned WindowShape.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewWindowShape() (*WindowShape, error) {
	result := C.native_window_shape_create()
	if result == 0 {
		return nil, nativeError("NewWindowShape")
	}
	return wrapWindowShape(uint64(result), false), nil
}

// AddPoint invokes the native AddPoint operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ws *WindowShape) AddPoint(point Point) error {
	cArg0, cArg0Cleanup := toCPoint(point)
	defer cArg0Cleanup()
	result := C.native_window_shape_add_point(C.native_window_shape_t(ws.nativeHandleValue()), cArg0)
	if !bool(result) {
		return nativeError("WindowShape.AddPoint")
	}
	return nil
}

// Clear invokes the native Clear operation.
func (ws *WindowShape) Clear() {
	C.native_window_shape_clear(C.native_window_shape_t(ws.nativeHandleValue()))
}

// PointCount invokes the native GetPointCount operation.
func (ws *WindowShape) PointCount() uint64 {
	result := C.native_window_shape_get_point_count(C.native_window_shape_t(ws.nativeHandleValue()))
	return uint64(result)
}

// PointAt invokes the native GetPointAt operation.
func (ws *WindowShape) PointAt(index uint64) Point {
	result := C.native_window_shape_get_point_at(C.native_window_shape_t(ws.nativeHandleValue()), C.ulong(index))
	return fromCPoint(result)
}

// WindowShadow owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type WindowShadow struct{ *nativeHandle }

func wrapWindowShadow(value uint64, borrowed bool) *WindowShadow {
	if value == 0 {
		return nil
	}
	return wrapWindowShadowState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapWindowShadowState(state *nativeHandle) *WindowShadow {
	return &WindowShadow{state}
}
func (ws *WindowShadow) nativeHandleValue() uint64 {
	if ws == nil || ws.nativeHandle == nil {
		return 0
	}
	return ws.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (ws *WindowShadow) Release() {
	if ws.nativeHandleValue() == 0 || ws.borrowed {
		return
	}
	C.native_window_shadow_free(C.native_window_shadow_t(ws.value))
	ws.value = 0
}

// NewWindowShadow creates an owned WindowShadow.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewWindowShadow() (*WindowShadow, error) {
	result := C.native_window_shadow_create()
	if result == 0 {
		return nil, nativeError("NewWindowShadow")
	}
	return wrapWindowShadow(uint64(result), false), nil
}

// SetColor invokes the native SetColor operation.
func (ws *WindowShadow) SetColor(color Color) {
	cArg0, cArg0Cleanup := toCColor(color)
	defer cArg0Cleanup()
	C.native_window_shadow_set_color(C.native_window_shadow_t(ws.nativeHandleValue()), cArg0)
}

// Color invokes the native GetColor operation.
func (ws *WindowShadow) Color() Color {
	result := C.native_window_shadow_get_color(C.native_window_shadow_t(ws.nativeHandleValue()))
	return fromCColor(result)
}

// SetBlurRadius invokes the native SetBlurRadius operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ws *WindowShadow) SetBlurRadius(radius float64) error {
	result := C.native_window_shadow_set_blur_radius(C.native_window_shadow_t(ws.nativeHandleValue()), C.double(radius))
	if !bool(result) {
		return nativeError("WindowShadow.SetBlurRadius")
	}
	return nil
}

// BlurRadius invokes the native GetBlurRadius operation.
func (ws *WindowShadow) BlurRadius() float64 {
	result := C.native_window_shadow_get_blur_radius(C.native_window_shadow_t(ws.nativeHandleValue()))
	return float64(result)
}

// SetOffset invokes the native SetOffset operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ws *WindowShadow) SetOffset(offset Point) error {
	cArg0, cArg0Cleanup := toCPoint(offset)
	defer cArg0Cleanup()
	result := C.native_window_shadow_set_offset(C.native_window_shadow_t(ws.nativeHandleValue()), cArg0)
	if !bool(result) {
		return nativeError("WindowShadow.SetOffset")
	}
	return nil
}

// Offset invokes the native GetOffset operation.
func (ws *WindowShadow) Offset() Point {
	result := C.native_window_shadow_get_offset(C.native_window_shadow_t(ws.nativeHandleValue()))
	return fromCPoint(result)
}

// ViewID identifies a native object.
type ViewID uint32

// ViewLayout represents native ViewLayout values.
type ViewLayout int32

const (
	ViewLayoutAbsolute ViewLayout = 0
	ViewLayoutRow      ViewLayout = 1
	ViewLayoutColumn   ViewLayout = 2
)

// ViewAlignment represents native ViewAlignment values.
type ViewAlignment int32

const (
	ViewAlignmentStretch ViewAlignment = 0
	ViewAlignmentStart   ViewAlignment = 1
	ViewAlignmentCenter  ViewAlignment = 2
	ViewAlignmentEnd     ViewAlignment = 3
)

// TextAlignment represents native TextAlignment values.
type TextAlignment int32

const (
	TextAlignmentStart  TextAlignment = 0
	TextAlignmentCenter TextAlignment = 1
	TextAlignmentEnd    TextAlignment = 2
)

// ViewBackend represents native ViewBackend values.
type ViewBackend int32

const (
	ViewBackendNative ViewBackend = 0
	ViewBackendWinUI3 ViewBackend = 1
)

// ViewEventType identifies the active event variant.
type ViewEventType int32

const (
	ViewEventFocused            ViewEventType = 0
	ViewEventBlurred            ViewEventType = 1
	ViewEventButtonClicked      ViewEventType = 2
	ViewEventTextFieldChanged   ViewEventType = 3
	ViewEventTextFieldSubmitted ViewEventType = 4
)

// ViewEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type ViewEvent struct {
	Type   ViewEventType
	ViewID ViewID
	Text   string
}

func fromCViewEvent(raw *C.native_view_event_t) ViewEvent {
	value := ViewEvent{Type: ViewEventType(raw._type)}
	value.ViewID = ViewID(raw.view_id)
	switch value.Type {
	case ViewEventFocused:
	case ViewEventBlurred:
	case ViewEventButtonClicked:
	case ViewEventTextFieldChanged:
		value.Text = C.GoString(C.go_native_view_event_t_text_field_changed_Text(raw))
	case ViewEventTextFieldSubmitted:
	}
	return value
}

//export goEvent_native_view_event_t
func goEvent_native_view_event_t(handle C.uintptr_t, event *C.native_view_event_t) {
	cgo.Handle(handle).Value().(func(ViewEvent))(fromCViewEvent(event))
}

// View owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type View struct{ *nativeHandle }

func wrapView(value uint64, borrowed bool) *View {
	if value == 0 {
		return nil
	}
	return wrapViewState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapViewState(state *nativeHandle) *View {
	return &View{state}
}
func (v *View) nativeHandleValue() uint64 {
	if v == nil || v.nativeHandle == nil {
		return 0
	}
	return v.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (v *View) Release() {
	if v.nativeHandleValue() == 0 || v.borrowed {
		return
	}
	C.native_view_free(C.native_view_t(v.value))
	v.value = 0
}

// NewView creates an owned View.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewView() (*View, error) {
	result := C.native_view_create()
	if result == 0 {
		return nil, nativeError("NewView")
	}
	return wrapView(uint64(result), false), nil
}

// NewViewFromNative creates an owned View.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewViewFromNative(nativeView unsafe.Pointer) (*View, error) {
	result := C.native_view_create_with_native_view(nativeView)
	if result == 0 {
		return nil, nativeError("NewViewFromNative")
	}
	return wrapView(uint64(result), false), nil
}

// ViewIsSupported invokes the native IsSupported operation.
func ViewIsSupported() bool {
	result := C.native_view_is_supported()
	return bool(result)
}

// ViewIsBackendSupported invokes the native IsBackendSupported operation.
func ViewIsBackendSupported(backend ViewBackend) bool {
	result := C.native_view_is_backend_supported(C.native_view_backend_t(backend))
	return bool(result)
}

// ViewSetDefaultBackend invokes the native SetDefaultBackend operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func ViewSetDefaultBackend(backend ViewBackend) error {
	result := C.native_view_set_default_backend(C.native_view_backend_t(backend))
	if !bool(result) {
		return nativeError("ViewSetDefaultBackend")
	}
	return nil
}

// ViewDefaultBackend invokes the native GetDefaultBackend operation.
func ViewDefaultBackend() ViewBackend {
	result := C.native_view_get_default_backend()
	return ViewBackend(result)
}

// ID invokes the native GetId operation.
func (v *View) ID() ViewID {
	result := C.native_view_get_id(C.native_view_t(v.nativeHandleValue()))
	return ViewID(result)
}

// Backend invokes the native GetBackend operation.
func (v *View) Backend() ViewBackend {
	result := C.native_view_get_backend(C.native_view_t(v.nativeHandleValue()))
	return ViewBackend(result)
}

// AddSubview invokes the native AddSubview operation.
func (v *View) AddSubview(subview *View) {
	C.native_view_add_subview(C.native_view_t(v.nativeHandleValue()), C.native_view_t(subview.nativeHandleValue()))
}

// InsertSubview invokes the native InsertSubview operation.
func (v *View) InsertSubview(index uint64, subview *View) {
	C.native_view_insert_subview(C.native_view_t(v.nativeHandleValue()), C.ulong(index), C.native_view_t(subview.nativeHandleValue()))
}

// RemoveSubview invokes the native RemoveSubview operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (v *View) RemoveSubview(subview *View) error {
	result := C.native_view_remove_subview(C.native_view_t(v.nativeHandleValue()), C.native_view_t(subview.nativeHandleValue()))
	if !bool(result) {
		return nativeError("View.RemoveSubview")
	}
	return nil
}

// RemoveSubviewAt invokes the native RemoveSubviewAt operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (v *View) RemoveSubviewAt(index uint64) error {
	result := C.native_view_remove_subview_at(C.native_view_t(v.nativeHandleValue()), C.ulong(index))
	if !bool(result) {
		return nativeError("View.RemoveSubviewAt")
	}
	return nil
}

// ClearSubviews invokes the native ClearSubviews operation.
func (v *View) ClearSubviews() {
	C.native_view_clear_subviews(C.native_view_t(v.nativeHandleValue()))
}

// SubviewCount invokes the native GetSubviewCount operation.
func (v *View) SubviewCount() uint64 {
	result := C.native_view_get_subview_count(C.native_view_t(v.nativeHandleValue()))
	return uint64(result)
}

// SubviewAt invokes the native GetSubviewAt operation.
// The returned reference is owned; nil means no object is available.
func (v *View) SubviewAt(index uint64) *View {
	result := C.native_view_get_subview_at(C.native_view_t(v.nativeHandleValue()), C.ulong(index))
	return wrapView(uint64(result), false)
}

// Subviews invokes the native GetSubviews operation.
func (v *View) Subviews() []*View {
	result := C.native_view_get_subviews(C.native_view_t(v.nativeHandleValue()))
	defer C.native_view_list_release(&result)
	return listViewFromC(result, false)
}

// Parent invokes the native GetParent operation.
// The returned reference is owned; nil means no object is available.
func (v *View) Parent() *View {
	result := C.native_view_get_parent(C.native_view_t(v.nativeHandleValue()))
	return wrapView(uint64(result), false)
}

// Window invokes the native GetWindow operation.
// The returned reference is owned; nil means no object is available.
func (v *View) Window() *Window {
	result := C.native_view_get_window(C.native_view_t(v.nativeHandleValue()))
	return wrapWindow(uint64(result), false)
}

// SetFrame invokes the native SetFrame operation.
func (v *View) SetFrame(frame Rectangle) {
	cArg0, cArg0Cleanup := toCRectangle(frame)
	defer cArg0Cleanup()
	C.native_view_set_frame(C.native_view_t(v.nativeHandleValue()), cArg0)
}

// Frame invokes the native GetFrame operation.
func (v *View) Frame() Rectangle {
	result := C.native_view_get_frame(C.native_view_t(v.nativeHandleValue()))
	return fromCRectangle(result)
}

// SetPreferredSize invokes the native SetPreferredSize operation.
func (v *View) SetPreferredSize(size Size) {
	cArg0, cArg0Cleanup := toCSize(size)
	defer cArg0Cleanup()
	C.native_view_set_preferred_size(C.native_view_t(v.nativeHandleValue()), cArg0)
}

// PreferredSize invokes the native GetPreferredSize operation.
func (v *View) PreferredSize() Size {
	result := C.native_view_get_preferred_size(C.native_view_t(v.nativeHandleValue()))
	return fromCSize(result)
}

// IntrinsicSize invokes the native GetIntrinsicSize operation.
func (v *View) IntrinsicSize() Size {
	result := C.native_view_get_intrinsic_size(C.native_view_t(v.nativeHandleValue()))
	return fromCSize(result)
}

// SetFlex invokes the native SetFlex operation.
func (v *View) SetFlex(flex float64) {
	C.native_view_set_flex(C.native_view_t(v.nativeHandleValue()), C.double(flex))
}

// Flex invokes the native GetFlex operation.
func (v *View) Flex() float64 {
	result := C.native_view_get_flex(C.native_view_t(v.nativeHandleValue()))
	return float64(result)
}

// SetAlignment invokes the native SetAlignment operation.
func (v *View) SetAlignment(alignment ViewAlignment) {
	C.native_view_set_alignment(C.native_view_t(v.nativeHandleValue()), C.native_view_alignment_t(alignment))
}

// Alignment invokes the native GetAlignment operation.
func (v *View) Alignment() ViewAlignment {
	result := C.native_view_get_alignment(C.native_view_t(v.nativeHandleValue()))
	return ViewAlignment(result)
}

// SetLayout invokes the native SetLayout operation.
func (v *View) SetLayout(layout ViewLayout) {
	C.native_view_set_layout(C.native_view_t(v.nativeHandleValue()), C.native_view_layout_t(layout))
}

// Layout invokes the native GetLayout operation.
func (v *View) Layout() ViewLayout {
	result := C.native_view_get_layout(C.native_view_t(v.nativeHandleValue()))
	return ViewLayout(result)
}

// SetSpacing invokes the native SetSpacing operation.
func (v *View) SetSpacing(spacing float64) {
	C.native_view_set_spacing(C.native_view_t(v.nativeHandleValue()), C.double(spacing))
}

// Spacing invokes the native GetSpacing operation.
func (v *View) Spacing() float64 {
	result := C.native_view_get_spacing(C.native_view_t(v.nativeHandleValue()))
	return float64(result)
}

// SetPadding invokes the native SetPadding operation.
func (v *View) SetPadding(padding EdgeInsets) {
	cArg0, cArg0Cleanup := toCEdgeInsets(padding)
	defer cArg0Cleanup()
	C.native_view_set_padding(C.native_view_t(v.nativeHandleValue()), cArg0)
}

// Padding invokes the native GetPadding operation.
func (v *View) Padding() EdgeInsets {
	result := C.native_view_get_padding(C.native_view_t(v.nativeHandleValue()))
	return fromCEdgeInsets(result)
}

// SetVisible invokes the native SetVisible operation.
func (v *View) SetVisible(isVisible bool) {
	C.native_view_set_visible(C.native_view_t(v.nativeHandleValue()), C.bool(isVisible))
}

// IsVisible invokes the native IsVisible operation.
func (v *View) IsVisible() bool {
	result := C.native_view_is_visible(C.native_view_t(v.nativeHandleValue()))
	return bool(result)
}

// SetEnabled invokes the native SetEnabled operation.
func (v *View) SetEnabled(isEnabled bool) {
	C.native_view_set_enabled(C.native_view_t(v.nativeHandleValue()), C.bool(isEnabled))
}

// IsEnabled invokes the native IsEnabled operation.
func (v *View) IsEnabled() bool {
	result := C.native_view_is_enabled(C.native_view_t(v.nativeHandleValue()))
	return bool(result)
}

// SetBackgroundColor invokes the native SetBackgroundColor operation.
func (v *View) SetBackgroundColor(color Color) {
	cArg0, cArg0Cleanup := toCColor(color)
	defer cArg0Cleanup()
	C.native_view_set_background_color(C.native_view_t(v.nativeHandleValue()), cArg0)
}

// BackgroundColor invokes the native GetBackgroundColor operation.
func (v *View) BackgroundColor() Color {
	result := C.native_view_get_background_color(C.native_view_t(v.nativeHandleValue()))
	return fromCColor(result)
}

// SetTooltip invokes the native SetTooltip operation.
func (v *View) SetTooltip(tooltip *string) {
	var cArg0 *C.char
	if tooltip != nil {
		cArg0 = C.CString(*tooltip)
		defer C.free(unsafe.Pointer(cArg0))
	}
	C.native_view_set_tooltip(C.native_view_t(v.nativeHandleValue()), cArg0)
}

// Tooltip invokes the native GetTooltip operation.
func (v *View) Tooltip() *string {
	result := C.native_view_get_tooltip(C.native_view_t(v.nativeHandleValue()))
	defer C.free_c_str(result)
	return optionalStringFromC(result)
}

// Focus invokes the native Focus operation.
func (v *View) Focus() {
	C.native_view_focus(C.native_view_t(v.nativeHandleValue()))
}

// Blur invokes the native Blur operation.
func (v *View) Blur() {
	C.native_view_blur(C.native_view_t(v.nativeHandleValue()))
}

// IsFocused invokes the native IsFocused operation.
func (v *View) IsFocused() bool {
	result := C.native_view_is_focused(C.native_view_t(v.nativeHandleValue()))
	return bool(result)
}

// NativeObject returns a borrowed platform pointer.
func (v *View) NativeObject() unsafe.Pointer {
	return C.native_view_get_native_object(C.native_view_t(v.nativeHandleValue()))
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (v *View) AddListener(callback func(ViewEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("View.AddListener")
	}
	data := newCallback(callback)
	id := C.native_view_add_listener(C.native_view_t(v.nativeHandleValue()), C.native_view_event_callback_t(C.go_get_native_view_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("View.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (v *View) RemoveListener(id ListenerID) error {
	if !bool(C.native_view_remove_listener(C.native_view_t(v.nativeHandleValue()), C.native_listener_id_t(id))) {
		return nativeError("View.RemoveListener")
	}
	return nil
}

// Label owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type Label struct{ *View }

func wrapLabel(value uint64, borrowed bool) *Label {
	if value == 0 {
		return nil
	}
	return wrapLabelState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapLabelState(state *nativeHandle) *Label {
	return &Label{wrapViewState(state)}
}
func (l *Label) nativeHandleValue() uint64 {
	if l == nil || l.View == nil {
		return 0
	}
	return l.View.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (l *Label) Release() {
	if l.nativeHandleValue() == 0 || l.borrowed {
		return
	}
	C.native_label_free(C.native_label_t(l.value))
	l.value = 0
}

// NewLabel creates an owned Label.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewLabel(text string) (*Label, error) {
	cArg0 := C.CString(text)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_label_create(cArg0)
	if result == 0 {
		return nil, nativeError("NewLabel")
	}
	return wrapLabel(uint64(result), false), nil
}

// SetText invokes the native SetText operation.
func (l *Label) SetText(text string) {
	cArg0 := C.CString(text)
	defer C.free(unsafe.Pointer(cArg0))
	C.native_label_set_text(C.native_label_t(l.nativeHandleValue()), cArg0)
}

// Text invokes the native GetText operation.
func (l *Label) Text() string {
	result := C.native_label_get_text(C.native_label_t(l.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// SetTextColor invokes the native SetTextColor operation.
func (l *Label) SetTextColor(color Color) {
	cArg0, cArg0Cleanup := toCColor(color)
	defer cArg0Cleanup()
	C.native_label_set_text_color(C.native_label_t(l.nativeHandleValue()), cArg0)
}

// TextColor invokes the native GetTextColor operation.
func (l *Label) TextColor() Color {
	result := C.native_label_get_text_color(C.native_label_t(l.nativeHandleValue()))
	return fromCColor(result)
}

// SetFontSize invokes the native SetFontSize operation.
func (l *Label) SetFontSize(size float64) {
	C.native_label_set_font_size(C.native_label_t(l.nativeHandleValue()), C.double(size))
}

// FontSize invokes the native GetFontSize operation.
func (l *Label) FontSize() float64 {
	result := C.native_label_get_font_size(C.native_label_t(l.nativeHandleValue()))
	return float64(result)
}

// SetTextAlignment invokes the native SetTextAlignment operation.
func (l *Label) SetTextAlignment(alignment TextAlignment) {
	C.native_label_set_text_alignment(C.native_label_t(l.nativeHandleValue()), C.native_text_alignment_t(alignment))
}

// TextAlignment invokes the native GetTextAlignment operation.
func (l *Label) TextAlignment() TextAlignment {
	result := C.native_label_get_text_alignment(C.native_label_t(l.nativeHandleValue()))
	return TextAlignment(result)
}

// Button owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type Button struct{ *View }

func wrapButton(value uint64, borrowed bool) *Button {
	if value == 0 {
		return nil
	}
	return wrapButtonState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapButtonState(state *nativeHandle) *Button {
	return &Button{wrapViewState(state)}
}
func (b *Button) nativeHandleValue() uint64 {
	if b == nil || b.View == nil {
		return 0
	}
	return b.View.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (b *Button) Release() {
	if b.nativeHandleValue() == 0 || b.borrowed {
		return
	}
	C.native_button_free(C.native_button_t(b.value))
	b.value = 0
}

// NewButton creates an owned Button.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewButton(text string) (*Button, error) {
	cArg0 := C.CString(text)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_button_create(cArg0)
	if result == 0 {
		return nil, nativeError("NewButton")
	}
	return wrapButton(uint64(result), false), nil
}

// SetText invokes the native SetText operation.
func (b *Button) SetText(text string) {
	cArg0 := C.CString(text)
	defer C.free(unsafe.Pointer(cArg0))
	C.native_button_set_text(C.native_button_t(b.nativeHandleValue()), cArg0)
}

// Text invokes the native GetText operation.
func (b *Button) Text() string {
	result := C.native_button_get_text(C.native_button_t(b.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// TextField owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type TextField struct{ *View }

func wrapTextField(value uint64, borrowed bool) *TextField {
	if value == 0 {
		return nil
	}
	return wrapTextFieldState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapTextFieldState(state *nativeHandle) *TextField {
	return &TextField{wrapViewState(state)}
}
func (tf *TextField) nativeHandleValue() uint64 {
	if tf == nil || tf.View == nil {
		return 0
	}
	return tf.View.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (tf *TextField) Release() {
	if tf.nativeHandleValue() == 0 || tf.borrowed {
		return
	}
	C.native_text_field_free(C.native_text_field_t(tf.value))
	tf.value = 0
}

// NewTextField creates an owned TextField.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewTextField(text string) (*TextField, error) {
	cArg0 := C.CString(text)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_text_field_create(cArg0)
	if result == 0 {
		return nil, nativeError("NewTextField")
	}
	return wrapTextField(uint64(result), false), nil
}

// SetText invokes the native SetText operation.
func (tf *TextField) SetText(text string) {
	cArg0 := C.CString(text)
	defer C.free(unsafe.Pointer(cArg0))
	C.native_text_field_set_text(C.native_text_field_t(tf.nativeHandleValue()), cArg0)
}

// Text invokes the native GetText operation.
func (tf *TextField) Text() string {
	result := C.native_text_field_get_text(C.native_text_field_t(tf.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// SetTextColor invokes the native SetTextColor operation.
func (tf *TextField) SetTextColor(color Color) {
	cArg0, cArg0Cleanup := toCColor(color)
	defer cArg0Cleanup()
	C.native_text_field_set_text_color(C.native_text_field_t(tf.nativeHandleValue()), cArg0)
}

// TextColor invokes the native GetTextColor operation.
func (tf *TextField) TextColor() Color {
	result := C.native_text_field_get_text_color(C.native_text_field_t(tf.nativeHandleValue()))
	return fromCColor(result)
}

// SetFontSize invokes the native SetFontSize operation.
func (tf *TextField) SetFontSize(size float64) {
	C.native_text_field_set_font_size(C.native_text_field_t(tf.nativeHandleValue()), C.double(size))
}

// FontSize invokes the native GetFontSize operation.
func (tf *TextField) FontSize() float64 {
	result := C.native_text_field_get_font_size(C.native_text_field_t(tf.nativeHandleValue()))
	return float64(result)
}

// SetTextAlignment invokes the native SetTextAlignment operation.
func (tf *TextField) SetTextAlignment(alignment TextAlignment) {
	C.native_text_field_set_text_alignment(C.native_text_field_t(tf.nativeHandleValue()), C.native_text_alignment_t(alignment))
}

// TextAlignment invokes the native GetTextAlignment operation.
func (tf *TextField) TextAlignment() TextAlignment {
	result := C.native_text_field_get_text_alignment(C.native_text_field_t(tf.nativeHandleValue()))
	return TextAlignment(result)
}

// SetPlaceholder invokes the native SetPlaceholder operation.
func (tf *TextField) SetPlaceholder(placeholder *string) {
	var cArg0 *C.char
	if placeholder != nil {
		cArg0 = C.CString(*placeholder)
		defer C.free(unsafe.Pointer(cArg0))
	}
	C.native_text_field_set_placeholder(C.native_text_field_t(tf.nativeHandleValue()), cArg0)
}

// Placeholder invokes the native GetPlaceholder operation.
func (tf *TextField) Placeholder() *string {
	result := C.native_text_field_get_placeholder(C.native_text_field_t(tf.nativeHandleValue()))
	defer C.free_c_str(result)
	return optionalStringFromC(result)
}

// SetEditable invokes the native SetEditable operation.
func (tf *TextField) SetEditable(isEditable bool) {
	C.native_text_field_set_editable(C.native_text_field_t(tf.nativeHandleValue()), C.bool(isEditable))
}

// IsEditable invokes the native IsEditable operation.
func (tf *TextField) IsEditable() bool {
	result := C.native_text_field_is_editable(C.native_text_field_t(tf.nativeHandleValue()))
	return bool(result)
}

// SetSecure invokes the native SetSecure operation.
func (tf *TextField) SetSecure(isSecure bool) {
	C.native_text_field_set_secure(C.native_text_field_t(tf.nativeHandleValue()), C.bool(isSecure))
}

// IsSecure invokes the native IsSecure operation.
func (tf *TextField) IsSecure() bool {
	result := C.native_text_field_is_secure(C.native_text_field_t(tf.nativeHandleValue()))
	return bool(result)
}

// SetMultiline invokes the native SetMultiline operation.
func (tf *TextField) SetMultiline(isMultiline bool) {
	C.native_text_field_set_multiline(C.native_text_field_t(tf.nativeHandleValue()), C.bool(isMultiline))
}

// IsMultiline invokes the native IsMultiline operation.
func (tf *TextField) IsMultiline() bool {
	result := C.native_text_field_is_multiline(C.native_text_field_t(tf.nativeHandleValue()))
	return bool(result)
}

// ImageView owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type ImageView struct{ *View }

func wrapImageView(value uint64, borrowed bool) *ImageView {
	if value == 0 {
		return nil
	}
	return wrapImageViewState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapImageViewState(state *nativeHandle) *ImageView {
	return &ImageView{wrapViewState(state)}
}
func (iv *ImageView) nativeHandleValue() uint64 {
	if iv == nil || iv.View == nil {
		return 0
	}
	return iv.View.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (iv *ImageView) Release() {
	if iv.nativeHandleValue() == 0 || iv.borrowed {
		return
	}
	C.native_image_view_free(C.native_image_view_t(iv.value))
	iv.value = 0
}

// NewImageView creates an owned ImageView.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewImageView() (*ImageView, error) {
	result := C.native_image_view_create()
	if result == 0 {
		return nil, nativeError("NewImageView")
	}
	return wrapImageView(uint64(result), false), nil
}

// SetImage invokes the native SetImage operation.
func (iv *ImageView) SetImage(image *Image) {
	C.native_image_view_set_image(C.native_image_view_t(iv.nativeHandleValue()), C.native_image_t(image.nativeHandleValue()))
}

// Image invokes the native GetImage operation.
// The returned reference is owned; nil means no object is available.
func (iv *ImageView) Image() *Image {
	result := C.native_image_view_get_image(C.native_image_view_t(iv.nativeHandleValue()))
	return wrapImage(uint64(result), false)
}

// WindowID identifies a native object.
type WindowID uint32

// TitleBarStyle represents native TitleBarStyle values.
type TitleBarStyle int32

const (
	TitleBarStyleNormal TitleBarStyle = 0
	TitleBarStyleHidden TitleBarStyle = 1
)

// WindowCornerPreference represents native WindowCornerPreference values.
type WindowCornerPreference int32

const (
	WindowCornerPreferenceDefault    WindowCornerPreference = 0
	WindowCornerPreferenceDoNotRound WindowCornerPreference = 1
	WindowCornerPreferenceRound      WindowCornerPreference = 2
	WindowCornerPreferenceRoundSmall WindowCornerPreference = 3
)

// WindowProperty represents native WindowProperty values.
type WindowProperty int32

const (
	WindowPropertyTitle                       WindowProperty = 0
	WindowPropertyResizable                   WindowProperty = 1
	WindowPropertyMovable                     WindowProperty = 2
	WindowPropertyMinimizable                 WindowProperty = 3
	WindowPropertyMaximizable                 WindowProperty = 4
	WindowPropertyFullScreenable              WindowProperty = 5
	WindowPropertyClosable                    WindowProperty = 6
	WindowPropertyWindowControlButtonsVisible WindowProperty = 7
	WindowPropertyAlwaysOnTop                 WindowProperty = 8
	WindowPropertyAlwaysOnBottom              WindowProperty = 9
	WindowPropertyTitleBarStyle               WindowProperty = 10
)

// WindowOcclusionState represents native WindowOcclusionState values.
type WindowOcclusionState int32

const (
	WindowOcclusionStateUnknown  WindowOcclusionState = 0
	WindowOcclusionStateVisible  WindowOcclusionState = 1
	WindowOcclusionStateOccluded WindowOcclusionState = 2
)

// VisualEffect represents native VisualEffect values.
type VisualEffect int32

const (
	VisualEffectNone    VisualEffect = 0
	VisualEffectBlur    VisualEffect = 1
	VisualEffectAcrylic VisualEffect = 2
	VisualEffectMica    VisualEffect = 3
	VisualEffectMicaAlt VisualEffect = 4
	VisualEffectHud     VisualEffect = 5
	VisualEffectPopover VisualEffect = 6
	VisualEffectMenu    VisualEffect = 7
)

// ResizeEdge represents native ResizeEdge values.
type ResizeEdge int32

const (
	ResizeEdgeTop         ResizeEdge = 0
	ResizeEdgeLeft        ResizeEdge = 1
	ResizeEdgeRight       ResizeEdge = 2
	ResizeEdgeBottom      ResizeEdge = 3
	ResizeEdgeTopLeft     ResizeEdge = 4
	ResizeEdgeTopRight    ResizeEdge = 5
	ResizeEdgeBottomLeft  ResizeEdge = 6
	ResizeEdgeBottomRight ResizeEdge = 7
)

// WindowEventType identifies the active event variant.
type WindowEventType int32

const (
	WindowEventFocused           WindowEventType = 0
	WindowEventBlurred           WindowEventType = 1
	WindowEventMinimized         WindowEventType = 2
	WindowEventMaximized         WindowEventType = 3
	WindowEventRestored          WindowEventType = 4
	WindowEventMoved             WindowEventType = 5
	WindowEventResized           WindowEventType = 6
	WindowEventCreated           WindowEventType = 7
	WindowEventClosed            WindowEventType = 8
	WindowEventEnteredFullScreen WindowEventType = 9
	WindowEventExitedFullScreen  WindowEventType = 10
	WindowEventCloseRequested    WindowEventType = 11
	WindowEventPropertyChanged   WindowEventType = 12
	WindowEventOcclusionChanged  WindowEventType = 13
)

// WindowEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type WindowEvent struct {
	Type           WindowEventType
	WindowID       WindowID
	NewPosition    Point
	NewSize        Size
	Request        *EventRequest
	Property       WindowProperty
	OcclusionState WindowOcclusionState
}

func fromCWindowEvent(raw *C.native_window_event_t) WindowEvent {
	value := WindowEvent{Type: WindowEventType(raw._type)}
	value.WindowID = WindowID(raw.window_id)
	switch value.Type {
	case WindowEventFocused:
	case WindowEventBlurred:
	case WindowEventMinimized:
	case WindowEventMaximized:
	case WindowEventRestored:
	case WindowEventMoved:
		value.NewPosition = fromCPoint(C.go_native_window_event_t_moved_NewPosition(raw))
	case WindowEventResized:
		value.NewSize = fromCSize(C.go_native_window_event_t_resized_NewSize(raw))
	case WindowEventCreated:
	case WindowEventClosed:
	case WindowEventEnteredFullScreen:
	case WindowEventExitedFullScreen:
	case WindowEventCloseRequested:
		value.Request = wrapEventRequest(uint64(C.go_native_window_event_t_close_requested_Request(raw)), true)
	case WindowEventPropertyChanged:
		value.Property = WindowProperty(C.go_native_window_event_t_property_changed_Property(raw))
	case WindowEventOcclusionChanged:
		value.OcclusionState = WindowOcclusionState(C.go_native_window_event_t_occlusion_changed_OcclusionState(raw))
	}
	return value
}

//export goEvent_native_window_event_t
func goEvent_native_window_event_t(handle C.uintptr_t, event *C.native_window_event_t) {
	cgo.Handle(handle).Value().(func(WindowEvent))(fromCWindowEvent(event))
}

// Window owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type Window struct{ *nativeHandle }

func wrapWindow(value uint64, borrowed bool) *Window {
	if value == 0 {
		return nil
	}
	return wrapWindowState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapWindowState(state *nativeHandle) *Window {
	return &Window{state}
}
func (w *Window) nativeHandleValue() uint64 {
	if w == nil || w.nativeHandle == nil {
		return 0
	}
	return w.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (w *Window) Release() {
	if w.nativeHandleValue() == 0 || w.borrowed {
		return
	}
	C.native_window_free(C.native_window_t(w.value))
	w.value = 0
}

// NewWindow creates an owned Window.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewWindow() (*Window, error) {
	result := C.native_window_create()
	if result == 0 {
		return nil, nativeError("NewWindow")
	}
	return wrapWindow(uint64(result), false), nil
}

// NewWindowFromNative creates an owned Window.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewWindowFromNative(nativeWindow unsafe.Pointer) (*Window, error) {
	result := C.native_window_create_with_native_window(nativeWindow)
	if result == 0 {
		return nil, nativeError("NewWindowFromNative")
	}
	return wrapWindow(uint64(result), false), nil
}

// WindowIsCloseSupported invokes the native IsCloseSupported operation.
func WindowIsCloseSupported() bool {
	result := C.native_window_is_close_supported()
	return bool(result)
}

// Close invokes the native Close operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) Close() error {
	result := C.native_window_close(C.native_window_t(w.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Window.Close")
	}
	return nil
}

// ID invokes the native GetId operation.
func (w *Window) ID() WindowID {
	result := C.native_window_get_id(C.native_window_t(w.nativeHandleValue()))
	return WindowID(result)
}

// ContentView invokes the native GetContentView operation.
// The returned reference is owned; nil means no object is available.
func (w *Window) ContentView() *View {
	result := C.native_window_get_content_view(C.native_window_t(w.nativeHandleValue()))
	return wrapView(uint64(result), false)
}

// Focus invokes the native Focus operation.
func (w *Window) Focus() {
	C.native_window_focus(C.native_window_t(w.nativeHandleValue()))
}

// Blur invokes the native Blur operation.
func (w *Window) Blur() {
	C.native_window_blur(C.native_window_t(w.nativeHandleValue()))
}

// IsFocused invokes the native IsFocused operation.
func (w *Window) IsFocused() bool {
	result := C.native_window_is_focused(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// Show invokes the native Show operation.
func (w *Window) Show() {
	C.native_window_show(C.native_window_t(w.nativeHandleValue()))
}

// ShowInactive invokes the native ShowInactive operation.
func (w *Window) ShowInactive() {
	C.native_window_show_inactive(C.native_window_t(w.nativeHandleValue()))
}

// Hide invokes the native Hide operation.
func (w *Window) Hide() {
	C.native_window_hide(C.native_window_t(w.nativeHandleValue()))
}

// IsVisible invokes the native IsVisible operation.
func (w *Window) IsVisible() bool {
	result := C.native_window_is_visible(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// OcclusionState invokes the native GetOcclusionState operation.
func (w *Window) OcclusionState() WindowOcclusionState {
	result := C.native_window_get_occlusion_state(C.native_window_t(w.nativeHandleValue()))
	return WindowOcclusionState(result)
}

// WindowIsOcclusionStateSupported invokes the native IsOcclusionStateSupported operation.
func WindowIsOcclusionStateSupported() bool {
	result := C.native_window_is_occlusion_state_supported()
	return bool(result)
}

// Maximize invokes the native Maximize operation.
func (w *Window) Maximize() {
	C.native_window_maximize(C.native_window_t(w.nativeHandleValue()))
}

// Unmaximize invokes the native Unmaximize operation.
func (w *Window) Unmaximize() {
	C.native_window_unmaximize(C.native_window_t(w.nativeHandleValue()))
}

// IsMaximized invokes the native IsMaximized operation.
func (w *Window) IsMaximized() bool {
	result := C.native_window_is_maximized(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// Minimize invokes the native Minimize operation.
func (w *Window) Minimize() {
	C.native_window_minimize(C.native_window_t(w.nativeHandleValue()))
}

// Restore invokes the native Restore operation.
func (w *Window) Restore() {
	C.native_window_restore(C.native_window_t(w.nativeHandleValue()))
}

// IsMinimized invokes the native IsMinimized operation.
func (w *Window) IsMinimized() bool {
	result := C.native_window_is_minimized(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetFullScreen invokes the native SetFullScreen operation.
func (w *Window) SetFullScreen(isFullScreen bool) {
	C.native_window_set_full_screen(C.native_window_t(w.nativeHandleValue()), C.bool(isFullScreen))
}

// IsFullScreen invokes the native IsFullScreen operation.
func (w *Window) IsFullScreen() bool {
	result := C.native_window_is_full_screen(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetBounds invokes the native SetBounds operation.
func (w *Window) SetBounds(bounds Rectangle) {
	cArg0, cArg0Cleanup := toCRectangle(bounds)
	defer cArg0Cleanup()
	C.native_window_set_bounds(C.native_window_t(w.nativeHandleValue()), cArg0)
}

// Bounds invokes the native GetBounds operation.
func (w *Window) Bounds() Rectangle {
	result := C.native_window_get_bounds(C.native_window_t(w.nativeHandleValue()))
	return fromCRectangle(result)
}

// SetContentBounds invokes the native SetContentBounds operation.
func (w *Window) SetContentBounds(bounds Rectangle) {
	cArg0, cArg0Cleanup := toCRectangle(bounds)
	defer cArg0Cleanup()
	C.native_window_set_content_bounds(C.native_window_t(w.nativeHandleValue()), cArg0)
}

// ContentBounds invokes the native GetContentBounds operation.
func (w *Window) ContentBounds() Rectangle {
	result := C.native_window_get_content_bounds(C.native_window_t(w.nativeHandleValue()))
	return fromCRectangle(result)
}

// SetSize invokes the native SetSize operation.
func (w *Window) SetSize(size Size, animate bool) {
	cArg0, cArg0Cleanup := toCSize(size)
	defer cArg0Cleanup()
	C.native_window_set_size(C.native_window_t(w.nativeHandleValue()), cArg0, C.bool(animate))
}

// Size invokes the native GetSize operation.
func (w *Window) Size() Size {
	result := C.native_window_get_size(C.native_window_t(w.nativeHandleValue()))
	return fromCSize(result)
}

// SetContentSize invokes the native SetContentSize operation.
func (w *Window) SetContentSize(size Size) {
	cArg0, cArg0Cleanup := toCSize(size)
	defer cArg0Cleanup()
	C.native_window_set_content_size(C.native_window_t(w.nativeHandleValue()), cArg0)
}

// ContentSize invokes the native GetContentSize operation.
func (w *Window) ContentSize() Size {
	result := C.native_window_get_content_size(C.native_window_t(w.nativeHandleValue()))
	return fromCSize(result)
}

// SetMinimumSize invokes the native SetMinimumSize operation.
func (w *Window) SetMinimumSize(size Size) {
	cArg0, cArg0Cleanup := toCSize(size)
	defer cArg0Cleanup()
	C.native_window_set_minimum_size(C.native_window_t(w.nativeHandleValue()), cArg0)
}

// MinimumSize invokes the native GetMinimumSize operation.
func (w *Window) MinimumSize() Size {
	result := C.native_window_get_minimum_size(C.native_window_t(w.nativeHandleValue()))
	return fromCSize(result)
}

// SetMaximumSize invokes the native SetMaximumSize operation.
func (w *Window) SetMaximumSize(size Size) {
	cArg0, cArg0Cleanup := toCSize(size)
	defer cArg0Cleanup()
	C.native_window_set_maximum_size(C.native_window_t(w.nativeHandleValue()), cArg0)
}

// MaximumSize invokes the native GetMaximumSize operation.
func (w *Window) MaximumSize() Size {
	result := C.native_window_get_maximum_size(C.native_window_t(w.nativeHandleValue()))
	return fromCSize(result)
}

// SetAspectRatio invokes the native SetAspectRatio operation.
func (w *Window) SetAspectRatio(aspectRatio float64) {
	C.native_window_set_aspect_ratio(C.native_window_t(w.nativeHandleValue()), C.double(aspectRatio))
}

// AspectRatio invokes the native GetAspectRatio operation.
func (w *Window) AspectRatio() float64 {
	result := C.native_window_get_aspect_ratio(C.native_window_t(w.nativeHandleValue()))
	return float64(result)
}

// SetResizable invokes the native SetResizable operation.
func (w *Window) SetResizable(isResizable bool) {
	C.native_window_set_resizable(C.native_window_t(w.nativeHandleValue()), C.bool(isResizable))
}

// IsResizable invokes the native IsResizable operation.
func (w *Window) IsResizable() bool {
	result := C.native_window_is_resizable(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetMovable invokes the native SetMovable operation.
func (w *Window) SetMovable(isMovable bool) {
	C.native_window_set_movable(C.native_window_t(w.nativeHandleValue()), C.bool(isMovable))
}

// IsMovable invokes the native IsMovable operation.
func (w *Window) IsMovable() bool {
	result := C.native_window_is_movable(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetMinimizable invokes the native SetMinimizable operation.
func (w *Window) SetMinimizable(isMinimizable bool) {
	C.native_window_set_minimizable(C.native_window_t(w.nativeHandleValue()), C.bool(isMinimizable))
}

// IsMinimizable invokes the native IsMinimizable operation.
func (w *Window) IsMinimizable() bool {
	result := C.native_window_is_minimizable(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetMaximizable invokes the native SetMaximizable operation.
func (w *Window) SetMaximizable(isMaximizable bool) {
	C.native_window_set_maximizable(C.native_window_t(w.nativeHandleValue()), C.bool(isMaximizable))
}

// IsMaximizable invokes the native IsMaximizable operation.
func (w *Window) IsMaximizable() bool {
	result := C.native_window_is_maximizable(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetFullScreenable invokes the native SetFullScreenable operation.
func (w *Window) SetFullScreenable(isFullScreenable bool) {
	C.native_window_set_full_screenable(C.native_window_t(w.nativeHandleValue()), C.bool(isFullScreenable))
}

// IsFullScreenable invokes the native IsFullScreenable operation.
func (w *Window) IsFullScreenable() bool {
	result := C.native_window_is_full_screenable(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetClosable invokes the native SetClosable operation.
func (w *Window) SetClosable(isClosable bool) {
	C.native_window_set_closable(C.native_window_t(w.nativeHandleValue()), C.bool(isClosable))
}

// IsClosable invokes the native IsClosable operation.
func (w *Window) IsClosable() bool {
	result := C.native_window_is_closable(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetWindowControlButtonsVisible invokes the native SetWindowControlButtonsVisible operation.
func (w *Window) SetWindowControlButtonsVisible(isVisible bool) {
	C.native_window_set_window_control_buttons_visible(C.native_window_t(w.nativeHandleValue()), C.bool(isVisible))
}

// IsWindowControlButtonsVisible invokes the native IsWindowControlButtonsVisible operation.
func (w *Window) IsWindowControlButtonsVisible() bool {
	result := C.native_window_is_window_control_buttons_visible(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetAlwaysOnTop invokes the native SetAlwaysOnTop operation.
func (w *Window) SetAlwaysOnTop(isAlwaysOnTop bool) {
	C.native_window_set_always_on_top(C.native_window_t(w.nativeHandleValue()), C.bool(isAlwaysOnTop))
}

// IsAlwaysOnTop invokes the native IsAlwaysOnTop operation.
func (w *Window) IsAlwaysOnTop() bool {
	result := C.native_window_is_always_on_top(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetAlwaysOnBottom invokes the native SetAlwaysOnBottom operation.
func (w *Window) SetAlwaysOnBottom(isAlwaysOnBottom bool) {
	C.native_window_set_always_on_bottom(C.native_window_t(w.nativeHandleValue()), C.bool(isAlwaysOnBottom))
}

// IsAlwaysOnBottom invokes the native IsAlwaysOnBottom operation.
func (w *Window) IsAlwaysOnBottom() bool {
	result := C.native_window_is_always_on_bottom(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetParentWindow invokes the native SetParentWindow operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) SetParentWindow(parent *Window) error {
	result := C.native_window_set_parent_window(C.native_window_t(w.nativeHandleValue()), C.native_window_t(parent.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Window.SetParentWindow")
	}
	return nil
}

// ParentWindow invokes the native GetParentWindow operation.
// The returned reference is owned; nil means no object is available.
func (w *Window) ParentWindow() *Window {
	result := C.native_window_get_parent_window(C.native_window_t(w.nativeHandleValue()))
	return wrapWindow(uint64(result), false)
}

// SetNonActivating invokes the native SetNonActivating operation.
func (w *Window) SetNonActivating(isNonActivating bool) {
	C.native_window_set_non_activating(C.native_window_t(w.nativeHandleValue()), C.bool(isNonActivating))
}

// IsNonActivating invokes the native IsNonActivating operation.
func (w *Window) IsNonActivating() bool {
	result := C.native_window_is_non_activating(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetPosition invokes the native SetPosition operation.
func (w *Window) SetPosition(point Point) {
	cArg0, cArg0Cleanup := toCPoint(point)
	defer cArg0Cleanup()
	C.native_window_set_position(C.native_window_t(w.nativeHandleValue()), cArg0)
}

// Position invokes the native GetPosition operation.
func (w *Window) Position() Point {
	result := C.native_window_get_position(C.native_window_t(w.nativeHandleValue()))
	return fromCPoint(result)
}

// Center invokes the native Center operation.
func (w *Window) Center() {
	C.native_window_center(C.native_window_t(w.nativeHandleValue()))
}

// SetTitle invokes the native SetTitle operation.
func (w *Window) SetTitle(title string) {
	cArg0 := C.CString(title)
	defer C.free(unsafe.Pointer(cArg0))
	C.native_window_set_title(C.native_window_t(w.nativeHandleValue()), cArg0)
}

// Title invokes the native GetTitle operation.
func (w *Window) Title() string {
	result := C.native_window_get_title(C.native_window_t(w.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// SetTitleBarColors invokes the native SetTitleBarColors operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) SetTitleBarColors(background, foreground Color) error {
	cArg0, cArg0Cleanup := toCColor(background)
	defer cArg0Cleanup()
	cArg1, cArg1Cleanup := toCColor(foreground)
	defer cArg1Cleanup()
	result := C.native_window_set_title_bar_colors(C.native_window_t(w.nativeHandleValue()), cArg0, cArg1)
	if !bool(result) {
		return nativeError("Window.SetTitleBarColors")
	}
	return nil
}

// ResetTitleBarColors invokes the native ResetTitleBarColors operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) ResetTitleBarColors() error {
	result := C.native_window_reset_title_bar_colors(C.native_window_t(w.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Window.ResetTitleBarColors")
	}
	return nil
}

// SetTitleBarStyle invokes the native SetTitleBarStyle operation.
func (w *Window) SetTitleBarStyle(style TitleBarStyle) {
	C.native_window_set_title_bar_style(C.native_window_t(w.nativeHandleValue()), C.native_title_bar_style_t(style))
}

// TitleBarStyle invokes the native GetTitleBarStyle operation.
func (w *Window) TitleBarStyle() TitleBarStyle {
	result := C.native_window_get_title_bar_style(C.native_window_t(w.nativeHandleValue()))
	return TitleBarStyle(result)
}

// SetCornerPreference invokes the native SetCornerPreference operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) SetCornerPreference(preference WindowCornerPreference) error {
	result := C.native_window_set_corner_preference(C.native_window_t(w.nativeHandleValue()), C.native_window_corner_preference_t(preference))
	if !bool(result) {
		return nativeError("Window.SetCornerPreference")
	}
	return nil
}

// CornerPreference invokes the native GetCornerPreference operation.
func (w *Window) CornerPreference() WindowCornerPreference {
	result := C.native_window_get_corner_preference(C.native_window_t(w.nativeHandleValue()))
	return WindowCornerPreference(result)
}

// WindowIsCornerPreferenceSupported invokes the native IsCornerPreferenceSupported operation.
func WindowIsCornerPreferenceSupported() bool {
	result := C.native_window_is_corner_preference_supported()
	return bool(result)
}

// SetContentUnderTitleBar invokes the native SetContentUnderTitleBar operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) SetContentUnderTitleBar(isContentUnderTitleBar bool) error {
	result := C.native_window_set_content_under_title_bar(C.native_window_t(w.nativeHandleValue()), C.bool(isContentUnderTitleBar))
	if !bool(result) {
		return nativeError("Window.SetContentUnderTitleBar")
	}
	return nil
}

// IsContentUnderTitleBar invokes the native IsContentUnderTitleBar operation.
func (w *Window) IsContentUnderTitleBar() bool {
	result := C.native_window_is_content_under_title_bar(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// WindowIsContentUnderTitleBarSupported invokes the native IsContentUnderTitleBarSupported operation.
func WindowIsContentUnderTitleBarSupported() bool {
	result := C.native_window_is_content_under_title_bar_supported()
	return bool(result)
}

// SetContentProtection invokes the native SetContentProtection operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) SetContentProtection(isContentProtected bool) error {
	result := C.native_window_set_content_protection(C.native_window_t(w.nativeHandleValue()), C.bool(isContentProtected))
	if !bool(result) {
		return nativeError("Window.SetContentProtection")
	}
	return nil
}

// IsContentProtected invokes the native IsContentProtected operation.
func (w *Window) IsContentProtected() bool {
	result := C.native_window_is_content_protected(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// WindowIsContentProtectionSupported invokes the native IsContentProtectionSupported operation.
func WindowIsContentProtectionSupported() bool {
	result := C.native_window_is_content_protection_supported()
	return bool(result)
}

// SetHasShadow invokes the native SetHasShadow operation.
func (w *Window) SetHasShadow(hasShadow bool) {
	C.native_window_set_has_shadow(C.native_window_t(w.nativeHandleValue()), C.bool(hasShadow))
}

// HasShadow invokes the native HasShadow operation.
func (w *Window) HasShadow() bool {
	result := C.native_window_has_shadow(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetCustomShadow invokes the native SetCustomShadow operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) SetCustomShadow(shadow *WindowShadow) error {
	result := C.native_window_set_custom_shadow(C.native_window_t(w.nativeHandleValue()), C.native_window_shadow_t(shadow.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Window.SetCustomShadow")
	}
	return nil
}

// CustomShadow invokes the native GetCustomShadow operation.
// The returned reference is owned; nil means no object is available.
func (w *Window) CustomShadow() *WindowShadow {
	result := C.native_window_get_custom_shadow(C.native_window_t(w.nativeHandleValue()))
	return wrapWindowShadow(uint64(result), false)
}

// SetOpacity invokes the native SetOpacity operation.
func (w *Window) SetOpacity(opacity float32) {
	C.native_window_set_opacity(C.native_window_t(w.nativeHandleValue()), C.float(opacity))
}

// Opacity invokes the native GetOpacity operation.
func (w *Window) Opacity() float32 {
	result := C.native_window_get_opacity(C.native_window_t(w.nativeHandleValue()))
	return float32(result)
}

// SetVisualEffect invokes the native SetVisualEffect operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) SetVisualEffect(effect VisualEffect) error {
	result := C.native_window_set_visual_effect(C.native_window_t(w.nativeHandleValue()), C.native_visual_effect_t(effect))
	if !bool(result) {
		return nativeError("Window.SetVisualEffect")
	}
	return nil
}

// VisualEffect invokes the native GetVisualEffect operation.
func (w *Window) VisualEffect() VisualEffect {
	result := C.native_window_get_visual_effect(C.native_window_t(w.nativeHandleValue()))
	return VisualEffect(result)
}

// WindowIsVisualEffectSupported invokes the native IsVisualEffectSupported operation.
func WindowIsVisualEffectSupported(effect VisualEffect) bool {
	result := C.native_window_is_visual_effect_supported(C.native_visual_effect_t(effect))
	return bool(result)
}

// SetShape invokes the native SetShape operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) SetShape(shape *WindowShape) error {
	result := C.native_window_set_shape(C.native_window_t(w.nativeHandleValue()), C.native_window_shape_t(shape.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Window.SetShape")
	}
	return nil
}

// IsShaped invokes the native IsShaped operation.
func (w *Window) IsShaped() bool {
	result := C.native_window_is_shaped(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// WindowIsShapeSupported invokes the native IsShapeSupported operation.
func WindowIsShapeSupported() bool {
	result := C.native_window_is_shape_supported()
	return bool(result)
}

// SetInputShape invokes the native SetInputShape operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) SetInputShape(shape *WindowShape) error {
	result := C.native_window_set_input_shape(C.native_window_t(w.nativeHandleValue()), C.native_window_shape_t(shape.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Window.SetInputShape")
	}
	return nil
}

// IsInputShaped invokes the native IsInputShaped operation.
func (w *Window) IsInputShaped() bool {
	result := C.native_window_is_input_shaped(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// WindowIsInputShapeSupported invokes the native IsInputShapeSupported operation.
func WindowIsInputShapeSupported() bool {
	result := C.native_window_is_input_shape_supported()
	return bool(result)
}

// SetBackgroundColor invokes the native SetBackgroundColor operation.
func (w *Window) SetBackgroundColor(color Color) {
	cArg0, cArg0Cleanup := toCColor(color)
	defer cArg0Cleanup()
	C.native_window_set_background_color(C.native_window_t(w.nativeHandleValue()), cArg0)
}

// BackgroundColor invokes the native GetBackgroundColor operation.
func (w *Window) BackgroundColor() Color {
	result := C.native_window_get_background_color(C.native_window_t(w.nativeHandleValue()))
	return fromCColor(result)
}

// SetVisibleOnAllWorkspaces invokes the native SetVisibleOnAllWorkspaces operation.
func (w *Window) SetVisibleOnAllWorkspaces(isVisibleOnAllWorkspaces bool) {
	C.native_window_set_visible_on_all_workspaces(C.native_window_t(w.nativeHandleValue()), C.bool(isVisibleOnAllWorkspaces))
}

// IsVisibleOnAllWorkspaces invokes the native IsVisibleOnAllWorkspaces operation.
func (w *Window) IsVisibleOnAllWorkspaces() bool {
	result := C.native_window_is_visible_on_all_workspaces(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetVisibleInTaskbar invokes the native SetVisibleInTaskbar operation.
func (w *Window) SetVisibleInTaskbar(isVisibleInTaskbar bool) {
	C.native_window_set_visible_in_taskbar(C.native_window_t(w.nativeHandleValue()), C.bool(isVisibleInTaskbar))
}

// IsVisibleInTaskbar invokes the native IsVisibleInTaskbar operation.
func (w *Window) IsVisibleInTaskbar() bool {
	result := C.native_window_is_visible_in_taskbar(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// SetIgnoreMouseEvents invokes the native SetIgnoreMouseEvents operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) SetIgnoreMouseEvents(isIgnoreMouseEvents, forward bool) error {
	result := C.native_window_set_ignore_mouse_events(C.native_window_t(w.nativeHandleValue()), C.bool(isIgnoreMouseEvents), C.bool(forward))
	if !bool(result) {
		return nativeError("Window.SetIgnoreMouseEvents")
	}
	return nil
}

// IsIgnoreMouseEvents invokes the native IsIgnoreMouseEvents operation.
func (w *Window) IsIgnoreMouseEvents() bool {
	result := C.native_window_is_ignore_mouse_events(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// IsMouseMoveForwardingEnabled invokes the native IsMouseMoveForwardingEnabled operation.
func (w *Window) IsMouseMoveForwardingEnabled() bool {
	result := C.native_window_is_mouse_move_forwarding_enabled(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// WindowIsMouseMoveForwardingSupported invokes the native IsMouseMoveForwardingSupported operation.
func WindowIsMouseMoveForwardingSupported() bool {
	result := C.native_window_is_mouse_move_forwarding_supported()
	return bool(result)
}

// SetFocusable invokes the native SetFocusable operation.
func (w *Window) SetFocusable(isFocusable bool) {
	C.native_window_set_focusable(C.native_window_t(w.nativeHandleValue()), C.bool(isFocusable))
}

// IsFocusable invokes the native IsFocusable operation.
func (w *Window) IsFocusable() bool {
	result := C.native_window_is_focusable(C.native_window_t(w.nativeHandleValue()))
	return bool(result)
}

// ShowSystemMenu invokes the native ShowSystemMenu operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) ShowSystemMenu(position Point) error {
	cArg0, cArg0Cleanup := toCPoint(position)
	defer cArg0Cleanup()
	result := C.native_window_show_system_menu(C.native_window_t(w.nativeHandleValue()), cArg0)
	if !bool(result) {
		return nativeError("Window.ShowSystemMenu")
	}
	return nil
}

// WindowIsSystemMenuSupported invokes the native IsSystemMenuSupported operation.
func WindowIsSystemMenuSupported() bool {
	result := C.native_window_is_system_menu_supported()
	return bool(result)
}

// SetMaximizeButtonBounds invokes the native SetMaximizeButtonBounds operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) SetMaximizeButtonBounds(bounds Rectangle) error {
	cArg0, cArg0Cleanup := toCRectangle(bounds)
	defer cArg0Cleanup()
	result := C.native_window_set_maximize_button_bounds(C.native_window_t(w.nativeHandleValue()), cArg0)
	if !bool(result) {
		return nativeError("Window.SetMaximizeButtonBounds")
	}
	return nil
}

// MaximizeButtonBounds invokes the native GetMaximizeButtonBounds operation.
func (w *Window) MaximizeButtonBounds() Rectangle {
	result := C.native_window_get_maximize_button_bounds(C.native_window_t(w.nativeHandleValue()))
	return fromCRectangle(result)
}

// WindowIsMaximizeButtonBoundsSupported invokes the native IsMaximizeButtonBoundsSupported operation.
func WindowIsMaximizeButtonBoundsSupported() bool {
	result := C.native_window_is_maximize_button_bounds_supported()
	return bool(result)
}

// PerformTitleBarDoubleClick invokes the native PerformTitleBarDoubleClick operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (w *Window) PerformTitleBarDoubleClick() error {
	result := C.native_window_perform_title_bar_double_click(C.native_window_t(w.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Window.PerformTitleBarDoubleClick")
	}
	return nil
}

// StartDragging invokes the native StartDragging operation.
func (w *Window) StartDragging() {
	C.native_window_start_dragging(C.native_window_t(w.nativeHandleValue()))
}

// StartResizing invokes the native StartResizing operation.
func (w *Window) StartResizing(edge ResizeEdge) {
	C.native_window_start_resizing(C.native_window_t(w.nativeHandleValue()), C.native_resize_edge_t(edge))
}

// NativeObject returns a borrowed platform pointer.
func (w *Window) NativeObject() unsafe.Pointer {
	return C.native_window_get_native_object(C.native_window_t(w.nativeHandleValue()))
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (w *Window) AddListener(callback func(WindowEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("Window.AddListener")
	}
	data := newCallback(callback)
	id := C.native_window_add_listener(C.native_window_t(w.nativeHandleValue()), C.native_window_event_callback_t(C.go_get_native_window_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("Window.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (w *Window) RemoveListener(id ListenerID) error {
	if !bool(C.native_window_remove_listener(C.native_window_t(w.nativeHandleValue()), C.native_listener_id_t(id))) {
		return nativeError("Window.RemoveListener")
	}
	return nil
}

type windowManager struct{}

// WindowManager provides access to the native WindowManager singleton.
// It has no owned handle and does not need to be released.
var WindowManager = windowManager{}

// Get invokes the native Get operation.
// The returned reference is owned; nil means no object is available.
func (wm windowManager) Get(id WindowID) *Window {
	result := C.native_window_manager_get(C.native_window_id_t(id))
	return wrapWindow(uint64(result), false)
}

// All invokes the native GetAll operation.
func (wm windowManager) All() []*Window {
	result := C.native_window_manager_get_all()
	defer C.native_window_list_release(&result)
	return listWindowFromC(result, false)
}

// Current invokes the native GetCurrent operation.
// The returned reference is owned; nil means no object is available.
func (wm windowManager) Current() *Window {
	result := C.native_window_manager_get_current()
	return wrapWindow(uint64(result), false)
}

// WindowAtPoint invokes the native GetWindowAtPoint operation.
// The returned reference is owned; nil means no object is available.
func (wm windowManager) WindowAtPoint(point Point, excludedWindowID WindowID) *Window {
	cArg0, cArg0Cleanup := toCPoint(point)
	defer cArg0Cleanup()
	result := C.native_window_manager_get_window_at_point(cArg0, C.native_window_id_t(excludedWindowID))
	return wrapWindow(uint64(result), false)
}

// SetWillShowHook invokes the native SetWillShowHook operation.
func (wm windowManager) SetWillShowHook(hook func(uint32)) {
	var cArg0Fn C.native_window_manager_set_will_show_hook_callback_t
	var cArg0Data unsafe.Pointer
	var cArg0Release C.native_release_user_data_t
	if hook != nil {
		cArg0Data = newCallback(hook)
		cArg0Fn = C.native_window_manager_set_will_show_hook_callback_t(C.go_get_native_window_manager_set_will_show_hook_callback_t())
		cArg0Release = C.native_release_user_data_t(C.go_get_release_callback())
	}
	C.native_window_manager_set_will_show_hook(cArg0Fn, cArg0Data, cArg0Release)
}

// SetWillHideHook invokes the native SetWillHideHook operation.
func (wm windowManager) SetWillHideHook(hook func(uint32)) {
	var cArg0Fn C.native_window_manager_set_will_hide_hook_callback_t
	var cArg0Data unsafe.Pointer
	var cArg0Release C.native_release_user_data_t
	if hook != nil {
		cArg0Data = newCallback(hook)
		cArg0Fn = C.native_window_manager_set_will_hide_hook_callback_t(C.go_get_native_window_manager_set_will_hide_hook_callback_t())
		cArg0Release = C.native_release_user_data_t(C.go_get_release_callback())
	}
	C.native_window_manager_set_will_hide_hook(cArg0Fn, cArg0Data, cArg0Release)
}

// HasWillShowHook invokes the native HasWillShowHook operation.
func (wm windowManager) HasWillShowHook() bool {
	result := C.native_window_manager_has_will_show_hook()
	return bool(result)
}

// HasWillHideHook invokes the native HasWillHideHook operation.
func (wm windowManager) HasWillHideHook() bool {
	result := C.native_window_manager_has_will_hide_hook()
	return bool(result)
}

// HandleWillShow invokes the native HandleWillShow operation.
func (wm windowManager) HandleWillShow(id WindowID) {
	C.native_window_manager_handle_will_show(C.native_window_id_t(id))
}

// HandleWillHide invokes the native HandleWillHide operation.
func (wm windowManager) HandleWillHide(id WindowID) {
	C.native_window_manager_handle_will_hide(C.native_window_id_t(id))
}

// CallOriginalShow invokes the native CallOriginalShow operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (wm windowManager) CallOriginalShow(id WindowID) error {
	result := C.native_window_manager_call_original_show(C.native_window_id_t(id))
	if !bool(result) {
		return nativeError("WindowManager.CallOriginalShow")
	}
	return nil
}

// CallOriginalHide invokes the native CallOriginalHide operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (wm windowManager) CallOriginalHide(id WindowID) error {
	result := C.native_window_manager_call_original_hide(C.native_window_id_t(id))
	if !bool(result) {
		return nativeError("WindowManager.CallOriginalHide")
	}
	return nil
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (wm windowManager) AddListener(callback func(WindowEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("WindowManager.AddListener")
	}
	data := newCallback(callback)
	id := C.native_window_manager_add_listener(C.native_window_event_callback_t(C.go_get_native_window_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("WindowManager.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (wm windowManager) RemoveListener(id ListenerID) error {
	if !bool(C.native_window_manager_remove_listener(C.native_listener_id_t(id))) {
		return nativeError("WindowManager.RemoveListener")
	}
	return nil
}

// WindowDragEventType identifies the active event variant.
type WindowDragEventType int32

const (
	WindowDragEventMoved     WindowDragEventType = 0
	WindowDragEventEnded     WindowDragEventType = 1
	WindowDragEventCancelled WindowDragEventType = 2
)

// WindowDragEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type WindowDragEvent struct {
	Type           WindowDragEventType
	WindowID       WindowID
	CursorPosition Point
}

func fromCWindowDragEvent(raw *C.native_window_drag_event_t) WindowDragEvent {
	value := WindowDragEvent{Type: WindowDragEventType(raw._type)}
	value.WindowID = WindowID(raw.window_id)
	value.CursorPosition = fromCPoint(raw.cursor_position)
	switch value.Type {
	case WindowDragEventMoved:
	case WindowDragEventEnded:
	case WindowDragEventCancelled:
	}
	return value
}

//export goEvent_native_window_drag_event_t
func goEvent_native_window_drag_event_t(handle C.uintptr_t, event *C.native_window_drag_event_t) {
	cgo.Handle(handle).Value().(func(WindowDragEvent))(fromCWindowDragEvent(event))
}

// WindowDragSession owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type WindowDragSession struct{ *nativeHandle }

func wrapWindowDragSession(value uint64, borrowed bool) *WindowDragSession {
	if value == 0 {
		return nil
	}
	return wrapWindowDragSessionState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapWindowDragSessionState(state *nativeHandle) *WindowDragSession {
	return &WindowDragSession{state}
}
func (wds *WindowDragSession) nativeHandleValue() uint64 {
	if wds == nil || wds.nativeHandle == nil {
		return 0
	}
	return wds.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (wds *WindowDragSession) Release() {
	if wds.nativeHandleValue() == 0 || wds.borrowed {
		return
	}
	C.native_window_drag_session_free(C.native_window_drag_session_t(wds.value))
	wds.value = 0
}

// NewWindowDragSession creates an owned WindowDragSession.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewWindowDragSession() (*WindowDragSession, error) {
	result := C.native_window_drag_session_create()
	if result == 0 {
		return nil, nativeError("NewWindowDragSession")
	}
	return wrapWindowDragSession(uint64(result), false), nil
}

// Start invokes the native Start operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (wds *WindowDragSession) Start(window *Window, anchor Point) error {
	cArg1, cArg1Cleanup := toCPoint(anchor)
	defer cArg1Cleanup()
	result := C.native_window_drag_session_start(C.native_window_drag_session_t(wds.nativeHandleValue()), C.native_window_t(window.nativeHandleValue()), cArg1)
	if !bool(result) {
		return nativeError("WindowDragSession.Start")
	}
	return nil
}

// Cancel invokes the native Cancel operation.
func (wds *WindowDragSession) Cancel() {
	C.native_window_drag_session_cancel(C.native_window_drag_session_t(wds.nativeHandleValue()))
}

// IsActive invokes the native IsActive operation.
func (wds *WindowDragSession) IsActive() bool {
	result := C.native_window_drag_session_is_active(C.native_window_drag_session_t(wds.nativeHandleValue()))
	return bool(result)
}

// WindowID invokes the native GetWindowId operation.
func (wds *WindowDragSession) WindowID() WindowID {
	result := C.native_window_drag_session_get_window_id(C.native_window_drag_session_t(wds.nativeHandleValue()))
	return WindowID(result)
}

// Anchor invokes the native GetAnchor operation.
func (wds *WindowDragSession) Anchor() Point {
	result := C.native_window_drag_session_get_anchor(C.native_window_drag_session_t(wds.nativeHandleValue()))
	return fromCPoint(result)
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (wds *WindowDragSession) AddListener(callback func(WindowDragEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("WindowDragSession.AddListener")
	}
	data := newCallback(callback)
	id := C.native_window_drag_session_add_listener(C.native_window_drag_session_t(wds.nativeHandleValue()), C.native_window_drag_event_callback_t(C.go_get_native_window_drag_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("WindowDragSession.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (wds *WindowDragSession) RemoveListener(id ListenerID) error {
	if !bool(C.native_window_drag_session_remove_listener(C.native_window_drag_session_t(wds.nativeHandleValue()), C.native_listener_id_t(id))) {
		return nativeError("WindowDragSession.RemoveListener")
	}
	return nil
}

// DragOperation represents native DragOperation values.
type DragOperation int32

const (
	DragOperationNone DragOperation = 0
	DragOperationCopy DragOperation = 1
	DragOperationMove DragOperation = 2
	DragOperationLink DragOperation = 3
)

// DragSourceEventType identifies the active event variant.
type DragSourceEventType int32

const (
	DragSourceEventEnded DragSourceEventType = 0
)

// DragSourceEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type DragSourceEvent struct {
	Type      DragSourceEventType
	WindowID  WindowID
	Position  Point
	Operation DragOperation
}

func fromCDragSourceEvent(raw *C.native_drag_source_event_t) DragSourceEvent {
	value := DragSourceEvent{Type: DragSourceEventType(raw._type)}
	value.WindowID = WindowID(raw.window_id)
	value.Position = fromCPoint(raw.position)
	switch value.Type {
	case DragSourceEventEnded:
		value.Operation = DragOperation(C.go_native_drag_source_event_t_ended_Operation(raw))
	}
	return value
}

//export goEvent_native_drag_source_event_t
func goEvent_native_drag_source_event_t(handle C.uintptr_t, event *C.native_drag_source_event_t) {
	cgo.Handle(handle).Value().(func(DragSourceEvent))(fromCDragSourceEvent(event))
}

// DragSource owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type DragSource struct{ *nativeHandle }

func wrapDragSource(value uint64, borrowed bool) *DragSource {
	if value == 0 {
		return nil
	}
	return wrapDragSourceState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapDragSourceState(state *nativeHandle) *DragSource {
	return &DragSource{state}
}
func (ds *DragSource) nativeHandleValue() uint64 {
	if ds == nil || ds.nativeHandle == nil {
		return 0
	}
	return ds.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (ds *DragSource) Release() {
	if ds.nativeHandleValue() == 0 || ds.borrowed {
		return
	}
	C.native_drag_source_free(C.native_drag_source_t(ds.value))
	ds.value = 0
}

// NewDragSource creates an owned DragSource.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewDragSource() (*DragSource, error) {
	result := C.native_drag_source_create()
	if result == 0 {
		return nil, nativeError("NewDragSource")
	}
	return wrapDragSource(uint64(result), false), nil
}

// DragSourceIsSupported invokes the native IsSupported operation.
func DragSourceIsSupported() bool {
	result := C.native_drag_source_is_supported()
	return bool(result)
}

// SetFilePaths invokes the native SetFilePaths operation.
func (ds *DragSource) SetFilePaths(filePaths []string) {
	cArg0, cArg0Cleanup := stringsToC(filePaths)
	defer cArg0Cleanup()
	C.native_drag_source_set_file_paths(C.native_drag_source_t(ds.nativeHandleValue()), cArg0)
}

// FilePaths invokes the native GetFilePaths operation.
func (ds *DragSource) FilePaths() []string {
	result := C.native_drag_source_get_file_paths(C.native_drag_source_t(ds.nativeHandleValue()))
	defer C.native_string_list_free(&result)
	return stringsFromC(result)
}

// SetText invokes the native SetText operation.
func (ds *DragSource) SetText(text *string) {
	var cArg0 *C.char
	if text != nil {
		cArg0 = C.CString(*text)
		defer C.free(unsafe.Pointer(cArg0))
	}
	C.native_drag_source_set_text(C.native_drag_source_t(ds.nativeHandleValue()), cArg0)
}

// Text invokes the native GetText operation.
func (ds *DragSource) Text() *string {
	result := C.native_drag_source_get_text(C.native_drag_source_t(ds.nativeHandleValue()))
	defer C.free_c_str(result)
	return optionalStringFromC(result)
}

// SetImage invokes the native SetImage operation.
func (ds *DragSource) SetImage(image *Image) {
	C.native_drag_source_set_image(C.native_drag_source_t(ds.nativeHandleValue()), C.native_image_t(image.nativeHandleValue()))
}

// Image invokes the native GetImage operation.
// The returned reference is owned; nil means no object is available.
func (ds *DragSource) Image() *Image {
	result := C.native_drag_source_get_image(C.native_drag_source_t(ds.nativeHandleValue()))
	return wrapImage(uint64(result), false)
}

// SetDragOperation invokes the native SetDragOperation operation.
func (ds *DragSource) SetDragOperation(operation DragOperation) {
	C.native_drag_source_set_drag_operation(C.native_drag_source_t(ds.nativeHandleValue()), C.native_drag_operation_t(operation))
}

// DragOperation invokes the native GetDragOperation operation.
func (ds *DragSource) DragOperation() DragOperation {
	result := C.native_drag_source_get_drag_operation(C.native_drag_source_t(ds.nativeHandleValue()))
	return DragOperation(result)
}

// StartDragging invokes the native StartDragging operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ds *DragSource) StartDragging(window *Window) error {
	result := C.native_drag_source_start_dragging(C.native_drag_source_t(ds.nativeHandleValue()), C.native_window_t(window.nativeHandleValue()))
	if !bool(result) {
		return nativeError("DragSource.StartDragging")
	}
	return nil
}

// IsDragging invokes the native IsDragging operation.
func (ds *DragSource) IsDragging() bool {
	result := C.native_drag_source_is_dragging(C.native_drag_source_t(ds.nativeHandleValue()))
	return bool(result)
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (ds *DragSource) AddListener(callback func(DragSourceEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("DragSource.AddListener")
	}
	data := newCallback(callback)
	id := C.native_drag_source_add_listener(C.native_drag_source_t(ds.nativeHandleValue()), C.native_drag_source_event_callback_t(C.go_get_native_drag_source_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("DragSource.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (ds *DragSource) RemoveListener(id ListenerID) error {
	if !bool(C.native_drag_source_remove_listener(C.native_drag_source_t(ds.nativeHandleValue()), C.native_listener_id_t(id))) {
		return nativeError("DragSource.RemoveListener")
	}
	return nil
}

// DropTargetEventType identifies the active event variant.
type DropTargetEventType int32

const (
	DropTargetEventEntered DropTargetEventType = 0
	DropTargetEventMoved   DropTargetEventType = 1
	DropTargetEventExited  DropTargetEventType = 2
	DropTargetEventDropped DropTargetEventType = 3
)

// DropTargetEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type DropTargetEvent struct {
	Type      DropTargetEventType
	WindowID  WindowID
	Position  Point
	FilePaths []string
	Text      string
}

func fromCDropTargetEvent(raw *C.native_drop_target_event_t) DropTargetEvent {
	value := DropTargetEvent{Type: DropTargetEventType(raw._type)}
	value.WindowID = WindowID(raw.window_id)
	value.Position = fromCPoint(raw.position)
	switch value.Type {
	case DropTargetEventEntered:
	case DropTargetEventMoved:
	case DropTargetEventExited:
	case DropTargetEventDropped:
		value.FilePaths = stringsFromC(C.go_native_drop_target_event_t_dropped_FilePaths(raw))
		value.Text = C.GoString(C.go_native_drop_target_event_t_dropped_Text(raw))
	}
	return value
}

//export goEvent_native_drop_target_event_t
func goEvent_native_drop_target_event_t(handle C.uintptr_t, event *C.native_drop_target_event_t) {
	cgo.Handle(handle).Value().(func(DropTargetEvent))(fromCDropTargetEvent(event))
}

// DropTarget owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type DropTarget struct{ *nativeHandle }

func wrapDropTarget(value uint64, borrowed bool) *DropTarget {
	if value == 0 {
		return nil
	}
	return wrapDropTargetState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapDropTargetState(state *nativeHandle) *DropTarget {
	return &DropTarget{state}
}
func (dt *DropTarget) nativeHandleValue() uint64 {
	if dt == nil || dt.nativeHandle == nil {
		return 0
	}
	return dt.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (dt *DropTarget) Release() {
	if dt.nativeHandleValue() == 0 || dt.borrowed {
		return
	}
	C.native_drop_target_free(C.native_drop_target_t(dt.value))
	dt.value = 0
}

// NewDropTarget creates an owned DropTarget.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewDropTarget(window *Window) (*DropTarget, error) {
	result := C.native_drop_target_create(C.native_window_t(window.nativeHandleValue()))
	if result == 0 {
		return nil, nativeError("NewDropTarget")
	}
	return wrapDropTarget(uint64(result), false), nil
}

// DropTargetIsSupported invokes the native IsSupported operation.
func DropTargetIsSupported() bool {
	result := C.native_drop_target_is_supported()
	return bool(result)
}

// WindowID invokes the native GetWindowId operation.
func (dt *DropTarget) WindowID() WindowID {
	result := C.native_drop_target_get_window_id(C.native_drop_target_t(dt.nativeHandleValue()))
	return WindowID(result)
}

// SetDropOperation invokes the native SetDropOperation operation.
func (dt *DropTarget) SetDropOperation(operation DragOperation) {
	C.native_drop_target_set_drop_operation(C.native_drop_target_t(dt.nativeHandleValue()), C.native_drag_operation_t(operation))
}

// DropOperation invokes the native GetDropOperation operation.
func (dt *DropTarget) DropOperation() DragOperation {
	result := C.native_drop_target_get_drop_operation(C.native_drop_target_t(dt.nativeHandleValue()))
	return DragOperation(result)
}

// IsActive invokes the native IsActive operation.
func (dt *DropTarget) IsActive() bool {
	result := C.native_drop_target_is_active(C.native_drop_target_t(dt.nativeHandleValue()))
	return bool(result)
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (dt *DropTarget) AddListener(callback func(DropTargetEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("DropTarget.AddListener")
	}
	data := newCallback(callback)
	id := C.native_drop_target_add_listener(C.native_drop_target_t(dt.nativeHandleValue()), C.native_drop_target_event_callback_t(C.go_get_native_drop_target_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("DropTarget.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (dt *DropTarget) RemoveListener(id ListenerID) error {
	if !bool(C.native_drop_target_remove_listener(C.native_drop_target_t(dt.nativeHandleValue()), C.native_listener_id_t(id))) {
		return nativeError("DropTarget.RemoveListener")
	}
	return nil
}

// PositioningStrategyType represents native PositioningStrategyType values.
type PositioningStrategyType int32

const (
	PositioningStrategyTypeAbsolute       PositioningStrategyType = 0
	PositioningStrategyTypeCursorPosition PositioningStrategyType = 1
	PositioningStrategyTypeRelative       PositioningStrategyType = 2
)

// PositioningStrategy owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type PositioningStrategy struct{ *nativeHandle }

func wrapPositioningStrategy(value uint64, borrowed bool) *PositioningStrategy {
	if value == 0 {
		return nil
	}
	return wrapPositioningStrategyState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapPositioningStrategyState(state *nativeHandle) *PositioningStrategy {
	return &PositioningStrategy{state}
}
func (ps *PositioningStrategy) nativeHandleValue() uint64 {
	if ps == nil || ps.nativeHandle == nil {
		return 0
	}
	return ps.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (ps *PositioningStrategy) Release() {
	if ps.nativeHandleValue() == 0 || ps.borrowed {
		return
	}
	C.native_positioning_strategy_free(C.native_positioning_strategy_t(ps.value))
	ps.value = 0
}

// PositioningStrategyAbsolute invokes the native Absolute operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func PositioningStrategyAbsolute(point Point) (*PositioningStrategy, error) {
	cArg0, cArg0Cleanup := toCPoint(point)
	defer cArg0Cleanup()
	result := C.native_positioning_strategy_absolute(cArg0)
	if result == 0 {
		return nil, nativeError("PositioningStrategyAbsolute")
	}
	return wrapPositioningStrategy(uint64(result), false), nil
}

// PositioningStrategyCursorPosition invokes the native CursorPosition operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func PositioningStrategyCursorPosition() (*PositioningStrategy, error) {
	result := C.native_positioning_strategy_cursor_position()
	if result == 0 {
		return nil, nativeError("PositioningStrategyCursorPosition")
	}
	return wrapPositioningStrategy(uint64(result), false), nil
}

// PositioningStrategyRelativeToRect invokes the native Relative operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func PositioningStrategyRelativeToRect(rect Rectangle, offset Point) (*PositioningStrategy, error) {
	cArg0, cArg0Cleanup := toCRectangle(rect)
	defer cArg0Cleanup()
	cArg1, cArg1Cleanup := toCPoint(offset)
	defer cArg1Cleanup()
	result := C.native_positioning_strategy_relative_with_rect_and_offset(cArg0, cArg1)
	if result == 0 {
		return nil, nativeError("PositioningStrategyRelativeToRect")
	}
	return wrapPositioningStrategy(uint64(result), false), nil
}

// PositioningStrategyRelativeToWindow invokes the native Relative operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func PositioningStrategyRelativeToWindow(window *Window, offset Point) (*PositioningStrategy, error) {
	cArg1, cArg1Cleanup := toCPoint(offset)
	defer cArg1Cleanup()
	result := C.native_positioning_strategy_relative_with_window_and_offset(C.native_window_t(window.nativeHandleValue()), cArg1)
	if result == 0 {
		return nil, nativeError("PositioningStrategyRelativeToWindow")
	}
	return wrapPositioningStrategy(uint64(result), false), nil
}

// Type invokes the native GetType operation.
func (ps *PositioningStrategy) Type() PositioningStrategyType {
	result := C.native_positioning_strategy_get_type(C.native_positioning_strategy_t(ps.nativeHandleValue()))
	return PositioningStrategyType(result)
}

// AbsolutePosition invokes the native GetAbsolutePosition operation.
func (ps *PositioningStrategy) AbsolutePosition() Point {
	result := C.native_positioning_strategy_get_absolute_position(C.native_positioning_strategy_t(ps.nativeHandleValue()))
	return fromCPoint(result)
}

// RelativeRectangle invokes the native GetRelativeRectangle operation.
func (ps *PositioningStrategy) RelativeRectangle() Rectangle {
	result := C.native_positioning_strategy_get_relative_rectangle(C.native_positioning_strategy_t(ps.nativeHandleValue()))
	return fromCRectangle(result)
}

// RelativeOffset invokes the native GetRelativeOffset operation.
func (ps *PositioningStrategy) RelativeOffset() Point {
	result := C.native_positioning_strategy_get_relative_offset(C.native_positioning_strategy_t(ps.nativeHandleValue()))
	return fromCPoint(result)
}

// MenuID identifies a native object.
type MenuID uint32

// MenuItemID identifies a native object.
type MenuItemID uint32

// MenuBackend represents native MenuBackend values.
type MenuBackend int32

const (
	MenuBackendNative MenuBackend = 0
	MenuBackendWinUI3 MenuBackend = 1
)

// MenuItemType represents native MenuItemType values.
type MenuItemType int32

const (
	MenuItemTypeNormal    MenuItemType = 0
	MenuItemTypeCheckbox  MenuItemType = 1
	MenuItemTypeRadio     MenuItemType = 2
	MenuItemTypeSeparator MenuItemType = 3
	MenuItemTypeSubmenu   MenuItemType = 4
)

// MenuItemState represents native MenuItemState values.
type MenuItemState int32

const (
	MenuItemStateUnchecked MenuItemState = 0
	MenuItemStateChecked   MenuItemState = 1
	MenuItemStateMixed     MenuItemState = 2
)

// MenuEventType identifies the active event variant.
type MenuEventType int32

const (
	MenuEventOpened            MenuEventType = 0
	MenuEventClosed            MenuEventType = 1
	MenuEventItemClicked       MenuEventType = 2
	MenuEventItemSubmenuOpened MenuEventType = 3
	MenuEventItemSubmenuClosed MenuEventType = 4
)

// MenuEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type MenuEvent struct {
	Type   MenuEventType
	MenuID MenuID
	ItemID MenuItemID
}

func fromCMenuEvent(raw *C.native_menu_event_t) MenuEvent {
	value := MenuEvent{Type: MenuEventType(raw._type)}
	switch value.Type {
	case MenuEventOpened:
		value.MenuID = MenuID(C.go_native_menu_event_t_opened_MenuId(raw))
	case MenuEventClosed:
		value.MenuID = MenuID(C.go_native_menu_event_t_closed_MenuId(raw))
	case MenuEventItemClicked:
		value.ItemID = MenuItemID(C.go_native_menu_event_t_item_clicked_ItemId(raw))
	case MenuEventItemSubmenuOpened:
		value.ItemID = MenuItemID(C.go_native_menu_event_t_item_submenu_opened_ItemId(raw))
	case MenuEventItemSubmenuClosed:
		value.ItemID = MenuItemID(C.go_native_menu_event_t_item_submenu_closed_ItemId(raw))
	}
	return value
}

//export goEvent_native_menu_event_t
func goEvent_native_menu_event_t(handle C.uintptr_t, event *C.native_menu_event_t) {
	cgo.Handle(handle).Value().(func(MenuEvent))(fromCMenuEvent(event))
}

// MenuItem owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type MenuItem struct{ *nativeHandle }

func wrapMenuItem(value uint64, borrowed bool) *MenuItem {
	if value == 0 {
		return nil
	}
	return wrapMenuItemState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapMenuItemState(state *nativeHandle) *MenuItem {
	return &MenuItem{state}
}
func (mi *MenuItem) nativeHandleValue() uint64 {
	if mi == nil || mi.nativeHandle == nil {
		return 0
	}
	return mi.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (mi *MenuItem) Release() {
	if mi.nativeHandleValue() == 0 || mi.borrowed {
		return
	}
	C.native_menu_item_free(C.native_menu_item_t(mi.value))
	mi.value = 0
}

// NewMenuItem creates an owned MenuItem.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewMenuItem(label string, kind MenuItemType) (*MenuItem, error) {
	cArg0 := C.CString(label)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_menu_item_create_with_label_and_type(cArg0, C.native_menu_item_type_t(kind))
	if result == 0 {
		return nil, nativeError("NewMenuItem")
	}
	return wrapMenuItem(uint64(result), false), nil
}

// NewMenuItemFromNative creates an owned MenuItem.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewMenuItemFromNative(nativeItem unsafe.Pointer) (*MenuItem, error) {
	result := C.native_menu_item_create_with_native_item(nativeItem)
	if result == 0 {
		return nil, nativeError("NewMenuItemFromNative")
	}
	return wrapMenuItem(uint64(result), false), nil
}

// ID invokes the native GetId operation.
func (mi *MenuItem) ID() MenuItemID {
	result := C.native_menu_item_get_id(C.native_menu_item_t(mi.nativeHandleValue()))
	return MenuItemID(result)
}

// Type invokes the native GetType operation.
func (mi *MenuItem) Type() MenuItemType {
	result := C.native_menu_item_get_type(C.native_menu_item_t(mi.nativeHandleValue()))
	return MenuItemType(result)
}

// SetLabel invokes the native SetLabel operation.
func (mi *MenuItem) SetLabel(label *string) {
	var cArg0 *C.char
	if label != nil {
		cArg0 = C.CString(*label)
		defer C.free(unsafe.Pointer(cArg0))
	}
	C.native_menu_item_set_label(C.native_menu_item_t(mi.nativeHandleValue()), cArg0)
}

// Label invokes the native GetLabel operation.
func (mi *MenuItem) Label() *string {
	result := C.native_menu_item_get_label(C.native_menu_item_t(mi.nativeHandleValue()))
	defer C.free_c_str(result)
	return optionalStringFromC(result)
}

// SetIcon invokes the native SetIcon operation.
func (mi *MenuItem) SetIcon(image *Image) {
	C.native_menu_item_set_icon(C.native_menu_item_t(mi.nativeHandleValue()), C.native_image_t(image.nativeHandleValue()))
}

// Icon invokes the native GetIcon operation.
// The returned reference is owned; nil means no object is available.
func (mi *MenuItem) Icon() *Image {
	result := C.native_menu_item_get_icon(C.native_menu_item_t(mi.nativeHandleValue()))
	return wrapImage(uint64(result), false)
}

// SetTooltip invokes the native SetTooltip operation.
func (mi *MenuItem) SetTooltip(tooltip *string) {
	var cArg0 *C.char
	if tooltip != nil {
		cArg0 = C.CString(*tooltip)
		defer C.free(unsafe.Pointer(cArg0))
	}
	C.native_menu_item_set_tooltip(C.native_menu_item_t(mi.nativeHandleValue()), cArg0)
}

// Tooltip invokes the native GetTooltip operation.
func (mi *MenuItem) Tooltip() *string {
	result := C.native_menu_item_get_tooltip(C.native_menu_item_t(mi.nativeHandleValue()))
	defer C.free_c_str(result)
	return optionalStringFromC(result)
}

// SetAccelerator invokes the native SetAccelerator operation.
func (mi *MenuItem) SetAccelerator(accelerator *KeyboardAccelerator) {
	var cArg0 *C.native_keyboard_accelerator_t
	if accelerator != nil {
		temp, cArg0Cleanup := toCKeyboardAccelerator(*accelerator)
		cArg0 = &temp
		defer cArg0Cleanup()
	}
	C.native_menu_item_set_accelerator(C.native_menu_item_t(mi.nativeHandleValue()), cArg0)
}

// Accelerator invokes the native GetAccelerator operation.
func (mi *MenuItem) Accelerator() KeyboardAccelerator {
	result := C.native_menu_item_get_accelerator(C.native_menu_item_t(mi.nativeHandleValue()))
	defer C.native_keyboard_accelerator_free(&result)
	return fromCKeyboardAccelerator(result)
}

// SetEnabled invokes the native SetEnabled operation.
func (mi *MenuItem) SetEnabled(enabled bool) {
	C.native_menu_item_set_enabled(C.native_menu_item_t(mi.nativeHandleValue()), C.bool(enabled))
}

// IsEnabled invokes the native IsEnabled operation.
func (mi *MenuItem) IsEnabled() bool {
	result := C.native_menu_item_is_enabled(C.native_menu_item_t(mi.nativeHandleValue()))
	return bool(result)
}

// SetState invokes the native SetState operation.
func (mi *MenuItem) SetState(state MenuItemState) {
	C.native_menu_item_set_state(C.native_menu_item_t(mi.nativeHandleValue()), C.native_menu_item_state_t(state))
}

// State invokes the native GetState operation.
func (mi *MenuItem) State() MenuItemState {
	result := C.native_menu_item_get_state(C.native_menu_item_t(mi.nativeHandleValue()))
	return MenuItemState(result)
}

// SetRadioGroup invokes the native SetRadioGroup operation.
func (mi *MenuItem) SetRadioGroup(groupID int32) {
	C.native_menu_item_set_radio_group(C.native_menu_item_t(mi.nativeHandleValue()), C.int(groupID))
}

// RadioGroup invokes the native GetRadioGroup operation.
func (mi *MenuItem) RadioGroup() int32 {
	result := C.native_menu_item_get_radio_group(C.native_menu_item_t(mi.nativeHandleValue()))
	return int32(result)
}

// SetSubmenu invokes the native SetSubmenu operation.
func (mi *MenuItem) SetSubmenu(submenu *Menu) {
	C.native_menu_item_set_submenu(C.native_menu_item_t(mi.nativeHandleValue()), C.native_menu_t(submenu.nativeHandleValue()))
}

// Submenu invokes the native GetSubmenu operation.
// The returned reference is owned; nil means no object is available.
func (mi *MenuItem) Submenu() *Menu {
	result := C.native_menu_item_get_submenu(C.native_menu_item_t(mi.nativeHandleValue()))
	return wrapMenu(uint64(result), false)
}

// NativeObject returns a borrowed platform pointer.
func (mi *MenuItem) NativeObject() unsafe.Pointer {
	return C.native_menu_item_get_native_object(C.native_menu_item_t(mi.nativeHandleValue()))
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (mi *MenuItem) AddListener(callback func(MenuEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("MenuItem.AddListener")
	}
	data := newCallback(callback)
	id := C.native_menu_item_add_listener(C.native_menu_item_t(mi.nativeHandleValue()), C.native_menu_event_callback_t(C.go_get_native_menu_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("MenuItem.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (mi *MenuItem) RemoveListener(id ListenerID) error {
	if !bool(C.native_menu_item_remove_listener(C.native_menu_item_t(mi.nativeHandleValue()), C.native_listener_id_t(id))) {
		return nativeError("MenuItem.RemoveListener")
	}
	return nil
}

// Menu owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type Menu struct{ *nativeHandle }

func wrapMenu(value uint64, borrowed bool) *Menu {
	if value == 0 {
		return nil
	}
	return wrapMenuState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapMenuState(state *nativeHandle) *Menu {
	return &Menu{state}
}
func (m *Menu) nativeHandleValue() uint64 {
	if m == nil || m.nativeHandle == nil {
		return 0
	}
	return m.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (m *Menu) Release() {
	if m.nativeHandleValue() == 0 || m.borrowed {
		return
	}
	C.native_menu_free(C.native_menu_t(m.value))
	m.value = 0
}

// NewMenu creates an owned Menu.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewMenu() (*Menu, error) {
	result := C.native_menu_create()
	if result == 0 {
		return nil, nativeError("NewMenu")
	}
	return wrapMenu(uint64(result), false), nil
}

// NewMenuFromNative creates an owned Menu.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewMenuFromNative(nativeMenu unsafe.Pointer) (*Menu, error) {
	result := C.native_menu_create_with_native_menu(nativeMenu)
	if result == 0 {
		return nil, nativeError("NewMenuFromNative")
	}
	return wrapMenu(uint64(result), false), nil
}

// ID invokes the native GetId operation.
func (m *Menu) ID() MenuID {
	result := C.native_menu_get_id(C.native_menu_t(m.nativeHandleValue()))
	return MenuID(result)
}

// SetBackend invokes the native SetBackend operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (m *Menu) SetBackend(backend MenuBackend) error {
	result := C.native_menu_set_backend(C.native_menu_t(m.nativeHandleValue()), C.native_menu_backend_t(backend))
	if !bool(result) {
		return nativeError("Menu.SetBackend")
	}
	return nil
}

// Backend invokes the native GetBackend operation.
func (m *Menu) Backend() MenuBackend {
	result := C.native_menu_get_backend(C.native_menu_t(m.nativeHandleValue()))
	return MenuBackend(result)
}

// MenuIsBackendSupported invokes the native IsBackendSupported operation.
func MenuIsBackendSupported(backend MenuBackend) bool {
	result := C.native_menu_is_backend_supported(C.native_menu_backend_t(backend))
	return bool(result)
}

// AddItem invokes the native AddItem operation.
func (m *Menu) AddItem(item *MenuItem) {
	C.native_menu_add_item(C.native_menu_t(m.nativeHandleValue()), C.native_menu_item_t(item.nativeHandleValue()))
}

// InsertItem invokes the native InsertItem operation.
func (m *Menu) InsertItem(index uint64, item *MenuItem) {
	C.native_menu_insert_item(C.native_menu_t(m.nativeHandleValue()), C.ulong(index), C.native_menu_item_t(item.nativeHandleValue()))
}

// RemoveItem invokes the native RemoveItem operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (m *Menu) RemoveItem(item *MenuItem) error {
	result := C.native_menu_remove_item(C.native_menu_t(m.nativeHandleValue()), C.native_menu_item_t(item.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Menu.RemoveItem")
	}
	return nil
}

// RemoveItemByID invokes the native RemoveItemById operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (m *Menu) RemoveItemByID(itemID MenuItemID) error {
	result := C.native_menu_remove_item_by_id(C.native_menu_t(m.nativeHandleValue()), C.native_menu_item_id_t(itemID))
	if !bool(result) {
		return nativeError("Menu.RemoveItemByID")
	}
	return nil
}

// RemoveItemAt invokes the native RemoveItemAt operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (m *Menu) RemoveItemAt(index uint64) error {
	result := C.native_menu_remove_item_at(C.native_menu_t(m.nativeHandleValue()), C.ulong(index))
	if !bool(result) {
		return nativeError("Menu.RemoveItemAt")
	}
	return nil
}

// Clear invokes the native Clear operation.
func (m *Menu) Clear() {
	C.native_menu_clear(C.native_menu_t(m.nativeHandleValue()))
}

// AddSeparator invokes the native AddSeparator operation.
func (m *Menu) AddSeparator() {
	C.native_menu_add_separator(C.native_menu_t(m.nativeHandleValue()))
}

// InsertSeparator invokes the native InsertSeparator operation.
func (m *Menu) InsertSeparator(index uint64) {
	C.native_menu_insert_separator(C.native_menu_t(m.nativeHandleValue()), C.ulong(index))
}

// ItemCount invokes the native GetItemCount operation.
func (m *Menu) ItemCount() uint64 {
	result := C.native_menu_get_item_count(C.native_menu_t(m.nativeHandleValue()))
	return uint64(result)
}

// ItemAt invokes the native GetItemAt operation.
// The returned reference is owned; nil means no object is available.
func (m *Menu) ItemAt(index uint64) *MenuItem {
	result := C.native_menu_get_item_at(C.native_menu_t(m.nativeHandleValue()), C.ulong(index))
	return wrapMenuItem(uint64(result), false)
}

// ItemByID invokes the native GetItemById operation.
// The returned reference is owned; nil means no object is available.
func (m *Menu) ItemByID(itemID MenuItemID) *MenuItem {
	result := C.native_menu_get_item_by_id(C.native_menu_t(m.nativeHandleValue()), C.native_menu_item_id_t(itemID))
	return wrapMenuItem(uint64(result), false)
}

// AllItems invokes the native GetAllItems operation.
func (m *Menu) AllItems() []*MenuItem {
	result := C.native_menu_get_all_items(C.native_menu_t(m.nativeHandleValue()))
	defer C.native_menu_item_list_release(&result)
	return listMenuItemFromC(result, false)
}

// Open invokes the native Open operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (m *Menu) Open(strategy *PositioningStrategy, placement Placement) error {
	result := C.native_menu_open(C.native_menu_t(m.nativeHandleValue()), C.native_positioning_strategy_t(strategy.nativeHandleValue()), C.native_placement_t(placement))
	if !bool(result) {
		return nativeError("Menu.Open")
	}
	return nil
}

// Close invokes the native Close operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (m *Menu) Close() error {
	result := C.native_menu_close(C.native_menu_t(m.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Menu.Close")
	}
	return nil
}

// NativeObject returns a borrowed platform pointer.
func (m *Menu) NativeObject() unsafe.Pointer {
	return C.native_menu_get_native_object(C.native_menu_t(m.nativeHandleValue()))
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (m *Menu) AddListener(callback func(MenuEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("Menu.AddListener")
	}
	data := newCallback(callback)
	id := C.native_menu_add_listener(C.native_menu_t(m.nativeHandleValue()), C.native_menu_event_callback_t(C.go_get_native_menu_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("Menu.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (m *Menu) RemoveListener(id ListenerID) error {
	if !bool(C.native_menu_remove_listener(C.native_menu_t(m.nativeHandleValue()), C.native_listener_id_t(id))) {
		return nativeError("Menu.RemoveListener")
	}
	return nil
}

// TrayIconID identifies a native object.
type TrayIconID uint32

// ContextMenuTrigger represents native ContextMenuTrigger values.
type ContextMenuTrigger int32

const (
	ContextMenuTriggerNone          ContextMenuTrigger = 0
	ContextMenuTriggerClicked       ContextMenuTrigger = 1
	ContextMenuTriggerRightClicked  ContextMenuTrigger = 2
	ContextMenuTriggerDoubleClicked ContextMenuTrigger = 3
)

// TrayIconPosition represents native TrayIconPosition values.
type TrayIconPosition int32

const (
	TrayIconPositionLeft  TrayIconPosition = 0
	TrayIconPositionRight TrayIconPosition = 1
)

// TrayIconEventType identifies the active event variant.
type TrayIconEventType int32

const (
	TrayIconEventClicked       TrayIconEventType = 0
	TrayIconEventRightClicked  TrayIconEventType = 1
	TrayIconEventDoubleClicked TrayIconEventType = 2
)

// TrayIconEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type TrayIconEvent struct {
	Type       TrayIconEventType
	TrayIconID TrayIconID
}

func fromCTrayIconEvent(raw *C.native_tray_icon_event_t) TrayIconEvent {
	value := TrayIconEvent{Type: TrayIconEventType(raw._type)}
	switch value.Type {
	case TrayIconEventClicked:
		value.TrayIconID = TrayIconID(C.go_native_tray_icon_event_t_clicked_TrayIconId(raw))
	case TrayIconEventRightClicked:
		value.TrayIconID = TrayIconID(C.go_native_tray_icon_event_t_right_clicked_TrayIconId(raw))
	case TrayIconEventDoubleClicked:
		value.TrayIconID = TrayIconID(C.go_native_tray_icon_event_t_double_clicked_TrayIconId(raw))
	}
	return value
}

//export goEvent_native_tray_icon_event_t
func goEvent_native_tray_icon_event_t(handle C.uintptr_t, event *C.native_tray_icon_event_t) {
	cgo.Handle(handle).Value().(func(TrayIconEvent))(fromCTrayIconEvent(event))
}

// TrayIcon owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type TrayIcon struct{ *nativeHandle }

func wrapTrayIcon(value uint64, borrowed bool) *TrayIcon {
	if value == 0 {
		return nil
	}
	return wrapTrayIconState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapTrayIconState(state *nativeHandle) *TrayIcon {
	return &TrayIcon{state}
}
func (ti *TrayIcon) nativeHandleValue() uint64 {
	if ti == nil || ti.nativeHandle == nil {
		return 0
	}
	return ti.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (ti *TrayIcon) Release() {
	if ti.nativeHandleValue() == 0 || ti.borrowed {
		return
	}
	C.native_tray_icon_free(C.native_tray_icon_t(ti.value))
	ti.value = 0
}

// NewTrayIcon creates an owned TrayIcon.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewTrayIcon() (*TrayIcon, error) {
	result := C.native_tray_icon_create()
	if result == 0 {
		return nil, nativeError("NewTrayIcon")
	}
	return wrapTrayIcon(uint64(result), false), nil
}

// NewTrayIconWithIdentifier creates an owned TrayIcon.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewTrayIconWithIdentifier(identifier string) (*TrayIcon, error) {
	cArg0 := C.CString(identifier)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_tray_icon_create_with_identifier(cArg0)
	if result == 0 {
		return nil, nativeError("NewTrayIconWithIdentifier")
	}
	return wrapTrayIcon(uint64(result), false), nil
}

// NewTrayIconFromNative creates an owned TrayIcon.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewTrayIconFromNative(tray unsafe.Pointer) (*TrayIcon, error) {
	result := C.native_tray_icon_create_with_tray(tray)
	if result == 0 {
		return nil, nativeError("NewTrayIconFromNative")
	}
	return wrapTrayIcon(uint64(result), false), nil
}

// ID invokes the native GetId operation.
func (ti *TrayIcon) ID() TrayIconID {
	result := C.native_tray_icon_get_id(C.native_tray_icon_t(ti.nativeHandleValue()))
	return TrayIconID(result)
}

// Identifier invokes the native GetIdentifier operation.
func (ti *TrayIcon) Identifier() string {
	result := C.native_tray_icon_get_identifier(C.native_tray_icon_t(ti.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// SetIcon invokes the native SetIcon operation.
func (ti *TrayIcon) SetIcon(image *Image) {
	C.native_tray_icon_set_icon(C.native_tray_icon_t(ti.nativeHandleValue()), C.native_image_t(image.nativeHandleValue()))
}

// Icon invokes the native GetIcon operation.
// The returned reference is owned; nil means no object is available.
func (ti *TrayIcon) Icon() *Image {
	result := C.native_tray_icon_get_icon(C.native_tray_icon_t(ti.nativeHandleValue()))
	return wrapImage(uint64(result), false)
}

// SetIconTemplate invokes the native SetIconTemplate operation.
func (ti *TrayIcon) SetIconTemplate(isIconTemplate bool) {
	C.native_tray_icon_set_icon_template(C.native_tray_icon_t(ti.nativeHandleValue()), C.bool(isIconTemplate))
}

// IsIconTemplate invokes the native IsIconTemplate operation.
func (ti *TrayIcon) IsIconTemplate() bool {
	result := C.native_tray_icon_is_icon_template(C.native_tray_icon_t(ti.nativeHandleValue()))
	return bool(result)
}

// SetIconSize invokes the native SetIconSize operation.
func (ti *TrayIcon) SetIconSize(size Size) {
	cArg0, cArg0Cleanup := toCSize(size)
	defer cArg0Cleanup()
	C.native_tray_icon_set_icon_size(C.native_tray_icon_t(ti.nativeHandleValue()), cArg0)
}

// IconSize invokes the native GetIconSize operation.
func (ti *TrayIcon) IconSize() Size {
	result := C.native_tray_icon_get_icon_size(C.native_tray_icon_t(ti.nativeHandleValue()))
	return fromCSize(result)
}

// SetIconPosition invokes the native SetIconPosition operation.
func (ti *TrayIcon) SetIconPosition(position TrayIconPosition) {
	C.native_tray_icon_set_icon_position(C.native_tray_icon_t(ti.nativeHandleValue()), C.native_tray_icon_position_t(position))
}

// IconPosition invokes the native GetIconPosition operation.
func (ti *TrayIcon) IconPosition() TrayIconPosition {
	result := C.native_tray_icon_get_icon_position(C.native_tray_icon_t(ti.nativeHandleValue()))
	return TrayIconPosition(result)
}

// SetTitle invokes the native SetTitle operation.
func (ti *TrayIcon) SetTitle(title *string) {
	var cArg0 *C.char
	if title != nil {
		cArg0 = C.CString(*title)
		defer C.free(unsafe.Pointer(cArg0))
	}
	C.native_tray_icon_set_title(C.native_tray_icon_t(ti.nativeHandleValue()), cArg0)
}

// Title invokes the native GetTitle operation.
func (ti *TrayIcon) Title() *string {
	result := C.native_tray_icon_get_title(C.native_tray_icon_t(ti.nativeHandleValue()))
	defer C.free_c_str(result)
	return optionalStringFromC(result)
}

// SetTooltip invokes the native SetTooltip operation.
func (ti *TrayIcon) SetTooltip(tooltip *string) {
	var cArg0 *C.char
	if tooltip != nil {
		cArg0 = C.CString(*tooltip)
		defer C.free(unsafe.Pointer(cArg0))
	}
	C.native_tray_icon_set_tooltip(C.native_tray_icon_t(ti.nativeHandleValue()), cArg0)
}

// Tooltip invokes the native GetTooltip operation.
func (ti *TrayIcon) Tooltip() *string {
	result := C.native_tray_icon_get_tooltip(C.native_tray_icon_t(ti.nativeHandleValue()))
	defer C.free_c_str(result)
	return optionalStringFromC(result)
}

// SetContentView invokes the native SetContentView operation.
func (ti *TrayIcon) SetContentView(view *View) {
	C.native_tray_icon_set_content_view(C.native_tray_icon_t(ti.nativeHandleValue()), C.native_view_t(view.nativeHandleValue()))
}

// ContentView invokes the native GetContentView operation.
// The returned reference is owned; nil means no object is available.
func (ti *TrayIcon) ContentView() *View {
	result := C.native_tray_icon_get_content_view(C.native_tray_icon_t(ti.nativeHandleValue()))
	return wrapView(uint64(result), false)
}

// SetContextMenu invokes the native SetContextMenu operation.
func (ti *TrayIcon) SetContextMenu(menu *Menu) {
	C.native_tray_icon_set_context_menu(C.native_tray_icon_t(ti.nativeHandleValue()), C.native_menu_t(menu.nativeHandleValue()))
}

// ContextMenu invokes the native GetContextMenu operation.
// The returned reference is owned; nil means no object is available.
func (ti *TrayIcon) ContextMenu() *Menu {
	result := C.native_tray_icon_get_context_menu(C.native_tray_icon_t(ti.nativeHandleValue()))
	return wrapMenu(uint64(result), false)
}

// SetContextMenuTrigger invokes the native SetContextMenuTrigger operation.
func (ti *TrayIcon) SetContextMenuTrigger(trigger ContextMenuTrigger) {
	C.native_tray_icon_set_context_menu_trigger(C.native_tray_icon_t(ti.nativeHandleValue()), C.native_context_menu_trigger_t(trigger))
}

// ContextMenuTrigger invokes the native GetContextMenuTrigger operation.
func (ti *TrayIcon) ContextMenuTrigger() ContextMenuTrigger {
	result := C.native_tray_icon_get_context_menu_trigger(C.native_tray_icon_t(ti.nativeHandleValue()))
	return ContextMenuTrigger(result)
}

// Bounds invokes the native GetBounds operation.
func (ti *TrayIcon) Bounds() Rectangle {
	result := C.native_tray_icon_get_bounds(C.native_tray_icon_t(ti.nativeHandleValue()))
	return fromCRectangle(result)
}

// SetVisible invokes the native SetVisible operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ti *TrayIcon) SetVisible(visible bool) error {
	result := C.native_tray_icon_set_visible(C.native_tray_icon_t(ti.nativeHandleValue()), C.bool(visible))
	if !bool(result) {
		return nativeError("TrayIcon.SetVisible")
	}
	return nil
}

// IsVisible invokes the native IsVisible operation.
func (ti *TrayIcon) IsVisible() bool {
	result := C.native_tray_icon_is_visible(C.native_tray_icon_t(ti.nativeHandleValue()))
	return bool(result)
}

// OpenContextMenu invokes the native OpenContextMenu operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ti *TrayIcon) OpenContextMenu() error {
	result := C.native_tray_icon_open_context_menu(C.native_tray_icon_t(ti.nativeHandleValue()))
	if !bool(result) {
		return nativeError("TrayIcon.OpenContextMenu")
	}
	return nil
}

// CloseContextMenu invokes the native CloseContextMenu operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (ti *TrayIcon) CloseContextMenu() error {
	result := C.native_tray_icon_close_context_menu(C.native_tray_icon_t(ti.nativeHandleValue()))
	if !bool(result) {
		return nativeError("TrayIcon.CloseContextMenu")
	}
	return nil
}

// NativeObject returns a borrowed platform pointer.
func (ti *TrayIcon) NativeObject() unsafe.Pointer {
	return C.native_tray_icon_get_native_object(C.native_tray_icon_t(ti.nativeHandleValue()))
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (ti *TrayIcon) AddListener(callback func(TrayIconEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("TrayIcon.AddListener")
	}
	data := newCallback(callback)
	id := C.native_tray_icon_add_listener(C.native_tray_icon_t(ti.nativeHandleValue()), C.native_tray_icon_event_callback_t(C.go_get_native_tray_icon_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("TrayIcon.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (ti *TrayIcon) RemoveListener(id ListenerID) error {
	if !bool(C.native_tray_icon_remove_listener(C.native_tray_icon_t(ti.nativeHandleValue()), C.native_listener_id_t(id))) {
		return nativeError("TrayIcon.RemoveListener")
	}
	return nil
}

type trayManager struct{}

// TrayManager provides access to the native TrayManager singleton.
// It has no owned handle and does not need to be released.
var TrayManager = trayManager{}

// IsSupported invokes the native IsSupported operation.
func (tm trayManager) IsSupported() bool {
	result := C.native_tray_manager_is_supported()
	return bool(result)
}

// Get invokes the native Get operation.
// The returned reference is owned; nil means no object is available.
func (tm trayManager) Get(id TrayIconID) *TrayIcon {
	result := C.native_tray_manager_get(C.native_tray_icon_id_t(id))
	return wrapTrayIcon(uint64(result), false)
}

// All invokes the native GetAll operation.
func (tm trayManager) All() []*TrayIcon {
	result := C.native_tray_manager_get_all()
	defer C.native_tray_icon_list_release(&result)
	return listTrayIconFromC(result, false)
}

// ShortcutID identifies a native object.
type ShortcutID uint32

// ShortcutScope represents native ShortcutScope values.
type ShortcutScope int32

const (
	ShortcutScopeGlobal      ShortcutScope = 0
	ShortcutScopeApplication ShortcutScope = 1
)

// ShortcutOptions holds the native ShortcutOptions value.
type ShortcutOptions struct {
	Accelerator string
	Callback    func()
	Description string
	Scope       ShortcutScope
	Enabled     bool
}

func fromCShortcutOptions(raw C.native_shortcut_options_t) ShortcutOptions {
	return ShortcutOptions{
		Accelerator: C.GoString(raw.accelerator),
		Description: C.GoString(raw.description),
		Scope:       ShortcutScope(raw.scope),
		Enabled:     bool(raw.enabled),
	}
}
func toCShortcutOptions(value ShortcutOptions) (C.native_shortcut_options_t, func()) {
	var raw C.native_shortcut_options_t
	var cleanup []func()
	cField0 := C.CString(value.Accelerator)
	cleanup = append(cleanup, func() { C.free(unsafe.Pointer(cField0)) })
	raw.accelerator = cField0
	var cField1Fn C.native_shortcut_options_callback_t
	var cField1Data unsafe.Pointer
	var cField1Release C.native_release_user_data_t
	if value.Callback != nil {
		cField1Data = newCallback(value.Callback)
		cField1Fn = C.native_shortcut_options_callback_t(C.go_get_native_shortcut_options_callback_t())
		cField1Release = C.native_release_user_data_t(C.go_get_release_callback())
	}
	raw.callback = cField1Fn
	raw.callback_user_data = cField1Data
	raw.callback_release_user_data = cField1Release
	cField2 := C.CString(value.Description)
	cleanup = append(cleanup, func() { C.free(unsafe.Pointer(cField2)) })
	raw.description = cField2
	raw.scope = C.native_shortcut_scope_t(value.Scope)
	raw.enabled = C.bool(value.Enabled)
	return raw, func() {
		for i := len(cleanup) - 1; i >= 0; i-- {
			cleanup[i]()
		}
	}
}

// ShortcutEventType identifies the active event variant.
type ShortcutEventType int32

const (
	ShortcutEventActivated          ShortcutEventType = 0
	ShortcutEventRegistered         ShortcutEventType = 1
	ShortcutEventUnregistered       ShortcutEventType = 2
	ShortcutEventRegistrationFailed ShortcutEventType = 3
	ShortcutEventReleased           ShortcutEventType = 4
)

// ShortcutEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type ShortcutEvent struct {
	Type         ShortcutEventType
	ShortcutID   ShortcutID
	Accelerator  string
	ErrorMessage string
}

func fromCShortcutEvent(raw *C.native_shortcut_event_t) ShortcutEvent {
	value := ShortcutEvent{Type: ShortcutEventType(raw._type)}
	value.ShortcutID = ShortcutID(raw.shortcut_id)
	value.Accelerator = C.GoString(raw.accelerator)
	switch value.Type {
	case ShortcutEventActivated:
	case ShortcutEventRegistered:
	case ShortcutEventUnregistered:
	case ShortcutEventRegistrationFailed:
		value.ErrorMessage = C.GoString(C.go_native_shortcut_event_t_registration_failed_ErrorMessage(raw))
	case ShortcutEventReleased:
	}
	return value
}

//export goEvent_native_shortcut_event_t
func goEvent_native_shortcut_event_t(handle C.uintptr_t, event *C.native_shortcut_event_t) {
	cgo.Handle(handle).Value().(func(ShortcutEvent))(fromCShortcutEvent(event))
}

// Shortcut owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type Shortcut struct{ *nativeHandle }

func wrapShortcut(value uint64, borrowed bool) *Shortcut {
	if value == 0 {
		return nil
	}
	return wrapShortcutState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapShortcutState(state *nativeHandle) *Shortcut {
	return &Shortcut{state}
}
func (s *Shortcut) nativeHandleValue() uint64 {
	if s == nil || s.nativeHandle == nil {
		return 0
	}
	return s.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (s *Shortcut) Release() {
	if s.nativeHandleValue() == 0 || s.borrowed {
		return
	}
	C.native_shortcut_free(C.native_shortcut_t(s.value))
	s.value = 0
}

// NewShortcut creates an owned Shortcut.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewShortcut(id ShortcutID, options ShortcutOptions) (*Shortcut, error) {
	cArg1, cArg1Cleanup := toCShortcutOptions(options)
	defer cArg1Cleanup()
	result := C.native_shortcut_create_with_id_and_options(C.native_shortcut_id_t(id), cArg1)
	if result == 0 {
		return nil, nativeError("NewShortcut")
	}
	return wrapShortcut(uint64(result), false), nil
}

// NewShortcutWithCallback creates an owned Shortcut.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewShortcutWithCallback(id ShortcutID, accelerator string, callback func()) (*Shortcut, error) {
	cArg1 := C.CString(accelerator)
	defer C.free(unsafe.Pointer(cArg1))
	var cArg2Fn C.native_shortcut_create_with_id_and_accelerator_and_callback_t
	var cArg2Data unsafe.Pointer
	var cArg2Release C.native_release_user_data_t
	if callback != nil {
		cArg2Data = newCallback(callback)
		cArg2Fn = C.native_shortcut_create_with_id_and_accelerator_and_callback_t(C.go_get_native_shortcut_create_with_id_and_accelerator_and_callback_t())
		cArg2Release = C.native_release_user_data_t(C.go_get_release_callback())
	}
	result := C.native_shortcut_create_with_id_and_accelerator_and_callback(C.native_shortcut_id_t(id), cArg1, cArg2Fn, cArg2Data, cArg2Release)
	if result == 0 {
		return nil, nativeError("NewShortcutWithCallback")
	}
	return wrapShortcut(uint64(result), false), nil
}

// ID invokes the native GetId operation.
func (s *Shortcut) ID() ShortcutID {
	result := C.native_shortcut_get_id(C.native_shortcut_t(s.nativeHandleValue()))
	return ShortcutID(result)
}

// Accelerator invokes the native GetAccelerator operation.
func (s *Shortcut) Accelerator() string {
	result := C.native_shortcut_get_accelerator(C.native_shortcut_t(s.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// Description invokes the native GetDescription operation.
func (s *Shortcut) Description() string {
	result := C.native_shortcut_get_description(C.native_shortcut_t(s.nativeHandleValue()))
	defer C.free_c_str(result)
	return C.GoString(result)
}

// SetDescription invokes the native SetDescription operation.
func (s *Shortcut) SetDescription(description string) {
	cArg0 := C.CString(description)
	defer C.free(unsafe.Pointer(cArg0))
	C.native_shortcut_set_description(C.native_shortcut_t(s.nativeHandleValue()), cArg0)
}

// Scope invokes the native GetScope operation.
func (s *Shortcut) Scope() ShortcutScope {
	result := C.native_shortcut_get_scope(C.native_shortcut_t(s.nativeHandleValue()))
	return ShortcutScope(result)
}

// SetEnabled invokes the native SetEnabled operation.
func (s *Shortcut) SetEnabled(enabled bool) {
	C.native_shortcut_set_enabled(C.native_shortcut_t(s.nativeHandleValue()), C.bool(enabled))
}

// IsEnabled invokes the native IsEnabled operation.
func (s *Shortcut) IsEnabled() bool {
	result := C.native_shortcut_is_enabled(C.native_shortcut_t(s.nativeHandleValue()))
	return bool(result)
}

// Invoke invokes the native Invoke operation.
func (s *Shortcut) Invoke() {
	C.native_shortcut_invoke(C.native_shortcut_t(s.nativeHandleValue()))
}

// SetCallback invokes the native SetCallback operation.
func (s *Shortcut) SetCallback(callback func()) {
	var cArg0Fn C.native_shortcut_set_callback_t
	var cArg0Data unsafe.Pointer
	var cArg0Release C.native_release_user_data_t
	if callback != nil {
		cArg0Data = newCallback(callback)
		cArg0Fn = C.native_shortcut_set_callback_t(C.go_get_native_shortcut_set_callback_t())
		cArg0Release = C.native_release_user_data_t(C.go_get_release_callback())
	}
	C.native_shortcut_set_callback(C.native_shortcut_t(s.nativeHandleValue()), cArg0Fn, cArg0Data, cArg0Release)
}

type shortcutManager struct{}

// ShortcutManager provides access to the native ShortcutManager singleton.
// It has no owned handle and does not need to be released.
var ShortcutManager = shortcutManager{}

// IsSupported invokes the native IsSupported operation.
func (sm shortcutManager) IsSupported() bool {
	result := C.native_shortcut_manager_is_supported()
	return bool(result)
}

// RegisterWithCallback invokes the native Register operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (sm shortcutManager) RegisterWithCallback(accelerator string, callback func()) (*Shortcut, error) {
	cArg0 := C.CString(accelerator)
	defer C.free(unsafe.Pointer(cArg0))
	var cArg1Fn C.native_shortcut_manager_register_callback_t
	var cArg1Data unsafe.Pointer
	var cArg1Release C.native_release_user_data_t
	if callback != nil {
		cArg1Data = newCallback(callback)
		cArg1Fn = C.native_shortcut_manager_register_callback_t(C.go_get_native_shortcut_manager_register_callback_t())
		cArg1Release = C.native_release_user_data_t(C.go_get_release_callback())
	}
	result := C.native_shortcut_manager_register_with_accelerator_and_callback(cArg0, cArg1Fn, cArg1Data, cArg1Release)
	if result == 0 {
		return nil, nativeError("ShortcutManager.RegisterWithCallback")
	}
	return wrapShortcut(uint64(result), false), nil
}

// Register invokes the native Register operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (sm shortcutManager) Register(options ShortcutOptions) (*Shortcut, error) {
	cArg0, cArg0Cleanup := toCShortcutOptions(options)
	defer cArg0Cleanup()
	result := C.native_shortcut_manager_register_with_options(cArg0)
	if result == 0 {
		return nil, nativeError("ShortcutManager.Register")
	}
	return wrapShortcut(uint64(result), false), nil
}

// UnregisterByID invokes the native Unregister operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (sm shortcutManager) UnregisterByID(id ShortcutID) error {
	result := C.native_shortcut_manager_unregister_with_id(C.native_shortcut_id_t(id))
	if !bool(result) {
		return nativeError("ShortcutManager.UnregisterByID")
	}
	return nil
}

// UnregisterByAccelerator invokes the native Unregister operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (sm shortcutManager) UnregisterByAccelerator(accelerator string) error {
	cArg0 := C.CString(accelerator)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_shortcut_manager_unregister_with_accelerator(cArg0)
	if !bool(result) {
		return nativeError("ShortcutManager.UnregisterByAccelerator")
	}
	return nil
}

// UnregisterAll invokes the native UnregisterAll operation.
func (sm shortcutManager) UnregisterAll() int32 {
	result := C.native_shortcut_manager_unregister_all()
	return int32(result)
}

// GetByID invokes the native Get operation.
// The returned reference is owned; nil means no object is available.
func (sm shortcutManager) GetByID(id ShortcutID) *Shortcut {
	result := C.native_shortcut_manager_get_with_id(C.native_shortcut_id_t(id))
	return wrapShortcut(uint64(result), false)
}

// GetByAccelerator invokes the native Get operation.
// The returned reference is owned; nil means no object is available.
func (sm shortcutManager) GetByAccelerator(accelerator string) *Shortcut {
	cArg0 := C.CString(accelerator)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_shortcut_manager_get_with_accelerator(cArg0)
	return wrapShortcut(uint64(result), false)
}

// All invokes the native GetAll operation.
func (sm shortcutManager) All() []*Shortcut {
	result := C.native_shortcut_manager_get_all()
	defer C.native_shortcut_list_release(&result)
	return listShortcutFromC(result, false)
}

// ByScope invokes the native GetByScope operation.
func (sm shortcutManager) ByScope(scope ShortcutScope) []*Shortcut {
	result := C.native_shortcut_manager_get_by_scope(C.native_shortcut_scope_t(scope))
	defer C.native_shortcut_list_release(&result)
	return listShortcutFromC(result, false)
}

// IsAvailable invokes the native IsAvailable operation.
func (sm shortcutManager) IsAvailable(accelerator string) bool {
	cArg0 := C.CString(accelerator)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_shortcut_manager_is_available(cArg0)
	return bool(result)
}

// IsValidAccelerator invokes the native IsValidAccelerator operation.
func (sm shortcutManager) IsValidAccelerator(accelerator string) bool {
	cArg0 := C.CString(accelerator)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_shortcut_manager_is_valid_accelerator(cArg0)
	return bool(result)
}

// SetEnabled invokes the native SetEnabled operation.
func (sm shortcutManager) SetEnabled(enabled bool) {
	C.native_shortcut_manager_set_enabled(C.bool(enabled))
}

// IsEnabled invokes the native IsEnabled operation.
func (sm shortcutManager) IsEnabled() bool {
	result := C.native_shortcut_manager_is_enabled()
	return bool(result)
}

// EmitShortcutActivated invokes the native EmitShortcutActivated operation.
func (sm shortcutManager) EmitShortcutActivated(id ShortcutID, accelerator string) {
	cArg1 := C.CString(accelerator)
	defer C.free(unsafe.Pointer(cArg1))
	C.native_shortcut_manager_emit_shortcut_activated(C.native_shortcut_id_t(id), cArg1)
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (sm shortcutManager) AddListener(callback func(ShortcutEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("ShortcutManager.AddListener")
	}
	data := newCallback(callback)
	id := C.native_shortcut_manager_add_listener(C.native_shortcut_event_callback_t(C.go_get_native_shortcut_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("ShortcutManager.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (sm shortcutManager) RemoveListener(id ListenerID) error {
	if !bool(C.native_shortcut_manager_remove_listener(C.native_listener_id_t(id))) {
		return nativeError("ShortcutManager.RemoveListener")
	}
	return nil
}

// KeyboardMonitor owns a native handle. Call Release on the UI thread when done.
// Copies share ownership state; borrowed event handles must not outlive their callback.
type KeyboardMonitor struct{ *nativeHandle }

func wrapKeyboardMonitor(value uint64, borrowed bool) *KeyboardMonitor {
	if value == 0 {
		return nil
	}
	return wrapKeyboardMonitorState(&nativeHandle{value: value, borrowed: borrowed})
}
func wrapKeyboardMonitorState(state *nativeHandle) *KeyboardMonitor {
	return &KeyboardMonitor{state}
}
func (km *KeyboardMonitor) nativeHandleValue() uint64 {
	if km == nil || km.nativeHandle == nil {
		return 0
	}
	return km.nativeHandle.nativeHandleValue()
}

// Release drops this owned reference. Repeated calls and nil receivers are safe.
func (km *KeyboardMonitor) Release() {
	if km.nativeHandleValue() == 0 || km.borrowed {
		return
	}
	C.native_keyboard_monitor_free(C.native_keyboard_monitor_t(km.value))
	km.value = 0
}

// NewKeyboardMonitor creates an owned KeyboardMonitor.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func NewKeyboardMonitor() (*KeyboardMonitor, error) {
	result := C.native_keyboard_monitor_create()
	if result == 0 {
		return nil, nativeError("NewKeyboardMonitor")
	}
	return wrapKeyboardMonitor(uint64(result), false), nil
}

// Start invokes the native Start operation.
func (km *KeyboardMonitor) Start() {
	C.native_keyboard_monitor_start(C.native_keyboard_monitor_t(km.nativeHandleValue()))
}

// Stop invokes the native Stop operation.
func (km *KeyboardMonitor) Stop() {
	C.native_keyboard_monitor_stop(C.native_keyboard_monitor_t(km.nativeHandleValue()))
}

// IsMonitoring invokes the native IsMonitoring operation.
func (km *KeyboardMonitor) IsMonitoring() bool {
	result := C.native_keyboard_monitor_is_monitoring(C.native_keyboard_monitor_t(km.nativeHandleValue()))
	return bool(result)
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (km *KeyboardMonitor) AddListener(callback func(KeyboardEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("KeyboardMonitor.AddListener")
	}
	data := newCallback(callback)
	id := C.native_keyboard_monitor_add_listener(C.native_keyboard_monitor_t(km.nativeHandleValue()), C.native_keyboard_event_callback_t(C.go_get_native_keyboard_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("KeyboardMonitor.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (km *KeyboardMonitor) RemoveListener(id ListenerID) error {
	if !bool(C.native_keyboard_monitor_remove_listener(C.native_keyboard_monitor_t(km.nativeHandleValue()), C.native_listener_id_t(id))) {
		return nativeError("KeyboardMonitor.RemoveListener")
	}
	return nil
}

// Brightness represents native Brightness values.
type Brightness int32

const (
	BrightnessSystem Brightness = 0
	BrightnessLight  Brightness = 1
	BrightnessDark   Brightness = 2
)

// ApplicationEventType identifies the active event variant.
type ApplicationEventType int32

const (
	ApplicationEventStarted       ApplicationEventType = 0
	ApplicationEventExiting       ApplicationEventType = 1
	ApplicationEventActivated     ApplicationEventType = 2
	ApplicationEventDeactivated   ApplicationEventType = 3
	ApplicationEventQuitRequested ApplicationEventType = 4
)

// ApplicationEvent copies an event payload. Handle fields are borrowed until the callback returns.
// Only fields belonging to Type are populated.
type ApplicationEvent struct {
	Type     ApplicationEventType
	ExitCode int32
	Request  *EventRequest
}

func fromCApplicationEvent(raw *C.native_application_event_t) ApplicationEvent {
	value := ApplicationEvent{Type: ApplicationEventType(raw._type)}
	switch value.Type {
	case ApplicationEventStarted:
	case ApplicationEventExiting:
		value.ExitCode = int32(C.go_native_application_event_t_exiting_ExitCode(raw))
	case ApplicationEventActivated:
	case ApplicationEventDeactivated:
	case ApplicationEventQuitRequested:
		value.Request = wrapEventRequest(uint64(C.go_native_application_event_t_quit_requested_Request(raw)), true)
	}
	return value
}

//export goEvent_native_application_event_t
func goEvent_native_application_event_t(handle C.uintptr_t, event *C.native_application_event_t) {
	cgo.Handle(handle).Value().(func(ApplicationEvent))(fromCApplicationEvent(event))
}

type application struct{}

// Application provides access to the native Application singleton.
// It has no owned handle and does not need to be released.
var Application = application{}

// Run invokes the native Run operation.
func (a application) Run() int32 {
	result := C.native_application_run()
	return int32(result)
}

// RunWithWindow invokes the native Run operation.
func (a application) RunWithWindow(window *Window) int32 {
	result := C.native_application_run_with_window(C.native_window_t(window.nativeHandleValue()))
	return int32(result)
}

// Quit invokes the native Quit operation.
func (a application) Quit(exitCode int32) {
	C.native_application_quit(C.int(exitCode))
}

// IsRunning invokes the native IsRunning operation.
func (a application) IsRunning() bool {
	result := C.native_application_is_running()
	return bool(result)
}

// IsSingleInstance invokes the native IsSingleInstance operation.
func (a application) IsSingleInstance() bool {
	result := C.native_application_is_single_instance()
	return bool(result)
}

// Show invokes the native Show operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (a application) Show() error {
	result := C.native_application_show()
	if !bool(result) {
		return nativeError("Application.Show")
	}
	return nil
}

// Hide invokes the native Hide operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (a application) Hide() error {
	result := C.native_application_hide()
	if !bool(result) {
		return nativeError("Application.Hide")
	}
	return nil
}

// IsVisible invokes the native IsVisible operation.
func (a application) IsVisible() bool {
	result := C.native_application_is_visible()
	return bool(result)
}

// SetIcon invokes the native SetIcon operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (a application) SetIcon(iconPath string) error {
	cArg0 := C.CString(iconPath)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_application_set_icon(cArg0)
	if !bool(result) {
		return nativeError("Application.SetIcon")
	}
	return nil
}

// SetDockIconVisible invokes the native SetDockIconVisible operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (a application) SetDockIconVisible(visible bool) error {
	result := C.native_application_set_dock_icon_visible(C.bool(visible))
	if !bool(result) {
		return nativeError("Application.SetDockIconVisible")
	}
	return nil
}

// SetProgressBar invokes the native SetProgressBar operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (a application) SetProgressBar(progress float64) error {
	result := C.native_application_set_progress_bar(C.double(progress))
	if !bool(result) {
		return nativeError("Application.SetProgressBar")
	}
	return nil
}

// SetBadgeLabel invokes the native SetBadgeLabel operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (a application) SetBadgeLabel(label string) error {
	cArg0 := C.CString(label)
	defer C.free(unsafe.Pointer(cArg0))
	result := C.native_application_set_badge_label(cArg0)
	if !bool(result) {
		return nativeError("Application.SetBadgeLabel")
	}
	return nil
}

// SetBrightness invokes the native SetBrightness operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (a application) SetBrightness(brightness Brightness) error {
	result := C.native_application_set_brightness(C.native_brightness_t(brightness))
	if !bool(result) {
		return nativeError("Application.SetBrightness")
	}
	return nil
}

// SetMenuBar invokes the native SetMenuBar operation.
// Failure wraps ErrOperationFailed; the native ABI provides no detailed cause.
func (a application) SetMenuBar(menu *Menu) error {
	result := C.native_application_set_menu_bar(C.native_menu_t(menu.nativeHandleValue()))
	if !bool(result) {
		return nativeError("Application.SetMenuBar")
	}
	return nil
}

// PrimaryWindow invokes the native GetPrimaryWindow operation.
// The returned reference is owned; nil means no object is available.
func (a application) PrimaryWindow() *Window {
	result := C.native_application_get_primary_window()
	return wrapWindow(uint64(result), false)
}

// SetPrimaryWindow invokes the native SetPrimaryWindow operation.
func (a application) SetPrimaryWindow(window *Window) {
	C.native_application_set_primary_window(C.native_window_t(window.nativeHandleValue()))
}

// AllWindows invokes the native GetAllWindows operation.
func (a application) AllWindows() []*Window {
	result := C.native_application_get_all_windows()
	defer C.native_window_list_release(&result)
	return listWindowFromC(result, false)
}

// AddListener invokes callback synchronously on the native UI thread.
// Remove the listener before releasing its owner. A nil callback is invalid.
func (a application) AddListener(callback func(ApplicationEvent)) (ListenerID, error) {
	if callback == nil {
		return 0, invalidArgument("Application.AddListener")
	}
	data := newCallback(callback)
	id := C.native_application_add_listener(C.native_application_event_callback_t(C.go_get_native_application_event_callback_t()), data, C.native_release_user_data_t(C.go_get_release_callback()))
	if id == 0 {
		return 0, nativeError("Application.AddListener")
	}
	return ListenerID(id), nil
}

// RemoveListener unregisters id; an unknown id returns an error.
func (a application) RemoveListener(id ListenerID) error {
	if !bool(C.native_application_remove_listener(C.native_listener_id_t(id))) {
		return nativeError("Application.RemoveListener")
	}
	return nil
}
func listDisplayFromC(raw C.native_display_list_t, borrowed bool) []*Display {
	result := make([]*Display, int(raw.count))
	for i, handle := range unsafe.Slice(raw.displays, int(raw.count)) {
		result[i] = wrapDisplay(uint64(handle), borrowed)
	}
	return result
}
func listMenuItemFromC(raw C.native_menu_item_list_t, borrowed bool) []*MenuItem {
	result := make([]*MenuItem, int(raw.count))
	for i, handle := range unsafe.Slice(raw.menu_items, int(raw.count)) {
		result[i] = wrapMenuItem(uint64(handle), borrowed)
	}
	return result
}
func listShortcutFromC(raw C.native_shortcut_list_t, borrowed bool) []*Shortcut {
	result := make([]*Shortcut, int(raw.count))
	for i, handle := range unsafe.Slice(raw.shortcuts, int(raw.count)) {
		result[i] = wrapShortcut(uint64(handle), borrowed)
	}
	return result
}
func listTrayIconFromC(raw C.native_tray_icon_list_t, borrowed bool) []*TrayIcon {
	result := make([]*TrayIcon, int(raw.count))
	for i, handle := range unsafe.Slice(raw.tray_icons, int(raw.count)) {
		result[i] = wrapTrayIcon(uint64(handle), borrowed)
	}
	return result
}
func listViewFromC(raw C.native_view_list_t, borrowed bool) []*View {
	result := make([]*View, int(raw.count))
	for i, handle := range unsafe.Slice(raw.views, int(raw.count)) {
		result[i] = wrapView(uint64(handle), borrowed)
	}
	return result
}
func listWindowFromC(raw C.native_window_list_t, borrowed bool) []*Window {
	result := make([]*Window, int(raw.count))
	for i, handle := range unsafe.Slice(raw.windows, int(raw.count)) {
		result[i] = wrapWindow(uint64(handle), borrowed)
	}
	return result
}

//export goCall_native_clipboard_read_callback_t
func goCall_native_clipboard_read_callback_t(handle C.uintptr_t, arg0 C.bool, arg1 unsafe.Pointer, delivery C.native_event_delivery_t) {
	defer C.native_event_delivery_complete(delivery, true)
	if !bool(C.native_event_delivery_is_active(delivery)) {
		return
	}
	cgo.Handle(handle).Value().(func(bool, ClipboardData))(bool(arg0), fromCClipboardData(*(*C.native_clipboard_data_t)(arg1)))
}

//export goCall_native_clipboard_read_file_paths_callback_t
func goCall_native_clipboard_read_file_paths_callback_t(handle C.uintptr_t, arg0 C.bool, arg1 unsafe.Pointer, delivery C.native_event_delivery_t) {
	defer C.native_event_delivery_complete(delivery, true)
	if !bool(C.native_event_delivery_is_active(delivery)) {
		return
	}
	cgo.Handle(handle).Value().(func(bool, []string))(bool(arg0), stringsFromC(*(*C.native_string_list_t)(arg1)))
}

//export goCall_native_clipboard_read_html_callback_t
func goCall_native_clipboard_read_html_callback_t(handle C.uintptr_t, arg0 C.bool, arg1 unsafe.Pointer, delivery C.native_event_delivery_t) {
	defer C.native_event_delivery_complete(delivery, true)
	if !bool(C.native_event_delivery_is_active(delivery)) {
		return
	}
	cgo.Handle(handle).Value().(func(bool, *string))(bool(arg0), optionalStringFromC((*C.char)(arg1)))
}

//export goCall_native_clipboard_read_image_callback_t
func goCall_native_clipboard_read_image_callback_t(handle C.uintptr_t, arg0 C.bool, arg1 C.native_image_t, delivery C.native_event_delivery_t) {
	defer C.native_event_delivery_complete(delivery, true)
	if !bool(C.native_event_delivery_is_active(delivery)) {
		return
	}
	cgo.Handle(handle).Value().(func(bool, *Image))(bool(arg0), wrapImage(uint64(C.native_handle_retain(arg1)), false))
}

//export goCall_native_clipboard_read_text_callback_t
func goCall_native_clipboard_read_text_callback_t(handle C.uintptr_t, arg0 C.bool, arg1 unsafe.Pointer, delivery C.native_event_delivery_t) {
	defer C.native_event_delivery_complete(delivery, true)
	if !bool(C.native_event_delivery_is_active(delivery)) {
		return
	}
	cgo.Handle(handle).Value().(func(bool, *string))(bool(arg0), optionalStringFromC((*C.char)(arg1)))
}

//export goCall_native_shortcut_create_with_id_and_accelerator_and_callback_t
func goCall_native_shortcut_create_with_id_and_accelerator_and_callback_t(handle C.uintptr_t) {
	cgo.Handle(handle).Value().(func())()
}

//export goCall_native_shortcut_manager_register_callback_t
func goCall_native_shortcut_manager_register_callback_t(handle C.uintptr_t) {
	cgo.Handle(handle).Value().(func())()
}

//export goCall_native_shortcut_options_callback_t
func goCall_native_shortcut_options_callback_t(handle C.uintptr_t) {
	cgo.Handle(handle).Value().(func())()
}

//export goCall_native_shortcut_set_callback_t
func goCall_native_shortcut_set_callback_t(handle C.uintptr_t) {
	cgo.Handle(handle).Value().(func())()
}

//export goCall_native_window_manager_set_will_hide_hook_callback_t
func goCall_native_window_manager_set_will_hide_hook_callback_t(handle C.uintptr_t, arg0 C.uint) {
	cgo.Handle(handle).Value().(func(uint32))(uint32(arg0))
}

//export goCall_native_window_manager_set_will_show_hook_callback_t
func goCall_native_window_manager_set_will_show_hook_callback_t(handle C.uintptr_t, arg0 C.uint) {
	cgo.Handle(handle).Value().(func(uint32))(uint32(arg0))
}