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

declare const GCProductCategoryArcadeStick: string;

declare const GCKeyRightShift: string;

declare const GCKeyF12: string;

declare const GCInputButtonB: string;

declare const GCKeyInsert: string;

declare const GCKeyCodePeriod: number;

declare const GCKeyCodeDeleteForward: number;

declare const GCKeyCodeHome: number;

declare const GCKeyCodeInternational3: number;

declare const GCKeyLANG9: string;

declare const GCInputRightBumper: string;

declare const GCKeyCodeF9: number;

declare const GCKeyCodeF3: number;

declare const GCKeyCodeKeypad7: number;

declare const GCProductCategoryMouse: string;

declare const GCHapticsLocalityAll: string;

declare const GCKeyRightAlt: string;

declare const GCKeyCodeZero: number;

declare const GCInputMicroGamepadButtonMenu: string;

declare const GCInputDirectionalCardinalDpad: string;

declare const GCKeyKeypadHyphen: string;

declare const GCInputMicroGamepadButtonX: string;

declare const GCKeyCodeBackslash: number;

declare const GCKeyCodeGraveAccentAndTilde: number;

declare const GCKeyCodeLeftAlt: number;

declare const GCKeyCodeInternational4: number;

declare const GCKeyCodeLeftShift: number;

declare const GCInputDualShockTouchpadOne: string;

declare const GCKeyCodeKeypadAsterisk: number;

declare const GCKeyM: string;

declare const GCKeyCodeLANG3: number;

declare const GCMouseDidBecomeCurrentNotification: string;

declare const GCControllerDidConnectNotification: string;

declare const GCKeyPrintScreen: string;

declare const GCKeyF3: string;

declare const GCMouseDidStopBeingCurrentNotification: string;

declare const GCKeyCodeKeypad4: number;

declare const GCInputRightTrigger: string;

declare const GCKeyK: string;

declare const GCInputDualShockTouchpadTwo: string;

declare const GCKeyCodeF15: number;

declare const GCKeyNonUSBackslash: string;

declare const GCProductCategoryMFi: string;

declare const GCKeyPower: string;

declare const GCHapticDurationInfinite: number;

declare const GCHapticsLocalityLeftTrigger: string;

declare const GCHapticsLocalityRightHandle: string;

declare const GCHapticsLocalityLeftHandle: string;

declare const GCMouseDidDisconnectNotification: string;

declare const GCMouseDidConnectNotification: string;

declare const GCControllerUserCustomizationsDidChangeNotification: string;

declare const GCControllerDidStopBeingCurrentNotification: string;

declare const GCControllerDidBecomeCurrentNotification: string;

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

declare const GCInputMicroGamepadButtonA: string;

declare const GCInputMicroGamepadDpad: string;

declare const GCKeyRightControl: string;

declare const GCKeyLeftGUI: string;

declare const GCKeyLeftAlt: string;

declare const GCKeyLeftShift: string;

declare const GCKeyLeftControl: string;

declare const GCKeyLANG7: string;

declare const GCKeyLANG4: string;

declare const GCKeyLANG1: string;

declare const GCKeyInternational8: string;

declare const GCKeyInternational7: string;

declare const GCKeyInternational6: string;

declare const GCKeyInternational5: string;

declare const GCKeyInternational4: string;

declare const GCKeyKeypadEqualSign: string;

declare const GCKeyKeypad9: string;

declare const GCKeyKeypad8: string;

declare const GCKeyKeypad7: string;

declare const GCKeyKeypad6: string;

declare const GCKeyKeypadEnter: string;

declare const GCKeyKeypadPlus: string;

declare const GCKeyKeypadAsterisk: string;

declare const GCKeyKeypadSlash: string;

declare const GCKeyDownArrow: string;

declare const GCKeyRightArrow: string;

declare const GCKeyDeleteForward: string;

declare const GCKeyPageUp: string;

declare const GCKeyHome: string;

declare const GCKeyPause: string;

declare const GCKeyScrollLock: string;

declare const GCKeyF19: string;

declare const GCKeyF18: string;

declare const GCKeyF17: string;

declare const GCKeyF16: string;

declare const GCKeyF14: string;

declare const GCKeyF13: string;

declare const GCKeyF11: string;

declare const GCKeyF8: string;

declare const GCKeyF7: string;

declare const GCKeyF6: string;

declare const GCKeyF4: string;

declare const GCKeyF2: string;

declare const GCKeyCapsLock: string;

declare const GCKeySlash: string;

declare const GCKeyPeriod: string;

declare const GCKeyComma: string;

declare const GCKeyGraveAccentAndTilde: string;

declare const GCKeyQuote: string;

declare const GCKeySemicolon: string;

declare const GCKeyBackslash: string;

declare const GCKeyCloseBracket: string;

declare const GCKeyEqualSign: string;

declare const GCKeySpacebar: string;

declare const GCKeyD: string;

declare const GCKeyTab: string;

declare const GCKeyDeleteOrBackspace: string;

