application

type ActivationPolicy int

type Alignment int

type AndroidOptions struct {
	// DisableScroll disables scrolling in the WebView
	DisableScroll bool

	// DisableBounce disables the overscroll bounce effect
	DisableOverscroll bool

	// EnableZoom allows pinch-to-zoom in the WebView (default: false)
	EnableZoom bool

	// UserAgent sets a custom user agent string
	UserAgent string

	// BackgroundColour sets the background colour of the WebView
	BackgroundColour RGBA

	// DisableHardwareAcceleration disables hardware acceleration for the WebView
	DisableHardwareAcceleration bool
}

type App struct {

	// Manager pattern for organized API
	Window      *WindowManager
	ContextMenu *ContextMenuManager
	KeyBinding  *KeyBindingManager
	Browser     *BrowserManager
	Env         *EnvironmentManager
	Dialog      *DialogManager
	Event       *EventManager
	Menu        *MenuManager
	Screen      *ScreenManager
	Clipboard   *ClipboardManager
	SystemTray  *SystemTrayManager

	Logger *slog.Logger
	// contains filtered or unexported fields
}

type ApplicationEvent struct {
	Id uint
	// contains filtered or unexported fields
}

type ApplicationEventContext struct {
	// contains filtered or unexported fields
}

type Args struct {
	// contains filtered or unexported fields
}

type AssetOptions struct {
	// Handler which serves all the content to the WebView.
	Handler http.Handler

	// Middleware is a HTTP Middleware which allows to hook into the AssetServer request chain. It allows to skip the default
	// request handler dynamically, e.g. implement specialized Routing etc.
	// The Middleware is called to build a new `http.Handler` used by the AssetSever and it also receives the default
	// handler used by the AssetServer as an argument.
	//
	// This middleware injects itself before any of Wails internal middlewares.
	//
	// If not defined, the default AssetServer request chain is executed.
	//
	// Multiple Middlewares can be chained together with:
	//   ChainMiddleware(middleware ...Middleware) Middleware
	Middleware Middleware

	// DisableLogging disables logging of the AssetServer. By default, the AssetServer logs every request.
	DisableLogging bool
}

type AssetServerTransport interface {
	Transport

	// ServeAssets configures the transport to serve assets.
	// The assetHandler is Wails' internal asset server that handles:
	//   - All static assets (HTML, CSS, JS, images, etc.)
	//   - /wails/runtime.js - The Wails runtime library
	//
	// The transport should integrate this handler into its HTTP server.
	// Typically this means mounting it at "/" and ensuring the IPC endpoint
	// (e.g., /wails/ws for WebSocket) is handled separately.
	//
	// This method is called after Start() completes successfully.
	ServeAssets(assetHandler http.Handler) error
}

type BackdropType int32

type BackgroundType int

type Bindings struct {
	// contains filtered or unexported fields
}

type BoundMethod struct {
	Method   reflect.Value `json:"-"`
	Name     string        `json:"name"`
	FQN      string        `json:"-"`
	Comments string        `json:"comments,omitempty"`
	Inputs   []*Parameter  `json:"inputs,omitempty"`
	Outputs  []*Parameter  `json:"outputs,omitempty"`

	ID uint32 `json:"id"`
	// contains filtered or unexported fields
}

type BrowserManager struct {
	// contains filtered or unexported fields
}

type Button struct {
	Label     string
	IsCancel  bool
	IsDefault bool
	Callback  func()
}

type ButtonState int

type CallError struct {
	Message string    `json:"message"`
	Cause   any       `json:"cause,omitempty"`
	Kind    ErrorKind `json:"kind"`
}

type CallOptions struct {
	MethodName string            `json:"methodName"`
	Args       []json.RawMessage `json:"args"`
	MethodID   uint32            `json:"methodID"`
}

type Calloc struct {
	// contains filtered or unexported fields
}

type Clipboard struct {
	// contains filtered or unexported fields
}

type ClipboardManager struct {
	// contains filtered or unexported fields
}

type Context struct {
	// contains filtered or unexported fields
}

type ContextMenu struct {
	*Menu
	// contains filtered or unexported fields
}

type ContextMenuData struct {
	Id   string `json:"id"`
	X    int    `json:"x"`
	Y    int    `json:"y"`
	Data string `json:"data"`
}

