/// <reference types="@nativescript/objc-node-api" />
/// <reference path="./AppKit.d.ts" />
/// <reference path="./Runtime.d.ts" />

declare const GCCurrentExtendedGamepadSnapshotDataVersion: interop.Enum<typeof GCExtendedGamepadSnapshotDataVersion>;

declare const GCKeyCodeQuote: number;

declare const GCInputLeftThumbstick: string;

declare const GCKeyCodeF1: number;

declare const GCKeyCodeKeypad7: number;

declare const GCHapticsLocalityLeftHandle: string;

declare const GCKeyKeypad6: string;

declare const GCKeyCodeKeyD: number;

declare const GCKeyLANG4: string;

declare const GCKeyCodeLANG8: number;

declare const GCControllerDidStopBeingCurrentNotification: string;

declare const GCKeyOne: string;

declare const GCKeyD: string;

declare const GCKeyCodeKeyT: number;

declare const GCHapticsLocalityRightTrigger: string;

declare const GCHapticsLocalityHandles: string;

declare const GCHapticsLocalityAll: string;

declare const GCMouseDidStopBeingCurrentNotification: string;

declare const GCKeyboardDidConnectNotification: string;

declare const GCControllerDidBecomeCurrentNotification: string;

declare const GCControllerDidDisconnectNotification: string;

declare const GCKeyCodeCloseBracket: number;

declare const GCKeyLeftGUI: string;

declare const GCKeyLeftAlt: string;

declare const GCKeyLeftControl: string;

declare const GCKeyLANG7: string;

declare const GCKeyLANG5: string;

declare const GCKeyLANG2: string;

declare const GCKeyLANG1: string;

declare const GCKeyInternational9: string;

declare const GCKeyInternational7: string;

declare const GCKeyInternational4: string;

declare const GCKeyInternational2: string;

declare const GCKeyNonUSBackslash: string;

declare const GCKeyKeypad0: string;

declare const GCKeyKeypad4: string;

declare const GCKeyKeypad3: string;

declare const GCKeyKeypad2: string;

declare const GCKeyKeypadPlus: string;

declare const GCKeyKeypadAsterisk: string;

declare const GCKeyKeypadNumLock: string;

declare const GCKeyDownArrow: string;

declare const GCKeyPageDown: string;

declare const GCKeyEnd: string;

declare const GCKeyDeleteForward: string;

declare const GCKeyPageUp: string;

declare const GCKeyF11: string;

declare const GCKeyF10: string;

declare const GCKeyF9: string;

declare const GCKeyF8: string;

declare const GCKeyF7: string;

declare const GCKeyF6: string;

declare const GCKeyF5: string;

declare const GCKeyF4: string;

declare const GCKeyCapsLock: string;

declare const GCKeySlash: string;

declare const GCKeyPeriod: string;

declare const GCKeyComma: string;

declare const GCKeySemicolon: string;

declare const GCKeyNonUSPound: string;

declare const GCKeyCloseBracket: string;

declare const GCKeyEqualSign: string;

declare const GCKeySpacebar: string;

declare const GCKeyZero: string;

declare const GCKeyNine: string;

declare const GCKeyEight: string;

declare const GCKeyFour: string;

declare const GCKeyThree: string;

declare const GCKeyZ: string;

declare const GCKeyW: string;

declare const GCKeyU: string;

declare const GCKeyT: string;

declare const GCKeyR: string;

declare const GCKeyO: string;

declare const GCKeyJ: string;

declare const GCKeyG: string;

declare const GCKeyF: string;

declare const GCKeyE: string;

declare const GCKeyC: string;

declare const GCKeyA: string;

declare const GCKeyCodeRightGUI: number;

declare const GCKeyCodeRightShift: number;

declare const GCKeyCodeLeftGUI: number;

declare const GCKeyCodeLeftAlt: number;

declare const GCKeyCodeLeftControl: number;

declare const GCKeyCodeLANG9: number;

declare const GCKeyCodeLANG5: number;

declare const GCKeyCodeLANG4: number;

declare const GCKeyCodeLANG3: number;

declare const GCKeyCodeInternational8: number;

declare const GCKeyCodeInternational5: number;

declare const GCKeyCodeInternational4: number;

declare const GCKeyCodeInternational2: number;