declare const GCKeyZero: string;

declare const GCKeyNine: string;

declare const GCKeySeven: string;

declare const GCKeyFive: string;

declare const GCKeyThree: string;

declare const GCKeyOne: string;

declare const GCKeyY: string;

declare const GCKeyX: string;

declare const GCKeyV: string;

declare const GCKeyT: string;

declare const GCKeyQ: string;

declare const GCKeyO: string;

declare const GCKeyN: string;

declare const GCKeyL: string;

declare const GCKeyI: string;

declare const GCKeyH: string;

declare const GCKeyF: string;

declare const GCKeyC: string;

declare const GCKeyA: string;

declare const GCKeyCodeRightShift: number;

declare const GCKeyCodeRightControl: number;

declare const GCKeyCodeLeftControl: number;

declare const GCKeyCodeLANG9: number;

declare const GCKeyCodeLANG8: number;

declare const GCKeyCodeKeypadNumLock: number;

declare const GCKeyCodeLANG6: number;

declare const GCKeyCodeLANG5: number;

declare const GCKeyCodeLANG2: number;

declare const GCKeyCodeInternational8: number;

declare const GCKeyCodeInternational6: number;

declare const GCKeyCodeInternational2: number;

declare const GCKeyCodeApplication: number;

declare const GCKeyCodeKeypad0: number;

declare const GCKeyCodeKeypad3: number;

declare const GCKeyCodeKeypad1: number;

declare const GCKeyCodeKeypadEnter: number;

declare const GCKeyCodeKeypadPlus: number;

declare const GCKeyCodeEnd: number;

declare const GCKeyCodePageUp: number;

declare const GCKeyCodeF20: number;

declare const GCKeyCodeF18: number;

declare const GCKeyCodeF17: number;

declare const GCKeyCodeF14: number;

declare const GCKeyCodeF13: number;

declare const GCKeyCodeF11: number;

declare const GCKeyCodeF10: number;

declare const GCKeyCodeSlash: number;

declare const GCKeyCodeComma: number;

declare const GCKeyCodeQuote: number;

declare const GCKeyCodeSemicolon: number;

declare const GCKeyCodeNonUSPound: number;

declare const GCKeyCodeDeleteOrBackspace: number;

declare const GCKeyCodeEscape: number;

declare const GCKeyCodeNine: number;

declare const GCKeyCodeEight: number;

declare const GCKeyCodeFour: number;

declare const GCKeyCodeThree: number;

declare const GCKeyCodeOne: number;

declare const GCKeyCodeKeyW: number;

declare const GCKeyCodeKeyV: number;

declare const GCKeyCodeKeyP: number;

declare const GCKeyCodeKeyJ: number;

declare const GCKeyCodeKeyF: number;

declare const GCKeyCodeKeyE: number;

declare const GCKeyCodeKeyB: number;

declare const GCInputButtonShare: string;

declare const GCInputButtonHome: string;

declare const GCInputLeftTrigger: string;

declare const GCInputTrigger: string;

declare const GCInputGripButton: string;

declare const GCInputRightThumbstickButton: string;

declare const GCInputThumbstickButton: string;

declare const GCInputButtonY: string;

declare const GCInputButtonX: string;

declare const GCProductCategoryCoalescedRemote: string;

declare const GCProductCategoryUniversalElectronicsRemote: string;

declare const GCPoint2Zero: GCPoint2;

declare const GCKeyCodeKeyT: number;

declare const GCKeyCodeKeyH: number;

declare const GCKeyG: string;

declare const GCKeyCodeSix: number;

declare const GCKeyCodeLANG7: number;

declare const GCProductCategoryDualSense: string;

declare const GCKeyCodeKeypadSlash: number;

declare const GCKeyCodeOpenBracket: number;

declare const GCKeyCodePrintScreen: number;

declare const GCKeyCodeFive: number;

declare const GCKeyLANG6: string;

declare const GCKeyR: string;

declare const GCKeyB: string;

declare const GCKeyCodeInternational1: number;

declare const GCKeyCodeF12: number;

declare const GCKeyCodeKeyL: number;

declare const GCKeyCodeKeyX: number;

declare const GCKeyCodeF2: number;

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

declare const GCKeyCodeKeyG: number;

declare const GCKeyEnd: string;

declare const GCKeyCodeF7: number;

declare const GCKeyCodeKeyY: number;

declare const GCKeyLeftArrow: string;

declare const GCKeyCodeF16: number;

declare const GCInputXboxPaddleFour: string;

declare const GCKeyCodeKeyU: number;

declare const GCProductCategoryControlCenterRemote: string;

declare const GCKeyInternational3: string;

declare const GCKeyCodeRightArrow: number;

declare const GCKeyCodeKeypad5: number;

declare const GCInputDirectionPad: string;

declare const GCKeyCodeReturnOrEnter: number;

declare const GCKeyLANG3: string;

declare const GCKeyF10: string;

declare const GCKeyCodeKeyK: number;

declare const GCKeyCodeInternational7: number;

