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

declare const SKRepeatMode: {
  Clamp: 1,
  Loop: 2,
};

declare const SKParticleRenderOrder: {
  OldestLast: 0,
  OldestFirst: 1,
  DontCare: 2,
};

declare const SKLabelVerticalAlignmentMode: {
  Baseline: 0,
  Center: 1,
  Top: 2,
  Bottom: 3,
};

declare const SKLabelHorizontalAlignmentMode: {
  Center: 0,
  Left: 1,
  Right: 2,
};

declare const SKTileSetType: {
  Grid: 0,
  Isometric: 1,
  HexagonalFlat: 2,
  HexagonalPointy: 3,
};

declare const SKTileDefinitionRotation: {
  Rotation0: 0,
  Rotation90: 1,
  Rotation180: 2,
  Rotation270: 3,
};

declare const SKAttributeType: {
  None: 0,
  Float: 1,
  VectorFloat2: 2,
  VectorFloat3: 3,
  VectorFloat4: 4,
  HalfFloat: 5,
  VectorHalfFloat2: 6,
  VectorHalfFloat3: 7,
  VectorHalfFloat4: 8,
};

declare const SKTextureFilteringMode: {
  Nearest: 0,
  Linear: 1,
};

declare const SKInterpolationMode: {
  Linear: 1,
  Spline: 2,
  Step: 3,
};

declare const SKActionTimingMode: {
  Linear: 0,
  EaseIn: 1,
  EaseOut: 2,
  EaseInEaseOut: 3,
};

declare const SKBlendMode: {
  Alpha: 0,
  Add: 1,
  Subtract: 2,
  Multiply: 3,
  MultiplyX2: 4,
  Screen: 5,
  Replace: 6,
  MultiplyAlpha: 7,
};

declare const SKTransitionDirection: {
  Up: 0,
  Down: 1,
  Right: 2,
  Left: 3,
};

declare const SKTileAdjacencyMask: {
  AdjacencyUp: 1,
  AdjacencyUpperRight: 2,
  AdjacencyRight: 4,
  AdjacencyLowerRight: 8,
  AdjacencyDown: 16,
  AdjacencyLowerLeft: 32,
  AdjacencyLeft: 64,
  AdjacencyUpperLeft: 128,
  AdjacencyAll: 255,
  HexFlatAdjacencyUp: 1,
  HexFlatAdjacencyUpperRight: 2,
  HexFlatAdjacencyLowerRight: 4,
  HexFlatAdjacencyDown: 8,
  HexFlatAdjacencyLowerLeft: 16,
  HexFlatAdjacencyUpperLeft: 32,
  HexFlatAdjacencyAll: 63,
  HexPointyAdjacencyUpperLeft: 1,
  HexPointyAdjacencyUpperRight: 2,
  HexPointyAdjacencyRight: 4,
  HexPointyAdjacencyLowerRight: 8,
  HexPointyAdjacencyLowerLeft: 16,
  HexPointyAdjacencyLeft: 32,
  HexPointyAdjacencyAdd: 63,
  AdjacencyUpEdge: 124,
  AdjacencyUpperRightEdge: 112,
  AdjacencyRightEdge: 241,
  AdjacencyLowerRightEdge: 193,
  AdjacencyDownEdge: 199,
  AdjacencyLowerLeftEdge: 7,
  AdjacencyLeftEdge: 31,
  AdjacencyUpperLeftEdge: 28,
  AdjacencyUpperRightCorner: 223,
  AdjacencyLowerRightCorner: 127,
  AdjacencyLowerLeftCorner: 253,
  AdjacencyUpperLeftCorner: 247,
};

declare const SKUniformType: {
  None: 0,
  Float: 1,
  FloatVector2: 2,
  FloatVector3: 3,
  FloatVector4: 4,
  FloatMatrix2: 5,
  FloatMatrix3: 6,
  FloatMatrix4: 7,
  Texture: 8,
};

declare const SKSceneScaleMode: {
  Fill: 0,
  AspectFill: 1,
  AspectFit: 2,
  ResizeFill: 3,
};

declare interface SKPhysicsContactDelegate extends NSObjectProtocol {
  didBeginContact?(contact: SKPhysicsContact): void;

  didEndContact?(contact: SKPhysicsContact): void;
}

declare class SKPhysicsContactDelegate extends NativeObject implements SKPhysicsContactDelegate {
}

declare interface SKViewDelegate extends NSObjectProtocol {
  viewShouldRenderAtTime?(view: SKView, time: number): boolean;
}

declare class SKViewDelegate extends NativeObject implements SKViewDelegate {
}

declare interface SKSceneDelegate extends NSObjectProtocol {
  updateForScene?(currentTime: number, scene: SKScene): void;

  didEvaluateActionsForScene?(scene: SKScene): void;

  didSimulatePhysicsForScene?(scene: SKScene): void;

  didApplyConstraintsForScene?(scene: SKScene): void;

  didFinishUpdateForScene?(scene: SKScene): void;
}

declare class SKSceneDelegate extends NativeObject implements SKSceneDelegate {
}

declare interface SKWarpable extends NSObjectProtocol {
  warpGeometry: SKWarpGeometry;

  subdivisionLevels: number;
}

declare class SKWarpable extends NativeObject implements SKWarpable {
}

declare class SKReachConstraints extends NSObject implements NSSecureCoding {
  lowerAngleLimit: number;

  upperAngleLimit: number;

  initWithLowerAngleLimitUpperAngleLimit(lowerAngleLimit: number, upperAngleLimit: number): this;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKLabelNode extends SKNode {
  static labelNodeWithText<This extends abstract new (...args: any) => any>(this: This, text: string | null): InstanceType<This>;

  static labelNodeWithAttributedText<This extends abstract new (...args: any) => any>(this: This, attributedText: NSAttributedString | null): InstanceType<This>;

  static labelNodeWithFontNamed<This extends abstract new (...args: any) => any>(this: This, fontName: string | null): InstanceType<This>;

  initWithFontNamed(fontName: string | null): this;

  verticalAlignmentMode: interop.Enum<typeof SKLabelVerticalAlignmentMode>;

  horizontalAlignmentMode: interop.Enum<typeof SKLabelHorizontalAlignmentMode>;

  numberOfLines: number;

  lineBreakMode: interop.Enum<typeof NSLineBreakMode>;

  preferredMaxLayoutWidth: number;

  fontName: string;

  text: string;

  attributedText: NSAttributedString;

  fontSize: number;

  fontColor: NSColor;

  colorBlendFactor: number;

  color: NSColor;

  blendMode: interop.Enum<typeof SKBlendMode>;
}

declare class SKPhysicsJointSpring extends SKPhysicsJoint {
  static jointWithBodyABodyBAnchorAAnchorB(bodyA: SKPhysicsBody, bodyB: SKPhysicsBody, anchorA: CGPoint, anchorB: CGPoint): SKPhysicsJointSpring;

  damping: number;

  frequency: number;
}

declare class SKSpriteNode extends SKNode implements SKWarpable {
  static spriteNodeWithTextureSize<This extends abstract new (...args: any) => any>(this: This, texture: SKTexture | null, size: CGSize): InstanceType<This>;

  static spriteNodeWithTexture<This extends abstract new (...args: any) => any>(this: This, texture: SKTexture | null): InstanceType<This>;

  static spriteNodeWithTextureNormalMap<This extends abstract new (...args: any) => any>(this: This, texture: SKTexture | null, normalMap: SKTexture | null): InstanceType<This>;

  static spriteNodeWithImageNamed<This extends abstract new (...args: any) => any>(this: This, name: string): InstanceType<This>;

  static spriteNodeWithImageNamedNormalMapped<This extends abstract new (...args: any) => any>(this: This, name: string, generateNormalMap: boolean): InstanceType<This>;

  static spriteNodeWithColorSize<This extends abstract new (...args: any) => any>(this: This, color: NSColor, size: CGSize): InstanceType<This>;

  initWithTextureColorSize(texture: SKTexture | null, color: NSColor, size: CGSize): this;

  initWithTexture(texture: SKTexture | null): this;

  initWithImageNamed(name: string): this;

  initWithColorSize(color: NSColor, size: CGSize): this;

  initWithCoder(coder: NSCoder): this;
  initWithCoder(aDecoder: NSCoder): this;