declare const GCKeyCodeInternational1: number;

declare const GCKeyCodeNonUSBackslash: number;

declare const GCKeyCodeKeypadPeriod: number;

declare const GCKeyCodeKeypad0: number;

declare const GCKeyCodeKeypad8: number;

declare const GCKeyCodeKeypad3: number;

declare const GCKeyCodeKeypad2: number;

declare const GCKeyCodeKeypadEnter: number;

declare const GCKeyCodeKeypadAsterisk: number;

declare const GCKeyCodeKeypadSlash: number;

declare const GCKeyCodeUpArrow: number;

declare const GCKeyCodePageDown: number;

declare const GCKeyCodeEnd: number;

declare const GCKeyCodeScrollLock: number;

declare const GCKeyCodeF11: number;

declare const GCKeyCodeF10: number;

declare const GCKeyCodeF9: number;

declare const GCKeyCodeF8: number;

declare const GCKeyCodeF7: number;

declare const GCKeyCodeF6: number;

declare const GCKeyCodeF4: number;

declare const GCKeyCodeF2: number;

declare const GCKeyCodeCapsLock: number;

declare const GCKeyCodeComma: number;

declare const GCKeyCodeOpenBracket: number;

declare const GCKeyCodeTab: number;

declare const GCKeyCodeEscape: number;

declare const GCKeyCodeReturnOrEnter: number;

declare const GCKeyCodeNine: number;

declare const GCKeyCodeEight: number;

declare const GCKeyCodeSeven: number;

declare const GCKeyCodeSix: number;

declare const GCKeyCodeTwo: number;

declare const GCKeyCodeOne: number;

declare const GCKeyCodeKeyZ: number;

declare const GCKeyCodeKeyY: number;

declare const GCKeyCodeKeyX: number;

declare const GCKeyCodeKeyW: number;

declare const GCKeyCodeKeyU: number;

declare const GCKeyCodeKeyR: number;

declare const GCKeyCodeKeyQ: number;

declare const GCKeyCodeKeyM: number;

declare const GCHapticsLocalityTriggers: string;

declare const GCKeyCodeKeyK: number;

declare const GCKeyCodeKeyG: number;

declare const GCKeyCodeKeyF: number;

declare const GCKeyCodeKeyE: number;

declare const GCKeyCodeKeyC: number;

declare const GCKeyCodeKeyA: number;

declare const GCInputXboxPaddleThree: string;

declare const GCInputXboxPaddleOne: string;

declare const GCInputRightTrigger: string;

declare const GCInputLeftTrigger: string;

declare const GCInputRightShoulder: string;

declare const GCInputRightThumbstickButton: string;

declare const GCInputDirectionPad: string;

declare const GCInputButtonY: string;

declare const GCInputButtonA: string;

declare const GCKeyKeypad1: string;

declare const GCKeyLeftArrow: string;

declare const GCKeyB: string;

declare const GCInputXboxPaddleFour: string;

declare const GCKeyCodeGraveAccentAndTilde: number;

declare const GCKeyCodeBackslash: number;

declare const GCInputDualShockTouchpadTwo: string;

declare const GCKeyS: string;

declare const GCKeyCodeKeyP: number;

declare const GCKeyInternational8: string;

declare const GCKeyKeypad7: string;

declare const GCKeyLANG8: string;

declare const GCHapticDurationInfinite: number;

declare const GCKeyKeypadPeriod: string;

declare const GCKeyQ: string;

declare const GCKeyCodeHyphen: number;

declare const GCKeyKeypad8: string;

declare const GCKeyCodeKeyL: number;

declare const GCKeyCodeLeftArrow: number;

declare const GCKeyCodeKeypad5: number;

declare const GCInputLeftThumbstickButton: string;

declare const GCKeyCodeKeyI: number;

declare const GCKeyCodeRightControl: number;

declare const GCInputXboxPaddleTwo: string;

declare const GCKeyM: string;

declare const GCKeyCodeKeyO: number;

declare const GCKeyPause: string;

declare const GCKeyGraveAccentAndTilde: string;

declare const GCKeyCodeKeyH: number;

declare const GCKeyH: string;

declare const GCKeyV: string;

declare const GCKeyRightGUI: string;

declare const GCKeyFive: string;