declare const GCKeyCodeF8: number;

declare const GCKeyF1: string;

declare const GCInputLeftBumper: string;

declare const GCKeySix: string;

declare const GCKeyCodeEqualSign: number;

declare const GCKeyKeypad5: string;

declare const GCKeyCodeF1: number;

declare const GCInputLeftThumbstickButton: string;

declare const GCInputRightThumbstick: string;

declare const GCKeyCodeF5: number;

declare const GCKeyF5: string;

declare const GCKeyCodeKeypad9: number;

declare const GCInputXboxPaddleTwo: string;

declare const GCKeyOpenBracket: string;

declare const GCKeyF9: string;

declare const GCKeyKeypad2: string;

declare const GCKeyCodeLANG1: number;

declare const GCKeyCodeKeyZ: number;

declare const GCProductCategoryKeyboard: string;

declare const GCProductCategorySiriRemote2ndGen: string;

declare const GCInputButtonMenu: string;

declare const GCKeyCodeKeyN: number;

declare const GCControllerDidDisconnectNotification: string;

declare const GCKeyCodeHyphen: number;

declare const GCProductCategoryHID: string;

declare const GCKeyCodeKeypadPeriod: number;

declare const GCKeyCodeF19: number;

declare const GCInputRightShoulder: string;

declare const GCKeyNonUSPound: string;

declare const GCKeyCodeKeypadEqualSign: number;

declare const GCKeyCodeRightAlt: number;

declare const GCKeyCodePower: number;

declare const GCHapticsLocalityTriggers: string;

declare const GCKeyCodeKeypadHyphen: number;

declare const GCProductCategorySiriRemote1stGen: string;

declare const GCKeyCodeKeypad2: number;

declare const GCKeyJ: string;

declare const GCKeyCodeInternational5: number;

declare const GCKeyCodeNonUSBackslash: number;

declare const GCInputLeftShoulder: string;

declare const GCKeyCodeKeyA: number;

declare const GCKeyEscape: string;

declare const GCKeyCodeInternational9: number;

declare const GCDualSenseAdaptiveTriggerDiscretePositionCount: number;

declare const GCKeyKeypad1: string;

declare const GCKeyboardDidDisconnectNotification: string;

declare const GCKeyLANG8: string;

declare const GCKeyZ: string;

declare const GCKeyF20: string;

declare const GCKeyCodePageDown: number;

declare const GCKeyCodePause: number;

declare const GCKeyW: string;

declare const GCKeyCodeLANG4: number;

declare const GCKeyInternational9: string;

declare const GCKeyCodeScrollLock: number;

declare const GCKeyCodeTwo: number;

declare const GCKeyTwo: string;

declare const GCKeyKeypad0: string;

declare const GCKeyCodeLeftGUI: number;

declare const GCKeyKeypad3: string;

declare const GCKeyKeypadNumLock: string;

declare const GCKeyCodeKeyD: number;

declare const GCProductCategorySpatialController: string;

declare const GCInputLeftThumbstick: string;

declare const GCKeyCodeSpacebar: number;

declare const GCKeyCodeTab: number;

declare const GCKeyLANG2: string;

declare const GCKeyCodeCloseBracket: number;

declare const GCKeyCodeKeyO: number;

declare const GCKeyInternational2: string;

declare const GCKeyCodeF6: number;

declare const GCKeyRightGUI: string;

declare const GCInputXboxPaddleThree: string;

declare const GCInputDualShockTouchpadButton: string;

declare const GCHapticsLocalityDefault: string;

declare const GCKeyF15: string;

declare const GCKeyKeypad4: string;

declare const GCKeyReturnOrEnter: string;

declare const GCHapticsLocalityHandles: string;

declare const GCKeyCodeInsert: number;

declare const GCKeyCodeF4: number;

declare const GCKeyU: string;

declare const GCKeyCodeCapsLock: number;

declare const GCProductCategoryXboxOne: string;

declare const GCKeyboardDidConnectNotification: string;

declare const GCKeyCodeLeftArrow: number;

declare const GCKeyCodeKeyS: number;

declare const GCInputButtonOptions: string;

declare const GCKeyCodeKeypad6: number;

declare const GCKeyCodeSeven: number;

declare const GCInputDirectionalDpad: string;

declare const GCKeyApplication: string;

declare const GCKeyCodeKeyC: number;

declare const GCKeyE: string;

declare const GCInputThumbstick: string;

declare const GCInputDirectionalCenterButton: string;

declare const GCKeyLANG5: string;

declare const GCInputButtonA: string;

declare const GCKeyInternational1: string;

declare const GCKeyPageDown: string;

declare const GCKeyCodeUpArrow: number;

declare const GCKeyEight: string;

declare const GCKeyCodeKeyR: number;

declare const GCProductCategoryDualShock4: string;

declare const GCKeyS: string;

declare const GCKeyFour: string;

declare const GCKeyCodeKeyI: number;

declare const GCInputDirectionalTouchSurfaceButton: string;

