import { Unregisterable } from './shared';

/**
 * Represents functions related to input and controllers in Steam.
 */
export interface Input {
	CalibrateControllerIMU(controllerIndex: any): any;

	CalibrateControllerJoystick(controllerIndex: any): any;

	CalibrateControllerTrackpads(controllerIndex: any): any;

	CancelGyroSWCalibration(): any;

	ClearSelectedConfigForApp(appId: number, controllerIndex: number): any;

	CloseDesktopConfigurator: any;

	/**
	 * Writes text.
	 * @param textToWrite The text to write.
	 */
	ControllerKeyboardSendText(textToWrite: string): void;

	/**
	 * Sets a specified key's pressed state.
	 * @param key The key index to set the state for.
	 * @param state `true` for pressed, `false` otherwise.
	 * @example
	 * Send paste command:
	 * ```
	 * SteamClient.Input.ControllerKeyboardSetKeyState(EHIDKeyboardKey.LControl, true);
	 * SteamClient.Input.ControllerKeyboardSetKeyState(EHIDKeyboardKey.V, true);
	 * SteamClient.Input.ControllerKeyboardSetKeyState(EHIDKeyboardKey.V, false);
	 * SteamClient.Input.ControllerKeyboardSetKeyState(EHIDKeyboardKey.LControl, false);
	 * ```
	 */
	ControllerKeyboardSetKeyState(key: EHIDKeyboardKey, state: boolean): void;

	DecrementCloudedControllerConfigsCounter(): any;

	DeletePersonalControllerConfiguration(param0: any): any;

	//f.Debug("sending to client"), this.SetEditingConfigurationValue(e, t, c.QU, (e => SteamClient.Input.DuplicateControllerConfigurationSourceMode(this.m_unControllerIndex, e))), this.SaveEditingConfiguration(e), this
	DuplicateControllerConfigurationSourceMode(controllerIndex: number, param1: any): any;

	EndControllerDeviceSupportFlow(): any;

	ExportCurrentControllerConfiguration(controllerIndex: number, appId: number, param2: number, title: string, description: string, param5: string): Promise<any>;

	ForceConfiguratorFocus(param0: boolean): any;

	ForceSimpleHapticEvent(param0: number, param1: number, param2: number, param3: number, param4: number): any;

	FreeControllerConfig(m_ChordSummaryConfiguration: any): any;

	GetConfigForAppAndController(appId: number, unControllerIndex: number): any;

	/**
	 * Retrieves the controller mapping string for the specified controller index.
	 * @param unControllerIndex The controller index.
	 * @returns the controller mapping string.
	 */
	GetControllerMappingString(unControllerIndex: number): Promise<string>;

	GetControllerPreviouslySeen(): Promise<number[]>;

	GetSteamControllerDongleState(): Promise<boolean>;

	GetTouchMenuIconsForApp(appId: number): Promise<any>;

	GetXboxDriverInstallState(): Promise<any>; // "{"nResult":0}"
	IdentifyController(controllerIndex: number): any;

	InitControllerSounds(): any;

	InitializeControllerPersonalizationSettings(controllerIndex: number): any;

	ModalKeyboardDismissed(): void;

	OpenDesktopConfigurator: any;

	PreviewConfigForAppAndController(appId: number, controllerIndex: number, workshopUri: string): any;

	PreviewControllerLEDColor(flHue: number, flSaturation: number, flBrightness: number): any;

	QueryControllerConfigsForApp(appId: number, controllerIndex: number, param2: boolean): any;

	RegisterForActiveControllerChanges: Unregisterable; // {"nActiveController":0}
	//param0 - e possibly appid?
	//param1 - some index?
	RegisterForConfigSelectionChanges(callback: (param0: number, param1: number) => void): Unregisterable;

	RegisterForControllerAccountChanges: Unregisterable;

	RegisterForControllerAnalogInputMessages(callback: (msgs: ControllerAnalogInputMessage[]) => void): Unregisterable;

	RegisterForControllerBatteryChanges(callback: any): Unregisterable;