declare const GCKeyKeypadSlash: string;

declare const GCKeyCodeKeypad9: number;

declare const GCKeyRightShift: string;

declare const GCInputButtonHome: string;

declare const GCKeyTwo: string;

declare const GCKeyCodeInternational3: number;

declare const GCKeyDeleteOrBackspace: string;

declare const GCKeyLANG9: string;

declare const GCKeyCodeFour: number;

declare const GCKeyScrollLock: string;

declare const GCKeyboardDidDisconnectNotification: string;

declare const GCKeyCodeSlash: number;

declare const GCKeyCodeRightArrow: number;

declare const GCKeyF12: string;

declare const GCInputButtonB: string;

declare const GCKeyInternational3: string;

declare const GCKeyCodeDeleteOrBackspace: number;

declare const GCKeyCodePeriod: number;

declare const GCKeyInternational1: string;

declare const GCKeyCodeDeleteForward: number;

declare const GCControllerDidConnectNotification: string;

declare const GCKeyRightAlt: string;

declare const GCKeyY: string;

declare const GCKeyLeftShift: string;

declare const GCInputButtonOptions: string;

declare const GCKeyN: string;

declare const GCInputDualShockTouchpadButton: string;

declare const GCKeyCodeKeyV: number;

declare const GCKeyCodeKeyB: number;

declare const GCKeyBackslash: string;

declare const GCKeyCodeFive: number;

declare const GCKeyCodePower: number;

declare const GCKeyCodeKeypadNumLock: number;

declare const GCKeyCodePageUp: number;

declare const GCMouseDidBecomeCurrentNotification: string;

declare const GCKeyCodeLANG7: number;

declare const GCKeyPower: string;

declare const GCKeyCodeKeyN: number;

declare const GCInputButtonX: string;

declare const GCKeyL: string;

declare const GCKeyCodeHome: number;

declare const GCKeyCodeInternational6: number;

declare const GCKeyTab: string;

declare const GCKeyCodePrintScreen: number;

declare const GCKeyCodeInternational7: number;

declare const GCHapticsLocalityDefault: string;

declare const GCInputRightThumbstick: string;

declare const GCKeyPrintScreen: string;

declare const GCKeyCodeKeypadPlus: number;

declare const GCKeyCodePause: number;

declare const GCKeyCodeLeftShift: number;

declare const GCKeyCodeSemicolon: number;

declare const GCKeyCodeKeypadHyphen: number;

declare const GCCurrentMicroGamepadSnapshotDataVersion: interop.Enum<typeof GCMicroGamepadSnapshotDataVersion>;

declare const GCKeyQuote: string;

declare const GCKeyCodeF5: number;

declare const GCKeyUpArrow: string;

declare const GCKeyOpenBracket: string;

declare const GCKeyCodeSpacebar: number;

declare const GCKeyReturnOrEnter: string;

declare const GCKeyLANG6: string;

declare const GCKeyCodeKeypad1: number;

declare const GCKeySeven: string;

declare const GCInputButtonMenu: string;

declare const GCKeyCodeF3: number;

declare const GCKeyCodeLANG1: number;

declare const GCKeyCodeInsert: number;

declare const GCMouseDidConnectNotification: string;

declare const GCKeyCodeDownArrow: number;

declare const GCKeyKeypad9: string;

declare const GCKeyCodeNonUSPound: number;

declare const GCKeyCodeKeyJ: number;

declare const GCKeyHyphen: string;

declare const GCKeySix: string;

declare const GCKeyP: string;

declare const GCKeyF2: string;

declare const GCKeyCodeApplication: number;

declare const GCKeyK: string;

declare const GCKeyInternational5: string;

declare const GCKeyCodeKeypad6: number;

declare const GCKeyF3: string;

declare const GCKeyCodeRightAlt: number;

declare const GCKeyKeypadEqualSign: string;

declare const GCKeyCodeKeypad4: number;

declare const GCKeyEscape: string;

declare const GCKeyCodeLANG2: number;

declare const GCInputLeftShoulder: string;

declare const GCKeyCodeInternational9: number;

declare const GCKeyKeypad5: string;

declare const GCKeyCodeLANG6: number;

declare const GCKeyInternational6: string;

declare const GCKeyRightControl: string;

declare const GCKeyCodeKeypadEqualSign: number;