type ContextMenuManager struct {
	// contains filtered or unexported fields
}

type CoreWebView2PermissionKind uint32

type CoreWebView2PermissionState uint32

type CustomEvent struct {
	Name string `json:"name"`
	Data any    `json:"data"`

	// Sender records the name of the window sending the event,
	// or "" if sent from application.
	Sender string `json:"sender,omitempty"`
	// contains filtered or unexported fields
}

type DialogManager struct {
	// contains filtered or unexported fields
}

type DialogType int

type DropTargetDetails struct {
	X          int               `json:"x"`
	Y          int               `json:"y"`
	ElementID  string            `json:"id"`
	ClassList  []string          `json:"classList"`
	Attributes map[string]string `json:"attributes,omitempty"`
}

type ElementDetailsPayload struct {
	ID         string            `json:"id"`
	ClassList  []string          `json:"classList"`
	Attributes map[string]string `json:"attributes"`
}

type EnvironmentInfo struct {
	OS           string
	Arch         string
	Debug        bool
	OSInfo       *operatingsystem.OS
	PlatformInfo map[string]any
}

type EnvironmentManager struct {
	// contains filtered or unexported fields
}

type ErrorKind string

type EventIPCTransport struct {
	// contains filtered or unexported fields
}

type EventListener struct {
	// contains filtered or unexported fields
}

type EventManager struct {
	// contains filtered or unexported fields
}

type EventProcessor struct {
	// contains filtered or unexported fields
}

type FatalError struct {
	// contains filtered or unexported fields
}

type FileFilter struct {
	DisplayName string // Filter information EG: "Image Files (*.jpg, *.png)"
	Pattern     string // semicolon separated list of extensions, EG: "*.jpg;*.png"
}

type GSList C.GSList

type GSListPointer *GSList

type HTTPTransport struct {
	// contains filtered or unexported fields
}

type HTTPTransportOption func(*HTTPTransport)

type IOSOptions struct {
	// DisableInputAccessoryView controls whether the iOS WKWebView shows the
	// input accessory toolbar (the bar with Next/Previous/Done) above the keyboard.
	// Default: false (accessory bar is shown).
	// true  => accessory view is disabled/hidden
	// false => accessory view is enabled/shown
	DisableInputAccessoryView bool

	// Scrolling & Bounce (defaults: scroll/bounce/indicators are enabled on iOS)
	// Use Disable* to keep default true behavior without surprising zero-values.
	DisableScroll           bool
	DisableBounce           bool
	DisableScrollIndicators bool

	// Navigation gestures (default false)
	EnableBackForwardNavigationGestures bool

	// Link previews (default true on iOS)
	// Use Disable* so default (false) means previews are enabled.
	DisableLinkPreview bool

	// Media playback
	// Inline playback (default false) -> Enable*
	EnableInlineMediaPlayback bool
	// Autoplay without user action (default false) -> Enable*
	EnableAutoplayWithoutUserAction bool

	// Inspector / Debug (default true in dev)
	// Use Disable* so default (false) keeps inspector enabled.
	DisableInspectable bool

	// User agent customization
	// If empty, defaults apply. ApplicationNameForUserAgent defaults to "wails.io".
	UserAgent                   string
	ApplicationNameForUserAgent string

	// App-wide background colour for the main iOS window prior to any WebView creation.
	// If AppBackgroundColourSet is true, the delegate will apply this colour to the app window
	// during didFinishLaunching. Otherwise, it defaults to white.
	AppBackgroundColourSet bool
	BackgroundColour       RGBA

	// EnableNativeTabs enables a native iOS UITabBar at the bottom of the screen.
	// When enabled, the native tab bar will dispatch a 'nativeTabSelected' CustomEvent
	// to the window with detail: { index: number }.
	// NOTE: If NativeTabsItems has one or more entries, native tabs are auto-enabled
	// regardless of this flag, and the provided items will be used.
	EnableNativeTabs bool

	// NativeTabsItems configures the labels and optional SF Symbol icons for the
	// native UITabBar. If one or more items are provided, native tabs are automatically
	// enabled. If empty and EnableNativeTabs is true, default items are used.
	NativeTabsItems []NativeTabItem
}

type IconPosition int