	RegisterForControllerCommandMessages(callback: (msg: ControllerCommandMessage) => void): Unregisterable;

	/**
	 * Registers a callback for changes in controller configuration cloud state.
	 * @param callback The callback function for config cloud state changes.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForControllerConfigCloudStateChanges(callback: (state: ControllerConfigCloudState) => void): Unregisterable;

	/**
	 * Registers a callback for receiving controller configuration info messages (controller layouts query, personal controller layout query).
	 * @param callback The callback function for controller config info messages.
	 * @returns an object that can be used to unregister the callback.
	 * @remarks Do Not Use, this will break the controller layout selection unless you know what you are doing.
	 */
	RegisterForControllerConfigInfoMessages(callback: (msgs: ControllerConfigInfoMessageList[] | ControllerConfigInfoMessageQuery[]) => void): Unregisterable;

	/**
	 * Registers a callback function to be invoked when controller input messages are received.
	 * @param callback The callback function to be invoked when controller input messages are received.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForControllerInputMessages(callback: (msgs: ControllerInputMessage[]) => void): Unregisterable;

	RegisterForControllerListChanges(callback: (controllerListChanges: ControllerInfo[]) => void): Unregisterable;

	/**
	 * Registers a callback for changes in the controller state (buttons presses, triggers presses, joystick changes etc...).
	 * @param callback The callback function for controller state changes.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForControllerStateChanges(callback: (changes: ControllerStateChange[]) => void): Unregisterable;

	RegisterForDualSenseUpdateNotification(callback: (m_strDualSenseUpdateProduct: string) => void): Unregisterable;

	/**
	 * Registers a callback for receiving game keyboard messages (text field popup for inputting text for games when in character creation or etc...).
	 * @param callback The callback function for game keyboard messages.
	 * @returns an object that can be used to unregister the callback.
	 */
	RegisterForGameKeyboardMessages(callback: (msg: GameKeyboardMessage) => void): Unregisterable;

	RegisterForRemotePlayConfigChanges(callback: () => void): Unregisterable;

	//data.appId, data.ulConfigId
	RegisterForShowControllerLayoutPreviewMessages(callback: (data: any) => void): Unregisterable;

	/*
            onTouchMenuInput(e) {
            for (let t = 0; t < e.length; t++) {
                const n = this.TouchMenuGetKey(e[t]), o = this.m_mapActiveTouchMenus.get(n);
                void 0 !== o && o.updateTouchMenuState(e[t])
            }
        }
     */
	RegisterForTouchMenuInputMessages(callback: (inputs: number[]) => void): Unregisterable;

	RegisterForTouchMenuMessages(callback: (msg: TouchMenuMessage) => void): Unregisterable;

	//param0 - index?
	RegisterForUIVisualization(param0: any, param1: any, param2: any): Unregisterable;

	RegisterForUnboundControllerListChanges(callback: (m_unboundControllerList: any) => void): Unregisterable; // param0 is an array

	/*
        OnDismissKeyboardMessage(e) {
            this.m_WindowStore.SteamUIWindows.forEach((e => e.VirtualKeyboardManager.SetVirtualKeyboardHidden(e.BrowserWindow)))
        }
     */
	RegisterForUserDismissKeyboardMessages(callback: (param0: any) => void): Unregisterable;

	RegisterForUserKeyboardMessages: Unregisterable;

	RequestGyroActive(controllerIndex: number, param1: boolean): any;

	RequestRemotePlayControllerConfigs(param0: any): any;

	ResetControllerBindings(param0: any): any;

	ResolveCloudedControllerConfigConflict(param0: any): any;

	RestoreControllerPersonalizationSettings(controllerIndex: number): any;

	SaveControllerCalibration(controllerIndex: number): any;

	SaveControllerPersonalizationSettings(param0: any): any;

	SaveControllerSounds: any;

	SaveEditingControllerConfiguration(controllerIndex: number, sharedConfig: boolean): any;