declare const GCHapticsLocalityLeftTrigger: string;

declare const GCKeyCodeEqualSign: number;

declare const GCKeyKeypadEnter: string;

declare const GCKeyCodeKeyS: number;

declare const GCKeyLANG3: string;

declare const GCKeyKeypadHyphen: string;

declare const GCKeyCodeZero: number;

declare const GCKeyApplication: string;

declare const GCMouseDidDisconnectNotification: string;

declare const GCHapticsLocalityRightHandle: string;

declare const GCKeyX: string;

declare const GCInputDualShockTouchpadOne: string;

declare const GCKeyCodeThree: number;

declare const GCKeyI: string;

declare const GCKeyCodeF12: number;

declare const GCKeyF1: string;

declare const GCKeyHome: string;

declare const GCKeyRightArrow: string;

declare const GCKeyInsert: string;

declare const GCExtendedGamepadSnapshotDataVersion: {
  Version1: 256,
  Version2: 257,
};

declare const GCTouchState: {
  Up: 0,
  Down: 1,
  Moving: 2,
};

declare const GCMicroGamepadSnapshotDataVersion: {
  GCMicroGamepadSnapshotDataVersion1: 256,
};

declare const GCDeviceBatteryState: {
  Unknown: -1,
  Discharging: 0,
  Charging: 1,
  Full: 2,
};

declare const GCControllerPlayerIndex: {
  IndexUnset: -1,
  Index1: 0,
  Index2: 1,
  Index3: 2,
  Index4: 3,
};

declare const GCSystemGestureState: {
  Enabled: 0,
  AlwaysReceive: 1,
  Disabled: 2,
};

declare class GCEulerAngles {
  constructor(init?: GCEulerAngles);
  pitch: number;
  yaw: number;
  roll: number;
}

declare class GCMicroGamepadSnapShotDataV100 {
  constructor(init?: GCMicroGamepadSnapShotDataV100);
  version: number;
  size: number;
  dpadX: number;
  dpadY: number;
  buttonA: number;
  buttonX: number;
}

declare class GCAcceleration {
  constructor(init?: GCAcceleration);
  x: number;
  y: number;
  z: number;
}

declare class GCDualSenseAdaptiveTriggerPositionalResistiveStrengths {
  constructor(init?: GCDualSenseAdaptiveTriggerPositionalResistiveStrengths);
  values: unknown /* const array */;
}

declare class GCExtendedGamepadSnapShotDataV100 {
  constructor(init?: GCExtendedGamepadSnapShotDataV100);
  version: number;
  size: number;
  dpadX: number;
  dpadY: number;
  buttonA: number;
  buttonB: number;
  buttonX: number;
  buttonY: number;
  leftShoulder: number;
  rightShoulder: number;
  leftThumbstickX: number;
  leftThumbstickY: number;
  rightThumbstickX: number;
  rightThumbstickY: number;
  leftTrigger: number;
  rightTrigger: number;
}

declare class GCGamepadSnapShotDataV100 {
  constructor(init?: GCGamepadSnapShotDataV100);
  version: number;
  size: number;
  dpadX: number;
  dpadY: number;
  buttonA: number;
  buttonB: number;
  buttonX: number;
  buttonY: number;
  leftShoulder: number;
  rightShoulder: number;
}

declare class GCDualSenseAdaptiveTriggerPositionalAmplitudes {
  constructor(init?: GCDualSenseAdaptiveTriggerPositionalAmplitudes);
  values: unknown /* const array */;
}

declare class GCExtendedGamepadSnapshotData {
  constructor(init?: GCExtendedGamepadSnapshotData);
  version: number;
  size: number;
  dpadX: number;
  dpadY: number;
  buttonA: number;
  buttonB: number;
  buttonX: number;
  buttonY: number;
  leftShoulder: number;
  rightShoulder: number;
  leftThumbstickX: number;
  leftThumbstickY: number;
  rightThumbstickX: number;
  rightThumbstickY: number;
  leftTrigger: number;
  rightTrigger: number;
  supportsClickableThumbsticks: boolean;
  leftThumbstickButton: boolean;
  rightThumbstickButton: boolean;
}

declare class GCQuaternion {
  constructor(init?: GCQuaternion);
  x: number;
  y: number;
  z: number;
  w: number;
}