type KeyBinding struct {
	Accelerator string
	Callback    func(window Window)
}

type KeyBindingManager struct {
	// contains filtered or unexported fields
}

type LRTB struct {
	Left   int
	Right  int
	Top    int
	Bottom int
}

type LinuxOptions struct {
	// DisableQuitOnLastWindowClosed disables the auto quit of the application if the last window has been closed.
	DisableQuitOnLastWindowClosed bool

	// ProgramName is used to set the program's name for the window manager via GTK's g_set_prgname().
	//This name should not be localized. [see the docs]
	//
	//When a .desktop file is created this value helps with window grouping and desktop icons when the .desktop file's Name
	//property differs form the executable's filename.
	//
	//[see the docs]: https://docs.gtk.org/glib/func.set_prgname.html
	ProgramName string
}

type LinuxWindow struct {
	// Icon Sets up the icon representing the window. This icon is used when the window is minimized
	// (also known as iconified).
	Icon []byte

	// WindowIsTranslucent sets the window's background to transparent when enabled.
	WindowIsTranslucent bool

	// WebviewGpuPolicy used for determining the hardware acceleration policy for the webview.
	//   - WebviewGpuPolicyAlways
	//   - WebviewGpuPolicyOnDemand
	//   - WebviewGpuPolicyNever
	//
	// Due to https://github.com/wailsapp/wails/issues/2977, if options.Linux is nil
	// in the call to wails.Run(), WebviewGpuPolicy is set by default to WebviewGpuPolicyNever.
	// Client code may override this behavior by passing a non-nil Options and set
	// WebviewGpuPolicy as needed.
	WebviewGpuPolicy WebviewGpuPolicy

	// WindowDidMoveDebounceMS is the debounce time in milliseconds for the WindowDidMove event
	WindowDidMoveDebounceMS uint16

	// Menu is the window's menu
	Menu *Menu
}

type MacAppearanceType string

type MacBackdrop int

type MacLiquidGlass struct {
	// Style of the glass effect
	Style MacLiquidGlassStyle

	// Material to use for NSVisualEffectView (when NSGlassEffectView is not available)
	// Set to NSVisualEffectMaterialAuto to use automatic selection based on Style
	Material NSVisualEffectMaterial

	// Corner radius for the glass effect (0 for square corners)
	CornerRadius float64

	// Tint color for the glass (optional, nil for no tint)
	TintColor *RGBA

	// Group identifier for merging multiple glass windows
	GroupID string

	// Spacing between grouped glass elements (in points)
	GroupSpacing float64
}

type MacLiquidGlassStyle int

type MacOptions struct {
	// ActivationPolicy is the activation policy for the application. Defaults to
	// applicationActivationPolicyRegular.
	ActivationPolicy ActivationPolicy
	// If set to true, the application will terminate when the last window is closed.
	ApplicationShouldTerminateAfterLastWindowClosed bool
}

type MacTitleBar struct {
	// AppearsTransparent will make the titlebar transparent
	AppearsTransparent bool
	// Hide will hide the titlebar
	Hide bool
	// HideTitle will hide the title
	HideTitle bool
	// FullSizeContent will extend the window content to the full size of the window
	FullSizeContent bool
	// UseToolbar will use a toolbar instead of a titlebar
	UseToolbar bool
	// HideToolbarSeparator will hide the toolbar separator
	HideToolbarSeparator bool
	// ShowToolbarWhenFullscreen will keep the toolbar visible when the window is in fullscreen mode
	ShowToolbarWhenFullscreen bool
	// ToolbarStyle is the style of toolbar to use
	ToolbarStyle MacToolbarStyle
}

type MacToolbarStyle int

type MacWebviewPreferences struct {
	// TabFocusesLinks will enable tabbing to links
	TabFocusesLinks u.Bool
	// TextInteractionEnabled will enable text interaction
	TextInteractionEnabled u.Bool
	// FullscreenEnabled will enable fullscreen
	FullscreenEnabled u.Bool
	// AllowsBackForwardNavigationGestures enables horizontal swipe gestures for back/forward navigation
	AllowsBackForwardNavigationGestures u.Bool
}