	//this.SetEditingConfigurationValue(e, t, c.sL, (e => SteamClient.Input.SetControllerConfigurationModeShiftBinding(this.m_unControllerIndex, e)))
	SetControllerConfigurationModeShiftBinding(controllerIndex: number, param1: any): any;

	SetControllerHapticSetting(controllerIndex: number, eHapticSetting: any): any;

	SetControllerMappingString(mapping: string): void;

	SetControllerName(controllerIndex: number, controllerName: string): any;

	SetControllerNintendoLayoutSetting: any;
	SetControllerPersonalizationName: any;

	//param0 - nLStickDeadzone, bSWAntiDrift, nRHapticStrength, flRPadPressureCurve
	/*
                SteamClient.Input.SetControllerPersonalizationSetting("nLStickDeadzone", e.nLStickDeadzone),
                SteamClient.Input.SetControllerPersonalizationSetting("nRStickDeadzone", e.nRStickDeadzone),
                SteamClient.Input.SetControllerPersonalizationSetting("bSWAntiDrift", e.bSWAntiDrift ? 1 : 0),
                SteamClient.Input.SetControllerPersonalizationSetting("nLHapticStrength", e.nLHapticStrength),
                SteamClient.Input.SetControllerPersonalizationSetting("nRHapticStrength", e.nRHapticStrength),
                SteamClient.Input.SetControllerPersonalizationSetting("flLPadPressureCurve", 100 * e.flLPadPressureCurve),
                SteamClient.Input.SetControllerPersonalizationSetting("flRPadPressureCurve", 100 * e.flRPadPressureCurve),
                SteamClient.Input.SetControllerPersonalizationSetting("ePlayerSlotLEDSetting", e),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nGyroSampleAngleOffsetX", e.nGyroSampleAngleOffsetX),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.bMomentumEnabled", e.bMomentumEnabled ? 1 : 0),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nMomentumFrictionX", e.nMomentumFrictionX),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nMomentumFrictionY", e.nMomentumFrictionY),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nAccerationLevel", e.nAccerationLevel),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.bInvertX", e.bInvertX ? 1 : 0),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.bInvertY", e.bInvertY ? 1 : 0),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nRotationAngle", e.nRotationAngle),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nTriggerClamping", e.nTriggerClamping),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nTriggerClampingAmount", e.nTriggerClampingAmount),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nGyroEnableButton", e.nGyroEnableButton),
                SteamClient.Input.SetControllerPersonalizationSetting("GyroPreferenceData.nGyroEnableButtonBehavior", e.nGyroEnableButtonBehavior),
     */
	SetControllerPersonalizationSetting(param0: string, param1: number): any;

	//param0 - flGyroStationaryTolerance, flAccelerometerStationaryTolerance,
	/*
                    SteamClient.Input.SetControllerPersonalizationSettingFloat("GyroPreferenceData.flGyroNaturalSensitivity", e.flGyroNaturalSensitivity),
                    SteamClient.Input.SetControllerPersonalizationSettingFloat("GyroPreferenceData.flGyroXYRatio", e.flGyroXYRatio),
                    SteamClient.Input.SetControllerPersonalizationSettingFloat("GyroPreferenceData.flGyroSpeedDeadzone", e.flGyroSpeedDeadzone),
                    SteamClient.Input.SetControllerPersonalizationSettingFloat("GyroPreferenceData.flGyroPrecisionSpeed", e.flGyroPrecisionSpeed),
                SteamClient.Input.SetControllerPersonalizationSettingFloat("flGyroStationaryTolerance", e.flGyroStationaryTolerance),
                SteamClient.Input.SetControllerPersonalizationSettingFloat("flAccelerometerStationaryTolerance", e.flAccelerometerStationaryTolerance),
     */
	SetControllerPersonalizationSettingFloat(param0: string, param1: number): any;

	SetControllerRumbleSetting(controllerIndex: number, rumblePreference: EControllerRumbleSetting): any;

	SetControllerUseUniversalFaceButtonGlyphs(controllerIndex: number, value: boolean): void;

	SetCursorActionset(param0: boolean): any;

	SetDualSenseUpdateNotification(param0: boolean): any;