declare class GCMicroGamepadSnapshotData {
  constructor(init?: GCMicroGamepadSnapshotData);
  version: number;
  size: number;
  dpadX: number;
  dpadY: number;
  buttonA: number;
  buttonX: number;
}

declare class GCRotationRate {
  constructor(init?: GCRotationRate);
  x: number;
  y: number;
  z: number;
}

declare function GCGamepadSnapShotDataV100FromNSData(snapshotData: interop.PointerConvertible, data: NSData): boolean;

declare function NSDataFromGCGamepadSnapShotDataV100(snapshotData: interop.PointerConvertible): NSData;

declare function GCExtendedGamepadSnapshotDataFromNSData(snapshotData: interop.PointerConvertible, data: NSData): boolean;

declare function NSDataFromGCExtendedGamepadSnapshotData(snapshotData: interop.PointerConvertible): NSData;

declare function GCExtendedGamepadSnapShotDataV100FromNSData(snapshotData: interop.PointerConvertible, data: NSData): boolean;

declare function NSDataFromGCExtendedGamepadSnapShotDataV100(snapshotData: interop.PointerConvertible): NSData;

declare function GCMicroGamepadSnapshotDataFromNSData(snapshotData: interop.PointerConvertible, data: NSData): boolean;

declare function NSDataFromGCMicroGamepadSnapshotData(snapshotData: interop.PointerConvertible): NSData;

declare function GCMicroGamepadSnapShotDataV100FromNSData(snapshotData: interop.PointerConvertible, data: NSData): boolean;

declare function NSDataFromGCMicroGamepadSnapShotDataV100(snapshotData: interop.PointerConvertible): NSData;

declare interface GCDirectionPadElementName extends GCPhysicalInputElementName {
}

declare class GCDirectionPadElementName extends NativeObject implements GCDirectionPadElementName {
}

declare interface GCSwitchElementName extends GCPhysicalInputElementName {
}

declare class GCSwitchElementName extends NativeObject implements GCSwitchElementName {
}

declare interface GCButtonElementName extends GCPhysicalInputElementName {
}

declare class GCButtonElementName extends NativeObject implements GCButtonElementName {
}

declare interface GCPhysicalInputElementName {
}

declare class GCPhysicalInputElementName extends NativeObject implements GCPhysicalInputElementName {
}

declare interface GCDevice extends NSObjectProtocol {
  handlerQueue: NSObject;

  readonly vendorName: string;

  readonly productCategory: string;

  readonly physicalInputProfile: GCPhysicalInputProfile;
}

declare class GCDevice extends NativeObject implements GCDevice {
}

declare interface GCAxisElementName extends GCPhysicalInputElementName {
}

declare class GCAxisElementName extends NativeObject implements GCAxisElementName {
}

declare class GCKeyboardInput extends GCPhysicalInputProfile {
  keyChangedHandler: (p1: GCKeyboardInput, p2: GCControllerButtonInput, p3: number, p4: boolean) => void;

  readonly anyKeyPressed: boolean;

  buttonForKeyCode(code: number): GCControllerButtonInput | null;

  isAnyKeyPressed(): boolean;
}

declare class GCEventViewController extends NSViewController {
  controllerUserInteractionEnabled: boolean;
}

declare class GCDeviceHaptics extends NSObject {
  readonly supportedLocalities: NSSet;

  createEngineWithLocality(locality: string): CHHapticEngine | null;
}

declare class GCMouse extends NSObject implements GCDevice {
  readonly mouseInput: GCMouseInput;

  static readonly current: GCMouse;

  static mice(): NSArray;

  handlerQueue: NSObject;

  readonly vendorName: string;

  readonly productCategory: string;

  readonly physicalInputProfile: GCPhysicalInputProfile;

  isEqual(object: interop.Object): boolean;

  readonly hash: number;

  readonly superclass: interop.Pointer;

  class(): interop.Pointer;

  self(): this;

  performSelector(aSelector: string): interop.Object;

  performSelectorWithObject(aSelector: string, object: interop.Object): interop.Object;

  performSelectorWithObjectWithObject(aSelector: string, object1: interop.Object, object2: interop.Object): interop.Object;

  readonly isProxy: boolean;