type MacWindow struct {
	// Backdrop is the backdrop type for the window
	Backdrop MacBackdrop
	// DisableShadow will disable the window shadow
	DisableShadow bool
	// TitleBar contains options for the Mac titlebar
	TitleBar MacTitleBar
	// Appearance is the appearance type for the window
	Appearance MacAppearanceType
	// InvisibleTitleBarHeight defines the height of an invisible titlebar which responds to dragging
	InvisibleTitleBarHeight int
	// Maps events from platform specific to common event types
	EventMapping map[events.WindowEventType]events.WindowEventType

	// EnableFraudulentWebsiteWarnings will enable warnings for fraudulent websites.
	// Default: false
	EnableFraudulentWebsiteWarnings bool

	// WebviewPreferences contains preferences for the webview
	WebviewPreferences MacWebviewPreferences

	// WindowLevel sets the window level to control the order of windows in the screen
	WindowLevel MacWindowLevel

	// CollectionBehavior controls how the window behaves across macOS Spaces and fullscreen
	CollectionBehavior MacWindowCollectionBehavior

	// LiquidGlass contains configuration for the Liquid Glass effect
	LiquidGlass MacLiquidGlass
}

type MacWindowCollectionBehavior int

type MacWindowLevel string

type MapArgs struct {
	// contains filtered or unexported fields
}

type Menu struct {
	// contains filtered or unexported fields
}

type MenuBarTheme struct {
	// Default is the default theme
	Default *TextTheme

	// Hover defines the theme to use when the menu item is hovered
	Hover *TextTheme

	// Selected defines the theme to use when the menu item is selected
	Selected *TextTheme
}

type MenuItem struct {
	// contains filtered or unexported fields
}

type MenuManager struct {
	// contains filtered or unexported fields
}

type MessageDialog struct {
	MessageDialogOptions
	// contains filtered or unexported fields
}

type MessageDialogOptions struct {
	DialogType DialogType
	Title      string
	Message    string
	Buttons    []*Button
	Icon       []byte
	// contains filtered or unexported fields
}

type MessageProcessor struct {
	// contains filtered or unexported fields
}

type Middleware func(next http.Handler) http.Handler

type NSVisualEffectMaterial int

type NativeTabIcon string

type NativeTabItem struct {
	Title       string        `json:"Title"`
	SystemImage NativeTabIcon `json:"SystemImage"`
}

type OffsetReference int

type OpenFileDialogOptions struct {
	CanChooseDirectories            bool
	CanChooseFiles                  bool
	CanCreateDirectories            bool
	ShowHiddenFiles                 bool
	ResolvesAliases                 bool
	AllowsMultipleSelection         bool
	HideExtension                   bool
	CanSelectHiddenExtension        bool
	TreatsFilePackagesAsDirectories bool
	AllowsOtherFileTypes            bool
	Filters                         []FileFilter
	Window                          Window

	Title      string
	Message    string
	ButtonText string
	Directory  string
}

type OpenFileDialogStruct struct {
	// contains filtered or unexported fields
}