declare const GCKeyP: string;

declare const GCInputXboxPaddleOne: string;

declare const GCKeyUpArrow: string;

declare const GCKeyCodeDownArrow: number;

declare const GCKeyHyphen: string;

declare const GCKeyKeypadPeriod: string;

declare const GCKeyCodeRightGUI: number;

declare const GCHapticsLocalityRightTrigger: string;

declare const GCKeyCodeKeypad8: number;

declare const GCKeyCodeKeyQ: number;

declare const GCKeyCodeKeyM: number;

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

declare const GCDualSenseAdaptiveTriggerStatus: {
  Unknown: -1,
  FeedbackNoLoad: 0,
  FeedbackLoadApplied: 1,
  WeaponReady: 2,
  WeaponFiring: 3,
  WeaponFired: 4,
  VibrationNotVibrating: 5,
  VibrationIsVibrating: 6,
  SlopeFeedbackReady: 7,
  SlopeFeedbackApplyingLoad: 8,
  SlopeFeedbackFinished: 9,
};

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

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

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

declare const GCDevicePhysicalInputElementChange: {
  UnknownChange: -1,
  NoChange: 0,
  Changed: 1,
};

declare const GCMicroGamepadSnapshotDataVersion: {
  GCMicroGamepadSnapshotDataVersion1: 256,
};

declare const GCUIEventTypes: {
  None: 0,
  Gamepad: 1,
};

declare const GCDualSenseAdaptiveTriggerMode: {
  Off: 0,
  Feedback: 1,
  Weapon: 2,
  Vibration: 3,
  SlopeFeedback: 4,
};

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

declare const GCPhysicalInputSourceDirection: {
  NotApplicable: 0,
  Up: 1,
  Right: 2,
  Down: 4,
  Left: 8,
};

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 GCQuaternion {
  constructor(init?: GCQuaternion);
  x: number;
  y: number;
  z: number;
  w: number;
}

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

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

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 GCPoint2 {
  constructor(init?: GCPoint2);
  x: number;
  y: number;
}

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

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 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 GCDualSenseAdaptiveTriggerPositionalResistiveStrengths {
  constructor(init?: GCDualSenseAdaptiveTriggerPositionalResistiveStrengths);
  values: unknown /* const array */;
}

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

declare function NSStringFromGCPoint2(point: GCPoint2): string;

declare function GCInputBackLeftButton(position: number): string;

declare function GCInputBackRightButton(position: number): string;

declare function GCInputArcadeButtonName(row: number, column: number): string;

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 GCPhysicalInputElement extends NSObjectProtocol {
  readonly aliases: NSSet;

  readonly localizedName: string;

  readonly sfSymbolsName: string;
}

declare class GCPhysicalInputElement extends NativeObject implements GCPhysicalInputElement {
}

declare interface GCAxis2DInput extends NSObjectProtocol {
  valueDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCAxis2DInput, p3: GCPoint2) => void;

  readonly value: GCPoint2;

  readonly analog: boolean;

  readonly canWrap: boolean;

  readonly lastValueTimestamp: number;

  readonly lastValueLatency: number;

  readonly sources: NSSet;

  setValueDidChangeHandler(valueDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCAxis2DInput, p3: GCPoint2) => void | null): void;

  isAnalog(): boolean;
}

declare class GCAxis2DInput extends NativeObject implements GCAxis2DInput {
}

declare interface GCPhysicalInputElementName {
}

declare class GCPhysicalInputElementName extends NativeObject implements GCPhysicalInputElementName {
}

declare interface GCPhysicalInputExtents extends NSObjectProtocol {
  readonly scaledValue: number;

  readonly minimumValue: number;

  readonly maximumValue: number;
}

declare class GCPhysicalInputExtents extends NativeObject implements GCPhysicalInputExtents {
}

declare interface GCPhysicalInputSource extends NSObjectProtocol {
  readonly elementAliases: NSSet;

  readonly elementLocalizedName: string;

  readonly sfSymbolsName: string;

  readonly direction: interop.Enum<typeof GCPhysicalInputSourceDirection>;
}

declare class GCPhysicalInputSource extends NativeObject implements GCPhysicalInputSource {
}

declare interface GCDevicePhysicalInputStateDiff extends NSObjectProtocol {
  changeForElement(element: GCPhysicalInputElement): interop.Enum<typeof GCDevicePhysicalInputElementChange>;

  changedElements(): NSEnumerator;
}

declare class GCDevicePhysicalInputStateDiff extends NativeObject implements GCDevicePhysicalInputStateDiff {
}

declare interface GCDirectionPadElement extends GCPhysicalInputElement {
  readonly xyAxes: GCAxis2DInput;

  readonly xAxis: GCAxisInput;

  readonly yAxis: GCAxisInput;

  readonly up: GCLinearInput;

  readonly down: GCLinearInput;

  readonly left: GCLinearInput;

  readonly right: GCLinearInput;
}

declare class GCDirectionPadElement extends NativeObject implements GCDirectionPadElement {
}