  isKindOfClass(aClass: interop.PointerConvertible): boolean;

  isMemberOfClass(aClass: interop.PointerConvertible): boolean;

  conformsToProtocol(aProtocol: interop.PointerConvertible): boolean;

  respondsToSelector(aSelector: string): boolean;

  retain(): this;

  release(): void;

  autorelease(): this;

  retainCount(): number;

  readonly zone: interop.Pointer;

  readonly description: string;

  readonly debugDescription: string;
}

declare class GCMicroGamepadSnapshot extends GCMicroGamepad {
  snapshotData: NSData;

  initWithSnapshotData(data: NSData): this;

  initWithControllerSnapshotData(controller: GCController, data: NSData): this;
}

declare class GCMicroGamepad extends GCPhysicalInputProfile {
  readonly controller: GCController | null;

  valueChangedHandler: (p1: GCMicroGamepad, p2: GCControllerElement) => void;

  saveSnapshot(): GCMicroGamepadSnapshot;

  readonly dpad: GCControllerDirectionPad;

  readonly buttonA: GCControllerButtonInput;

  readonly buttonX: GCControllerButtonInput;

  readonly buttonMenu: GCControllerButtonInput;

  reportsAbsoluteDpadValues: boolean;

  allowsRotation: boolean;

  setStateFromMicroGamepad(microGamepad: GCMicroGamepad): void;
}

declare class GCDualShockGamepad extends GCExtendedGamepad {
  readonly touchpadButton: GCControllerButtonInput;

  readonly touchpadPrimary: GCControllerDirectionPad;

  readonly touchpadSecondary: GCControllerDirectionPad;
}

declare class GCXboxGamepad extends GCExtendedGamepad {
  readonly paddleButton1: GCControllerButtonInput;

  readonly paddleButton2: GCControllerButtonInput;

  readonly paddleButton3: GCControllerButtonInput;

  readonly paddleButton4: GCControllerButtonInput;
}

declare class GCMouseInput extends GCPhysicalInputProfile {
  mouseMovedHandler: (p1: GCMouseInput, p2: number, p3: number) => void;

  readonly scroll: GCDeviceCursor;

  readonly leftButton: GCControllerButtonInput;

  readonly rightButton: GCControllerButtonInput;

  readonly middleButton: GCControllerButtonInput;

  readonly auxiliaryButtons: NSArray;
}

declare class GCExtendedGamepad extends GCPhysicalInputProfile {
  readonly controller: GCController | null;

  valueChangedHandler: (p1: GCExtendedGamepad, p2: GCControllerElement) => void;

  saveSnapshot(): GCExtendedGamepadSnapshot;

  readonly dpad: GCControllerDirectionPad;

  readonly buttonA: GCControllerButtonInput;

  readonly buttonB: GCControllerButtonInput;

  readonly buttonX: GCControllerButtonInput;

  readonly buttonY: GCControllerButtonInput;

  readonly buttonMenu: GCControllerButtonInput;

  readonly buttonOptions: GCControllerButtonInput;

  readonly buttonHome: GCControllerButtonInput;

  readonly leftThumbstick: GCControllerDirectionPad;

  readonly rightThumbstick: GCControllerDirectionPad;

  readonly leftShoulder: GCControllerButtonInput;

  readonly rightShoulder: GCControllerButtonInput;

  readonly leftTrigger: GCControllerButtonInput;

  readonly rightTrigger: GCControllerButtonInput;

  readonly leftThumbstickButton: GCControllerButtonInput;

  readonly rightThumbstickButton: GCControllerButtonInput;

  setStateFromExtendedGamepad(extendedGamepad: GCExtendedGamepad): void;
}

declare class GCGamepadSnapshot extends GCGamepad {
  snapshotData: NSData;

  initWithSnapshotData(data: NSData): this;

  initWithControllerSnapshotData(controller: GCController, data: NSData): this;
}

declare class GCPhysicalInputProfile extends NSObject {
  readonly device: GCDevice | null;

  readonly lastEventTimestamp: number;

  readonly elements: NSDictionary;

  readonly buttons: NSDictionary;

  readonly axes: NSDictionary;

  readonly dpads: NSDictionary;

  readonly touchpads: NSDictionary;

  readonly allElements: NSSet;

  readonly allButtons: NSSet;