type Options struct {
	// Name is the name of the application (used in the default about box)
	Name string

	// Description is the description of the application (used in the default about box)
	Description string

	// Icon is the icon of the application (used in the default about box)
	Icon []byte

	// Mac is the Mac specific configuration for Mac builds
	Mac MacOptions

	// Windows is the Windows specific configuration for Windows builds
	Windows WindowsOptions

	// Linux is the Linux specific configuration for Linux builds
	Linux LinuxOptions

	// IOS is the iOS specific configuration for iOS builds
	IOS IOSOptions

	// Android is the Android specific configuration for Android builds
	Android AndroidOptions

	// Services allows you to bind Go methods to the frontend.
	Services []Service

	// MarshalError will be called if non-nil
	// to marshal to JSON the error values returned by service methods.
	//
	// MarshalError is not allowed to fail,
	// but it may return a nil slice to fall back
	// to the default error handling mechanism.
	//
	// If the returned slice is not nil, it must contain valid JSON.
	MarshalError func(error) []byte

	// BindAliases allows you to specify alias IDs for your bound methods.
	// Example: `BindAliases: map[uint32]uint32{1: 1411160069}` states that alias ID 1 maps to the Go method with ID 1411160069.
	BindAliases map[uint32]uint32

	// Logger is a slog.Logger instance used for logging Wails system messages (not application messages).
	// If not defined, a default logger is used.
	Logger *slog.Logger

	// LogLevel defines the log level of the Wails system logger.
	LogLevel slog.Level

	// Assets are the application assets to be used.
	Assets AssetOptions

	// Flags are key value pairs that are available to the frontend.
	// This is also used by Wails to provide information to the frontend.
	Flags map[string]any

	// PanicHandler is called when a panic occurs
	PanicHandler func(*PanicDetails)

	// DisableDefaultSignalHandler disables the default signal handler
	DisableDefaultSignalHandler bool

	// KeyBindings is a map of key bindings to functions
	KeyBindings map[string]func(window Window)

	// OnShutdown is called when the application is about to terminate.
	// This is useful for cleanup tasks.
	// The shutdown process blocks until this function returns.
	OnShutdown func()

	// PostShutdown is called after the application
	// has finished shutting down, just before process termination.
	// This is useful for testing and logging purposes
	// on platforms where the Run() method does not return.
	// When PostShutdown is called, the application instance is not usable anymore.
	// The shutdown process blocks until this function returns.
	PostShutdown func()

	// ShouldQuit is a function that is called when the user tries to quit the application.
	// If the function returns true, the application will quit.
	// If the function returns false, the application will not quit.
	ShouldQuit func() bool

	// RawMessageHandler is called when the frontend sends a raw message.
	// This is useful for implementing custom frontend-to-backend communication.
	RawMessageHandler func(window Window, message string, originInfo *OriginInfo)

	// WarningHandler is called when a warning occurs
	WarningHandler func(string)

	// ErrorHandler is called when an error occurs
	ErrorHandler func(err error)

	// File extensions associated with the application
	// Example: [".txt", ".md"]
	// The '.' is required
	FileAssociations []string

	// SingleInstance options for single instance functionality
	SingleInstance *SingleInstanceOptions

	// Transport allows you to provide a custom IPC transport layer.
	// When set, Wails will use your transport instead of the default HTTP fetch-based transport.
	// This allows you to use WebSockets, custom protocols, or any other transport mechanism
	// while retaining all Wails generated bindings and event communication.
	//
	// The default transport uses HTTP fetch requests to /wails/runtime + events via js.Exec in webview.
	// If not specified, the default transport is used.
	//
	// Example use case: Implementing WebSocket-based or PostMessage IPC.
	Transport Transport
}

type OriginInfo struct {
	Origin      string
	TopOrigin   string
	IsMainFrame bool
}

type PX struct {
	W, H int
	Pix  []byte
}

type PanicDetails struct {
	StackTrace     string
	Error          error
	Time           time.Time
	FullStackTrace string
}

type Parameter struct {
	Name        string `json:"name,omitempty"`
	TypeName    string `json:"type"`
	ReflectType reflect.Type
}

type PathType int

type PathTypes int

type Point struct {
	X int
	Y int
}

type RGBA struct {
	Red, Green, Blue, Alpha uint8
}

type Rect struct {
	X      int
	Y      int
	Width  int
	Height int
}

type Role uint

type RuntimeRequest struct {
	// Object identifies which Wails subsystem to call (Call=0, Clipboard=1, etc.)
	// See objectNames in runtime.ts
	Object int `json:"object"`

	// Method identifies which method within the object to call
	Method int `json:"method"`

	// Args contains the method arguments
	Args *Args `json:"args"`

	// WebviewWindowName identifies the source window by name (optional, sent via header x-wails-window-name)
	WebviewWindowName string `json:"webviewWindowName,omitempty"`

	// WebviewWindowID identifies the source window (optional, sent via header x-wails-window-id)
	WebviewWindowID uint32 `json:"webviewWindowId,omitempty"`

	// ClientID identifies the frontend client (sent via header x-wails-client-id)
	ClientID string `json:"clientId,omitempty"`
}

type SaveFileDialogOptions struct {
	CanCreateDirectories            bool
	ShowHiddenFiles                 bool
	CanSelectHiddenExtension        bool
	AllowOtherFileTypes             bool
	HideExtension                   bool
	TreatsFilePackagesAsDirectories bool
	Title                           string
	Message                         string
	Directory                       string
	Filename                        string
	ButtonText                      string
	Filters                         []FileFilter
	Window                          Window
}