declare interface GCSwitchElement extends GCPhysicalInputElement {
  readonly positionInput: GCSwitchPositionInput;
}

declare class GCSwitchElement extends NativeObject implements GCSwitchElement {
}

declare interface GCSwitchPositionInput extends NSObjectProtocol {
  positionDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCSwitchPositionInput, p3: number) => void;

  readonly position: number;

  readonly positionRange: _NSRange;

  readonly sequential: boolean;

  readonly canWrap: boolean;

  readonly lastPositionTimestamp: number;

  readonly lastPositionLatency: number;

  readonly sources: NSSet;

  setPositionDidChangeHandler(positionDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCSwitchPositionInput, p3: number) => void | null): void;

  isSequential(): boolean;
}

declare class GCSwitchPositionInput extends NativeObject implements GCSwitchPositionInput {
}

declare interface GCAxisElement extends GCPhysicalInputElement {
  readonly absoluteInput: GCAxisInput;

  readonly relativeInput: GCRelativeInput;
}

declare class GCAxisElement extends NativeObject implements GCAxisElement {
}

declare interface GCRelativeInput extends NSObjectProtocol {
  deltaDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCRelativeInput, p3: number) => void;

  readonly delta: number;

  readonly analog: boolean;

  readonly lastDeltaTimestamp: number;

  readonly lastDeltaLatency: number;

  readonly sources: NSSet;

  setDeltaDidChangeHandler(deltaDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCRelativeInput, p3: number) => void | null): void;

  isAnalog(): boolean;
}

declare class GCRelativeInput extends NativeObject implements GCRelativeInput {
}

declare interface GCAxisInput extends NSObjectProtocol {
  valueDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCAxisInput, p3: number) => void;

  readonly value: number;

  readonly analog: boolean;

  readonly canWrap: boolean;

  readonly lastValueTimestamp: number;

  readonly lastValueLatency: number;

  readonly sources: NSSet;

  setValueDidChangeHandler(valueDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCAxisInput, p3: number) => void | null): void;

  isAnalog(): boolean;
}

declare class GCAxisInput extends NativeObject implements GCAxisInput {
}

declare interface GCLinearInput extends NSObjectProtocol {
  valueDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCLinearInput, p3: number) => void;

  readonly value: number;

  readonly analog: boolean;

  readonly canWrap: boolean;

  readonly lastValueTimestamp: number;

  readonly lastValueLatency: number;

  readonly physicalExtents: GCPhysicalInputExtents;

  readonly sources: NSSet;

  setValueDidChangeHandler(valueDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCLinearInput, p3: number) => void | null): void;

  isAnalog(): boolean;
}

declare class GCLinearInput extends NativeObject implements GCLinearInput {
}

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 GCDevice extends NSObjectProtocol {
  handlerQueue: NSObject;

  readonly vendorName: string;

  readonly productCategory: string;

  readonly physicalInputProfile: GCPhysicalInputProfile;

  setHandlerQueue(handlerQueue: NSObject): void;
}

declare class GCDevice extends NativeObject implements GCDevice {
}

declare interface GCGameControllerSceneDelegate extends NSObjectProtocol {
  sceneDidActivateGameControllerWithContext(scene: UIScene, context: GCGameControllerActivationContext): void;
}

declare class GCGameControllerSceneDelegate extends NativeObject implements GCGameControllerSceneDelegate {
}

declare interface GCDevicePhysicalInputState extends NSObjectProtocol {
  readonly device: GCDevice | null;

  readonly lastEventTimestamp: number;

  readonly lastEventLatency: number;

  readonly elements: GCPhysicalInputElementCollection;

  readonly buttons: GCPhysicalInputElementCollection;

  readonly axes: GCPhysicalInputElementCollection;

  readonly switches: GCPhysicalInputElementCollection;

  readonly dpads: GCPhysicalInputElementCollection;

  objectForKeyedSubscript(key: string): GCPhysicalInputElement | null;
}

declare class GCDevicePhysicalInputState extends NativeObject implements GCDevicePhysicalInputState {
}

declare interface GCAxisElementName extends GCPhysicalInputElementName {
}

declare class GCAxisElementName extends NativeObject implements GCAxisElementName {
}

declare interface GCButtonElement extends GCPhysicalInputElement {
  readonly pressedInput: GCLinearInput;

  readonly touchedInput: GCTouchedStateInput;

  readonly forceInput: GCLinearInput;
}

declare class GCButtonElement extends NativeObject implements GCButtonElement {
}

declare interface GCDevicePhysicalInput extends GCDevicePhysicalInputState {
  readonly device: GCDevice | null;

  queue: NSObject;

  elementValueDidChangeHandler: (p1: GCDevicePhysicalInput, p2: GCPhysicalInputElement) => void;

  capture(): GCDevicePhysicalInputState;

  inputStateAvailableHandler: (p1: GCDevicePhysicalInput) => void;

  inputStateQueueDepth: number;

  nextInputState(): GCDevicePhysicalInputState;