	/*
            SetEditingConfigurationValue(e, t, n, o) {
            const a = new r.BinaryWriter;
            n.serializeBinaryToWriter(n.fromObject(t), a);
            const s = a.getResultBase64String();
            f.Debug("SetEditingConfigurationValue serializeBinaryToWriter", (0, i.ZN)(t), s), this.EditingConfigurationWillUpdate(), this.m_updatingEditingConfigurationPromise = o(s).then((t => {
                if (null == t) return f.Debug("SetEditingConfigurationValue returned nothing."), void (0, i.z)((() => this.UpdateEditingConfiguration(e, this.m_unControllerIndex, this.EditingConfiguration)));
                const n = c.bE.deserializeBinary(t).toObject();
                f.Debug("SetEditingConfigurationValue returned controller configuration.", n), this.UpdateEditingConfiguration(e, this.m_unControllerIndex, n), this.m_nEditNumber++, -1 == n.url.indexOf("autosave://") && this.SaveEditingConfiguration(e)
            })).catch((e => {
                f.Error("SetEditingConfigurationValue fail:", o, l.jt(e.result), e.message), this.m_bIsUpdatingActiveConfiguration = !1
            }))
        }

        SetControllerActionSet(e, t) {
            this.SetEditingConfigurationValue(e, t, c.X3, (e => SteamClient.Input.SetEditingControllerConfigurationActionSet(this.m_unControllerIndex, e)))
        }
     */
	SetEditingControllerConfigurationActionSet(controllerIndex: number, param1: any): any;

	//this.SetEditingConfigurationValue(e, t, c.io, (e => SteamClient.Input.SetEditingControllerConfigurationInputActivator(this.m_unControllerIndex, e)))
	SetEditingControllerConfigurationInputActivator(controllerIndex: number, param1: any): any;

	//this.SetEditingConfigurationValue(e, t, c.tH, (e => SteamClient.Input.SetEditingControllerConfigurationInputActivatorEnabled(this.m_unControllerIndex, e)))
	SetEditingControllerConfigurationInputActivatorEnabled(controllerIndex: number, param1: any): any;

	//this.SetEditingConfigurationValue(e, t, c.J2, (e => SteamClient.Input.SetEditingControllerConfigurationInputBinding(this.m_unControllerIndex, e)))
	SetEditingControllerConfigurationInputBinding(controllerIndex: number, param1: any): any;

	//this.SetEditingConfigurationValue(e, t, c.Sz, (e => SteamClient.Input.SetEditingControllerConfigurationMiscSetting(this.m_unControllerIndex, e)))
	SetEditingControllerConfigurationMiscSetting(controllerIndex: number, param1: any): any;

	//f.Debug("sending to client"), this.SetEditingConfigurationValue(e, t, c.QU, (e => SteamClient.Input.SetEditingControllerConfigurationSourceMode(this.m_unControllerIndex, e)))
	SetEditingControllerConfigurationSourceMode(controllerIndex: number, param1: any): any;

	SetGamepadKeyboardText(param0: boolean, param1: string): any;

	SetKeyboardActionset(param0: boolean, param1: boolean): any;

	/**
	 * Sets the mouse position.
	 * @param pid 0
	 * @param x Mouse X position.
	 * @param y Mouse Y position.
	 */
	SetMousePosition(pid: number, x: number, y: number): void;

	SetSelectedConfigForApp(appId: number, controllerIndex: number, url: string, param3: boolean): any;

	SetSteamControllerDonglePairingMode(bEnable: boolean, bSilent: boolean): any;

	SetVirtualMenuKeySelected(unControllerIndex: number, unMenuIndex: number, m_controllerMenuActiveMenuItem: number): any; //
	SetWebBrowserActionset(param0: boolean): any;

	SetXboxDriverInstallState(param0: any): any; // state

	/**
	 * Opens the Steam Input controller settings.
	 * This function displays the Steam Input controller settings for configuration.
	 */
	ShowControllerSettings(): void;

	StandaloneKeyboardDismissed(): any;