type SaveFileDialogStruct struct {
	// contains filtered or unexported fields
}

type Screen struct {
	ID               string  // A unique identifier for the display
	Name             string  // The name of the display
	ScaleFactor      float32 // The scale factor of the display (DPI/96)
	X                int     // The x-coordinate of the top-left corner of the rectangle
	Y                int     // The y-coordinate of the top-left corner of the rectangle
	Size             Size    // The size of the display
	Bounds           Rect    // The bounds of the display
	PhysicalBounds   Rect    // The physical bounds of the display (before scaling)
	WorkArea         Rect    // The work area of the display
	PhysicalWorkArea Rect    // The physical work area of the display (before scaling)
	IsPrimary        bool    // Whether this is the primary display
	Rotation         float32 // The rotation of the display
}

type ScreenManager struct {
	// contains filtered or unexported fields
}

type ScreenPlacement struct {
	// contains filtered or unexported fields
}

type SecondInstanceData struct {
	Args           []string          `json:"args"`
	WorkingDir     string            `json:"workingDir"`
	AdditionalData map[string]string `json:"additionalData,omitempty"`
}

type Service struct {
	// contains filtered or unexported fields
}

type ServiceName interface {
	ServiceName() string
}

type ServiceOptions struct {
	// Name can be set to override the name of the service
	// for logging and debugging purposes.
	//
	// If empty, it will default
	// either to the value obtained through the [ServiceName] interface,
	// or to the type name.
	Name string

	// If the service instance implements [http.Handler],
	// it will be mounted on the internal asset server
	// at the prefix specified by Route.
	Route string

	// MarshalError will be called if non-nil
	// to marshal to JSON the error values returned by this service's methods.
	//
	// MarshalError is not allowed to fail,
	// but it may return a nil slice to fall back
	// to the globally configured error handler.
	//
	// If the returned slice is not nil, it must contain valid JSON.
	MarshalError func(error) []byte
}

type ServiceShutdown interface {
	ServiceShutdown() error
}

type ServiceStartup interface {
	ServiceStartup(ctx context.Context, options ServiceOptions) error
}

type SingleInstanceOptions struct {
	// UniqueID is used to identify the application instance
	// This should be unique per application, e.g. "com.myapp.myapplication"
	UniqueID string

	// OnSecondInstanceLaunch is called when a second instance of the application is launched
	// The callback receives data about the second instance launch
	OnSecondInstanceLaunch func(data SecondInstanceData)

	// AdditionalData allows passing custom data from second instance to first
	AdditionalData map[string]string

	// ExitCode is the exit code to use when the second instance exits
	ExitCode int

	// EncryptionKey is a 32-byte key used for encrypting instance communication
	// If not provided (zero array), data will be sent unencrypted
	EncryptionKey [32]byte
}

type Size struct {
	Width  int
	Height int
}

type SystemTray struct {
	// contains filtered or unexported fields
}

type SystemTrayManager struct {
	// contains filtered or unexported fields
}

type TextTheme struct {
	// Text is the colour of the text
	Text *uint32

	// Background is the background colour of the text
	Background *uint32
}

type Theme int

type ThemeSettings struct {
	// Dark mode active window
	DarkModeActive *WindowTheme

	// Dark mode inactive window
	DarkModeInactive *WindowTheme

	// Light mode active window
	LightModeActive *WindowTheme

	// Light mode inactive window
	LightModeInactive *WindowTheme

	// Dark mode MenuBar
	DarkModeMenuBar *MenuBarTheme

	// Light mode MenuBar
	LightModeMenuBar *MenuBarTheme
}

type Transport interface {
	// Start initializes and starts the transport layer.
	// The provided handler should be called to process Wails runtime requests.
	// The context is the application context and will be cancelled on shutdown.
	Start(ctx context.Context, messageProcessor *MessageProcessor) error

	JSClient() []byte

	// Stop gracefully shuts down the transport.
	Stop() error
}

type TransportHTTPHandler interface {
	Handler() func(next http.Handler) http.Handler
}

type Void interface {
	// contains filtered or unexported methods
}

type WailsEventListener interface {
	DispatchWailsEvent(event *CustomEvent)
}

type WebviewGpuPolicy int

type WebviewWindow struct {
	// contains filtered or unexported fields
}