  setQueue(queue: NSObject | null): void;

  setElementValueDidChangeHandler(elementValueDidChangeHandler: (p1: GCDevicePhysicalInput, p2: GCPhysicalInputElement) => void | null): void;

  setInputStateAvailableHandler(inputStateAvailableHandler: (p1: GCDevicePhysicalInput) => void | null): void;

  setInputStateQueueDepth(inputStateQueueDepth: number): void;
}

declare class GCDevicePhysicalInput extends NativeObject implements GCDevicePhysicalInput {
}

declare interface GCTouchedStateInput extends NSObjectProtocol {
  touchedDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCTouchedStateInput, p3: boolean) => void;

  readonly touched: boolean;

  readonly lastTouchedStateTimestamp: number;

  readonly lastTouchedStateLatency: number;

  readonly sources: NSSet;

  setTouchedDidChangeHandler(touchedDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCTouchedStateInput, p3: boolean) => void | null): void;

  isTouched(): boolean;
}

declare class GCTouchedStateInput extends NativeObject implements GCTouchedStateInput {
}

declare interface GCPressedStateInput extends NSObjectProtocol {
  pressedDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCPressedStateInput, p3: boolean) => void;

  readonly pressed: boolean;

  readonly lastPressedStateTimestamp: number;

  readonly lastPressedStateLatency: number;

  readonly sources: NSSet;

  setPressedDidChangeHandler(pressedDidChangeHandler: (p1: GCPhysicalInputElement, p2: GCPressedStateInput, p3: boolean) => void | null): void;

  isPressed(): boolean;
}

declare class GCPressedStateInput extends NativeObject implements GCPressedStateInput {
}

declare class GCEventViewController extends UIViewController {
  controllerUserInteractionEnabled: boolean;

  setControllerUserInteractionEnabled(controllerUserInteractionEnabled: boolean): void;
}

declare class GCDeviceLight extends NSObject {
  color: GCColor;

  setColor(color: GCColor): void;
}

declare class GCControllerInputState extends NSObject implements GCDevicePhysicalInputState {
  readonly device: GCDevice | null;

  readonly lastEventTimestamp: number;

  readonly lastEventLatency: number;

  readonly elements: GCPhysicalInputElementCollection;

  readonly buttons: GCPhysicalInputElementCollection;

  readonly axes: GCPhysicalInputElementCollection;

  readonly switches: GCPhysicalInputElementCollection;

  readonly dpads: GCPhysicalInputElementCollection;

  objectForKeyedSubscript(key: string): GCPhysicalInputElement | null;

  isEqual(object: interop.Object): boolean;

  readonly hash: number;

  readonly superclass: interop.Object;

  class(): interop.Object;

  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.Object): boolean;

  isMemberOfClass(aClass: interop.Object): 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 GCVirtualController extends NSObject {
  static virtualControllerWithConfiguration(configuration: GCVirtualControllerConfiguration): GCVirtualController;

  initWithConfiguration(configuration: GCVirtualControllerConfiguration): this;

  connectWithReplyHandler(reply: (p1: NSError) => void | null): void;

  disconnect(): void;

  readonly controller: GCController;

  updateConfigurationForElementConfiguration(element: string, config: (p1: GCVirtualControllerElementConfiguration) => GCVirtualControllerElementConfiguration): void;

  setValueForButtonElement(value: number, element: string): void;

  setPositionForDirectionPadElement(position: CGPoint, element: string): void;
}

declare class GCEventInteraction extends NSObject {
  init(): this;

  handledEventTypes: interop.Enum<typeof GCUIEventTypes>;

  receivesEventsInView: boolean;

  setHandledEventTypes(handledEventTypes: interop.Enum<typeof GCUIEventTypes>): void;

  setReceivesEventsInView(receivesEventsInView: boolean): void;
}

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;

  setHandlerQueue(handlerQueue: NSObject): void;

  isEqual(object: interop.Object): boolean;

  readonly hash: number;

  readonly superclass: interop.Object;

  class(): interop.Object;

  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.Object): boolean;

  isMemberOfClass(aClass: interop.Object): 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 GCDirectionalGamepad extends GCMicroGamepad {
}

declare class GCMicroGamepadSnapshot extends GCMicroGamepad {
  snapshotData: NSData;

  initWithSnapshotData(data: NSData): this;

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

  setSnapshotData(snapshotData: NSData): void;
}

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;

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

  setReportsAbsoluteDpadValues(reportsAbsoluteDpadValues: boolean): void;

  setAllowsRotation(allowsRotation: boolean): void;
}

// @ts-ignore ClassDecl.tsIgnore
declare class GCDualSenseGamepad extends GCExtendedGamepad {
  readonly touchpadButton: GCControllerButtonInput;

  readonly touchpadPrimary: GCControllerDirectionPad;

  readonly touchpadSecondary: GCControllerDirectionPad;

  // @ts-ignore MemberDecl.tsIgnore
  readonly leftTrigger: GCDualSenseAdaptiveTrigger;