  readonly allAxes: NSSet;

  readonly allDpads: NSSet;

  readonly allTouchpads: NSSet;

  objectForKeyedSubscript(key: string): GCControllerElement | null;

  capture(): this;

  setStateFromPhysicalInput(physicalInput: GCPhysicalInputProfile): void;
}

declare class GCMotion extends NSObject {
  readonly controller: GCController | null;

  valueChangedHandler: (p1: GCMotion) => void;

  readonly sensorsRequireManualActivation: boolean;

  sensorsActive: boolean;

  readonly hasGravityAndUserAcceleration: boolean;

  readonly gravity: GCAcceleration;

  readonly userAcceleration: GCAcceleration;

  readonly acceleration: GCAcceleration;

  readonly hasAttitudeAndRotationRate: boolean;

  readonly hasAttitude: boolean;

  readonly hasRotationRate: boolean;

  readonly attitude: GCQuaternion;

  readonly rotationRate: GCRotationRate;

  setStateFromMotion(motion: GCMotion): void;
}

declare class GCDeviceCursor extends GCControllerDirectionPad {
}

declare class GCControllerDirectionPad extends GCControllerElement {
  valueChangedHandler: (p1: GCControllerDirectionPad, p2: number, p3: number) => void;

  readonly xAxis: GCControllerAxisInput;

  readonly yAxis: GCControllerAxisInput;

  readonly up: GCControllerButtonInput;

  readonly down: GCControllerButtonInput;

  readonly left: GCControllerButtonInput;

  readonly right: GCControllerButtonInput;

  setValueForXAxisYAxis(xAxis: number, yAxis: number): void;
}

declare class GCControllerElement extends NSObject {
  readonly collection: GCControllerElement;

  readonly analog: boolean;

  readonly boundToSystemGesture: boolean;

  preferredSystemGestureState: interop.Enum<typeof GCSystemGestureState>;

  sfSymbolsName: string;

  localizedName: string;

  unmappedSfSymbolsName: string;

  unmappedLocalizedName: string;

  readonly aliases: NSSet;

  isAnalog(): boolean;

  isBoundToSystemGesture(): boolean;
}

declare class GCDeviceLight extends NSObject {
  color: GCColor;
}

declare class GCColor extends NSObject implements NSCopying, NSSecureCoding {
  initWithRedGreenBlue(red: number, green: number, blue: number): this;

  readonly red: number;

  readonly green: number;

  readonly blue: number;

  copyWithZone(zone: interop.PointerConvertible): interop.Object;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class GCControllerButtonInput extends GCControllerElement {
  valueChangedHandler: (p1: GCControllerButtonInput, p2: number, p3: boolean) => void;

  pressedChangedHandler: (p1: GCControllerButtonInput, p2: number, p3: boolean) => void;

  touchedChangedHandler: (p1: GCControllerButtonInput, p2: number, p3: boolean, p4: boolean) => void;

  readonly value: number;

  readonly pressed: boolean;

  readonly touched: boolean;

  isPressed(): boolean;

  isTouched(): boolean;
}

declare class GCControllerAxisInput extends GCControllerElement {
  valueChangedHandler: (p1: GCControllerAxisInput, p2: number) => void;

  readonly value: number;
}

declare class GCControllerTouchpad extends GCControllerElement {
  readonly button: GCControllerButtonInput;

  touchDown: (p1: GCControllerTouchpad, p2: number, p3: number, p4: number, p5: boolean) => void;

  touchMoved: (p1: GCControllerTouchpad, p2: number, p3: number, p4: number, p5: boolean) => void;

  touchUp: (p1: GCControllerTouchpad, p2: number, p3: number, p4: number, p5: boolean) => void;

  readonly touchSurface: GCControllerDirectionPad;

  readonly touchState: interop.Enum<typeof GCTouchState>;

  reportsAbsoluteTouchSurfaceValues: boolean;

  setValueForXAxisYAxisTouchDownButtonValue(xAxis: number, yAxis: number, touchDown: boolean, buttonValue: number): void;
}

declare class GCDeviceBattery extends NSObject {
  readonly batteryLevel: number;

  readonly batteryState: interop.Enum<typeof GCDeviceBatteryState>;
}

declare class GCExtendedGamepadSnapshot extends GCExtendedGamepad {
  snapshotData: NSData;