	StartControllerDeviceSupportFlow(param0: any, param1: any, callback: (param2: any) => void): any;

	/*
    this.m_updatingEditingConfigurationPromise = SteamClient.Input.StartEditingControllerConfigurationForAppIDAndControllerIndex(e, t).then((n=>{
                                const o = c.bE.deserializeBinary(n).toObject();
                                f.Debug("Loaded controller config for appid", e, n, o),
                                    (0,
                                        i.z)((()=>this.UpdateEditingConfiguration(e, t, o)))
                            }
                        )).catch((n=>{
                                f.Debug("Loading controller config for appid rejected", e, n),
                                    (0,
                                        i.z)((()=>this.UpdateEditingConfiguration(e, t, null)))
                            }
                        ))
     */
	StartEditingControllerConfigurationForAppIDAndControllerIndex(m_appId: number, m_unControllerIndex: number): Promise<any>;

	StartGyroSWCalibration(callback: () => void): any;

	StopEditingControllerConfiguration(controllerIndex: number): any;

	SwapControllerConfigurationSourceModes: any;

	//this.SetEditingConfigurationValue(e, t, c.Qb, (e => SteamClient.Input.SwapControllerModeInputBindings(this.m_unControllerIndex, e)))
	SwapControllerModeInputBindings(controllerIndex: number, param1: any): any;

	SwapControllerOrder(controllerIndex1: number, controllerIndex2: number): any;

	SyncCloudedControllerConfigs(): any;

	// type - enum
	/*
    Off - 0, Tick, Click
     */
	TriggerHapticPulse(controllerIndex: number, eHapticType: number, param2: number): any;

	TriggerSimpleHapticEvent(controllerIndex: number, eHapticType: number, unIntensity: number, ndBGain: number, param4: number): any;

	UnregisterForControllerStateChanges(): void;

	UnregisterForUIVisualization(controllerIndex: number): any;

	UploadChangesForCloudedControllerConfigs(): any;
}

export enum EHIDKeyboardKey {
	Invalid,
	BeforeFirst = 3,
	A,
	B,
	C,
	D,
	E,
	F,
	G,
	H,
	I,
	J,
	K,
	L,
	M,
	N,
	O,
	P,
	Q,
	R,
	S,
	T,
	U,
	V,
	W,
	X,
	Y,
	Z,
	Key_1,
	Key_2,
	Key_3,
	Key_4,
	Key_5,
	Key_6,
	Key_7,
	Key_8,
	Key_9,
	Key_0,
	Return,
	Escape,
	Backspace,
	Tab,
	Space,
	Dash,
	Equals,
	LeftBracket,
	RightBracket,
	Backslash,
	Unused1,
	Semicolon,
	SingleQuote,
	Backtick,
	Comma,
	Period,
	ForwardSlash,
	CapsLock,
	F1,
	F2,
	F3,
	F4,
	F5,
	F6,
	F7,
	F8,
	F9,
	F10,
	F11,
	F12,
	PrintScreen,
	ScrollLock,
	Break,
	Insert,
	Home,
	PageUp,
	Delete,
	End,
	PageDown,
	RightArrow,
	LeftArrow,
	DownArrow,
	UpArrow,
	NumLock,
	KeypadForwardSlash,
	KeypadAsterisk,
	KeypadDash,
	KeypadPlus,
	KeypadEnter,
	Keypad_1,
	Keypad_2,
	Keypad_3,
	Keypad_4,
	Keypad_5,
	Keypad_6,
	Keypad_7,
	Keypad_8,
	Keypad_9,
	Keypad_0,
	KeypadPeriod,
	LAlt,
	LShift,
	LWin,
	LControl,
	RAlt,
	RShift,
	RWin,
	RControl,
	VolUp,
	VolDown,
	Mute,
	Play,
	Stop,
	Next,
	Prev,
	AfterLast,
}

export interface ControllerAnalogInputMessage {
	nA: number;
	x: number;
	y: number;
	nC: number;
}