  texture: SKTexture;

  normalTexture: SKTexture;

  lightingBitMask: number;

  shadowCastBitMask: number;

  shadowedBitMask: number;

  centerRect: CGRect;

  colorBlendFactor: number;

  color: NSColor;

  blendMode: interop.Enum<typeof SKBlendMode>;

  anchorPoint: CGPoint;

  size: CGSize;

  scaleToSize(size: CGSize): void;

  shader: SKShader;

  get attributeValues(): NSDictionary;
  set attributeValues(value: NSDictionary<interop.Object, interop.Object> | Record<interop.Object, interop.Object>);

  valueForAttributeNamed(key: string): SKAttributeValue;

  setValueForAttributeNamed(value: SKAttributeValue, key: string): void;

  warpGeometry: SKWarpGeometry;

  subdivisionLevels: number;

  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 SKTileDefinition extends NSObject implements NSCopying, NSSecureCoding {
  static tileDefinitionWithTexture<This extends abstract new (...args: any) => any>(this: This, texture: SKTexture): InstanceType<This>;

  static tileDefinitionWithTextureSize<This extends abstract new (...args: any) => any>(this: This, texture: SKTexture, size: CGSize): InstanceType<This>;

  static tileDefinitionWithTextureNormalTextureSize<This extends abstract new (...args: any) => any>(this: This, texture: SKTexture, normalTexture: SKTexture, size: CGSize): InstanceType<This>;

  static tileDefinitionWithTexturesSizeTimePerFrame<This extends abstract new (...args: any) => any>(this: This, textures: NSArray<interop.Object> | Array<interop.Object>, size: CGSize, timePerFrame: number): InstanceType<This>;

  static tileDefinitionWithTexturesNormalTexturesSizeTimePerFrame<This extends abstract new (...args: any) => any>(this: This, textures: NSArray<interop.Object> | Array<interop.Object>, normalTextures: NSArray<interop.Object> | Array<interop.Object>, size: CGSize, timePerFrame: number): InstanceType<This>;

  initWithTexture(texture: SKTexture): this;

  initWithTextureSize(texture: SKTexture, size: CGSize): this;

  initWithTextureNormalTextureSize(texture: SKTexture, normalTexture: SKTexture, size: CGSize): this;

  initWithTexturesSizeTimePerFrame(textures: NSArray<interop.Object> | Array<interop.Object>, size: CGSize, timePerFrame: number): this;

  initWithTexturesNormalTexturesSizeTimePerFrame(textures: NSArray<interop.Object> | Array<interop.Object>, normalTextures: NSArray<interop.Object> | Array<interop.Object>, size: CGSize, timePerFrame: number): this;

  get textures(): NSArray;
  set textures(value: NSArray<interop.Object> | Array<interop.Object>);

  get normalTextures(): NSArray;
  set normalTextures(value: NSArray<interop.Object> | Array<interop.Object>);

  userData: NSMutableDictionary;

  name: string;

  size: CGSize;

  timePerFrame: number;

  placementWeight: number;

  rotation: interop.Enum<typeof SKTileDefinitionRotation>;

  flipVertically: boolean;

  flipHorizontally: boolean;

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKAttributeValue extends NSObject implements NSSecureCoding {
  static valueWithFloat<This extends abstract new (...args: any) => any>(this: This, value: number): InstanceType<This>;

  static valueWithVectorFloat2<This extends abstract new (...args: any) => any>(this: This, value: unknown /* ext vector */): InstanceType<This>;

  static valueWithVectorFloat3<This extends abstract new (...args: any) => any>(this: This, value: unknown /* ext vector */): InstanceType<This>;

  static valueWithVectorFloat4<This extends abstract new (...args: any) => any>(this: This, value: unknown /* ext vector */): InstanceType<This>;

  init(): this;

  floatValue: number;

  vectorFloat2Value: unknown /* ext vector */;

  vectorFloat3Value: unknown /* ext vector */;

  vectorFloat4Value: unknown /* ext vector */;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKEmitterNode extends SKNode {
  advanceSimulationTime(sec: number): void;

  resetSimulation(): void;

  particleTexture: SKTexture;

  particleBlendMode: interop.Enum<typeof SKBlendMode>;

  particleColor: NSColor;

  particleColorRedRange: number;

  particleColorGreenRange: number;

  particleColorBlueRange: number;

  particleColorAlphaRange: number;

  particleColorRedSpeed: number;

  particleColorGreenSpeed: number;

  particleColorBlueSpeed: number;

  particleColorAlphaSpeed: number;

  particleColorSequence: SKKeyframeSequence;

  particleColorBlendFactor: number;

  particleColorBlendFactorRange: number;

  particleColorBlendFactorSpeed: number;

  particleColorBlendFactorSequence: SKKeyframeSequence;

  particlePosition: CGPoint;

  particlePositionRange: CGVector;

  particleSpeed: number;

  particleSpeedRange: number;

  emissionAngle: number;

  emissionAngleRange: number;

  xAcceleration: number;

  yAcceleration: number;

  particleBirthRate: number;

  numParticlesToEmit: number;

  particleLifetime: number;

  particleLifetimeRange: number;

  particleRotation: number;

  particleRotationRange: number;

  particleRotationSpeed: number;

  particleSize: CGSize;

  particleScale: number;

  particleScaleRange: number;

  particleScaleSpeed: number;

  particleScaleSequence: SKKeyframeSequence;

  particleAlpha: number;

  particleAlphaRange: number;

  particleAlphaSpeed: number;

  particleAlphaSequence: SKKeyframeSequence;

  particleAction: SKAction;

  fieldBitMask: number;

  targetNode: SKNode;

  shader: SKShader;

  get attributeValues(): NSDictionary;
  set attributeValues(value: NSDictionary<interop.Object, interop.Object> | Record<interop.Object, interop.Object>);

  valueForAttributeNamed(key: string): SKAttributeValue;

  setValueForAttributeNamed(value: SKAttributeValue, key: string): void;

  particleZPosition: number;

  particleRenderOrder: interop.Enum<typeof SKParticleRenderOrder>;

  particleZPositionRange: number;

  particleZPositionSpeed: number;
}

declare class SKKeyframeSequence extends NSObject implements NSSecureCoding, NSCopying {
  initWithKeyframeValuesTimes(values: NSArray<interop.Object> | Array<interop.Object>, times: NSArray<interop.Object> | Array<interop.Object>): this;

  initWithCapacity(numItems: number): this;

  initWithCoder(aDecoder: NSCoder): this;

  count(): number;

  addKeyframeValueTime(value: interop.Object, time: number): void;

  removeLastKeyframe(): void;

  removeKeyframeAtIndex(index: number): void;

  setKeyframeValueForIndex(value: interop.Object, index: number): void;

  setKeyframeTimeForIndex(time: number, index: number): void;

  setKeyframeValueTimeForIndex(value: interop.Object, time: number, index: number): void;

  getKeyframeValueForIndex(index: number): interop.Object;

  getKeyframeTimeForIndex(index: number): number;

  sampleAtTime(time: number): interop.Object;

  interpolationMode: interop.Enum<typeof SKInterpolationMode>;

  repeatMode: interop.Enum<typeof SKRepeatMode>;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

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

declare class SKTexture extends NSObject implements NSCopying, NSSecureCoding {
  static textureWithImageNamed<This extends abstract new (...args: any) => any>(this: This, name: string): InstanceType<This>;

  static textureWithRectInTexture<This extends abstract new (...args: any) => any>(this: This, rect: CGRect, texture: SKTexture): InstanceType<This>;

  static textureVectorNoiseWithSmoothnessSize<This extends abstract new (...args: any) => any>(this: This, smoothness: number, size: CGSize): InstanceType<This>;

  static textureNoiseWithSmoothnessSizeGrayscale<This extends abstract new (...args: any) => any>(this: This, smoothness: number, size: CGSize, grayscale: boolean): InstanceType<This>;

  static textureWithCGImage<This extends abstract new (...args: any) => any>(this: This, image: interop.Object): InstanceType<This>;

  static textureWithImage<This extends abstract new (...args: any) => any>(this: This, image: NSImage): InstanceType<This>;

  static textureWithDataSize<This extends abstract new (...args: any) => any>(this: This, pixelData: NSData, size: CGSize): InstanceType<This>;

  static textureWithDataSizeFlipped<This extends abstract new (...args: any) => any>(this: This, pixelData: NSData, size: CGSize, flipped: boolean): InstanceType<This>;

  static textureWithDataSizeRowLengthAlignment<This extends abstract new (...args: any) => any>(this: This, pixelData: NSData, size: CGSize, rowLength: number, alignment: number): InstanceType<This>;

  textureByApplyingCIFilter(filter: CIFilter): this;

  textureByGeneratingNormalMap(): this;

  textureByGeneratingNormalMapWithSmoothnessContrast(smoothness: number, contrast: number): this;

  textureRect(): CGRect;

  size(): CGSize;

  filteringMode: interop.Enum<typeof SKTextureFilteringMode>;

  usesMipmaps: boolean;

  CGImage(): interop.Object;

  static preloadTexturesWithCompletionHandler(textures: NSArray<interop.Object> | Array<interop.Object>, completionHandler: () => void): void;

  preloadWithCompletionHandler(completionHandler: () => void): void;

  static textureWithNoiseMap<This extends abstract new (...args: any) => any>(this: This, noiseMap: GKNoiseMap): InstanceType<This>;

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKPhysicsBody extends NSObject implements NSCopying, NSSecureCoding {
  static bodyWithCircleOfRadius(r: number): SKPhysicsBody;

  static bodyWithCircleOfRadiusCenter(r: number, center: CGPoint): SKPhysicsBody;

  static bodyWithRectangleOfSize(s: CGSize): SKPhysicsBody;

  static bodyWithRectangleOfSizeCenter(s: CGSize, center: CGPoint): SKPhysicsBody;

  static bodyWithPolygonFromPath(path: interop.Object): SKPhysicsBody;

  static bodyWithEdgeFromPointToPoint(p1: CGPoint, p2: CGPoint): SKPhysicsBody;

  static bodyWithEdgeChainFromPath(path: interop.Object): SKPhysicsBody;

  static bodyWithEdgeLoopFromPath(path: interop.Object): SKPhysicsBody;

  static bodyWithEdgeLoopFromRect(rect: CGRect): SKPhysicsBody;

  static bodyWithTextureSize(texture: SKTexture, size: CGSize): SKPhysicsBody;

  static bodyWithTextureAlphaThresholdSize(texture: SKTexture, alphaThreshold: number, size: CGSize): SKPhysicsBody;

  static bodyWithBodies(bodies: NSArray<interop.Object> | Array<interop.Object>): SKPhysicsBody;

  dynamic: boolean;

  usesPreciseCollisionDetection: boolean;

  allowsRotation: boolean;

  pinned: boolean;

  resting: boolean;

  friction: number;

  charge: number;

  restitution: number;

  linearDamping: number;

  angularDamping: number;

  density: number;

  mass: number;

  readonly area: number;

  affectedByGravity: boolean;

  fieldBitMask: number;

  categoryBitMask: number;

  collisionBitMask: number;

  contactTestBitMask: number;

  readonly joints: NSArray;

  readonly node: SKNode;

  velocity: CGVector;

  angularVelocity: number;

  applyForce(force: CGVector): void;

  applyForceAtPoint(force: CGVector, point: CGPoint): void;

  applyTorque(torque: number): void;

  applyImpulse(impulse: CGVector): void;

  applyImpulseAtPoint(impulse: CGVector, point: CGPoint): void;

  applyAngularImpulse(impulse: number): void;

  allContactedBodies(): NSArray;

  isDynamic(): boolean;

  isResting(): boolean;

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKPhysicsJointLimit extends SKPhysicsJoint {
  maxLength: number;

  static jointWithBodyABodyBAnchorAAnchorB(bodyA: SKPhysicsBody, bodyB: SKPhysicsBody, anchorA: CGPoint, anchorB: CGPoint): SKPhysicsJointLimit;
}

declare class SKPhysicsContact extends NSObject {
  readonly bodyA: SKPhysicsBody;

  readonly bodyB: SKPhysicsBody;

  readonly contactPoint: CGPoint;

  readonly contactNormal: CGVector;

  readonly collisionImpulse: number;
}

declare class SKPhysicsJointSliding extends SKPhysicsJoint {
  static jointWithBodyABodyBAnchorAxis(bodyA: SKPhysicsBody, bodyB: SKPhysicsBody, anchor: CGPoint, axis: CGVector): SKPhysicsJointSliding;

  shouldEnableLimits: boolean;

  lowerDistanceLimit: number;

  upperDistanceLimit: number;
}

declare class SKPhysicsJointPin extends SKPhysicsJoint {
  static jointWithBodyABodyBAnchor(bodyA: SKPhysicsBody, bodyB: SKPhysicsBody, anchor: CGPoint): SKPhysicsJointPin;

  shouldEnableLimits: boolean;

  lowerAngleLimit: number;

  upperAngleLimit: number;

  frictionTorque: number;

  rotationSpeed: number;
}

declare class SKConstraint extends NSObject implements NSSecureCoding, NSCopying {
  enabled: boolean;

  referenceNode: SKNode;

  static positionX<This extends abstract new (...args: any) => any>(this: This, range: SKRange): InstanceType<This>;

  static positionY<This extends abstract new (...args: any) => any>(this: This, range: SKRange): InstanceType<This>;

  static positionXY<This extends abstract new (...args: any) => any>(this: This, xRange: SKRange, yRange: SKRange): InstanceType<This>;

  static distanceToNode<This extends abstract new (...args: any) => any>(this: This, range: SKRange, node: SKNode): InstanceType<This>;

  static distanceToPoint<This extends abstract new (...args: any) => any>(this: This, range: SKRange, point: CGPoint): InstanceType<This>;

  static distanceToPointInNode<This extends abstract new (...args: any) => any>(this: This, range: SKRange, point: CGPoint, node: SKNode): InstanceType<This>;

  static zRotation<This extends abstract new (...args: any) => any>(this: This, zRange: SKRange): InstanceType<This>;

  static orientToNodeOffset<This extends abstract new (...args: any) => any>(this: This, node: SKNode, radians: SKRange): InstanceType<This>;

  static orientToPointOffset<This extends abstract new (...args: any) => any>(this: This, point: CGPoint, radians: SKRange): InstanceType<This>;

  static orientToPointInNodeOffset<This extends abstract new (...args: any) => any>(this: This, point: CGPoint, node: SKNode, radians: SKRange): InstanceType<This>;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;

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

declare class SKMutableTexture extends SKTexture {
  initWithSize(size: CGSize): this;

  static mutableTextureWithSize<This extends abstract new (...args: any) => any>(this: This, size: CGSize): InstanceType<This>;

  initWithSizePixelFormat(size: CGSize, format: number): this;

  modifyPixelDataWithBlock(block: (p1: interop.PointerConvertible, p2: number) => void): void;
}

declare class SKTileGroup extends NSObject implements NSCopying, NSSecureCoding {
  static tileGroupWithTileDefinition<This extends abstract new (...args: any) => any>(this: This, tileDefinition: SKTileDefinition): InstanceType<This>;

  static tileGroupWithRules<This extends abstract new (...args: any) => any>(this: This, rules: NSArray<interop.Object> | Array<interop.Object>): InstanceType<This>;

  static emptyTileGroup<This extends abstract new (...args: any) => any>(this: This): InstanceType<This>;

  initWithTileDefinition(tileDefinition: SKTileDefinition): this;

  initWithRules(rules: NSArray<interop.Object> | Array<interop.Object>): this;

  get rules(): NSArray;
  set rules(value: NSArray<interop.Object> | Array<interop.Object>);

  name: string;

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKTileSet extends NSObject implements NSCopying, NSSecureCoding {
  static tileSetWithTileGroups<This extends abstract new (...args: any) => any>(this: This, tileGroups: NSArray<interop.Object> | Array<interop.Object>): InstanceType<This>;

  static tileSetWithTileGroupsTileSetType<This extends abstract new (...args: any) => any>(this: This, tileGroups: NSArray<interop.Object> | Array<interop.Object>, tileSetType: interop.Enum<typeof SKTileSetType>): InstanceType<This>;

  initWithTileGroups(tileGroups: NSArray<interop.Object> | Array<interop.Object>): this;

  initWithTileGroupsTileSetType(tileGroups: NSArray<interop.Object> | Array<interop.Object>, tileSetType: interop.Enum<typeof SKTileSetType>): this;

  static tileSetNamed<This extends abstract new (...args: any) => any>(this: This, name: string): InstanceType<This>;

  static tileSetFromURL<This extends abstract new (...args: any) => any>(this: This, url: NSURL): InstanceType<This>;

  get tileGroups(): NSArray;
  set tileGroups(value: NSArray<interop.Object> | Array<interop.Object>);

  name: string;

  type: interop.Enum<typeof SKTileSetType>;

  defaultTileGroup: SKTileGroup;

  defaultTileSize: CGSize;

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKAttribute extends NSObject implements NSSecureCoding {
  static attributeWithNameType<This extends abstract new (...args: any) => any>(this: This, name: string, type: interop.Enum<typeof SKAttributeType>): InstanceType<This>;

  initWithNameType(name: string, type: interop.Enum<typeof SKAttributeType>): this;

  readonly name: string;

  readonly type: interop.Enum<typeof SKAttributeType>;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKView extends NSView implements NSSecureCoding {
  paused: boolean;

  showsFPS: boolean;

  showsDrawCount: boolean;

  showsNodeCount: boolean;

  showsQuadCount: boolean;

  showsPhysics: boolean;

  showsFields: boolean;

  asynchronous: boolean;

  allowsTransparency: boolean;

  ignoresSiblingOrder: boolean;

  shouldCullNonVisibleNodes: boolean;

  preferredFramesPerSecond: number;

  disableDepthStencilBuffer: boolean;

  delegate: NSObject;

  frameInterval: number;

  preferredFrameRate: number;

  presentScene(scene: SKScene | null): void;

  presentSceneTransition(scene: SKScene, transition: SKTransition): void;

  readonly scene: SKScene;

  textureFromNode(node: SKNode): SKTexture;

  textureFromNodeCrop(node: SKNode, crop: CGRect): SKTexture;

  convertPointToScene(point: CGPoint, scene: SKScene): CGPoint;

  convertPointFromScene(point: CGPoint, scene: SKScene): CGPoint;

  isPaused(): boolean;

  isAsynchronous(): boolean;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKRegion extends NSObject implements NSCopying, NSSecureCoding {
  readonly path: interop.Object;

  static infiniteRegion<This extends abstract new (...args: any) => any>(this: This): InstanceType<This>;

  initWithRadius(radius: number): this;

  initWithSize(size: CGSize): this;

  initWithPath(path: interop.Object): this;

  inverseRegion(): this;

  regionByUnionWithRegion(region: SKRegion): this;

  regionByDifferenceFromRegion(region: SKRegion): this;

  regionByIntersectionWithRegion(region: SKRegion): this;

  containsPoint(point: CGPoint): boolean;

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKTransformNode extends SKNode {
  xRotation: number;

  yRotation: number;

  setEulerAngles(euler: unknown /* ext vector */): void;

  eulerAngles(): unknown /* ext vector */;

  setRotationMatrix(rotationMatrix: simd_float3x3): void;

  rotationMatrix(): simd_float3x3;

  setQuaternion(quaternion: simd_quatf): void;

  quaternion(): simd_quatf;
}

declare class SK3DNode extends SKNode {
  initWithViewportSize(viewportSize: CGSize): this;

  initWithCoder(coder: NSCoder): this;
  initWithCoder(aDecoder: NSCoder): this;

  static nodeWithViewportSize<This extends abstract new (...args: any) => any>(this: This, viewportSize: CGSize): InstanceType<This>;

  viewportSize: CGSize;

  scnScene: SCNScene;

  sceneTime: number;

  hitTestOptions(point: CGPoint, options: NSDictionary<interop.Object, interop.Object> | Record<interop.Object, interop.Object> | null): NSArray;

  projectPoint(point: unknown /* ext vector */): unknown /* ext vector */;

  unprojectPoint(point: unknown /* ext vector */): unknown /* ext vector */;

  playing: boolean;

  loops: boolean;

  pointOfView: SCNNode;

  autoenablesDefaultLighting: boolean;

  isPlaying(): boolean;
}

declare class SKReferenceNode extends SKNode {
  initWithURL(url: NSURL | null): this;

  initWithFileNamed(fileName: string | null): this;

  initWithCoder(coder: NSCoder): this;
  initWithCoder(aDecoder: NSCoder): this;

  static referenceNodeWithFileNamed<This extends abstract new (...args: any) => any>(this: This, fileName: string): InstanceType<This>;

  static referenceNodeWithURL<This extends abstract new (...args: any) => any>(this: This, referenceURL: NSURL): InstanceType<This>;

  didLoadReferenceNode(node: SKNode | null): void;

  resolveReferenceNode(): void;
}

declare class SKCropNode extends SKNode {
  maskNode: SKNode;
}

declare class SKAudioNode extends SKNode implements NSSecureCoding {
  initWithAVAudioNode(node: AVAudioNode | null): this;

  initWithCoder(coder: NSCoder): this;
  initWithCoder(aDecoder: NSCoder): this;

  initWithFileNamed(name: string): this;

  initWithURL(url: NSURL): this;

  avAudioNode: AVAudioNode;

  autoplayLooped: boolean;

  positional: boolean;

  isPositional(): boolean;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;
}

declare class SKVideoNode extends SKNode {
  static videoNodeWithAVPlayer(player: AVPlayer): SKVideoNode;

  static videoNodeWithVideoFileNamed(videoFile: string): SKVideoNode;

  static videoNodeWithFileNamed(videoFile: string): SKVideoNode;

  static videoNodeWithVideoURL(videoURL: NSURL): SKVideoNode;

  static videoNodeWithURL(videoURL: NSURL): SKVideoNode;

  initWithAVPlayer(player: AVPlayer): this;

  initWithVideoFileNamed(videoFile: string): this;

  initWithFileNamed(videoFile: string): this;

  initWithVideoURL(url: NSURL): this;

  initWithURL(url: NSURL): this;

  initWithCoder(coder: NSCoder): this;
  initWithCoder(aDecoder: NSCoder): this;

  play(): void;

  pause(): void;

  size: CGSize;

  anchorPoint: CGPoint;
}

declare class SKShapeNode extends SKNode {
  static shapeNodeWithPath<This extends abstract new (...args: any) => any>(this: This, path: interop.Object): InstanceType<This>;

  static shapeNodeWithPathCentered<This extends abstract new (...args: any) => any>(this: This, path: interop.Object, centered: boolean): InstanceType<This>;

  static shapeNodeWithRect<This extends abstract new (...args: any) => any>(this: This, rect: CGRect): InstanceType<This>;

  static shapeNodeWithRectOfSize<This extends abstract new (...args: any) => any>(this: This, size: CGSize): InstanceType<This>;

  static shapeNodeWithRectCornerRadius<This extends abstract new (...args: any) => any>(this: This, rect: CGRect, cornerRadius: number): InstanceType<This>;

  static shapeNodeWithRectOfSizeCornerRadius<This extends abstract new (...args: any) => any>(this: This, size: CGSize, cornerRadius: number): InstanceType<This>;

  static shapeNodeWithCircleOfRadius<This extends abstract new (...args: any) => any>(this: This, radius: number): InstanceType<This>;

  static shapeNodeWithEllipseInRect<This extends abstract new (...args: any) => any>(this: This, rect: CGRect): InstanceType<This>;

  static shapeNodeWithEllipseOfSize<This extends abstract new (...args: any) => any>(this: This, size: CGSize): InstanceType<This>;

  static shapeNodeWithPointsCount<This extends abstract new (...args: any) => any>(this: This, points: interop.PointerConvertible, numPoints: number): InstanceType<This>;

  static shapeNodeWithSplinePointsCount<This extends abstract new (...args: any) => any>(this: This, points: interop.PointerConvertible, numPoints: number): InstanceType<This>;

  path: interop.Object;

  strokeColor: NSColor;

  fillColor: NSColor;

  blendMode: interop.Enum<typeof SKBlendMode>;

  antialiased: boolean;

  lineWidth: number;

  glowWidth: number;

  lineCap: interop.Enum<typeof CGLineCap>;

  lineJoin: interop.Enum<typeof CGLineJoin>;

  miterLimit: number;

  readonly lineLength: number;

  fillTexture: SKTexture;

  fillShader: SKShader;

  strokeTexture: SKTexture;

  strokeShader: SKShader;

  get attributeValues(): NSDictionary;
  set attributeValues(value: NSDictionary<interop.Object, interop.Object> | Record<interop.Object, interop.Object>);

  valueForAttributeNamed(key: string): SKAttributeValue;

  setValueForAttributeNamed(value: SKAttributeValue, key: string): void;

  isAntialiased(): boolean;
}

declare class SKScene extends SKEffectNode implements GKSceneRootNodeType {
  initWithSize(size: CGSize): this;

  static sceneWithSize<This extends abstract new (...args: any) => any>(this: This, size: CGSize): InstanceType<This>;

  sceneDidLoad(): void;

  size: CGSize;

  scaleMode: interop.Enum<typeof SKSceneScaleMode>;

  camera: SKCameraNode;

  listener: SKNode;

  readonly audioEngine: AVAudioEngine;

  backgroundColor: NSColor;

  delegate: SKSceneDelegate;

  anchorPoint: CGPoint;

  readonly physicsWorld: SKPhysicsWorld;

  readonly view: SKView;

  convertPointFromView(point: CGPoint): CGPoint;

  convertPointToView(point: CGPoint): CGPoint;

  update(currentTime: number): void;

  didEvaluateActions(): void;

  didSimulatePhysics(): void;

  didApplyConstraints(): void;

  didFinishUpdate(): void;

  didMoveToView(view: SKView): void;

  willMoveFromView(view: SKView): void;

  didChangeSize(oldSize: CGSize): void;

  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 SKWarpGeometryGrid extends SKWarpGeometry implements NSSecureCoding {
  initWithCoder(coder: NSCoder): this;
  initWithCoder(aDecoder: NSCoder): this;

  static grid<This extends abstract new (...args: any) => any>(this: This): InstanceType<This>;

  static gridWithColumnsRows<This extends abstract new (...args: any) => any>(this: This, cols: number, rows: number): InstanceType<This>;

  static gridWithColumnsRowsSourcePositionsDestPositions<This extends abstract new (...args: any) => any>(this: This, cols: number, rows: number, sourcePositions: interop.PointerConvertible, destPositions: interop.PointerConvertible): InstanceType<This>;

  initWithColumnsRowsSourcePositionsDestPositions(cols: number, rows: number, sourcePositions: interop.PointerConvertible, destPositions: interop.PointerConvertible): this;

  readonly numberOfColumns: number;

  readonly numberOfRows: number;

  readonly vertexCount: number;

  sourcePositionAtIndex(index: number): unknown /* ext vector */;

  destPositionAtIndex(index: number): unknown /* ext vector */;

  gridByReplacingSourcePositions(sourcePositions: interop.PointerConvertible): this;

  gridByReplacingDestPositions(destPositions: interop.PointerConvertible): this;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;
}

declare class SKWarpGeometry extends NSObject implements NSCopying, NSSecureCoding {
  copyWithZone(zone: interop.PointerConvertible): interop.Object;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKNode extends NSResponder implements NSCopying, NSSecureCoding {
  init(): this;

  initWithCoder(coder: NSCoder): this;
  initWithCoder(aDecoder: NSCoder): this;

  static node<This extends abstract new (...args: any) => any>(this: This): InstanceType<This>;

  static nodeWithFileNamed<This extends abstract new (...args: any) => any>(this: This, filename: string): InstanceType<This>;

  static nodeWithFileNamedSecurelyWithClassesAndError<This extends abstract new (...args: any) => any>(this: This, filename: string, classes: NSSet, error: interop.PointerConvertible): InstanceType<This>;

  readonly frame: CGRect;

  calculateAccumulatedFrame(): CGRect;

  position: CGPoint;

  zPosition: number;

  zRotation: number;

  xScale: number;

  yScale: number;

  speed: number;

  alpha: number;

  paused: boolean;

  hidden: boolean;

  userInteractionEnabled: boolean;

  readonly parent: SKNode;

  readonly children: NSArray;

  name: string;

  readonly scene: SKScene;

  physicsBody: SKPhysicsBody;

  userData: NSMutableDictionary;

  reachConstraints: SKReachConstraints;

  get constraints(): NSArray;
  set constraints(value: NSArray<interop.Object> | Array<interop.Object>);

  get attributeValues(): NSDictionary;
  set attributeValues(value: NSDictionary<interop.Object, interop.Object> | Record<interop.Object, interop.Object>);

  valueForAttributeNamed(key: string): SKAttributeValue;

  setValueForAttributeNamed(value: SKAttributeValue, key: string): void;

  setScale(scale: number): void;

  addChild(node: SKNode): void;

  insertChildAtIndex(node: SKNode, index: number): void;

  removeChildrenInArray(nodes: NSArray<interop.Object> | Array<interop.Object>): void;

  removeAllChildren(): void;

  removeFromParent(): void;

  moveToParent(parent: SKNode): void;

  childNodeWithName(name: string): SKNode;

  enumerateChildNodesWithNameUsingBlock(name: string, block: (p1: SKNode, p2: interop.PointerConvertible) => void): void;

  objectForKeyedSubscript(name: string): NSArray;

  inParentHierarchy(parent: SKNode): boolean;

  runAction(action: SKAction): void;

  runActionCompletion(action: SKAction, block: () => void): void;

  runActionWithKey(action: SKAction, key: string): void;

  hasActions(): boolean;

  actionForKey(key: string): SKAction;

  removeActionForKey(key: string): void;

  removeAllActions(): void;

  containsPoint(p: CGPoint): boolean;

  nodeAtPoint(p: CGPoint): SKNode;

  nodesAtPoint(p: CGPoint): NSArray;

  convertPointFromNode(point: CGPoint, node: SKNode): CGPoint;

  convertPointToNode(point: CGPoint, node: SKNode): CGPoint;

  intersectsNode(node: SKNode): boolean;

  isEqualToNode(node: SKNode): boolean;

  isPaused(): boolean;

  isHidden(): boolean;

  isUserInteractionEnabled(): boolean;

  accessibilityElement: boolean;

  accessibilityRole: string;

  accessibilityRoleDescription: string;

  accessibilitySubrole: string;

  accessibilityFrame: CGRect;

  accessibilityParent: interop.Object;

  get accessibilityChildren(): NSArray;
  set accessibilityChildren(value: NSArray<interop.Object> | Array<interop.Object>);

  accessibilityHelp: string;

  accessibilityLabel: string;

  accessibilityEnabled: boolean;

  accessibilityHitTest(point: CGPoint): interop.Object;

  isAccessibilityElement(): boolean;

  isAccessibilityEnabled(): boolean;

  static obstaclesFromSpriteTexturesAccuracy(sprites: NSArray<interop.Object> | Array<interop.Object>, accuracy: number): NSArray;

  static obstaclesFromNodeBounds(nodes: NSArray<interop.Object> | Array<interop.Object>): NSArray;

  static obstaclesFromNodePhysicsBodies(nodes: NSArray<interop.Object> | Array<interop.Object>): NSArray;

  entity: GKEntity;

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;
}

declare class SKTileMapNode extends SKNode implements NSCopying, NSSecureCoding {
  static tileMapNodeWithTileSetColumnsRowsTileSize<This extends abstract new (...args: any) => any>(this: This, tileSet: SKTileSet, columns: number, rows: number, tileSize: CGSize): InstanceType<This>;

  static tileMapNodeWithTileSetColumnsRowsTileSizeFillWithTileGroup<This extends abstract new (...args: any) => any>(this: This, tileSet: SKTileSet, columns: number, rows: number, tileSize: CGSize, tileGroup: SKTileGroup): InstanceType<This>;

  static tileMapNodeWithTileSetColumnsRowsTileSizeTileGroupLayout<This extends abstract new (...args: any) => any>(this: This, tileSet: SKTileSet, columns: number, rows: number, tileSize: CGSize, tileGroupLayout: NSArray<interop.Object> | Array<interop.Object>): InstanceType<This>;

  initWithTileSetColumnsRowsTileSize(tileSet: SKTileSet, columns: number, rows: number, tileSize: CGSize): this;

  initWithTileSetColumnsRowsTileSizeFillWithTileGroup(tileSet: SKTileSet, columns: number, rows: number, tileSize: CGSize, tileGroup: SKTileGroup): this;

  initWithTileSetColumnsRowsTileSizeTileGroupLayout(tileSet: SKTileSet, columns: number, rows: number, tileSize: CGSize, tileGroupLayout: NSArray<interop.Object> | Array<interop.Object>): this;

  numberOfColumns: number;

  numberOfRows: number;

  tileSize: CGSize;

  readonly mapSize: CGSize;

  tileSet: SKTileSet;

  colorBlendFactor: number;

  color: NSColor;

  blendMode: interop.Enum<typeof SKBlendMode>;

  anchorPoint: CGPoint;

  shader: SKShader;

  get attributeValues(): NSDictionary;
  set attributeValues(value: NSDictionary<interop.Object, interop.Object> | Record<interop.Object, interop.Object>);

  valueForAttributeNamed(key: string): SKAttributeValue;

  setValueForAttributeNamed(value: SKAttributeValue, key: string): void;

  lightingBitMask: number;

  enableAutomapping: boolean;

  fillWithTileGroup(tileGroup: SKTileGroup | null): void;

  tileDefinitionAtColumnRow(column: number, row: number): SKTileDefinition;

  tileGroupAtColumnRow(column: number, row: number): SKTileGroup;

  setTileGroupForColumnRow(tileGroup: SKTileGroup | null, column: number, row: number): void;

  setTileGroupAndTileDefinitionForColumnRow(tileGroup: SKTileGroup, tileDefinition: SKTileDefinition, column: number, row: number): void;

  tileColumnIndexFromPosition(position: CGPoint): number;

  tileRowIndexFromPosition(position: CGPoint): number;

  centerOfTileAtColumnRow(column: number, row: number): CGPoint;

  static tileMapNodesWithTileSetColumnsRowsTileSizeFromNoiseMapTileTypeNoiseMapThresholds(tileSet: SKTileSet, columns: number, rows: number, tileSize: CGSize, noiseMap: GKNoiseMap, thresholds: NSArray<interop.Object> | Array<interop.Object>): NSArray;

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(aDecoder: NSCoder): this;
  initWithCoder(coder: NSCoder): this;
  initWithCoder(coder: NSCoder): this;
}

declare class SKCameraNode extends SKNode {
  containsNode(node: SKNode): boolean;

  containedNodeSet(): NSSet;
}

declare class SKPhysicsJointFixed extends SKPhysicsJoint {
  static jointWithBodyABodyBAnchor(bodyA: SKPhysicsBody, bodyB: SKPhysicsBody, anchor: CGPoint): SKPhysicsJointFixed;
}

declare class SKPhysicsJoint extends NSObject implements NSSecureCoding {
  bodyA: SKPhysicsBody;

  bodyB: SKPhysicsBody;

  readonly reactionForce: CGVector;

  readonly reactionTorque: number;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKRenderer extends NSObject {
  static rendererWithDevice(device: MTLDevice): SKRenderer;

  renderWithViewportCommandBufferRenderPassDescriptor(viewport: CGRect, commandBuffer: MTLCommandBuffer, renderPassDescriptor: MTLRenderPassDescriptor): void;

  renderWithViewportRenderCommandEncoderRenderPassDescriptorCommandQueue(viewport: CGRect, renderCommandEncoder: MTLRenderCommandEncoder, renderPassDescriptor: MTLRenderPassDescriptor, commandQueue: MTLCommandQueue): void;

  updateAtTime(currentTime: number): void;

  scene: SKScene;

  ignoresSiblingOrder: boolean;

  shouldCullNonVisibleNodes: boolean;

  showsDrawCount: boolean;

  showsNodeCount: boolean;

  showsQuadCount: boolean;

  showsPhysics: boolean;

  showsFields: boolean;
}

declare class SKAction extends NSObject implements NSCopying, NSSecureCoding {
  duration: number;

  timingMode: interop.Enum<typeof SKActionTimingMode>;

  timingFunction: (p1: number) => number;

  speed: number;

  reversedAction(): SKAction;

  static moveByDuration(delta: CGVector, duration: number): SKAction;

  static moveByXYDuration(deltaX: number, deltaY: number, duration: number): SKAction;

  static moveToDuration(location: CGPoint, duration: number): SKAction;

  static moveToXDuration(x: number, duration: number): SKAction;

  static moveToYDuration(y: number, duration: number): SKAction;

  static rotateByAngleDuration(radians: number, duration: number): SKAction;

  static rotateToAngleDuration(radians: number, duration: number): SKAction;

  static rotateToAngleDurationShortestUnitArc(radians: number, duration: number, shortestUnitArc: boolean): SKAction;

  static resizeByWidthHeightDuration(width: number, height: number, duration: number): SKAction;

  static resizeToWidthHeightDuration(width: number, height: number, duration: number): SKAction;

  static resizeToWidthDuration(width: number, duration: number): SKAction;

  static resizeToHeightDuration(height: number, duration: number): SKAction;

  static scaleByDuration(scale: number, duration: number): SKAction;

  static scaleXByYDuration(xScale: number, yScale: number, duration: number): SKAction;

  static scaleToDuration(scale: number, duration: number): SKAction;

  static scaleXToYDuration(xScale: number, yScale: number, duration: number): SKAction;

  static scaleXToDuration(scale: number, duration: number): SKAction;

  static scaleYToDuration(scale: number, duration: number): SKAction;

  static scaleToSizeDuration(size: CGSize, duration: number): SKAction;

  static sequence(actions: NSArray<interop.Object> | Array<interop.Object>): SKAction;

  static group(actions: NSArray<interop.Object> | Array<interop.Object>): SKAction;

  static repeatActionCount(action: SKAction, count: number): SKAction;

  static repeatActionForever(action: SKAction): SKAction;

  static fadeInWithDuration(duration: number): SKAction;

  static fadeOutWithDuration(duration: number): SKAction;

  static fadeAlphaByDuration(factor: number, duration: number): SKAction;

  static fadeAlphaToDuration(alpha: number, duration: number): SKAction;

  static hide(): SKAction;

  static unhide(): SKAction;

  static setTexture(texture: SKTexture): SKAction;

  static setNormalTexture(texture: SKTexture): SKAction;

  static setTextureResize(texture: SKTexture, resize: boolean): SKAction;

  static setNormalTextureResize(texture: SKTexture, resize: boolean): SKAction;

  static animateWithTexturesTimePerFrame(textures: NSArray<interop.Object> | Array<interop.Object>, sec: number): SKAction;

  static animateWithNormalTexturesTimePerFrame(textures: NSArray<interop.Object> | Array<interop.Object>, sec: number): SKAction;

  static animateWithTexturesTimePerFrameResizeRestore(textures: NSArray<interop.Object> | Array<interop.Object>, sec: number, resize: boolean, restore: boolean): SKAction;

  static animateWithNormalTexturesTimePerFrameResizeRestore(textures: NSArray<interop.Object> | Array<interop.Object>, sec: number, resize: boolean, restore: boolean): SKAction;

  static playSoundFileNamedWaitForCompletion(soundFile: string, wait: boolean): SKAction;

  static colorizeWithColorColorBlendFactorDuration(color: NSColor, colorBlendFactor: number, duration: number): SKAction;

  static colorizeWithColorBlendFactorDuration(colorBlendFactor: number, sec: number): SKAction;

  static falloffToDuration(falloff: number, duration: number): SKAction;

  static falloffByDuration(falloff: number, duration: number): SKAction;

  static followPathDuration(path: interop.Object, duration: number): SKAction;

  static followPathAsOffsetOrientToPathDuration(path: interop.Object, offset: boolean, orient: boolean, duration: number): SKAction;

  static followPathSpeed(path: interop.Object, speed: number): SKAction;

  static followPathAsOffsetOrientToPathSpeed(path: interop.Object, offset: boolean, orient: boolean, speed: number): SKAction;

  static speedByDuration(speed: number, duration: number): SKAction;

  static speedToDuration(speed: number, duration: number): SKAction;

  static reachToRootNodeDuration(position: CGPoint, root: SKNode, duration: number): SKAction;

  static reachToRootNodeVelocity(position: CGPoint, root: SKNode, velocity: number): SKAction;

  static reachToNodeRootNodeDuration(node: SKNode, root: SKNode, sec: number): SKAction;

  static reachToNodeRootNodeVelocity(node: SKNode, root: SKNode, velocity: number): SKAction;

  static strengthToDuration(strength: number, duration: number): SKAction;

  static strengthByDuration(strength: number, duration: number): SKAction;

  static waitForDuration(duration: number): SKAction;

  static waitForDurationWithRange(duration: number, durationRange: number): SKAction;

  static removeFromParent(): SKAction;

  static performSelectorOnTarget(selector: string, target: interop.Object): SKAction;

  static runBlock(block: () => void): SKAction;

  static runBlockQueue(block: () => void, queue: NSObject): SKAction;

  static runActionOnChildWithName(action: SKAction, name: string): SKAction;

  static customActionWithDurationActionBlock(duration: number, block: (p1: SKNode, p2: number) => void): SKAction;

  static actionNamed(name: string): SKAction;

  static actionNamedDuration(name: string, duration: number): SKAction;

  static actionNamedFromURL(name: string, url: NSURL): SKAction;

  static actionNamedFromURLDuration(name: string, url: NSURL, duration: number): SKAction;

  static changeChargeToDuration(v: number, duration: number): SKAction;

  static changeChargeByDuration(v: number, duration: number): SKAction;

  static changeMassToDuration(v: number, duration: number): SKAction;

  static changeMassByDuration(v: number, duration: number): SKAction;

  static applyForceDuration(force: CGVector, duration: number): SKAction;

  static applyForceAtPointDuration(force: CGVector, point: CGPoint, duration: number): SKAction;

  static applyTorqueDuration(torque: number, duration: number): SKAction;

  static applyImpulseDuration(impulse: CGVector, duration: number): SKAction;

  static applyImpulseAtPointDuration(impulse: CGVector, point: CGPoint, duration: number): SKAction;

  static applyAngularImpulseDuration(impulse: number, duration: number): SKAction;

  static play(): SKAction;

  static pause(): SKAction;

  static stop(): SKAction;

  static changePlaybackRateToDuration(v: number, duration: number): SKAction;

  static changePlaybackRateByDuration(v: number, duration: number): SKAction;

  static changeVolumeToDuration(v: number, duration: number): SKAction;

  static changeVolumeByDuration(v: number, duration: number): SKAction;

  static warpToDuration(warp: SKWarpGeometry, duration: number): SKAction;

  static animateWithWarpsTimes(warps: NSArray<interop.Object> | Array<interop.Object>, times: NSArray<interop.Object> | Array<interop.Object>): SKAction;

  static animateWithWarpsTimesRestore(warps: NSArray<interop.Object> | Array<interop.Object>, times: NSArray<interop.Object> | Array<interop.Object>, restore: boolean): SKAction;

  static stereoPanToDuration(v: number, duration: number): SKAction;

  static stereoPanByDuration(v: number, duration: number): SKAction;

  static changeReverbToDuration(v: number, duration: number): SKAction;

  static changeReverbByDuration(v: number, duration: number): SKAction;

  static changeObstructionToDuration(v: number, duration: number): SKAction;

  static changeObstructionByDuration(v: number, duration: number): SKAction;

  static changeOcclusionToDuration(v: number, duration: number): SKAction;

  static changeOcclusionByDuration(v: number, duration: number): SKAction;

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKLightNode extends SKNode {
  enabled: boolean;

  lightColor: NSColor;

  ambientColor: NSColor;

  shadowColor: NSColor;

  falloff: number;

  categoryBitMask: number;

  isEnabled(): boolean;
}

declare class SKShader extends NSObject implements NSCopying, NSSecureCoding {
  initWithSource(source: string): this;

  initWithSourceUniforms(source: string, uniforms: NSArray<interop.Object> | Array<interop.Object>): this;

  static shader<This extends abstract new (...args: any) => any>(this: This): InstanceType<This>;

  static shaderWithSource<This extends abstract new (...args: any) => any>(this: This, source: string): InstanceType<This>;

  static shaderWithSourceUniforms<This extends abstract new (...args: any) => any>(this: This, source: string, uniforms: NSArray<interop.Object> | Array<interop.Object>): InstanceType<This>;

  static shaderWithFileNamed<This extends abstract new (...args: any) => any>(this: This, name: string): InstanceType<This>;

  source: string;

  get uniforms(): NSArray;
  set uniforms(value: NSArray<interop.Object> | Array<interop.Object>);

  addUniform(uniform: SKUniform): void;

  uniformNamed(name: string): SKUniform;

  removeUniformNamed(name: string): void;

  get attributes(): NSArray;
  set attributes(value: NSArray<interop.Object> | Array<interop.Object>);

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKRange extends NSObject implements NSSecureCoding, NSCopying {
  initWithLowerLimitUpperLimit(lower: number, upper: number): this;

  static rangeWithLowerLimitUpperLimit<This extends abstract new (...args: any) => any>(this: This, lower: number, upper: number): InstanceType<This>;

  static rangeWithLowerLimit<This extends abstract new (...args: any) => any>(this: This, lower: number): InstanceType<This>;

  static rangeWithUpperLimit<This extends abstract new (...args: any) => any>(this: This, upper: number): InstanceType<This>;

  static rangeWithConstantValue<This extends abstract new (...args: any) => any>(this: This, value: number): InstanceType<This>;

  static rangeWithValueVariance<This extends abstract new (...args: any) => any>(this: This, value: number, variance: number): InstanceType<This>;

  static rangeWithNoLimits<This extends abstract new (...args: any) => any>(this: This): InstanceType<This>;

  lowerLimit: number;

  upperLimit: number;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;

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

declare class SKEffectNode extends SKNode implements SKWarpable {
  filter: CIFilter;

  shouldCenterFilter: boolean;

  shouldEnableEffects: boolean;

  shouldRasterize: boolean;

  blendMode: interop.Enum<typeof SKBlendMode>;

  shader: SKShader;

  get attributeValues(): NSDictionary;
  set attributeValues(value: NSDictionary<interop.Object, interop.Object> | Record<interop.Object, interop.Object>);

  valueForAttributeNamed(key: string): SKAttributeValue;

  setValueForAttributeNamed(value: SKAttributeValue, key: string): void;

  warpGeometry: SKWarpGeometry;

  subdivisionLevels: number;

  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 SKUniform extends NSObject implements NSCopying, NSSecureCoding {
  static uniformWithName<This extends abstract new (...args: any) => any>(this: This, name: string): InstanceType<This>;

  static uniformWithNameTexture<This extends abstract new (...args: any) => any>(this: This, name: string, texture: SKTexture | null): InstanceType<This>;

  static uniformWithNameFloat<This extends abstract new (...args: any) => any>(this: This, name: string, value: number): InstanceType<This>;

  static uniformWithNameVectorFloat2<This extends abstract new (...args: any) => any>(this: This, name: string, value: unknown /* ext vector */): InstanceType<This>;

  static uniformWithNameVectorFloat3<This extends abstract new (...args: any) => any>(this: This, name: string, value: unknown /* ext vector */): InstanceType<This>;

  static uniformWithNameVectorFloat4<This extends abstract new (...args: any) => any>(this: This, name: string, value: unknown /* ext vector */): InstanceType<This>;

  static uniformWithNameMatrixFloat2x2<This extends abstract new (...args: any) => any>(this: This, name: string, value: simd_float2x2): InstanceType<This>;

  static uniformWithNameMatrixFloat3x3<This extends abstract new (...args: any) => any>(this: This, name: string, value: simd_float3x3): InstanceType<This>;

  static uniformWithNameMatrixFloat4x4<This extends abstract new (...args: any) => any>(this: This, name: string, value: simd_float4x4): InstanceType<This>;

  readonly name: string;

  readonly uniformType: interop.Enum<typeof SKUniformType>;

  textureValue: SKTexture;

  floatValue: number;

  vectorFloat2Value: unknown /* ext vector */;

  vectorFloat3Value: unknown /* ext vector */;

  vectorFloat4Value: unknown /* ext vector */;

  matrixFloat2x2Value: simd_float2x2;

  matrixFloat3x3Value: simd_float3x3;

  matrixFloat4x4Value: simd_float4x4;

  initWithName(name: string): this;

  initWithNameTexture(name: string, texture: SKTexture | null): this;

  initWithNameFloat(name: string, value: number): this;

  initWithNameVectorFloat2(name: string, value: unknown /* ext vector */): this;

  initWithNameVectorFloat3(name: string, value: unknown /* ext vector */): this;

  initWithNameVectorFloat4(name: string, value: unknown /* ext vector */): this;

  initWithNameMatrixFloat2x2(name: string, value: simd_float2x2): this;

  initWithNameMatrixFloat3x3(name: string, value: simd_float3x3): this;

  initWithNameMatrixFloat4x4(name: string, value: simd_float4x4): this;

  floatVector2Value: _GLKVector2;

  floatVector3Value: _GLKVector3;

  floatVector4Value: _GLKVector4;

  floatMatrix2Value: _GLKMatrix2;

  floatMatrix3Value: _GLKMatrix3;

  floatMatrix4Value: _GLKMatrix4;

  static uniformWithNameFloatVector2<This extends abstract new (...args: any) => any>(this: This, name: string, value: _GLKVector2): InstanceType<This>;

  static uniformWithNameFloatVector3<This extends abstract new (...args: any) => any>(this: This, name: string, value: _GLKVector3): InstanceType<This>;

  static uniformWithNameFloatVector4<This extends abstract new (...args: any) => any>(this: This, name: string, value: _GLKVector4): InstanceType<This>;

  static uniformWithNameFloatMatrix2<This extends abstract new (...args: any) => any>(this: This, name: string, value: _GLKMatrix2): InstanceType<This>;

  static uniformWithNameFloatMatrix3<This extends abstract new (...args: any) => any>(this: This, name: string, value: _GLKMatrix3): InstanceType<This>;

  static uniformWithNameFloatMatrix4<This extends abstract new (...args: any) => any>(this: This, name: string, value: _GLKMatrix4): InstanceType<This>;

  initWithNameFloatVector2(name: string, value: _GLKVector2): this;

  initWithNameFloatVector3(name: string, value: _GLKVector3): this;

  initWithNameFloatVector4(name: string, value: _GLKVector4): this;

  initWithNameFloatMatrix2(name: string, value: _GLKMatrix2): this;

  initWithNameFloatMatrix3(name: string, value: _GLKMatrix3): this;

  initWithNameFloatMatrix4(name: string, value: _GLKMatrix4): this;

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKTileGroupRule extends NSObject implements NSCopying, NSSecureCoding {
  static tileGroupRuleWithAdjacencyTileDefinitions<This extends abstract new (...args: any) => any>(this: This, adjacency: interop.Enum<typeof SKTileAdjacencyMask>, tileDefinitions: NSArray<interop.Object> | Array<interop.Object>): InstanceType<This>;

  initWithAdjacencyTileDefinitions(adjacency: interop.Enum<typeof SKTileAdjacencyMask>, tileDefinitions: NSArray<interop.Object> | Array<interop.Object>): this;

  adjacency: interop.Enum<typeof SKTileAdjacencyMask>;

  get tileDefinitions(): NSArray;
  set tileDefinitions(value: NSArray<interop.Object> | Array<interop.Object>);

  name: string;

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

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKTextureAtlas extends NSObject implements NSSecureCoding {
  static atlasNamed<This extends abstract new (...args: any) => any>(this: This, name: string): InstanceType<This>;

  static atlasWithDictionary<This extends abstract new (...args: any) => any>(this: This, properties: NSDictionary<interop.Object, interop.Object> | Record<interop.Object, interop.Object>): InstanceType<This>;

  textureNamed(name: string): SKTexture;

  static preloadTextureAtlasesWithCompletionHandler(textureAtlases: NSArray<interop.Object> | Array<interop.Object>, completionHandler: () => void): void;

  static preloadTextureAtlasesNamedWithCompletionHandler(atlasNames: NSArray<interop.Object> | Array<interop.Object>, completionHandler: (p1: NSError, p2: NSArray<interop.Object> | Array<interop.Object>) => void | null): void;

  preloadWithCompletionHandler(completionHandler: () => void): void;

  readonly textureNames: NSArray;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKPhysicsWorld extends NSObject implements NSSecureCoding {
  gravity: CGVector;

  speed: number;

  contactDelegate: SKPhysicsContactDelegate;

  addJoint(joint: SKPhysicsJoint): void;

  removeJoint(joint: SKPhysicsJoint): void;

  removeAllJoints(): void;

  sampleFieldsAt(position: unknown /* ext vector */): unknown /* ext vector */;

  bodyAtPoint(point: CGPoint): SKPhysicsBody;

  bodyInRect(rect: CGRect): SKPhysicsBody;

  bodyAlongRayStartEnd(start: CGPoint, end: CGPoint): SKPhysicsBody;

  enumerateBodiesAtPointUsingBlock(point: CGPoint, block: (p1: SKPhysicsBody, p2: interop.PointerConvertible) => void): void;

  enumerateBodiesInRectUsingBlock(rect: CGRect, block: (p1: SKPhysicsBody, p2: interop.PointerConvertible) => void): void;

  enumerateBodiesAlongRayStartEndUsingBlock(start: CGPoint, end: CGPoint, block: (p1: SKPhysicsBody, p2: CGPoint, p3: CGVector, p4: interop.PointerConvertible) => void): void;

  static readonly supportsSecureCoding: boolean;

  encodeWithCoder(coder: NSCoder): void;

  initWithCoder(coder: NSCoder): this;
}

declare class SKTransition extends NSObject implements NSCopying {
  static crossFadeWithDuration(sec: number): SKTransition;

  static fadeWithDuration(sec: number): SKTransition;

  static fadeWithColorDuration(color: NSColor, sec: number): SKTransition;

  static flipHorizontalWithDuration(sec: number): SKTransition;

  static flipVerticalWithDuration(sec: number): SKTransition;

  static revealWithDirectionDuration(direction: interop.Enum<typeof SKTransitionDirection>, sec: number): SKTransition;

  static moveInWithDirectionDuration(direction: interop.Enum<typeof SKTransitionDirection>, sec: number): SKTransition;

  static pushWithDirectionDuration(direction: interop.Enum<typeof SKTransitionDirection>, sec: number): SKTransition;

  static doorsOpenHorizontalWithDuration(sec: number): SKTransition;

  static doorsOpenVerticalWithDuration(sec: number): SKTransition;

  static doorsCloseHorizontalWithDuration(sec: number): SKTransition;

  static doorsCloseVerticalWithDuration(sec: number): SKTransition;

  static doorwayWithDuration(sec: number): SKTransition;

  static transitionWithCIFilterDuration(filter: CIFilter, sec: number): SKTransition;

  pausesIncomingScene: boolean;

  pausesOutgoingScene: boolean;

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

declare class SKFieldNode extends SKNode {
  region: SKRegion;

  strength: number;

  falloff: number;

  minimumRadius: number;

  enabled: boolean;

  exclusive: boolean;

  categoryBitMask: number;

  direction: unknown /* ext vector */;

  smoothness: number;

  animationSpeed: number;

  texture: SKTexture;

  static dragField(): SKFieldNode;

  static vortexField(): SKFieldNode;

  static radialGravityField(): SKFieldNode;

  static linearGravityFieldWithVector(direction: unknown /* ext vector */): SKFieldNode;

  static velocityFieldWithVector(direction: unknown /* ext vector */): SKFieldNode;

  static velocityFieldWithTexture(velocityTexture: SKTexture): SKFieldNode;

  static noiseFieldWithSmoothnessAnimationSpeed(smoothness: number, speed: number): SKFieldNode;

  static turbulenceFieldWithSmoothnessAnimationSpeed(smoothness: number, speed: number): SKFieldNode;

  static springField(): SKFieldNode;

  static electricField(): SKFieldNode;

  static magneticField(): SKFieldNode;

  static customFieldWithEvaluationBlock(block: (p1: unknown /* ext vector */, p2: unknown /* ext vector */, p3: number, p4: number, p5: number) => unknown /* ext vector */): SKFieldNode;

  isEnabled(): boolean;

  isExclusive(): boolean;
}