  initWithSnapshotData(data: NSData): this;

  initWithControllerSnapshotData(controller: GCController, data: NSData): this;
}

declare class GCGamepad extends GCPhysicalInputProfile {
  readonly controller: GCController | null;

  valueChangedHandler: (p1: GCGamepad, p2: GCControllerElement) => void;

  saveSnapshot(): GCGamepadSnapshot;

  readonly dpad: GCControllerDirectionPad;

  readonly buttonA: GCControllerButtonInput;

  readonly buttonB: GCControllerButtonInput;

  readonly buttonX: GCControllerButtonInput;

  readonly buttonY: GCControllerButtonInput;

  readonly leftShoulder: GCControllerButtonInput;

  readonly rightShoulder: GCControllerButtonInput;
}

declare class GCKeyboard extends NSObject implements GCDevice {
  readonly keyboardInput: GCKeyboardInput;

  static readonly coalescedKeyboard: GCKeyboard;

  handlerQueue: NSObject;

  readonly vendorName: string;

  readonly productCategory: string;

  readonly physicalInputProfile: GCPhysicalInputProfile;

  isEqual(object: interop.Object): boolean;

  readonly hash: number;

  readonly superclass: interop.Pointer;

  class(): interop.Pointer;

  self(): this;

  performSelector(aSelector: string): interop.Object;

  performSelectorWithObject(aSelector: string, object: interop.Object): interop.Object;

  performSelectorWithObjectWithObject(aSelector: string, object1: interop.Object, object2: interop.Object): interop.Object;

  readonly isProxy: boolean;

  isKindOfClass(aClass: interop.PointerConvertible): boolean;

  isMemberOfClass(aClass: interop.PointerConvertible): boolean;

  conformsToProtocol(aProtocol: interop.PointerConvertible): boolean;

  respondsToSelector(aSelector: string): boolean;

  retain(): this;

  release(): void;

  autorelease(): this;

  retainCount(): number;

  readonly zone: interop.Pointer;

  readonly description: string;

  readonly debugDescription: string;
}

declare class GCController extends NSObject implements GCDevice {
  static controllers(): NSArray;

  static readonly current: GCController;

  controllerPausedHandler: (p1: GCController) => void;

  readonly attachedToDevice: boolean;

  playerIndex: interop.Enum<typeof GCControllerPlayerIndex>;

  readonly battery: GCDeviceBattery;

  readonly physicalInputProfile: GCPhysicalInputProfile;

  readonly gamepad: GCGamepad;

  readonly microGamepad: GCMicroGamepad;

  readonly extendedGamepad: GCExtendedGamepad;

  readonly motion: GCMotion;

  readonly light: GCDeviceLight;

  readonly haptics: GCDeviceHaptics;

  static supportsHIDDevice(device: interop.Object): boolean;

  isAttachedToDevice(): boolean;

  readonly snapshot: boolean;

  capture(): GCController;

  static controllerWithMicroGamepad(): GCController;

  static controllerWithExtendedGamepad(): GCController;

  isSnapshot(): boolean;

  static startWirelessControllerDiscoveryWithCompletionHandler(completionHandler: () => void | null): void;

  static stopWirelessControllerDiscovery(): void;

  handlerQueue: NSObject;

  readonly vendorName: string;

  readonly productCategory: string;

  isEqual(object: interop.Object): boolean;

  readonly hash: number;

  readonly superclass: interop.Pointer;

  class(): interop.Pointer;

  self(): this;

  performSelector(aSelector: string): interop.Object;

  performSelectorWithObject(aSelector: string, object: interop.Object): interop.Object;

  performSelectorWithObjectWithObject(aSelector: string, object1: interop.Object, object2: interop.Object): interop.Object;

  readonly isProxy: boolean;

  isKindOfClass(aClass: interop.PointerConvertible): boolean;

  isMemberOfClass(aClass: interop.PointerConvertible): boolean;

  conformsToProtocol(aProtocol: interop.PointerConvertible): boolean;

  respondsToSelector(aSelector: string): boolean;

  retain(): this;

  release(): void;

  autorelease(): this;

  retainCount(): number;

  readonly zone: interop.Pointer;

  readonly description: string;

  readonly debugDescription: string;
}