export interface ControllerCommandMessage {
	/**
	 * @todo enum
	 */
	eAction: number;
	nControllerIndex: number;
}

export interface ControllerConfigCloudState {
	bSyncDone: boolean;
	bSyncConflict: boolean;
	bSyncError: boolean;
}

export interface ControllerConfigInfoMessage {
	appID: number;
}

export interface ControllerConfigInfoMessageQuery extends ControllerConfigInfoMessage {
	bPersonalQueryDone: boolean;
}

export interface ControllerConfigInfoMessageList extends ControllerConfigInfoMessage {
	nControllerType: number;
	publishedFileID: string;
	accountID: number;
	Title: string;
	Description: string;
	URL: string;
	timeUpdated: string;
	bOfficial: boolean;
	bProgenitorOfficial: boolean;
	bRecommended: boolean;
	bProgenitorRecommended: boolean;
	bUsesSIAPI: boolean;
	bUsesMouse: boolean;
	bUsesKeyboard: boolean;
	bUsesGamepad: boolean;
	/**
	 * @todo unconfirmed
	 */
	eExportType: EControllerConfigExportType;
	playtime: string;
	bSelected: boolean;
}

export enum EControllerConfigExportType {
	Unknown,
	PersonalLocal,
	PersonalCloud,
	Community,
	Template,
	Official,
	OfficialDefault,
}

export enum EControllerRumbleSetting {
	ControllerPreference,
	Off,
	On,
}

// TODO: Not the actual name, but the enum is only represented in a dropdown
// options vector, ty valve
export enum EThirdPartyControllerConfiguration {
	Off,
	DefaultSetting,
	On,
}

export interface ControllerInputMessage {
	nA: number;
	bS: boolean;
	nC: number;
}

export interface ActiveAccount {
	strActiveAccountID: string;
	strName: string;
	strAvatarHash: string;
}

export interface ControllerInfo {
	strName: string;
	eControllerType: EControllerType;
	nXInputIndex: number;
	nControllerIndex: number;
	eRumblePreference: EControllerRumbleSetting;
	bWireless: boolean;
	unUniqueID: number;
	unVendorID: number;
	unProductID: number;
	/** Bitmask */
	unCapabilities: number;
	strFirmwareBuildTime: string;
	strSerialNumber: string;
	strChipID: string;
	nLEDColorR: number;
	nLEDColorG: number;
	nLEDColorB: number;
	flLEDBrightness: number;
	flLEDSaturation: number;
	nTurnOnSound: number;
	nTurnOffSound: number;
	nLStickDeadzone: number;
	nRStickDeadzone: number;
	nLHapticStrength: number;
	nRHapticStrength: number;
	flLPadPressureCurve: number;
	flRPadPressureCurve: number;
	bHaptics: boolean;
	bSWAntiDrift: boolean;
	flGyroStationaryTolerance: number;
	flAccelerometerStationaryTolerance: number;
	bRemoteDevice: boolean;
	bNintendoLayout: boolean;
	bUseReversedLayout: boolean;
	ActiveAccount: ActiveAccount | undefined;
	vecAltAccounts: any[]; // The type for this property might need to be more specific based on the actual data structure
}

export enum EControllerType {
	None = -1,
	Unknown,
	UnknownSteamController,
	SteamController, // Codename Gordon
	SteamControllerV2, // Codename Headcrab
	SteamControllerNeptune, // Steam Deck
	FrontPanelBoard = 20,
	Generic = 30,
	XBox360Controller,
	XBoxOneController,
	PS3Controller,
	PS4Controller,
	WiiController,
	AppleController,
	AndroidController,
	SwitchProController,
	SwitchJoyConLeft,
	SwitchJoyConRight,
	SwitchJoyConPair,
	SwitchProGenericInputOnlyController,
	MobileTouch,
	SwitchProXInputSwitchController,
	PS5Controller,
	XboxEliteController,
	LastController, // Unverified
	PS5EdgeController,
	GenericKeyboard = 400,
	GenericMouse = 800,
}