  // @ts-ignore MemberDecl.tsIgnore
  readonly rightTrigger: GCDualSenseAdaptiveTrigger;
}

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;

  readonly buttonShare: GCControllerButtonInput;
}

declare class GCExtendedGamepadSnapshot extends GCExtendedGamepad {
  snapshotData: NSData;

  initWithSnapshotData(data: NSData): this;

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

  setSnapshotData(snapshotData: NSData): void;
}

declare class GCGamepadSnapshot extends GCGamepad {
  snapshotData: NSData;

  initWithSnapshotData(data: NSData): this;

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

  setSnapshotData(snapshotData: NSData): 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;

  setGravity(gravity: GCAcceleration): void;

  setUserAcceleration(userAcceleration: GCAcceleration): void;

  setAcceleration(acceleration: GCAcceleration): void;

  setAttitude(attitude: GCQuaternion): void;

  setRotationRate(rotationRate: GCRotationRate): void;

  setStateFromMotion(motion: GCMotion): void;

  setValueChangedHandler(valueChangedHandler: (p1: GCMotion) => void | null): void;

  setSensorsActive(sensorsActive: boolean): void;
}

declare class GCDualSenseAdaptiveTrigger extends GCControllerButtonInput {
  readonly mode: interop.Enum<typeof GCDualSenseAdaptiveTriggerMode>;

  readonly status: interop.Enum<typeof GCDualSenseAdaptiveTriggerStatus>;

  readonly armPosition: number;

  setModeSlopeFeedbackWithStartPositionEndPositionStartStrengthEndStrength(startPosition: number, endPosition: number, startStrength: number, endStrength: number): void;

  setModeFeedbackWithStartPositionResistiveStrength(startPosition: number, resistiveStrength: number): void;

  setModeFeedbackWithResistiveStrengths(positionalResistiveStrengths: GCDualSenseAdaptiveTriggerPositionalResistiveStrengths): void;

  setModeWeaponWithStartPositionEndPositionResistiveStrength(startPosition: number, endPosition: number, resistiveStrength: number): void;

  setModeVibrationWithStartPositionAmplitudeFrequency(startPosition: number, amplitude: number, frequency: number): void;

  setModeVibrationWithAmplitudesFrequency(positionalAmplitudes: GCDualSenseAdaptiveTriggerPositionalAmplitudes, frequency: number): void;

  setModeOff(): void;
}

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;

  setValueChangedHandler(valueChangedHandler: (p1: GCControllerDirectionPad, p2: number, p3: number) => void | null): 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;

  setPreferredSystemGestureState(preferredSystemGestureState: interop.Enum<typeof GCSystemGestureState>): void;

  setSfSymbolsName(sfSymbolsName: string | null): void;

  setLocalizedName(localizedName: string | null): void;

  setUnmappedSfSymbolsName(unmappedSfSymbolsName: string | null): void;

  setUnmappedLocalizedName(unmappedLocalizedName: string | null): void;
}

declare class GCDeviceBattery extends NSObject {
  readonly batteryLevel: number;

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

declare class GCPhysicalInputElementCollection<Key = interop.Object, Element = interop.Object> extends NSObject implements NSFastEnumeration {
  readonly count: number;

  elementForAlias(alias: Key): Element | null;

  objectForKeyedSubscript(key: Key): Element | null;

  elementEnumerator(): NSEnumerator;

  countByEnumeratingWithStateObjectsCount(state: interop.PointerConvertible, buffer: interop.PointerConvertible, len: number): number;

  readonly [Symbol.iterator]: () => Iterator<any>;

}

declare class GCVirtualControllerConfiguration extends NSObject {
  elements: NSSet;

  hidden: boolean;

  setElements(elements: NSSet): void;

  isHidden(): boolean;

  setHidden(hidden: boolean): void;
}

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

  readonly anyKeyPressed: boolean;

  buttonForKeyCode(code: number): GCControllerButtonInput | null;

  setKeyChangedHandler(keyChangedHandler: (p1: GCKeyboardInput, p2: GCControllerButtonInput, p3: number, p4: boolean) => void | null): void;

  isAnyKeyPressed(): boolean;
}

declare class GCGameControllerActivationContext extends NSObject {
  readonly previousApplicationBundleID: string;
}

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

  readonly lastEventTimestamp: number;

  readonly hasRemappedElements: boolean;

  valueDidChangeHandler: (p1: GCPhysicalInputProfile, p2: GCControllerElement) => void;

  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;

  mappedElementAliasForPhysicalInputName(inputName: string): string;

  mappedPhysicalInputNamesForElementAlias(elementAlias: string): NSSet;

  setValueDidChangeHandler(valueDidChangeHandler: (p1: GCPhysicalInputProfile, p2: GCControllerElement) => void | null): void;
}

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 GCDeviceHaptics extends NSObject {
  readonly supportedLocalities: NSSet;

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

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;

  setValue(value: number): void;

  setValueChangedHandler(valueChangedHandler: (p1: GCControllerButtonInput, p2: number, p3: boolean) => void | null): void;

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

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

  isPressed(): boolean;

  isTouched(): boolean;
}

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;

  setValueChangedHandler(valueChangedHandler: (p1: GCExtendedGamepad, p2: GCControllerElement) => void | null): void;
}

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;

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

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

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

  setReportsAbsoluteTouchSurfaceValues(reportsAbsoluteTouchSurfaceValues: boolean): void;
}