export interface ControllerStateChange {
	unControllerIndex: number;
	unPacketNum: number;
	/**
	 * Bitmask representing pressed upper buttons.
	 * - Bit 0-8: Unknown (@todo Please provide more details if known)
	 * - Bit 9: L4
	 * - Bit 10: R4
	 * - Bit 11-13: Unknown (@todo Please provide more details if known)
	 * - Bit 14: Left Joystick Touch
	 * - Bit 15: Right Joystick Touch
	 * - Bit 16-17: Unknown (@todo Please provide more details if known)
	 * - Bit 18: Quick Access Menu
	 */
	ulUpperButtons: number;
	/**
	 * Bitmask representing pressed buttons.
	 * - Bit 0: R2
	 * - Bit 1: L2
	 * - Bit 2: R1
	 * - Bit 3: L1
	 * - Bit 4: Y
	 * - Bit 5: B
	 * - Bit 6: X
	 * - Bit 7: A
	 * - Bit 8: D-Pad Up
	 * - Bit 9: D-Pad Right
	 * - Bit 10: D-Pad Left
	 * - Bit 11: D-Pad Down
	 * - Bit 12: Select
	 * - Bit 13: Steam/Home
	 * - Bit 14: Start
	 * - Bit 15: L5
	 * - Bit 16: R5
	 * - Bit 17: Left Touchpad Click
	 * - Bit 18: Right Touchpad Click
	 * - Bit 19: Left Touchpad Touch
	 * - Bit 20: Right Touchpad Touch
	 * - Bit 21: Unknown (@todo Please provide more details if known)
	 * - Bit 22: L3
	 * - Bit 23-25: Unknown (@todo Please provide more details if known)
	 * - Bit 26: R3
	 * - Bit 27-28: Unknown (@todo Please provide more details if known)
	 * - Bit 29: Mute (Dualsense)
	 * - Bit 30-31: Unknown (@todo Please provide more details if known)
	 */
	ulButtons: number;
	sLeftPadX: number;
	sLeftPadY: number;
	sRightPadX: number;
	sRightPadY: number;
	sCenterPadX: number;
	sCenterPadY: number;
	sLeftStickX: number;
	sLeftStickY: number;
	sRightStickX: number;
	sRightStickY: number;
	sTriggerL: number;
	sTriggerR: number;
	flTrustedGravityVectorX: number;
	flTrustedGravityVectorY: number;
	flTrustedGravityVectorZ: number;
	flSoftwareQuatW: number;
	flSoftwareQuatX: number;
	flSoftwareQuatY: number;
	flSoftwareQuatZ: number;
	flSoftwareGyroDegreesPerSecondPitch: number;
	flSoftwareGyroDegreesPerSecondYaw: number;
	flSoftwareGyroDegreesPerSecondRoll: number;
	flHardwareQuatW: number;
	flHardwareQuatX: number;
	flHardwareQuatY: number;
	flHardwareQuatZ: number;
	flHardwareGyroDegreesPerSecondPitch: number;
	flHardwareGyroDegreesPerSecondYaw: number;
	flHardwareGyroDegreesPerSecondRoll: number;
	flGyroNoiseLength: number;
	flGyroCalibrationProgress: number;
	flGravityVectorX: number;
	flGravityVectorY: number;
	flGravityVectorZ: number;
	flAccelerometerNoiseLength: number;
	sBatteryLevel: number;
	sPressurePadLeft: number;
	sPressurePadRight: number;
	sPressureBumperLeft: number;
	sPressureBumperRight: number;
	unHardwareUpdateInMicrosec: number;
}

export interface GameKeyboardMessage {
	m_bOpen: boolean;
	nAppID: number;
	m_dwPID: number;
	m_dwOverlayPID: number;
	m_hPipe: number;
	/** @todo enum */
	m_eInputMode: number;
	/** @todo enum */
	m_eLineInputMode: number;
	m_pchDescription: string;
	m_unCharMax: number;
	m_pchExistingText: string;
}

export interface TouchMenuMessage {
	bHasVirtualMenus: boolean;
	unControllerIndex: number;
	appID: number;
}