declare class GCVirtualControllerElementConfiguration extends NSObject {
  hidden: boolean;

  path: UIBezierPath;

  actsAsTouchpad: boolean;

  isHidden(): boolean;

  setHidden(hidden: boolean): void;

  setPath(path: UIBezierPath | null): void;

  setActsAsTouchpad(actsAsTouchpad: boolean): void;
}

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;

  setMouseMovedHandler(mouseMovedHandler: (p1: GCMouseInput, p2: number, p3: number) => void | null): void;
}

declare class GCDeviceCursor extends GCControllerDirectionPad {
}

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

  readonly value: number;

  setValue(value: number): void;

  setValueChangedHandler(valueChangedHandler: (p1: GCControllerAxisInput, p2: number) => void | null): void;
}

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

  static readonly current: GCController;

  controllerPausedHandler: (p1: GCController) => void;

  static shouldMonitorBackgroundEvents: boolean;

  readonly attachedToDevice: boolean;

  playerIndex: interop.Enum<typeof GCControllerPlayerIndex>;

  readonly input: GCControllerLiveInput;

  readonly battery: GCDeviceBattery;

  readonly physicalInputProfile: GCPhysicalInputProfile;

  readonly gamepad: GCGamepad;

  readonly microGamepad: GCMicroGamepad;

  readonly extendedGamepad: GCExtendedGamepad;

  readonly motion: GCMotion;

  readonly light: GCDeviceLight;

  readonly haptics: GCDeviceHaptics;

  setControllerPausedHandler(controllerPausedHandler: (p1: GCController) => void | null): void;

  static setShouldMonitorBackgroundEvents(shouldMonitorBackgroundEvents: boolean): void;

  isAttachedToDevice(): boolean;

  setPlayerIndex(playerIndex: interop.Enum<typeof GCControllerPlayerIndex>): void;

  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;

  setHandlerQueue(handlerQueue: NSObject): void;

  isEqual(object: interop.Object): boolean;

  readonly hash: number;

  readonly superclass: interop.Object;

  class(): interop.Object;

  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.Object): boolean;

  isMemberOfClass(aClass: interop.Object): 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 GCKeyboard extends NSObject implements GCDevice {
  readonly keyboardInput: GCKeyboardInput;

  static readonly coalescedKeyboard: GCKeyboard;

  handlerQueue: NSObject;

  readonly vendorName: string;

  readonly productCategory: string;

  readonly physicalInputProfile: GCPhysicalInputProfile;

  setHandlerQueue(handlerQueue: NSObject): void;

  isEqual(object: interop.Object): boolean;

  readonly hash: number;

  readonly superclass: interop.Object;

  class(): interop.Object;

  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.Object): boolean;

  isMemberOfClass(aClass: interop.Object): 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 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;

  setValueChangedHandler(valueChangedHandler: (p1: GCGamepad, p2: GCControllerElement) => void | null): void;
}

declare class GCControllerLiveInput extends GCControllerInputState implements GCDevicePhysicalInput {
  readonly unmappedInput: GCControllerLiveInput;

  capture(): GCControllerInputState;

  nextInputState(): GCControllerInputState;

  readonly device: GCDevice | null;

  queue: NSObject;

  elementValueDidChangeHandler: (p1: GCDevicePhysicalInput, p2: GCPhysicalInputElement) => void;

  inputStateAvailableHandler: (p1: GCDevicePhysicalInput) => void;

  inputStateQueueDepth: number;

  setQueue(queue: NSObject | null): void;

  setElementValueDidChangeHandler(elementValueDidChangeHandler: (p1: GCDevicePhysicalInput, p2: GCPhysicalInputElement) => void | null): void;

  setInputStateAvailableHandler(inputStateAvailableHandler: (p1: GCDevicePhysicalInput) => void | null): void;

  setInputStateQueueDepth(inputStateQueueDepth: number): void;

  readonly lastEventTimestamp: number;

  readonly lastEventLatency: number;

  readonly elements: GCPhysicalInputElementCollection;

  readonly buttons: GCPhysicalInputElementCollection;

  readonly axes: GCPhysicalInputElementCollection;

  readonly switches: GCPhysicalInputElementCollection;

  readonly dpads: GCPhysicalInputElementCollection;

  objectForKeyedSubscript(key: string): GCPhysicalInputElement | null;

  isEqual(object: interop.Object): boolean;

  readonly hash: number;

  readonly superclass: interop.Object;

  class(): interop.Object;

  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.Object): boolean;

  isMemberOfClass(aClass: interop.Object): 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;
}

