/// <reference types="@nativescript/objc-node-api" />

declare const kCGWindowLayer: interop.Pointer;

declare const kCGPDFContextOutputIntents: interop.Pointer;

declare const kCGColorSpaceDCIP3: interop.Pointer;

declare const kCGWindowNumber: interop.Pointer;

declare const kCGFontVariationAxisMinValue: interop.Pointer;

declare const kCGColorSpaceExtendedSRGB: interop.Pointer;

declare const kCGColorSpaceITUR_709: interop.Pointer;

declare const kCGColorSpaceITUR_2100_PQ: interop.Pointer;

declare const CGAffineTransformIdentity: CGAffineTransform;

declare const kCGWindowBackingLocationVideoMemory: interop.Pointer;

declare const kCGWindowMemoryUsage: interop.Pointer;

declare const kCGColorSpaceExtendedRange: interop.Pointer;

declare const kCGDisplayStreamMinimumFrameTime: interop.Pointer;

declare const kCGPDFTagPropertyTitleText: interop.Pointer;

declare const kCGDisplayStreamYCbCrMatrix_SMPTE_240M_1995: interop.Pointer;

declare const kCGDisplayStreamYCbCrMatrix_ITU_R_601_4: interop.Pointer;

declare const kCGDisplayStreamYCbCrMatrix: interop.Pointer;

declare const kCGDisplayStreamColorSpace: interop.Pointer;

declare const kCGDisplayStreamPreserveAspectRatio: interop.Pointer;

declare const kCGDisplayStreamDestinationRect: interop.Pointer;

declare const kCGDisplayStreamSourceRect: interop.Pointer;

declare const kCGWindowIsOnscreen: interop.Pointer;

declare const kCGWindowOwnerPID: interop.Pointer;

declare const kCGWindowAlpha: interop.Pointer;

declare const kCGWindowSharingState: interop.Pointer;

declare const kCGWindowStoreType: interop.Pointer;

declare const kCGPDFTagPropertyAlternativeText: interop.Pointer;

declare const kCGPDFTagPropertyActualText: interop.Pointer;

declare const kCGPDFContextCreatePDFA: interop.Pointer;

declare const kCGPDFContextCreateLinearizedPDF: interop.Pointer;

declare const kCGPDFContextAccessPermissions: interop.Pointer;

declare const kCGPDFXRegistryName: interop.Pointer;

declare const kCGPDFXOutputConditionIdentifier: interop.Pointer;

declare const kCGPDFXOutputIntentSubtype: interop.Pointer;

declare const kCGPDFContextOutputIntent: interop.Pointer;

declare const kCGPDFContextAllowsPrinting: interop.Pointer;

declare const kCGPDFContextEncryptionKeyLength: interop.Pointer;

declare const kCGPDFContextOwnerPassword: interop.Pointer;

declare const kCGPDFContextCreator: interop.Pointer;

declare const kCGPDFContextKeywords: interop.Pointer;

declare const kCGPDFContextSubject: interop.Pointer;

declare const kCGPDFContextAuthor: interop.Pointer;

declare const kCGPDFContextArtBox: interop.Pointer;

declare const kCGPDFContextTrimBox: interop.Pointer;

declare const kCGPDFContextBleedBox: interop.Pointer;

declare const kCGPDFContextCropBox: interop.Pointer;

declare const kCGColorConversionTRCSize: interop.Pointer;

declare const kCGColorConversionBlackPointCompensation: interop.Pointer;

declare const kCGColorSpaceAdobeRGB1998: interop.Pointer;

declare const CGSizeZero: CGSize;

declare const kCGWindowName: interop.Pointer;

declare const kCGPDFOutlineTitle: interop.Pointer;

declare const kCGColorSpaceDisplayP3_HLG: interop.Pointer;

declare const kCGPDFContextMediaBox: interop.Pointer;

declare const kCGPDFOutlineDestinationRect: interop.Pointer;

declare const kCGPDFOutlineChildren: interop.Pointer;

declare const kCGBitmapByteOrder32Host: interop.Enum<typeof CGBitmapInfo>;

declare const kCGBitmapByteOrder16Host: interop.Enum<typeof CGBitmapInfo>;

declare const kCGFontVariationAxisMaxValue: interop.Pointer;

declare const kCGFontVariationAxisName: interop.Pointer;

declare const kCGGlyphMax: number;

declare const kCGFontIndexInvalid: number;

declare const kCGFontIndexMax: number;

declare const kCGColorClear: interop.Pointer;

declare const kCGColorBlack: interop.Pointer;

declare const kCGColorSpaceExtendedLinearGray: interop.Pointer;

declare const kCGColorSpaceLinearGray: interop.Pointer;

declare const kCGColorSpaceExtendedGray: interop.Pointer;

declare const kCGColorSpaceLinearSRGB: interop.Pointer;

declare const kCGColorSpaceITUR_2020_PQ_EOTF: interop.Pointer;

declare const kCGColorSpaceDisplayP3_PQ_EOTF: interop.Pointer;

declare const kCGColorSpaceITUR_2020_HLG: interop.Pointer;

declare const kCGColorSpaceITUR_2020_PQ: interop.Pointer;

declare const kCGColorSpaceExtendedLinearDisplayP3: interop.Pointer;

declare const kCGColorSpaceExtendedDisplayP3: interop.Pointer;

declare const kCGColorSpaceROMMRGB: interop.Pointer;

declare const kCGColorSpaceACESCGLinear: interop.Pointer;

declare const kCGColorSpaceGenericLab: interop.Pointer;

declare const kCGColorSpaceGenericXYZ: interop.Pointer;

declare const kCGColorSpaceSRGB: interop.Pointer;

declare const kCGColorSpaceGenericCMYK: interop.Pointer;

declare const kCGColorSpaceGenericRGB: interop.Pointer;

declare const kCGPDFXInfo: interop.Pointer;

declare const kCGPDFOutlineDestination: interop.Pointer;

declare const kCGDisplayStreamShowCursor: interop.Pointer;

declare const kCGColorSpaceDisplayP3: interop.Pointer;

declare const kCGPDFContextTitle: interop.Pointer;

declare const kCGWindowWorkspace: interop.Pointer;

declare const kCGDisplayShowDuplicateLowResolutionModes: interop.Pointer;

declare const kCGColorSpaceGenericGrayGamma2_2: interop.Pointer;

declare const kCGWindowOwnerName: interop.Pointer;

declare const kCGPDFTagPropertyLanguageText: interop.Pointer;

declare const kCGPDFXOutputCondition: interop.Pointer;

declare const kCGAdaptiveMaximumBitDepth: interop.Pointer;

declare const CGPointZero: CGPoint;

declare const kCGColorSpaceExtendedLinearSRGB: interop.Pointer;

declare const kCGColorSpaceITUR_2020: interop.Pointer;

declare const kCGColorSpaceGenericGray: interop.Pointer;

declare const kCGPDFXDestinationOutputProfile: interop.Pointer;

declare const kCGColorSpaceExtendedITUR_2020: interop.Pointer;

declare const kCGColorWhite: interop.Pointer;

declare const kCGPDFContextAllowsCopying: interop.Pointer;

declare const kCGFontVariationAxisDefaultValue: interop.Pointer;

declare const kCGDisplayStreamQueueDepth: interop.Pointer;

declare const kCGColorSpaceITUR_2100_HLG: interop.Pointer;

declare const CGRectZero: CGRect;

declare const kCGColorSpaceDisplayP3_PQ: interop.Pointer;

declare const kCGDisplayStreamYCbCrMatrix_ITU_R_709_2: interop.Pointer;

declare const kCGPDFContextUserPassword: interop.Pointer;

declare const kCGWindowBounds: interop.Pointer;

declare const CGRectNull: CGRect;

declare const kCGColorSpaceExtendedLinearITUR_2020: interop.Pointer;

declare const CGRectInfinite: CGRect;

declare const kCGColorSpaceGenericRGBLinear: interop.Pointer;

declare const CGEventTapLocation: {
  HID: 0,
  Session: 1,
  AnnotatedSession: 2,
};

declare const CGInterpolationQuality: {
  Default: 0,
  None: 1,
  Low: 2,
  Medium: 4,
  High: 3,
};

declare const CGLineJoin: {
  Miter: 0,
  Round: 1,
  Bevel: 2,
};

declare const CGConfigureOption: {
  ForAppOnly: 0,
  ForSession: 1,
  Permanently: 2,
};

declare const CGPDFBox: {
  Media: 0,
  Crop: 1,
  Bleed: 2,
  Trim: 3,
  Art: 4,
};

declare const CGEventSourceStateID: {
  Private: -1,
  CombinedSessionState: 0,
  HIDSystemState: 1,
};

declare const CGImagePixelFormatInfo: {
  Mask: 983040,
  Packed: 0,
  RGB555: 65536,
  RGB565: 131072,
  RGB101010: 196608,
  RGBCIF10: 262144,
};

declare const CGGradientDrawingOptions: {
  BeforeStart: 1,
  AfterEnd: 2,
};

declare const CGGlyphDeprecatedEnum: {
  Min: 0,
  Max: 1,
};

declare const CGPatternTiling: {
  NoDistortion: 0,
  ConstantSpacingMinimalDistortion: 1,
  ConstantSpacing: 2,
};

declare const CGEventMouseSubtype: {
  Default: 0,
  TabletPoint: 1,
  TabletProximity: 2,
};

declare const CGPDFDataFormat: {
  Raw: 0,
  JPEGEncoded: 1,
  JPEG2000: 2,
};

declare const CGComponent: {
  Unknown: 0,
  Integer8Bit: 1,
  Integer10Bit: 6,
  Integer16Bit: 2,
  Integer32Bit: 3,
  Float16Bit: 5,
  Float32Bit: 4,
};

declare const CGWindowListOption: {
  OptionAll: 0,
  OptionOnScreenOnly: 1,
  OptionOnScreenAboveWindow: 2,
  OptionOnScreenBelowWindow: 4,
  OptionIncludingWindow: 8,
  ExcludeDesktopElements: 16,
};

declare const CGPDFObjectType: {
  Null: 1,
  Boolean: 2,
  Integer: 3,
  Real: 4,
  Name: 5,
  String: 6,
  Array: 7,
  Dictionary: 8,
  Stream: 9,
};

declare const CGScreenUpdateOperation: {
  Refresh: 0,
  Move: 1,
  ReducedDirtyRectangleCount: -2147483648,
};

declare const CGImageComponentInfo: {
  Integer: 0,
  Float: 256,
};

declare const CGEventTapPlacement: {
  HeadInsert: 0,
  TailAppend: 1,
};

declare const CGScrollPhase: {
  Began: 1,
  Changed: 2,
  Ended: 4,
  Cancelled: 8,
  MayBegin: 128,
};

declare const CGEventField: {
  MouseEventNumber: 0,
  MouseEventClickState: 1,
  MouseEventPressure: 2,
  MouseEventButtonNumber: 3,
  MouseEventDeltaX: 4,
  MouseEventDeltaY: 5,
  MouseEventInstantMouser: 6,
  MouseEventSubtype: 7,
  KeyboardEventAutorepeat: 8,
  KeyboardEventKeycode: 9,
  KeyboardEventKeyboardType: 10,
  ScrollWheelEventDeltaAxis1: 11,
  ScrollWheelEventDeltaAxis2: 12,
  ScrollWheelEventDeltaAxis3: 13,
  ScrollWheelEventFixedPtDeltaAxis1: 93,
  ScrollWheelEventFixedPtDeltaAxis2: 94,
  ScrollWheelEventFixedPtDeltaAxis3: 95,
  ScrollWheelEventPointDeltaAxis1: 96,
  ScrollWheelEventPointDeltaAxis2: 97,
  ScrollWheelEventPointDeltaAxis3: 98,
  ScrollWheelEventScrollPhase: 99,
  ScrollWheelEventScrollCount: 100,
  ScrollWheelEventMomentumPhase: 123,
  ScrollWheelEventInstantMouser: 14,
  TabletEventPointX: 15,
  TabletEventPointY: 16,
  TabletEventPointZ: 17,
  TabletEventPointButtons: 18,
  TabletEventPointPressure: 19,
  TabletEventTiltX: 20,
  TabletEventTiltY: 21,
  TabletEventRotation: 22,
  TabletEventTangentialPressure: 23,
  TabletEventDeviceID: 24,
  TabletEventVendor1: 25,
  TabletEventVendor2: 26,
  TabletEventVendor3: 27,
  TabletProximityEventVendorID: 28,
  TabletProximityEventTabletID: 29,
  TabletProximityEventPointerID: 30,
  TabletProximityEventDeviceID: 31,
  TabletProximityEventSystemTabletID: 32,
  TabletProximityEventVendorPointerType: 33,
  TabletProximityEventVendorPointerSerialNumber: 34,
  TabletProximityEventVendorUniqueID: 35,
  TabletProximityEventCapabilityMask: 36,
  TabletProximityEventPointerType: 37,
  TabletProximityEventEnterProximity: 38,
  EventTargetProcessSerialNumber: 39,
  EventTargetUnixProcessID: 40,
  EventSourceUnixProcessID: 41,
  EventSourceUserData: 42,
  EventSourceUserID: 43,
  EventSourceGroupID: 44,
  EventSourceStateID: 45,
  ScrollWheelEventIsContinuous: 88,
  MouseEventWindowUnderMousePointer: 91,
  MouseEventWindowUnderMousePointerThatCanHandleThisEvent: 92,
  EventUnacceleratedPointerMovementX: 170,
  EventUnacceleratedPointerMovementY: 171,
  ScrollWheelEventMomentumOptionPhase: 173,
  ScrollWheelEventAcceleratedDeltaAxis1: 176,
  ScrollWheelEventAcceleratedDeltaAxis2: 175,
  ScrollWheelEventRawDeltaAxis1: 178,
  ScrollWheelEventRawDeltaAxis2: 177,
};

declare const CGEventFlags: {
  AlphaShift: 65536,
  Shift: 131072,
  Control: 262144,
  Alternate: 524288,
  Command: 1048576,
  Help: 4194304,
  SecondaryFn: 8388608,
  NumericPad: 2097152,
  NonCoalesced: 256,
};

declare const CGGesturePhase: {
  None: 0,
  Began: 1,
  Changed: 2,
  Ended: 4,
  Cancelled: 8,
  MayBegin: 128,
};

declare const CGDisplayStreamFrameStatus: {
  FrameComplete: 0,
  FrameIdle: 1,
  FrameBlank: 2,
  Stopped: 3,
};

declare const CGDisplayStreamUpdateRectType: {
  Refreshed: 0,
  Moved: 1,
  Dirty: 2,
  ReducedDirty: 3,
};

declare const CGDisplayChangeSummaryFlags: {
  BeginConfiguration: 1,
  Moved: 2,
  SetMain: 4,
  SetMode: 8,
  Add: 16,
  Remove: 32,
  Enabled: 256,
  Disabled: 512,
  Mirror: 1024,
  UnMirror: 2048,
  DesktopShapeChanged: 4096,
};

declare const CGWindowLevelKey: {
  BaseWindowLevelKey: 0,
  MinimumWindowLevelKey: 1,
  DesktopWindowLevelKey: 2,
  BackstopMenuLevelKey: 3,
  NormalWindowLevelKey: 4,
  FloatingWindowLevelKey: 5,
  TornOffMenuWindowLevelKey: 6,
  DockWindowLevelKey: 7,
  MainMenuWindowLevelKey: 8,
  StatusWindowLevelKey: 9,
  ModalPanelWindowLevelKey: 10,
  PopUpMenuWindowLevelKey: 11,
  DraggingWindowLevelKey: 12,
  ScreenSaverWindowLevelKey: 13,
  MaximumWindowLevelKey: 14,
  OverlayWindowLevelKey: 15,
  HelpWindowLevelKey: 16,
  UtilityWindowLevelKey: 17,
  DesktopIconWindowLevelKey: 18,
  CursorWindowLevelKey: 19,
  AssistiveTechHighWindowLevelKey: 20,
  NumberOfWindowLevelKeys: 21,
};

declare const CGWindowBackingType: {
  Retained: 0,
  Nonretained: 1,
  Buffered: 2,
};

declare const CGWindowSharingType: {
  None: 0,
  ReadOnly: 1,
  ReadWrite: 2,
};

declare const CGBitmapLayout: {
  AlphaOnly: 0,
  Gray: 1,
  GrayAlpha: 2,
  RGBA: 3,
  ARGB: 4,
  RGBX: 5,
  XRGB: 6,
  BGRA: 7,
  BGRX: 8,
  ABGR: 9,
  XBGR: 10,
  CMYK: 11,
};

declare const CGColorModel: {
  NoColorant: 0,
  Gray: 1,
  RGB: 2,
  CMYK: 4,
  Lab: 8,
  DeviceN: 16,
};

declare const CGCaptureOptions: {
  Options: 0,
  Fill: 1,
};

declare const CGBlendMode: {
  Normal: 0,
  Multiply: 1,
  Screen: 2,
  Overlay: 3,
  Darken: 4,
  Lighten: 5,
  ColorDodge: 6,
  ColorBurn: 7,
  SoftLight: 8,
  HardLight: 9,
  Difference: 10,
  Exclusion: 11,
  Hue: 12,
  Saturation: 13,
  Color: 14,
  Luminosity: 15,
  Clear: 16,
  Copy: 17,
  SourceIn: 18,
  SourceOut: 19,
  SourceAtop: 20,
  DestinationOver: 21,
  DestinationIn: 22,
  DestinationOut: 23,
  DestinationAtop: 24,
  XOR: 25,
  PlusDarker: 26,
  PlusLighter: 27,
};

declare const CGTextEncoding: {
  FontSpecific: 0,
  MacRoman: 1,
};

declare const CGError: {
  Success: 0,
  Failure: 1000,
  IllegalArgument: 1001,
  InvalidConnection: 1002,
  InvalidContext: 1003,
  CannotComplete: 1004,
  NotImplemented: 1006,
  RangeCheck: 1007,
  TypeCheck: 1008,
  InvalidOperation: 1010,
  NoneAvailable: 1011,
};

declare const CGPathDrawingMode: {
  Fill: 0,
  EOFill: 1,
  Stroke: 2,
  FillStroke: 3,
  EOFillStroke: 4,
};

declare const CGImageAlphaInfo: {
  None: 0,
  PremultipliedLast: 1,
  PremultipliedFirst: 2,
  Last: 3,
  First: 4,
  NoneSkipLast: 5,
  NoneSkipFirst: 6,
  Only: 7,
};

declare const CGColorRenderingIntent: {
  Default: 0,
  AbsoluteColorimetric: 1,
  RelativeColorimetric: 2,
  Perceptual: 3,
  Saturation: 4,
};

declare const CGEventTapOptions: {
  Default: 0,
  ListenOnly: 1,
};

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

declare const CGFontPostScriptFormat: {
  Type1: 1,
  Type3: 3,
  Type42: 42,
};

declare const CGTextDrawingMode: {
  Fill: 0,
  Stroke: 1,
  FillStroke: 2,
  Invisible: 3,
  FillClip: 4,
  StrokeClip: 5,
  FillStrokeClip: 6,
  Clip: 7,
};

declare const CGEventSuppressionState: {
  EventSuppressionStateSuppressionInterval: 0,
  EventSuppressionStateRemoteMouseDrag: 1,
  NumberOfEventSuppressionStates: 2,
};

declare const CGPDFTagType: {
  Document: 100,
  Part: 101,
  Art: 102,
  Section: 103,
  Div: 104,
  BlockQuote: 105,
  Caption: 106,
  TOC: 107,
  TOCI: 108,
  Index: 109,
  NonStructure: 110,
  Private: 111,
  Paragraph: 200,
  Header: 201,
  Header1: 202,
  Header2: 203,
  Header3: 204,
  Header4: 205,
  Header5: 206,
  Header6: 207,
  List: 300,
  ListItem: 301,
  Label: 302,
  ListBody: 303,
  Table: 400,
  TableRow: 401,
  TableHeaderCell: 402,
  TableDataCell: 403,
  TableHeader: 404,
  TableBody: 405,
  TableFooter: 406,
  Span: 500,
  Quote: 501,
  Note: 502,
  Reference: 503,
  Bibliography: 504,
  Code: 505,
  Link: 506,
  Annotation: 507,
  Ruby: 600,
  RubyBaseText: 601,
  RubyAnnotationText: 602,
  RubyPunctuation: 603,
  Warichu: 604,
  WarichuText: 605,
  WarichuPunctiation: 606,
  Figure: 700,
  Formula: 701,
  Form: 702,
  Object: 800,
};

declare const CGImageByteOrderInfo: {
  OrderMask: 28672,
  OrderDefault: 0,
  Order16Little: 4096,
  Order32Little: 8192,
  Order16Big: 12288,
  Order32Big: 16384,
  Order16Host: 4096,
  Order32Host: 8192,
};

declare const CGEventFilterMask: {
  LocalMouse: 1,
  LocalKeyboard: 2,
  SystemDefined: 4,
};

declare const CGBitmapInfo: {
  AlphaInfoMask: 31,
  ComponentInfoMask: 3840,
  ByteOrderInfoMask: 28672,
  PixelFormatInfoMask: 983040,
  FloatInfoMask: 3840,
  ByteOrderMask: 28672,
  FloatComponents: 256,
  ByteOrderDefault: 0,
  ByteOrder16Little: 4096,
  ByteOrder32Little: 8192,
  ByteOrder16Big: 12288,
  ByteOrder32Big: 16384,
};

declare const CGColorConversionInfoTransformType: {
  From: 0,
  To: 1,
  Apply: 2,
};

declare const CGWindowImageOption: {
  Default: 0,
  BoundsIgnoreFraming: 1,
  ShouldBeOpaque: 2,
  OnlyShadows: 4,
  BestResolution: 8,
  NominalResolution: 16,
};

declare const CGPDFAccessPermissions: {
  LowQualityPrinting: 1,
  HighQualityPrinting: 2,
  DocumentChanges: 4,
  DocumentAssembly: 8,
  ContentCopying: 16,
  ContentAccessibility: 32,
  Commenting: 64,
  FormFieldEntry: 128,
};

declare const CGMomentumScrollPhase: {
  None: 0,
  Begin: 1,
  Continue: 2,
  End: 3,
};

declare const CGEventType: {
  Null: 0,
  LeftMouseDown: 1,
  LeftMouseUp: 2,
  RightMouseDown: 3,
  RightMouseUp: 4,
  MouseMoved: 5,
  LeftMouseDragged: 6,
  RightMouseDragged: 7,
  KeyDown: 10,
  KeyUp: 11,
  FlagsChanged: 12,
  ScrollWheel: 22,
  TabletPointer: 23,
  TabletProximity: 24,
  OtherMouseDown: 25,
  OtherMouseUp: 26,
  OtherMouseDragged: 27,
  TapDisabledByTimeout: -2,
  TapDisabledByUserInput: -1,
};

declare const CGPathElementType: {
  MoveToPoint: 0,
  AddLineToPoint: 1,
  AddQuadCurveToPoint: 2,
  AddCurveToPoint: 3,
  CloseSubpath: 4,
};

declare const CGColorSpaceModel: {
  Unknown: -1,
  Monochrome: 0,
  RGB: 1,
  CMYK: 2,
  Lab: 3,
  DeviceN: 4,
  Indexed: 5,
  Pattern: 6,
  XYZ: 7,
};

declare const CGScrollEventUnit: {
  Pixel: 0,
  Line: 1,
};

declare const CGLineCap: {
  Butt: 0,
  Round: 1,
  Square: 2,
};

declare class CGFunctionCallbacks {
  constructor(init?: CGFunctionCallbacks);
  version: number;
  evaluate: (p1: interop.PointerConvertible, p2: interop.PointerConvertible, p3: interop.PointerConvertible) => void | null;
  releaseInfo: (p1: interop.PointerConvertible) => void | null;
}

declare class CGContentToneMappingInfo {
  constructor(init?: CGContentToneMappingInfo);
  method: interop.Enum<typeof CGToneMapping>;
  options: interop.Object | null;
}

declare class CGDataProvider {
  constructor(init?: CGDataProvider);
}

declare class CGPath {
  constructor(init?: CGPath);
}

declare class CGPDFStream {
  constructor(init?: CGPDFStream);
}

declare class CGColorConversionInfo {
  constructor(init?: CGColorConversionInfo);
}

declare class CGDataConsumerCallbacks {
  constructor(init?: CGDataConsumerCallbacks);
  putBytes: (p1: interop.PointerConvertible, p2: interop.PointerConvertible, p3: number) => number | null;
  releaseConsumer: (p1: interop.PointerConvertible) => void | null;
}

declare class CGDataConsumer {
  constructor(init?: CGDataConsumer);
}

declare class CGPDFDictionary {
  constructor(init?: CGPDFDictionary);
}

declare class CGDeviceColor {
  constructor(init?: CGDeviceColor);
  red: number;
  green: number;
  blue: number;
}

declare class CGDataProviderDirectCallbacks {
  constructor(init?: CGDataProviderDirectCallbacks);
  version: number;
  getBytePointer: (p1: interop.PointerConvertible) => interop.Pointer | null;
  releaseBytePointer: (p1: interop.PointerConvertible, p2: interop.PointerConvertible) => void | null;
  getBytesAtPosition: (p1: interop.PointerConvertible, p2: interop.PointerConvertible, p3: number, p4: number) => number | null;
  releaseInfo: (p1: interop.PointerConvertible) => void | null;
}

declare class CGScreenUpdateMoveDelta {
  constructor(init?: CGScreenUpdateMoveDelta);
  dX: number;
  dY: number;
}

declare class CGColorSpace {
  constructor(init?: CGColorSpace);
}

declare class CGPDFString {
  constructor(init?: CGPDFString);
}

declare class CGPSConverterCallbacks {
  constructor(init?: CGPSConverterCallbacks);
  version: number;
  beginDocument: (p1: interop.PointerConvertible) => void | null;
  endDocument: (p1: interop.PointerConvertible, p2: boolean) => void | null;
  beginPage: (p1: interop.PointerConvertible, p2: number, p3: interop.PointerConvertible) => void | null;
  endPage: (p1: interop.PointerConvertible, p2: number, p3: interop.PointerConvertible) => void | null;
  noteProgress: (p1: interop.PointerConvertible) => void | null;
  noteMessage: (p1: interop.PointerConvertible, p2: interop.PointerConvertible) => void | null;
  releaseInfo: (p1: interop.PointerConvertible) => void | null;
}

declare class __CGEventSource {
  constructor(init?: __CGEventSource);
}

declare class __CGEventTapInformation {
  constructor(init?: __CGEventTapInformation);
  eventTapID: number;
  tapPoint: interop.Enum<typeof CGEventTapLocation>;
  options: interop.Enum<typeof CGEventTapOptions>;
  eventsOfInterest: number;
  tappingProcess: number;
  processBeingTapped: number;
  enabled: boolean;
  minUsecLatency: number;
  avgUsecLatency: number;
  maxUsecLatency: number;
}

declare class __CGEventTapProxy {
  constructor(init?: __CGEventTapProxy);
}

declare class __CGEvent {
  constructor(init?: __CGEvent);
}

declare class CGDisplayMode {
  constructor(init?: CGDisplayMode);
}

declare class CGPDFScanner {
  constructor(init?: CGPDFScanner);
}

declare class CGPDFOperatorTable {
  constructor(init?: CGPDFOperatorTable);
}

declare class CGPDFContentStream {
  constructor(init?: CGPDFContentStream);
}

declare class CGColorDataFormat {
  constructor(init?: CGColorDataFormat);
  version: number;
  colorspace_info: interop.Object | null;
  bitmap_info: interop.Enum<typeof CGBitmapInfo>;
  bits_per_component: number;
  bytes_per_row: number;
  intent: interop.Enum<typeof CGColorRenderingIntent>;
  decode: interop.Pointer;
}

declare class CGPSConverter {
  constructor(init?: CGPSConverter);
}

declare class CGContentInfo {
  constructor(init?: CGContentInfo);
  deepestImageComponent: interop.Enum<typeof CGComponent>;
  contentColorModels: interop.Enum<typeof CGColorModel>;
  hasWideGamut: boolean;
  hasTransparency: boolean;
  largestContentHeadroom: number;
}

declare class CGRenderingBufferProvider {
  constructor(init?: CGRenderingBufferProvider);
}

declare class CGColorBufferFormat {
  constructor(init?: CGColorBufferFormat);
  version: number;
  bitmapInfo: interop.Enum<typeof CGBitmapInfo>;
  bitsPerComponent: number;
  bitsPerPixel: number;
  bytesPerRow: number;
}

declare class CGPDFPage {
  constructor(init?: CGPDFPage);
}

declare class CGImage {
  constructor(init?: CGImage);
}

declare class CGFunction {
  constructor(init?: CGFunction);
}

declare class CGShading {
  constructor(init?: CGShading);
}

declare class CGGradient {
  constructor(init?: CGGradient);
}

declare class CGFont {
  constructor(init?: CGFont);
}

declare class CGPattern {
  constructor(init?: CGPattern);
}

declare class CGColor {
  constructor(init?: CGColor);
}

declare class CGPatternCallbacks {
  constructor(init?: CGPatternCallbacks);
  version: number;
  drawPattern: (p1: interop.PointerConvertible, p2: interop.PointerConvertible) => void | null;
  releaseInfo: (p1: interop.PointerConvertible) => void | null;
}

declare class CGPDFArray {
  constructor(init?: CGPDFArray);
}

declare class CGPDFObject {
  constructor(init?: CGPDFObject);
}

declare class CGDataProviderSequentialCallbacks {
  constructor(init?: CGDataProviderSequentialCallbacks);
  version: number;
  getBytes: (p1: interop.PointerConvertible, p2: interop.PointerConvertible, p3: number) => number | null;
  skipForward: (p1: interop.PointerConvertible, p2: number) => number | null;
  rewind: (p1: interop.PointerConvertible) => void | null;
  releaseInfo: (p1: interop.PointerConvertible) => void | null;
}

declare class CGPDFDocument {
  constructor(init?: CGPDFDocument);
}

declare class CGContext {
  constructor(init?: CGContext);
}

declare class _CGDisplayConfigRef {
  constructor(init?: _CGDisplayConfigRef);
}

declare class ColorSyncProfile {
  constructor(init?: ColorSyncProfile);
}

declare class CGLayer {
  constructor(init?: CGLayer);
}

declare class CGDisplayStreamUpdate {
  constructor(init?: CGDisplayStreamUpdate);
}

declare class CGDisplayStream {
  constructor(init?: CGDisplayStream);
}

declare class CGBitmapParameters {
  constructor(init?: CGBitmapParameters);
  width: number;
  height: number;
  bytesPerPixel: number;
  alignedBytesPerRow: number;
  component: interop.Enum<typeof CGComponent>;
  layout: interop.Enum<typeof CGBitmapLayout>;
  format: interop.Enum<typeof CGImagePixelFormatInfo>;
  colorSpace: interop.Object | null;
  hasPremultipliedAlpha: boolean;
  byteOrder: number;
  edrTargetHeadroom: number;
}

declare class __IOSurface {
  constructor(init?: __IOSurface);
}

declare class CGPathElement {
  constructor(init?: CGPathElement);
  type: interop.Enum<typeof CGPathElementType>;
  points: interop.Pointer;
}

declare function CGRectGetMinX(rect: CGRect): number;

declare function CGRectGetMidX(rect: CGRect): number;

declare function CGRectGetMaxX(rect: CGRect): number;

declare function CGRectGetMinY(rect: CGRect): number;

declare function CGRectGetMidY(rect: CGRect): number;

declare function CGRectGetMaxY(rect: CGRect): number;

declare function CGRectGetWidth(rect: CGRect): number;

declare function CGRectGetHeight(rect: CGRect): number;

declare function CGPointEqualToPoint(point1: CGPoint, point2: CGPoint): boolean;

declare function CGSizeEqualToSize(size1: CGSize, size2: CGSize): boolean;

declare function CGRectEqualToRect(rect1: CGRect, rect2: CGRect): boolean;

declare function CGRectStandardize(rect: CGRect): CGRect;

declare function CGRectIsEmpty(rect: CGRect): boolean;

declare function CGRectIsNull(rect: CGRect): boolean;

declare function CGRectIsInfinite(rect: CGRect): boolean;

declare function CGRectInset(rect: CGRect, dx: number, dy: number): CGRect;

declare function CGRectIntegral(rect: CGRect): CGRect;

declare function CGRectUnion(r1: CGRect, r2: CGRect): CGRect;

declare function CGRectIntersection(r1: CGRect, r2: CGRect): CGRect;

declare function CGRectOffset(rect: CGRect, dx: number, dy: number): CGRect;

declare function CGRectDivide(rect: CGRect, slice: interop.PointerConvertible, remainder: interop.PointerConvertible, amount: number, edge: interop.Enum<typeof CGRectEdge>): void;

declare function CGRectContainsPoint(rect: CGRect, point: CGPoint): boolean;

declare function CGRectContainsRect(rect1: CGRect, rect2: CGRect): boolean;

declare function CGRectIntersectsRect(rect1: CGRect, rect2: CGRect): boolean;

declare function CGPointCreateDictionaryRepresentation(point: CGPoint): interop.Object;

declare function CGPointMakeWithDictionaryRepresentation(dict: interop.Object, point: interop.PointerConvertible): boolean;

declare function CGSizeCreateDictionaryRepresentation(size: CGSize): interop.Object;

declare function CGSizeMakeWithDictionaryRepresentation(dict: interop.Object, size: interop.PointerConvertible): boolean;

declare function CGRectCreateDictionaryRepresentation(p1: CGRect): interop.Object;

declare function CGRectMakeWithDictionaryRepresentation(dict: interop.Object, rect: interop.PointerConvertible): boolean;

declare function CGAffineTransformMake(a: number, b: number, c: number, d: number, tx: number, ty: number): CGAffineTransform;

declare function CGAffineTransformMakeTranslation(tx: number, ty: number): CGAffineTransform;

declare function CGAffineTransformMakeScale(sx: number, sy: number): CGAffineTransform;

declare function CGAffineTransformMakeRotation(angle: number): CGAffineTransform;

declare function CGAffineTransformIsIdentity(t: CGAffineTransform): boolean;

declare function CGAffineTransformTranslate(t: CGAffineTransform, tx: number, ty: number): CGAffineTransform;

declare function CGAffineTransformScale(t: CGAffineTransform, sx: number, sy: number): CGAffineTransform;

declare function CGAffineTransformRotate(t: CGAffineTransform, angle: number): CGAffineTransform;

declare function CGAffineTransformInvert(t: CGAffineTransform): CGAffineTransform;

declare function CGAffineTransformConcat(t1: CGAffineTransform, t2: CGAffineTransform): CGAffineTransform;

declare function CGAffineTransformEqualToTransform(t1: CGAffineTransform, t2: CGAffineTransform): boolean;

declare function CGPointApplyAffineTransform(point: CGPoint, t: CGAffineTransform): CGPoint;

declare function CGSizeApplyAffineTransform(size: CGSize, t: CGAffineTransform): CGSize;

declare function CGRectApplyAffineTransform(rect: CGRect, t: CGAffineTransform): CGRect;

declare function CGDataProviderGetTypeID(): number;

declare function CGDataProviderCreateSequential(info: interop.PointerConvertible, callbacks: interop.PointerConvertible): interop.Object;

declare function CGDataProviderCreateDirect(info: interop.PointerConvertible, size: number, callbacks: interop.PointerConvertible): interop.Object;

declare function CGDataProviderCreateWithData(info: interop.PointerConvertible, data: interop.PointerConvertible, size: number, releaseData: (p1: interop.PointerConvertible, p2: interop.PointerConvertible, p3: number) => void): interop.Object;

declare function CGDataProviderCreateWithCFData(data: interop.Object): interop.Object;

declare function CGDataProviderCreateWithURL(url: interop.Object): interop.Object;

declare function CGDataProviderCreateWithFilename(filename: string): interop.Object;

declare function CGDataProviderRetain(provider: interop.Object): interop.Object;

declare function CGDataProviderRelease(provider: interop.Object): void;

declare function CGDataProviderCopyData(provider: interop.Object): interop.Object;

declare function CGDataProviderGetInfo(provider: interop.Object): interop.Pointer;

declare function CGColorSpaceCreateDeviceGray(): interop.Object;

declare function CGColorSpaceCreateDeviceRGB(): interop.Object;

declare function CGColorSpaceCreateDeviceCMYK(): interop.Object;

declare function CGColorSpaceCreateCalibratedGray(whitePoint: interop.PointerConvertible, blackPoint: interop.PointerConvertible, gamma: number): interop.Object;

declare function CGColorSpaceCreateCalibratedRGB(whitePoint: interop.PointerConvertible, blackPoint: interop.PointerConvertible, gamma: interop.PointerConvertible, matrix: interop.PointerConvertible): interop.Object;

declare function CGColorSpaceCreateLab(whitePoint: interop.PointerConvertible, blackPoint: interop.PointerConvertible, range: interop.PointerConvertible): interop.Object;

declare function CGColorSpaceCreateWithICCData(data: interop.Object): interop.Object;

declare function CGColorSpaceCreateICCBased(nComponents: number, range: interop.PointerConvertible, profile: interop.Object, alternate: interop.Object): interop.Object;

declare function CGColorSpaceCreateIndexed(baseSpace: interop.Object, lastIndex: number, colorTable: interop.PointerConvertible): interop.Object;

declare function CGColorSpaceCreatePattern(baseSpace: interop.Object): interop.Object;

declare function CGColorSpaceCreateWithName(name: interop.Object): interop.Object;

declare function CGColorSpaceRetain(space: interop.Object): interop.Object;

declare function CGColorSpaceRelease(space: interop.Object): void;

declare function CGColorSpaceGetName(space: interop.Object): interop.Object;

declare function CGColorSpaceCopyName(space: interop.Object): interop.Object;

declare function CGColorSpaceGetTypeID(): number;

declare function CGColorSpaceGetNumberOfComponents(space: interop.Object): number;

declare function CGColorSpaceGetModel(space: interop.Object): interop.Enum<typeof CGColorSpaceModel>;

declare function CGColorSpaceGetBaseColorSpace(space: interop.Object): interop.Object;

declare function CGColorSpaceGetColorTableCount(space: interop.Object): number;

declare function CGColorSpaceGetColorTable(space: interop.Object, table: interop.PointerConvertible): void;

declare function CGColorSpaceCopyICCData(space: interop.Object): interop.Object;

declare function CGColorSpaceIsWideGamutRGB(p1: interop.Object): boolean;

declare function CGColorSpaceIsHDR(p1: interop.Object): boolean;

declare function CGColorSpaceUsesITUR_2100TF(p1: interop.Object): boolean;

declare function CGColorSpaceSupportsOutput(space: interop.Object): boolean;

declare function CGColorSpaceCopyPropertyList(space: interop.Object): interop.Object;

declare function CGColorSpaceCreateWithPropertyList(plist: interop.Object): interop.Object;

declare function CGColorSpaceUsesExtendedRange(space: interop.Object): boolean;

declare function CGColorSpaceCreateLinearized(space: interop.Object): interop.Object;

declare function CGColorSpaceCreateExtended(space: interop.Object): interop.Object;

declare function CGColorSpaceCreateExtendedLinearized(space: interop.Object): interop.Object;

declare function CGColorSpaceCreateWithICCProfile(data: interop.Object): interop.Object;

declare function CGColorSpaceCopyICCProfile(space: interop.Object): interop.Object;

declare function CGColorSpaceCreateWithPlatformColorSpace(ref: interop.PointerConvertible): interop.Object;

declare function CGPatternGetTypeID(): number;

declare function CGPatternCreate(info: interop.PointerConvertible, bounds: CGRect, matrix: CGAffineTransform, xStep: number, yStep: number, tiling: interop.Enum<typeof CGPatternTiling>, isColored: boolean, callbacks: interop.PointerConvertible): interop.Object;

declare function CGPatternRetain(pattern: interop.Object): interop.Object;

declare function CGPatternRelease(pattern: interop.Object): void;

declare function CGColorCreate(space: interop.Object, components: interop.PointerConvertible): interop.Object;

declare function CGColorCreateGenericGray(gray: number, alpha: number): interop.Object;

declare function CGColorCreateGenericRGB(red: number, green: number, blue: number, alpha: number): interop.Object;

declare function CGColorCreateGenericCMYK(cyan: number, magenta: number, yellow: number, black: number, alpha: number): interop.Object;

declare function CGColorCreateGenericGrayGamma2_2(gray: number, alpha: number): interop.Object;

declare function CGColorCreateSRGB(red: number, green: number, blue: number, alpha: number): interop.Object;

declare function CGColorGetConstantColor(colorName: interop.Object): interop.Object;

declare function CGColorCreateWithPattern(space: interop.Object, pattern: interop.Object, components: interop.PointerConvertible): interop.Object;

declare function CGColorCreateCopy(color: interop.Object): interop.Object;

declare function CGColorCreateCopyWithAlpha(color: interop.Object, alpha: number): interop.Object;

declare function CGColorCreateCopyByMatchingToColorSpace(p1: interop.Object, intent: interop.Enum<typeof CGColorRenderingIntent>, color: interop.Object, options: interop.Object): interop.Object;

declare function CGColorRetain(color: interop.Object): interop.Object;

declare function CGColorRelease(color: interop.Object): void;

declare function CGColorEqualToColor(color1: interop.Object, color2: interop.Object): boolean;

declare function CGColorGetNumberOfComponents(color: interop.Object): number;

declare function CGColorGetComponents(color: interop.Object): interop.Pointer;

declare function CGColorGetAlpha(color: interop.Object): number;

declare function CGColorGetColorSpace(color: interop.Object): interop.Object;

declare function CGColorGetPattern(color: interop.Object): interop.Object;

declare function CGColorGetTypeID(): number;

declare function CGFontGetTypeID(): number;

declare function CGFontCreateWithPlatformFont(platformFontReference: interop.PointerConvertible): interop.Object;

declare function CGFontCreateWithDataProvider(provider: interop.Object): interop.Object;

declare function CGFontCreateWithFontName(name: interop.Object): interop.Object;

declare function CGFontCreateCopyWithVariations(font: interop.Object, variations: interop.Object): interop.Object;

declare function CGFontRetain(font: interop.Object): interop.Object;

declare function CGFontRelease(font: interop.Object): void;

declare function CGFontGetNumberOfGlyphs(font: interop.Object): number;

declare function CGFontGetUnitsPerEm(font: interop.Object): number;

declare function CGFontCopyPostScriptName(font: interop.Object): interop.Object;

declare function CGFontCopyFullName(font: interop.Object): interop.Object;

declare function CGFontGetAscent(font: interop.Object): number;

declare function CGFontGetDescent(font: interop.Object): number;

declare function CGFontGetLeading(font: interop.Object): number;

declare function CGFontGetCapHeight(font: interop.Object): number;

declare function CGFontGetXHeight(font: interop.Object): number;

declare function CGFontGetFontBBox(font: interop.Object): CGRect;

declare function CGFontGetItalicAngle(font: interop.Object): number;

declare function CGFontGetStemV(font: interop.Object): number;

declare function CGFontCopyVariationAxes(font: interop.Object): interop.Object;

declare function CGFontCopyVariations(font: interop.Object): interop.Object;

declare function CGFontGetGlyphAdvances(font: interop.Object, glyphs: interop.PointerConvertible, count: number, advances: interop.PointerConvertible): boolean;

declare function CGFontGetGlyphBBoxes(font: interop.Object, glyphs: interop.PointerConvertible, count: number, bboxes: interop.PointerConvertible): boolean;

declare function CGFontGetGlyphWithGlyphName(font: interop.Object, name: interop.Object): number;

declare function CGFontCopyGlyphNameForGlyph(font: interop.Object, glyph: number): interop.Object;

declare function CGFontCanCreatePostScriptSubset(font: interop.Object, format: interop.Enum<typeof CGFontPostScriptFormat>): boolean;

declare function CGFontCreatePostScriptSubset(font: interop.Object, subsetName: interop.Object, format: interop.Enum<typeof CGFontPostScriptFormat>, glyphs: interop.PointerConvertible, count: number, encoding: interop.PointerConvertible): interop.Object;

declare function CGFontCreatePostScriptEncoding(font: interop.Object, encoding: interop.PointerConvertible): interop.Object;

declare function CGFontCopyTableTags(font: interop.Object): interop.Object;

declare function CGFontCopyTableForTag(font: interop.Object, tag: number): interop.Object;

declare function CGGradientGetTypeID(): number;

declare function CGGradientCreateWithColorComponents(space: interop.Object, components: interop.PointerConvertible, locations: interop.PointerConvertible, count: number): interop.Object;

declare function CGGradientCreateWithColors(space: interop.Object, colors: interop.Object, locations: interop.PointerConvertible): interop.Object;

declare function CGGradientRetain(gradient: interop.Object): interop.Object;

declare function CGGradientRelease(gradient: interop.Object): void;

declare function CGImageGetTypeID(): number;

declare function CGImageCreate(width: number, height: number, bitsPerComponent: number, bitsPerPixel: number, bytesPerRow: number, space: interop.Object, bitmapInfo: interop.Enum<typeof CGBitmapInfo>, provider: interop.Object, decode: interop.PointerConvertible, shouldInterpolate: boolean, intent: interop.Enum<typeof CGColorRenderingIntent>): interop.Object;

declare function CGImageMaskCreate(width: number, height: number, bitsPerComponent: number, bitsPerPixel: number, bytesPerRow: number, provider: interop.Object, decode: interop.PointerConvertible, shouldInterpolate: boolean): interop.Object;

declare function CGImageCreateCopy(image: interop.Object): interop.Object;

declare function CGImageCreateWithJPEGDataProvider(source: interop.Object, decode: interop.PointerConvertible, shouldInterpolate: boolean, intent: interop.Enum<typeof CGColorRenderingIntent>): interop.Object;

declare function CGImageCreateWithPNGDataProvider(source: interop.Object, decode: interop.PointerConvertible, shouldInterpolate: boolean, intent: interop.Enum<typeof CGColorRenderingIntent>): interop.Object;

declare function CGImageCreateWithImageInRect(image: interop.Object, rect: CGRect): interop.Object;

declare function CGImageCreateWithMask(image: interop.Object, mask: interop.Object): interop.Object;

declare function CGImageCreateWithMaskingColors(image: interop.Object, components: interop.PointerConvertible): interop.Object;

declare function CGImageCreateCopyWithColorSpace(image: interop.Object, space: interop.Object): interop.Object;

declare function CGImageRetain(image: interop.Object): interop.Object;

declare function CGImageRelease(image: interop.Object): void;

declare function CGImageIsMask(image: interop.Object): boolean;

declare function CGImageGetWidth(image: interop.Object): number;

declare function CGImageGetHeight(image: interop.Object): number;

declare function CGImageGetBitsPerComponent(image: interop.Object): number;

declare function CGImageGetBitsPerPixel(image: interop.Object): number;

declare function CGImageGetBytesPerRow(image: interop.Object): number;

declare function CGImageGetColorSpace(image: interop.Object): interop.Object;

declare function CGImageGetAlphaInfo(image: interop.Object): interop.Enum<typeof CGImageAlphaInfo>;

declare function CGImageGetDataProvider(image: interop.Object): interop.Object;

declare function CGImageGetDecode(image: interop.Object): interop.Pointer;

declare function CGImageGetShouldInterpolate(image: interop.Object): boolean;

declare function CGImageGetRenderingIntent(image: interop.Object): interop.Enum<typeof CGColorRenderingIntent>;

declare function CGImageGetBitmapInfo(image: interop.Object): interop.Enum<typeof CGBitmapInfo>;

declare function CGImageGetByteOrderInfo(image: interop.Object): interop.Enum<typeof CGImageByteOrderInfo>;

declare function CGImageGetPixelFormatInfo(image: interop.Object): interop.Enum<typeof CGImagePixelFormatInfo>;

declare function CGImageGetUTType(image: interop.Object): interop.Object;

declare function CGPathGetTypeID(): number;

declare function CGPathCreateMutable(): interop.Object;

declare function CGPathCreateCopy(path: interop.Object): interop.Object;

declare function CGPathCreateCopyByTransformingPath(path: interop.Object, transform: interop.PointerConvertible): interop.Object;

declare function CGPathCreateMutableCopy(path: interop.Object): interop.Object;

declare function CGPathCreateMutableCopyByTransformingPath(path: interop.Object, transform: interop.PointerConvertible): interop.Object;

declare function CGPathCreateWithRect(rect: CGRect, transform: interop.PointerConvertible): interop.Object;

declare function CGPathCreateWithEllipseInRect(rect: CGRect, transform: interop.PointerConvertible): interop.Object;

declare function CGPathCreateWithRoundedRect(rect: CGRect, cornerWidth: number, cornerHeight: number, transform: interop.PointerConvertible): interop.Object;

declare function CGPathAddRoundedRect(path: interop.Object, transform: interop.PointerConvertible, rect: CGRect, cornerWidth: number, cornerHeight: number): void;

declare function CGPathCreateCopyByDashingPath(path: interop.Object, transform: interop.PointerConvertible, phase: number, lengths: interop.PointerConvertible, count: number): interop.Object;

declare function CGPathCreateCopyByStrokingPath(path: interop.Object, transform: interop.PointerConvertible, lineWidth: number, lineCap: interop.Enum<typeof CGLineCap>, lineJoin: interop.Enum<typeof CGLineJoin>, miterLimit: number): interop.Object;

declare function CGPathRetain(path: interop.Object): interop.Object;

declare function CGPathRelease(path: interop.Object): void;

declare function CGPathEqualToPath(path1: interop.Object, path2: interop.Object): boolean;

declare function CGPathMoveToPoint(path: interop.Object, m: interop.PointerConvertible, x: number, y: number): void;

declare function CGPathAddLineToPoint(path: interop.Object, m: interop.PointerConvertible, x: number, y: number): void;

declare function CGPathAddQuadCurveToPoint(path: interop.Object, m: interop.PointerConvertible, cpx: number, cpy: number, x: number, y: number): void;

declare function CGPathAddCurveToPoint(path: interop.Object, m: interop.PointerConvertible, cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;

declare function CGPathCloseSubpath(path: interop.Object): void;

declare function CGPathAddRect(path: interop.Object, m: interop.PointerConvertible, rect: CGRect): void;

declare function CGPathAddRects(path: interop.Object, m: interop.PointerConvertible, rects: interop.PointerConvertible, count: number): void;

declare function CGPathAddLines(path: interop.Object, m: interop.PointerConvertible, points: interop.PointerConvertible, count: number): void;

declare function CGPathAddEllipseInRect(path: interop.Object, m: interop.PointerConvertible, rect: CGRect): void;

declare function CGPathAddRelativeArc(path: interop.Object, matrix: interop.PointerConvertible, x: number, y: number, radius: number, startAngle: number, delta: number): void;

declare function CGPathAddArc(path: interop.Object, m: interop.PointerConvertible, x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise: boolean): void;

declare function CGPathAddArcToPoint(path: interop.Object, m: interop.PointerConvertible, x1: number, y1: number, x2: number, y2: number, radius: number): void;

declare function CGPathAddPath(path1: interop.Object, m: interop.PointerConvertible, path2: interop.Object): void;

declare function CGPathIsEmpty(path: interop.Object): boolean;

declare function CGPathIsRect(path: interop.Object, rect: interop.PointerConvertible): boolean;

declare function CGPathGetCurrentPoint(path: interop.Object): CGPoint;

declare function CGPathGetBoundingBox(path: interop.Object): CGRect;

declare function CGPathGetPathBoundingBox(path: interop.Object): CGRect;

declare function CGPathContainsPoint(path: interop.Object, m: interop.PointerConvertible, point: CGPoint, eoFill: boolean): boolean;

declare function CGPathApply(path: interop.Object, info: interop.PointerConvertible, function$: (p1: interop.PointerConvertible, p2: interop.PointerConvertible) => void): void;

declare function CGPathApplyWithBlock(path: interop.Object, block: (p1: interop.PointerConvertible) => void): void;

declare function CGPDFObjectGetType(object: interop.PointerConvertible): interop.Enum<typeof CGPDFObjectType>;

declare function CGPDFObjectGetValue(object: interop.PointerConvertible, type: interop.Enum<typeof CGPDFObjectType>, value: interop.PointerConvertible): boolean;

declare function CGPDFStreamGetDictionary(stream: interop.PointerConvertible): interop.Pointer;

declare function CGPDFStreamCopyData(stream: interop.PointerConvertible, format: interop.PointerConvertible): interop.Object;

declare function CGPDFStringGetLength(string: interop.PointerConvertible): number;

declare function CGPDFStringGetBytePtr(string: interop.PointerConvertible): interop.Pointer;

declare function CGPDFStringCopyTextString(string: interop.PointerConvertible): interop.Object;

declare function CGPDFStringCopyDate(string: interop.PointerConvertible): interop.Object;

declare function CGPDFArrayGetCount(array: interop.PointerConvertible): number;

declare function CGPDFArrayGetObject(array: interop.PointerConvertible, index: number, value: interop.PointerConvertible): boolean;

declare function CGPDFArrayGetNull(array: interop.PointerConvertible, index: number): boolean;

declare function CGPDFArrayGetBoolean(array: interop.PointerConvertible, index: number, value: interop.PointerConvertible): boolean;

declare function CGPDFArrayGetInteger(array: interop.PointerConvertible, index: number, value: interop.PointerConvertible): boolean;

declare function CGPDFArrayGetNumber(array: interop.PointerConvertible, index: number, value: interop.PointerConvertible): boolean;

declare function CGPDFArrayGetName(array: interop.PointerConvertible, index: number, value: interop.PointerConvertible): boolean;

declare function CGPDFArrayGetString(array: interop.PointerConvertible, index: number, value: interop.PointerConvertible): boolean;

declare function CGPDFArrayGetArray(array: interop.PointerConvertible, index: number, value: interop.PointerConvertible): boolean;

declare function CGPDFArrayGetDictionary(array: interop.PointerConvertible, index: number, value: interop.PointerConvertible): boolean;

declare function CGPDFArrayGetStream(array: interop.PointerConvertible, index: number, value: interop.PointerConvertible): boolean;

declare function CGPDFArrayApplyBlock(array: interop.PointerConvertible, block: (p1: number, p2: interop.PointerConvertible, p3: interop.PointerConvertible) => boolean, info: interop.PointerConvertible): void;

declare function CGPDFDictionaryGetCount(dict: interop.PointerConvertible): number;

declare function CGPDFDictionaryGetObject(dict: interop.PointerConvertible, key: string, value: interop.PointerConvertible): boolean;

declare function CGPDFDictionaryGetBoolean(dict: interop.PointerConvertible, key: string, value: interop.PointerConvertible): boolean;

declare function CGPDFDictionaryGetInteger(dict: interop.PointerConvertible, key: string, value: interop.PointerConvertible): boolean;

declare function CGPDFDictionaryGetNumber(dict: interop.PointerConvertible, key: string, value: interop.PointerConvertible): boolean;

declare function CGPDFDictionaryGetName(dict: interop.PointerConvertible, key: string, value: interop.PointerConvertible): boolean;

declare function CGPDFDictionaryGetString(dict: interop.PointerConvertible, key: string, value: interop.PointerConvertible): boolean;

declare function CGPDFDictionaryGetArray(dict: interop.PointerConvertible, key: string, value: interop.PointerConvertible): boolean;

declare function CGPDFDictionaryGetDictionary(dict: interop.PointerConvertible, key: string, value: interop.PointerConvertible): boolean;

declare function CGPDFDictionaryGetStream(dict: interop.PointerConvertible, key: string, value: interop.PointerConvertible): boolean;

declare function CGPDFDictionaryApplyFunction(dict: interop.PointerConvertible, function$: (p1: string, p2: interop.PointerConvertible, p3: interop.PointerConvertible) => void, info: interop.PointerConvertible): void;

declare function CGPDFDictionaryApplyBlock(dict: interop.PointerConvertible, block: (p1: string, p2: interop.PointerConvertible, p3: interop.PointerConvertible) => boolean, info: interop.PointerConvertible): void;

declare function CGPDFPageRetain(page: interop.Object): interop.Object;

declare function CGPDFPageRelease(page: interop.Object): void;

declare function CGPDFPageGetDocument(page: interop.Object): interop.Object;

declare function CGPDFPageGetPageNumber(page: interop.Object): number;

declare function CGPDFPageGetBoxRect(page: interop.Object, box: interop.Enum<typeof CGPDFBox>): CGRect;

declare function CGPDFPageGetRotationAngle(page: interop.Object): number;

declare function CGPDFPageGetDrawingTransform(page: interop.Object, box: interop.Enum<typeof CGPDFBox>, rect: CGRect, rotate: number, preserveAspectRatio: boolean): CGAffineTransform;

declare function CGPDFPageGetDictionary(page: interop.Object): interop.Pointer;

declare function CGPDFPageGetTypeID(): number;

declare function CGPDFDocumentCreateWithProvider(provider: interop.Object): interop.Object;

declare function CGPDFDocumentCreateWithURL(url: interop.Object): interop.Object;

declare function CGPDFDocumentRetain(document: interop.Object): interop.Object;

declare function CGPDFDocumentRelease(document: interop.Object): void;

declare function CGPDFDocumentGetVersion(document: interop.Object, majorVersion: interop.PointerConvertible, minorVersion: interop.PointerConvertible): void;

declare function CGPDFDocumentIsEncrypted(document: interop.Object): boolean;

declare function CGPDFDocumentUnlockWithPassword(document: interop.Object, password: string): boolean;

declare function CGPDFDocumentIsUnlocked(document: interop.Object): boolean;

declare function CGPDFDocumentAllowsPrinting(document: interop.Object): boolean;

declare function CGPDFDocumentAllowsCopying(document: interop.Object): boolean;

declare function CGPDFDocumentGetNumberOfPages(document: interop.Object): number;

declare function CGPDFDocumentGetPage(document: interop.Object, pageNumber: number): interop.Object;

declare function CGPDFDocumentGetCatalog(document: interop.Object): interop.Pointer;

declare function CGPDFDocumentGetInfo(document: interop.Object): interop.Pointer;

declare function CGPDFDocumentGetID(document: interop.Object): interop.Pointer;

declare function CGPDFDocumentGetTypeID(): number;

declare function CGPDFDocumentGetOutline(document: interop.Object): interop.Object;

declare function CGPDFDocumentGetAccessPermissions(document: interop.Object): interop.Enum<typeof CGPDFAccessPermissions>;

declare function CGPDFDocumentGetMediaBox(document: interop.Object, page: number): CGRect;

declare function CGPDFDocumentGetCropBox(document: interop.Object, page: number): CGRect;

declare function CGPDFDocumentGetBleedBox(document: interop.Object, page: number): CGRect;

declare function CGPDFDocumentGetTrimBox(document: interop.Object, page: number): CGRect;

declare function CGPDFDocumentGetArtBox(document: interop.Object, page: number): CGRect;

declare function CGPDFDocumentGetRotationAngle(document: interop.Object, page: number): number;

declare function CGFunctionGetTypeID(): number;

declare function CGFunctionCreate(info: interop.PointerConvertible, domainDimension: number, domain: interop.PointerConvertible, rangeDimension: number, range: interop.PointerConvertible, callbacks: interop.PointerConvertible): interop.Object;

declare function CGFunctionRetain(function$: interop.Object): interop.Object;

declare function CGFunctionRelease(function$: interop.Object): void;

declare function CGShadingGetTypeID(): number;

declare function CGShadingCreateAxial(space: interop.Object, start: CGPoint, end: CGPoint, function$: interop.Object, extendStart: boolean, extendEnd: boolean): interop.Object;

declare function CGShadingCreateRadial(space: interop.Object, start: CGPoint, startRadius: number, end: CGPoint, endRadius: number, function$: interop.Object, extendStart: boolean, extendEnd: boolean): interop.Object;

declare function CGShadingRetain(shading: interop.Object): interop.Object;

declare function CGShadingRelease(shading: interop.Object): void;

declare function CGContextGetTypeID(): number;

declare function CGContextSaveGState(c: interop.Object): void;

declare function CGContextRestoreGState(c: interop.Object): void;

declare function CGContextScaleCTM(c: interop.Object, sx: number, sy: number): void;

declare function CGContextTranslateCTM(c: interop.Object, tx: number, ty: number): void;

declare function CGContextRotateCTM(c: interop.Object, angle: number): void;

declare function CGContextConcatCTM(c: interop.Object, transform: CGAffineTransform): void;

declare function CGContextGetCTM(c: interop.Object): CGAffineTransform;

declare function CGContextSetLineWidth(c: interop.Object, width: number): void;

declare function CGContextSetLineCap(c: interop.Object, cap: interop.Enum<typeof CGLineCap>): void;

declare function CGContextSetLineJoin(c: interop.Object, join: interop.Enum<typeof CGLineJoin>): void;

declare function CGContextSetMiterLimit(c: interop.Object, limit: number): void;

declare function CGContextSetLineDash(c: interop.Object, phase: number, lengths: interop.PointerConvertible, count: number): void;

declare function CGContextSetFlatness(c: interop.Object, flatness: number): void;

declare function CGContextSetAlpha(c: interop.Object, alpha: number): void;

declare function CGContextSetBlendMode(c: interop.Object, mode: interop.Enum<typeof CGBlendMode>): void;

declare function CGContextBeginPath(c: interop.Object): void;

declare function CGContextMoveToPoint(c: interop.Object, x: number, y: number): void;

declare function CGContextAddLineToPoint(c: interop.Object, x: number, y: number): void;

declare function CGContextAddCurveToPoint(c: interop.Object, cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void;

declare function CGContextAddQuadCurveToPoint(c: interop.Object, cpx: number, cpy: number, x: number, y: number): void;

declare function CGContextClosePath(c: interop.Object): void;

declare function CGContextAddRect(c: interop.Object, rect: CGRect): void;

declare function CGContextAddRects(c: interop.Object, rects: interop.PointerConvertible, count: number): void;

declare function CGContextAddLines(c: interop.Object, points: interop.PointerConvertible, count: number): void;

declare function CGContextAddEllipseInRect(c: interop.Object, rect: CGRect): void;

declare function CGContextAddArc(c: interop.Object, x: number, y: number, radius: number, startAngle: number, endAngle: number, clockwise: number): void;

declare function CGContextAddArcToPoint(c: interop.Object, x1: number, y1: number, x2: number, y2: number, radius: number): void;

declare function CGContextAddPath(c: interop.Object, path: interop.Object): void;

declare function CGContextReplacePathWithStrokedPath(c: interop.Object): void;

declare function CGContextIsPathEmpty(c: interop.Object): boolean;

declare function CGContextGetPathCurrentPoint(c: interop.Object): CGPoint;

declare function CGContextGetPathBoundingBox(c: interop.Object): CGRect;

declare function CGContextCopyPath(c: interop.Object): interop.Object;

declare function CGContextPathContainsPoint(c: interop.Object, point: CGPoint, mode: interop.Enum<typeof CGPathDrawingMode>): boolean;

declare function CGContextDrawPath(c: interop.Object, mode: interop.Enum<typeof CGPathDrawingMode>): void;

declare function CGContextFillPath(c: interop.Object): void;

declare function CGContextEOFillPath(c: interop.Object): void;

declare function CGContextStrokePath(c: interop.Object): void;

declare function CGContextFillRect(c: interop.Object, rect: CGRect): void;

declare function CGContextFillRects(c: interop.Object, rects: interop.PointerConvertible, count: number): void;

declare function CGContextStrokeRect(c: interop.Object, rect: CGRect): void;

declare function CGContextStrokeRectWithWidth(c: interop.Object, rect: CGRect, width: number): void;

declare function CGContextClearRect(c: interop.Object, rect: CGRect): void;

declare function CGContextFillEllipseInRect(c: interop.Object, rect: CGRect): void;

declare function CGContextStrokeEllipseInRect(c: interop.Object, rect: CGRect): void;

declare function CGContextStrokeLineSegments(c: interop.Object, points: interop.PointerConvertible, count: number): void;

declare function CGContextClip(c: interop.Object): void;

declare function CGContextEOClip(c: interop.Object): void;

declare function CGContextResetClip(c: interop.Object): void;

declare function CGContextClipToMask(c: interop.Object, rect: CGRect, mask: interop.Object): void;

declare function CGContextGetClipBoundingBox(c: interop.Object): CGRect;

declare function CGContextClipToRect(c: interop.Object, rect: CGRect): void;

declare function CGContextClipToRects(c: interop.Object, rects: interop.PointerConvertible, count: number): void;

declare function CGContextSetFillColorWithColor(c: interop.Object, color: interop.Object): void;

declare function CGContextSetStrokeColorWithColor(c: interop.Object, color: interop.Object): void;

declare function CGContextSetFillColorSpace(c: interop.Object, space: interop.Object): void;

declare function CGContextSetStrokeColorSpace(c: interop.Object, space: interop.Object): void;

declare function CGContextSetFillColor(c: interop.Object, components: interop.PointerConvertible): void;

declare function CGContextSetStrokeColor(c: interop.Object, components: interop.PointerConvertible): void;

declare function CGContextSetFillPattern(c: interop.Object, pattern: interop.Object, components: interop.PointerConvertible): void;

declare function CGContextSetStrokePattern(c: interop.Object, pattern: interop.Object, components: interop.PointerConvertible): void;

declare function CGContextSetPatternPhase(c: interop.Object, phase: CGSize): void;

declare function CGContextSetGrayFillColor(c: interop.Object, gray: number, alpha: number): void;

declare function CGContextSetGrayStrokeColor(c: interop.Object, gray: number, alpha: number): void;

declare function CGContextSetRGBFillColor(c: interop.Object, red: number, green: number, blue: number, alpha: number): void;

declare function CGContextSetRGBStrokeColor(c: interop.Object, red: number, green: number, blue: number, alpha: number): void;

declare function CGContextSetCMYKFillColor(c: interop.Object, cyan: number, magenta: number, yellow: number, black: number, alpha: number): void;

declare function CGContextSetCMYKStrokeColor(c: interop.Object, cyan: number, magenta: number, yellow: number, black: number, alpha: number): void;

declare function CGContextSetRenderingIntent(c: interop.Object, intent: interop.Enum<typeof CGColorRenderingIntent>): void;

declare function CGContextDrawImage(c: interop.Object, rect: CGRect, image: interop.Object): void;

declare function CGContextDrawTiledImage(c: interop.Object, rect: CGRect, image: interop.Object): void;

declare function CGContextGetInterpolationQuality(c: interop.Object): interop.Enum<typeof CGInterpolationQuality>;

declare function CGContextSetInterpolationQuality(c: interop.Object, quality: interop.Enum<typeof CGInterpolationQuality>): void;

declare function CGContextSetShadowWithColor(c: interop.Object, offset: CGSize, blur: number, color: interop.Object): void;

declare function CGContextSetShadow(c: interop.Object, offset: CGSize, blur: number): void;

declare function CGContextDrawLinearGradient(c: interop.Object, gradient: interop.Object, startPoint: CGPoint, endPoint: CGPoint, options: interop.Enum<typeof CGGradientDrawingOptions>): void;

declare function CGContextDrawRadialGradient(c: interop.Object, gradient: interop.Object, startCenter: CGPoint, startRadius: number, endCenter: CGPoint, endRadius: number, options: interop.Enum<typeof CGGradientDrawingOptions>): void;

declare function CGContextDrawShading(c: interop.Object, shading: interop.Object): void;

declare function CGContextSetCharacterSpacing(c: interop.Object, spacing: number): void;

declare function CGContextSetTextPosition(c: interop.Object, x: number, y: number): void;

declare function CGContextGetTextPosition(c: interop.Object): CGPoint;

declare function CGContextSetTextMatrix(c: interop.Object, t: CGAffineTransform): void;

declare function CGContextGetTextMatrix(c: interop.Object): CGAffineTransform;

declare function CGContextSetTextDrawingMode(c: interop.Object, mode: interop.Enum<typeof CGTextDrawingMode>): void;

declare function CGContextSetFont(c: interop.Object, font: interop.Object): void;

declare function CGContextSetFontSize(c: interop.Object, size: number): void;

declare function CGContextShowGlyphsAtPositions(c: interop.Object, glyphs: interop.PointerConvertible, Lpositions: interop.PointerConvertible, count: number): void;

declare function CGContextDrawPDFPage(c: interop.Object, page: interop.Object): void;

declare function CGContextBeginPage(c: interop.Object, mediaBox: interop.PointerConvertible): void;

declare function CGContextEndPage(c: interop.Object): void;

declare function CGContextRetain(c: interop.Object): interop.Object;

declare function CGContextRelease(c: interop.Object): void;

declare function CGContextFlush(c: interop.Object): void;

declare function CGContextSynchronize(c: interop.Object): void;

declare function CGContextSetShouldAntialias(c: interop.Object, shouldAntialias: boolean): void;

declare function CGContextSetAllowsAntialiasing(c: interop.Object, allowsAntialiasing: boolean): void;

declare function CGContextSetShouldSmoothFonts(c: interop.Object, shouldSmoothFonts: boolean): void;

declare function CGContextSetAllowsFontSmoothing(c: interop.Object, allowsFontSmoothing: boolean): void;

declare function CGContextSetShouldSubpixelPositionFonts(c: interop.Object, shouldSubpixelPositionFonts: boolean): void;

declare function CGContextSetAllowsFontSubpixelPositioning(c: interop.Object, allowsFontSubpixelPositioning: boolean): void;

declare function CGContextSetShouldSubpixelQuantizeFonts(c: interop.Object, shouldSubpixelQuantizeFonts: boolean): void;

declare function CGContextSetAllowsFontSubpixelQuantization(c: interop.Object, allowsFontSubpixelQuantization: boolean): void;

declare function CGContextBeginTransparencyLayer(c: interop.Object, auxiliaryInfo: interop.Object): void;

declare function CGContextBeginTransparencyLayerWithRect(c: interop.Object, rect: CGRect, auxInfo: interop.Object): void;

declare function CGContextEndTransparencyLayer(c: interop.Object): void;

declare function CGContextGetUserSpaceToDeviceSpaceTransform(c: interop.Object): CGAffineTransform;

declare function CGContextConvertPointToDeviceSpace(c: interop.Object, point: CGPoint): CGPoint;

declare function CGContextConvertPointToUserSpace(c: interop.Object, point: CGPoint): CGPoint;

declare function CGContextConvertSizeToDeviceSpace(c: interop.Object, size: CGSize): CGSize;

declare function CGContextConvertSizeToUserSpace(c: interop.Object, size: CGSize): CGSize;

declare function CGContextConvertRectToDeviceSpace(c: interop.Object, rect: CGRect): CGRect;

declare function CGContextConvertRectToUserSpace(c: interop.Object, rect: CGRect): CGRect;

declare function CGContextSelectFont(c: interop.Object, name: string, size: number, textEncoding: interop.Enum<typeof CGTextEncoding>): void;

declare function CGContextShowText(c: interop.Object, string: string, length: number): void;

declare function CGContextShowTextAtPoint(c: interop.Object, x: number, y: number, string: string, length: number): void;

declare function CGContextShowGlyphs(c: interop.Object, g: interop.PointerConvertible, count: number): void;

declare function CGContextShowGlyphsAtPoint(c: interop.Object, x: number, y: number, glyphs: interop.PointerConvertible, count: number): void;

declare function CGContextShowGlyphsWithAdvances(c: interop.Object, glyphs: interop.PointerConvertible, advances: interop.PointerConvertible, count: number): void;

declare function CGContextDrawPDFDocument(c: interop.Object, rect: CGRect, document: interop.Object, page: number): void;

declare function CGBitmapContextCreateWithData(data: interop.PointerConvertible, width: number, height: number, bitsPerComponent: number, bytesPerRow: number, space: interop.Object, bitmapInfo: interop.Enum<typeof CGBitmapInfo>, releaseCallback: (p1: interop.PointerConvertible, p2: interop.PointerConvertible) => void, releaseInfo: interop.PointerConvertible): interop.Object;

declare function CGBitmapContextCreate(data: interop.PointerConvertible, width: number, height: number, bitsPerComponent: number, bytesPerRow: number, space: interop.Object, bitmapInfo: interop.Enum<typeof CGBitmapInfo>): interop.Object;

declare function CGBitmapContextGetData(context: interop.Object): interop.Pointer;

declare function CGBitmapContextGetWidth(context: interop.Object): number;

declare function CGBitmapContextGetHeight(context: interop.Object): number;

declare function CGBitmapContextGetBitsPerComponent(context: interop.Object): number;

declare function CGBitmapContextGetBitsPerPixel(context: interop.Object): number;

declare function CGBitmapContextGetBytesPerRow(context: interop.Object): number;

declare function CGBitmapContextGetColorSpace(context: interop.Object): interop.Object;

declare function CGBitmapContextGetAlphaInfo(context: interop.Object): interop.Enum<typeof CGImageAlphaInfo>;

declare function CGBitmapContextGetBitmapInfo(context: interop.Object): interop.Enum<typeof CGBitmapInfo>;

declare function CGBitmapContextCreateImage(context: interop.Object): interop.Object;

declare function CGColorConversionInfoGetTypeID(): number;

declare function CGColorConversionInfoCreate(src: interop.Object, dst: interop.Object): interop.Pointer;

declare function CGColorConversionInfoCreateWithOptions(src: interop.Object, dst: interop.Object, options: interop.Object): interop.Pointer;

declare function CGColorConversionInfoCreateFromList(options: interop.Object, p2: interop.Object, p3: interop.Enum<typeof CGColorConversionInfoTransformType>, p4: interop.Enum<typeof CGColorRenderingIntent>): interop.Pointer;

declare function CGColorConversionInfoCreateFromListWithArguments(options: interop.Object, p2: interop.Object, p3: interop.Enum<typeof CGColorConversionInfoTransformType>, p4: interop.Enum<typeof CGColorRenderingIntent>, p5: string): interop.Pointer;

declare function CGConvertColorDataWithFormat(width: number, height: number, dst_data: interop.PointerConvertible, dst_format: CGColorDataFormat, src_data: interop.PointerConvertible, src_format: CGColorDataFormat, options: interop.Object): boolean;

declare function CGDataConsumerGetTypeID(): number;

declare function CGDataConsumerCreate(info: interop.PointerConvertible, cbks: interop.PointerConvertible): interop.Object;

declare function CGDataConsumerCreateWithURL(url: interop.Object): interop.Object;

declare function CGDataConsumerCreateWithCFData(data: interop.Object): interop.Object;

declare function CGDataConsumerRetain(consumer: interop.Object): interop.Object;

declare function CGDataConsumerRelease(consumer: interop.Object): void;

declare function CGErrorSetCallback(callback: () => void): void;

declare function CGLayerCreateWithContext(context: interop.Object, size: CGSize, auxiliaryInfo: interop.Object): interop.Object;

declare function CGLayerRetain(layer: interop.Object): interop.Object;

declare function CGLayerRelease(layer: interop.Object): void;

declare function CGLayerGetSize(layer: interop.Object): CGSize;

declare function CGLayerGetContext(layer: interop.Object): interop.Object;

declare function CGContextDrawLayerInRect(context: interop.Object, rect: CGRect, layer: interop.Object): void;

declare function CGContextDrawLayerAtPoint(context: interop.Object, point: CGPoint, layer: interop.Object): void;

declare function CGLayerGetTypeID(): number;

declare function CGPDFContentStreamCreateWithPage(page: interop.Object): interop.Pointer;

declare function CGPDFContentStreamCreateWithStream(stream: interop.PointerConvertible, streamResources: interop.PointerConvertible, parent: interop.PointerConvertible): interop.Pointer;

declare function CGPDFContentStreamRetain(cs: interop.PointerConvertible): interop.Pointer;

declare function CGPDFContentStreamRelease(cs: interop.PointerConvertible): void;

declare function CGPDFContentStreamGetStreams(cs: interop.PointerConvertible): interop.Object;

declare function CGPDFContentStreamGetResource(cs: interop.PointerConvertible, category: string, name: string): interop.Pointer;

declare function CGPDFContextCreate(consumer: interop.Object, mediaBox: interop.PointerConvertible, auxiliaryInfo: interop.Object): interop.Object;

declare function CGPDFContextCreateWithURL(url: interop.Object, mediaBox: interop.PointerConvertible, auxiliaryInfo: interop.Object): interop.Object;

declare function CGPDFContextClose(context: interop.Object): void;

declare function CGPDFContextBeginPage(context: interop.Object, pageInfo: interop.Object): void;

declare function CGPDFContextEndPage(context: interop.Object): void;

declare function CGPDFContextAddDocumentMetadata(context: interop.Object, metadata: interop.Object): void;

declare function CGPDFContextSetParentTree(context: interop.Object, parentTreeDictionary: interop.PointerConvertible): void;

declare function CGPDFContextSetIDTree(context: interop.Object, IDTreeDictionary: interop.PointerConvertible): void;

declare function CGPDFContextSetPageTagStructureTree(context: interop.Object, pageTagStructureTreeDictionary: interop.Object): void;

declare function CGPDFContextSetURLForRect(context: interop.Object, url: interop.Object, rect: CGRect): void;

declare function CGPDFContextAddDestinationAtPoint(context: interop.Object, name: interop.Object, point: CGPoint): void;

declare function CGPDFContextSetDestinationForRect(context: interop.Object, name: interop.Object, rect: CGRect): void;

declare function CGPDFContextSetOutline(context: interop.Object, outline: interop.Object): void;

declare function CGPDFTagTypeGetName(tagType: interop.Enum<typeof CGPDFTagType>): string;

declare function CGPDFContextBeginTag(context: interop.Object, tagType: interop.Enum<typeof CGPDFTagType>, tagProperties: interop.Object): void;

declare function CGPDFContextEndTag(context: interop.Object): void;

declare function CGPDFScannerCreate(cs: interop.PointerConvertible, table: interop.PointerConvertible, info: interop.PointerConvertible): interop.Pointer;

declare function CGPDFScannerRetain(scanner: interop.PointerConvertible): interop.Pointer;

declare function CGPDFScannerRelease(scanner: interop.PointerConvertible): void;

declare function CGPDFScannerScan(scanner: interop.PointerConvertible): boolean;

declare function CGPDFScannerGetContentStream(scanner: interop.PointerConvertible): interop.Pointer;

declare function CGPDFScannerPopObject(scanner: interop.PointerConvertible, value: interop.PointerConvertible): boolean;

declare function CGPDFScannerPopBoolean(scanner: interop.PointerConvertible, value: interop.PointerConvertible): boolean;

declare function CGPDFScannerPopInteger(scanner: interop.PointerConvertible, value: interop.PointerConvertible): boolean;

declare function CGPDFScannerPopNumber(scanner: interop.PointerConvertible, value: interop.PointerConvertible): boolean;

declare function CGPDFScannerPopName(scanner: interop.PointerConvertible, value: interop.PointerConvertible): boolean;

declare function CGPDFScannerPopString(scanner: interop.PointerConvertible, value: interop.PointerConvertible): boolean;

declare function CGPDFScannerPopArray(scanner: interop.PointerConvertible, value: interop.PointerConvertible): boolean;

declare function CGPDFScannerPopDictionary(scanner: interop.PointerConvertible, value: interop.PointerConvertible): boolean;

declare function CGPDFScannerPopStream(scanner: interop.PointerConvertible, value: interop.PointerConvertible): boolean;

declare function CGPDFScannerStop(s: interop.PointerConvertible): void;

declare function CGPDFOperatorTableCreate(): interop.Pointer;

declare function CGPDFOperatorTableRetain(table: interop.PointerConvertible): interop.Pointer;

declare function CGPDFOperatorTableRelease(table: interop.PointerConvertible): void;

declare function CGPDFOperatorTableSetCallback(table: interop.PointerConvertible, name: string, callback: (p1: interop.PointerConvertible, p2: interop.PointerConvertible) => void): void;

declare function CGWindowListCopyWindowInfo(option: interop.Enum<typeof CGWindowListOption>, relativeToWindow: number): interop.Object;

declare function CGWindowListCreate(option: interop.Enum<typeof CGWindowListOption>, relativeToWindow: number): interop.Object;

declare function CGWindowListCreateDescriptionFromArray(windowArray: interop.Object): interop.Object;

declare function CGWindowListCreateImage(screenBounds: CGRect, listOption: interop.Enum<typeof CGWindowListOption>, windowID: number, imageOption: interop.Enum<typeof CGWindowImageOption>): interop.Object;

declare function CGWindowListCreateImageFromArray(screenBounds: CGRect, windowArray: interop.Object, imageOption: interop.Enum<typeof CGWindowImageOption>): interop.Object;

declare function CGPreflightScreenCaptureAccess(): boolean;

declare function CGRequestScreenCaptureAccess(): boolean;

declare function CGWindowLevelForKey(key: interop.Enum<typeof CGWindowLevelKey>): number;

declare function CGMainDisplayID(): number;

declare function CGGetDisplaysWithPoint(point: CGPoint, maxDisplays: number, displays: interop.PointerConvertible, matchingDisplayCount: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGGetDisplaysWithRect(rect: CGRect, maxDisplays: number, displays: interop.PointerConvertible, matchingDisplayCount: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGGetDisplaysWithOpenGLDisplayMask(mask: number, maxDisplays: number, displays: interop.PointerConvertible, matchingDisplayCount: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGGetActiveDisplayList(maxDisplays: number, activeDisplays: interop.PointerConvertible, displayCount: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGGetOnlineDisplayList(maxDisplays: number, onlineDisplays: interop.PointerConvertible, displayCount: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGDisplayIDToOpenGLDisplayMask(display: number): number;

declare function CGOpenGLDisplayMaskToDisplayID(mask: number): number;

declare function CGDisplayBounds(display: number): CGRect;

declare function CGDisplayPixelsWide(display: number): number;

declare function CGDisplayPixelsHigh(display: number): number;

declare function CGDisplayCopyAllDisplayModes(display: number, options: interop.Object): interop.Object;

declare function CGDisplayCopyDisplayMode(display: number): interop.Object;

declare function CGDisplaySetDisplayMode(display: number, mode: interop.Object, options: interop.Object): interop.Enum<typeof CGError>;

declare function CGDisplayModeGetWidth(mode: interop.Object): number;

declare function CGDisplayModeGetHeight(mode: interop.Object): number;

declare function CGDisplayModeCopyPixelEncoding(mode: interop.Object): interop.Object;

declare function CGDisplayModeGetRefreshRate(mode: interop.Object): number;

declare function CGDisplayModeGetIOFlags(mode: interop.Object): number;

declare function CGDisplayModeGetIODisplayModeID(mode: interop.Object): number;

declare function CGDisplayModeIsUsableForDesktopGUI(mode: interop.Object): boolean;

declare function CGDisplayModeGetTypeID(): number;

declare function CGDisplayModeRetain(mode: interop.Object): interop.Object;

declare function CGDisplayModeRelease(mode: interop.Object): void;

declare function CGDisplayModeGetPixelWidth(mode: interop.Object): number;

declare function CGDisplayModeGetPixelHeight(mode: interop.Object): number;

declare function CGSetDisplayTransferByFormula(display: number, redMin: number, redMax: number, redGamma: number, greenMin: number, greenMax: number, greenGamma: number, blueMin: number, blueMax: number, blueGamma: number): interop.Enum<typeof CGError>;

declare function CGGetDisplayTransferByFormula(display: number, redMin: interop.PointerConvertible, redMax: interop.PointerConvertible, redGamma: interop.PointerConvertible, greenMin: interop.PointerConvertible, greenMax: interop.PointerConvertible, greenGamma: interop.PointerConvertible, blueMin: interop.PointerConvertible, blueMax: interop.PointerConvertible, blueGamma: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGDisplayGammaTableCapacity(display: number): number;

declare function CGSetDisplayTransferByTable(display: number, tableSize: number, redTable: interop.PointerConvertible, greenTable: interop.PointerConvertible, blueTable: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGGetDisplayTransferByTable(display: number, capacity: number, redTable: interop.PointerConvertible, greenTable: interop.PointerConvertible, blueTable: interop.PointerConvertible, sampleCount: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGSetDisplayTransferByByteTable(display: number, tableSize: number, redTable: interop.PointerConvertible, greenTable: interop.PointerConvertible, blueTable: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGDisplayRestoreColorSyncSettings(): void;

declare function CGDisplayIsCaptured(display: number): number;

declare function CGDisplayCapture(display: number): interop.Enum<typeof CGError>;

declare function CGDisplayCaptureWithOptions(display: number, options: interop.Enum<typeof CGCaptureOptions>): interop.Enum<typeof CGError>;

declare function CGDisplayRelease(display: number): interop.Enum<typeof CGError>;

declare function CGCaptureAllDisplays(): interop.Enum<typeof CGError>;

declare function CGCaptureAllDisplaysWithOptions(options: interop.Enum<typeof CGCaptureOptions>): interop.Enum<typeof CGError>;

declare function CGReleaseAllDisplays(): interop.Enum<typeof CGError>;

declare function CGShieldingWindowID(display: number): number;

declare function CGShieldingWindowLevel(): number;

declare function CGDisplayCreateImage(displayID: number): interop.Object;

declare function CGDisplayCreateImageForRect(display: number, rect: CGRect): interop.Object;

declare function CGDisplayHideCursor(display: number): interop.Enum<typeof CGError>;

declare function CGDisplayShowCursor(display: number): interop.Enum<typeof CGError>;

declare function CGDisplayMoveCursorToPoint(display: number, point: CGPoint): interop.Enum<typeof CGError>;

declare function CGGetLastMouseDelta(deltaX: interop.PointerConvertible, deltaY: interop.PointerConvertible): void;

declare function CGDisplayGetDrawingContext(display: number): interop.Object;

declare function CGDisplayAvailableModes(dsp: number): interop.Object;

declare function CGDisplayBestModeForParameters(display: number, bitsPerPixel: number, width: number, height: number, exactMatch: interop.PointerConvertible): interop.Object;

declare function CGDisplayBestModeForParametersAndRefreshRate(display: number, bitsPerPixel: number, width: number, height: number, refreshRate: number, exactMatch: interop.PointerConvertible): interop.Object;

declare function CGDisplayCurrentMode(display: number): interop.Object;

declare function CGDisplaySwitchToMode(display: number, mode: interop.Object): interop.Enum<typeof CGError>;

declare function CGBeginDisplayConfiguration(config: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGConfigureDisplayOrigin(config: interop.PointerConvertible, display: number, x: number, y: number): interop.Enum<typeof CGError>;

declare function CGConfigureDisplayWithDisplayMode(config: interop.PointerConvertible, display: number, mode: interop.Object, options: interop.Object): interop.Enum<typeof CGError>;

declare function CGConfigureDisplayStereoOperation(config: interop.PointerConvertible, display: number, stereo: number, forceBlueLine: number): interop.Enum<typeof CGError>;

declare function CGConfigureDisplayMirrorOfDisplay(config: interop.PointerConvertible, display: number, master: number): interop.Enum<typeof CGError>;

declare function CGCancelDisplayConfiguration(config: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGCompleteDisplayConfiguration(config: interop.PointerConvertible, option: interop.Enum<typeof CGConfigureOption>): interop.Enum<typeof CGError>;

declare function CGRestorePermanentDisplayConfiguration(): void;

declare function CGDisplayRegisterReconfigurationCallback(callback: (p1: number, p2: interop.Enum<typeof CGDisplayChangeSummaryFlags>, p3: interop.PointerConvertible) => void, userInfo: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGDisplayRemoveReconfigurationCallback(callback: (p1: number, p2: interop.Enum<typeof CGDisplayChangeSummaryFlags>, p3: interop.PointerConvertible) => void, userInfo: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGDisplaySetStereoOperation(display: number, stereo: number, forceBlueLine: number, option: interop.Enum<typeof CGConfigureOption>): interop.Enum<typeof CGError>;

declare function CGDisplayIsActive(display: number): number;

declare function CGDisplayIsAsleep(display: number): number;

declare function CGDisplayIsOnline(display: number): number;

declare function CGDisplayIsMain(display: number): number;

declare function CGDisplayIsBuiltin(display: number): number;

declare function CGDisplayIsInMirrorSet(display: number): number;

declare function CGDisplayIsAlwaysInMirrorSet(display: number): number;

declare function CGDisplayIsInHWMirrorSet(display: number): number;

declare function CGDisplayMirrorsDisplay(display: number): number;

declare function CGDisplayUsesOpenGLAcceleration(display: number): number;

declare function CGDisplayIsStereo(display: number): number;

declare function CGDisplayPrimaryDisplay(display: number): number;

declare function CGDisplayUnitNumber(display: number): number;

declare function CGDisplayVendorNumber(display: number): number;

declare function CGDisplayModelNumber(display: number): number;

declare function CGDisplaySerialNumber(display: number): number;

declare function CGDisplayIOServicePort(display: number): number;

declare function CGDisplayScreenSize(display: number): CGSize;

declare function CGDisplayRotation(display: number): number;

declare function CGDisplayCopyColorSpace(display: number): interop.Object;

declare function CGConfigureDisplayMode(config: interop.PointerConvertible, display: number, mode: interop.Object): interop.Enum<typeof CGError>;

declare function CGConfigureDisplayFadeEffect(config: interop.PointerConvertible, fadeOutSeconds: number, fadeInSeconds: number, fadeRed: number, fadeGreen: number, fadeBlue: number): interop.Enum<typeof CGError>;

declare function CGAcquireDisplayFadeReservation(seconds: number, token: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGReleaseDisplayFadeReservation(token: number): interop.Enum<typeof CGError>;

declare function CGDisplayFade(token: number, duration: number, startBlend: number, endBlend: number, redBlend: number, greenBlend: number, blueBlend: number, synchronous: number): interop.Enum<typeof CGError>;

declare function CGDisplayFadeOperationInProgress(): number;

declare function CGDisplayStreamUpdateGetTypeID(): number;

declare function CGDisplayStreamUpdateGetRects(updateRef: interop.Object, rectType: interop.Enum<typeof CGDisplayStreamUpdateRectType>, rectCount: interop.PointerConvertible): interop.Pointer;

declare function CGDisplayStreamUpdateCreateMergedUpdate(firstUpdate: interop.Object, secondUpdate: interop.Object): interop.Object;

declare function CGDisplayStreamUpdateGetMovedRectsDelta(updateRef: interop.Object, dx: interop.PointerConvertible, dy: interop.PointerConvertible): void;

declare function CGDisplayStreamUpdateGetDropCount(updateRef: interop.Object): number;

declare function CGDisplayStreamGetTypeID(): number;

declare function CGDisplayStreamCreate(display: number, outputWidth: number, outputHeight: number, pixelFormat: number, properties: interop.Object, handler: (p1: interop.Enum<typeof CGDisplayStreamFrameStatus>, p2: number, p3: interop.PointerConvertible, p4: interop.PointerConvertible) => void): interop.Object;

declare function CGDisplayStreamCreateWithDispatchQueue(display: number, outputWidth: number, outputHeight: number, pixelFormat: number, properties: interop.Object, queue: NSObject, handler: (p1: interop.Enum<typeof CGDisplayStreamFrameStatus>, p2: number, p3: interop.PointerConvertible, p4: interop.PointerConvertible) => void): interop.Object;

declare function CGDisplayStreamStart(displayStream: interop.Object): interop.Enum<typeof CGError>;

declare function CGDisplayStreamStop(displayStream: interop.Object): interop.Enum<typeof CGError>;

declare function CGDisplayStreamGetRunLoopSource(displayStream: interop.Object): interop.Object;

declare function CGRegisterScreenRefreshCallback(callback: (p1: number, p2: interop.PointerConvertible, p3: interop.PointerConvertible) => void, userInfo: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGUnregisterScreenRefreshCallback(callback: (p1: number, p2: interop.PointerConvertible, p3: interop.PointerConvertible) => void, userInfo: interop.PointerConvertible): void;

declare function CGWaitForScreenRefreshRects(rects: interop.PointerConvertible, count: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGScreenRegisterMoveCallback(callback: (p1: CGScreenUpdateMoveDelta, p2: number, p3: interop.PointerConvertible, p4: interop.PointerConvertible) => void, userInfo: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGScreenUnregisterMoveCallback(callback: (p1: CGScreenUpdateMoveDelta, p2: number, p3: interop.PointerConvertible, p4: interop.PointerConvertible) => void, userInfo: interop.PointerConvertible): void;

declare function CGWaitForScreenUpdateRects(requestedOperations: interop.Enum<typeof CGScreenUpdateOperation>, currentOperation: interop.PointerConvertible, rects: interop.PointerConvertible, rectCount: interop.PointerConvertible, delta: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGReleaseScreenRefreshRects(rects: interop.PointerConvertible): void;

declare function CGCursorIsVisible(): number;

declare function CGCursorIsDrawnInFramebuffer(): number;

declare function CGWarpMouseCursorPosition(newCursorPosition: CGPoint): interop.Enum<typeof CGError>;

declare function CGAssociateMouseAndMouseCursorPosition(connected: number): interop.Enum<typeof CGError>;

declare function CGWindowServerCreateServerPort(): interop.Object;

declare function CGEnableEventStateCombining(combineState: number): interop.Enum<typeof CGError>;

declare function CGInhibitLocalEvents(inhibit: number): interop.Enum<typeof CGError>;

declare function CGPostMouseEvent(mouseCursorPosition: CGPoint, updateMouseCursorPosition: number, buttonCount: number, mouseButtonDown: number): interop.Enum<typeof CGError>;

declare function CGPostScrollWheelEvent(wheelCount: number, wheel1: number): interop.Enum<typeof CGError>;

declare function CGPostKeyboardEvent(keyChar: number, virtualKey: number, keyDown: number): interop.Enum<typeof CGError>;

declare function CGSetLocalEventsFilterDuringSuppressionState(filter: interop.Enum<typeof CGEventFilterMask>, state: interop.Enum<typeof CGEventSuppressionState>): interop.Enum<typeof CGError>;

declare function CGSetLocalEventsSuppressionInterval(seconds: number): interop.Enum<typeof CGError>;

declare function CGWindowServerCFMachPort(): interop.Object;

declare function CGEventGetTypeID(): number;

declare function CGEventCreate(source: interop.Object): interop.Object;

declare function CGEventCreateData(allocator: interop.Object, event: interop.Object): interop.Object;

declare function CGEventCreateFromData(allocator: interop.Object, data: interop.Object): interop.Object;

declare function CGEventCreateMouseEvent(source: interop.Object, mouseType: interop.Enum<typeof CGEventType>, mouseCursorPosition: CGPoint, mouseButton: interop.Enum<typeof CGMouseButton>): interop.Object;

declare function CGEventCreateKeyboardEvent(source: interop.Object, virtualKey: number, keyDown: boolean): interop.Object;

declare function CGEventCreateScrollWheelEvent(source: interop.Object, units: interop.Enum<typeof CGScrollEventUnit>, wheelCount: number, wheel1: number): interop.Object;

declare function CGEventCreateScrollWheelEvent2(source: interop.Object, units: interop.Enum<typeof CGScrollEventUnit>, wheelCount: number, wheel1: number, wheel2: number, wheel3: number): interop.Object;

declare function CGEventCreateCopy(event: interop.Object): interop.Object;

declare function CGEventCreateSourceFromEvent(event: interop.Object): interop.Object;

declare function CGEventSetSource(event: interop.Object, source: interop.Object): void;

declare function CGEventGetType(event: interop.Object): interop.Enum<typeof CGEventType>;

declare function CGEventSetType(event: interop.Object, type: interop.Enum<typeof CGEventType>): void;

declare function CGEventGetTimestamp(event: interop.Object): number;

declare function CGEventSetTimestamp(event: interop.Object, timestamp: number): void;

declare function CGEventGetLocation(event: interop.Object): CGPoint;

declare function CGEventGetUnflippedLocation(event: interop.Object): CGPoint;

declare function CGEventSetLocation(event: interop.Object, location: CGPoint): void;

declare function CGEventGetFlags(event: interop.Object): interop.Enum<typeof CGEventFlags>;

declare function CGEventSetFlags(event: interop.Object, flags: interop.Enum<typeof CGEventFlags>): void;

declare function CGEventKeyboardGetUnicodeString(event: interop.Object, maxStringLength: number, actualStringLength: interop.PointerConvertible, unicodeString: interop.PointerConvertible): void;

declare function CGEventKeyboardSetUnicodeString(event: interop.Object, stringLength: number, unicodeString: interop.PointerConvertible): void;

declare function CGEventGetIntegerValueField(event: interop.Object, field: interop.Enum<typeof CGEventField>): number;

declare function CGEventSetIntegerValueField(event: interop.Object, field: interop.Enum<typeof CGEventField>, value: number): void;

declare function CGEventGetDoubleValueField(event: interop.Object, field: interop.Enum<typeof CGEventField>): number;

declare function CGEventSetDoubleValueField(event: interop.Object, field: interop.Enum<typeof CGEventField>, value: number): void;

declare function CGEventTapCreate(tap: interop.Enum<typeof CGEventTapLocation>, place: interop.Enum<typeof CGEventTapPlacement>, options: interop.Enum<typeof CGEventTapOptions>, eventsOfInterest: number, callback: (p1: interop.PointerConvertible, p2: interop.Enum<typeof CGEventType>, p3: interop.PointerConvertible, p4: interop.PointerConvertible) => interop.Pointer, userInfo: interop.PointerConvertible): interop.Object;

declare function CGEventTapCreateForPSN(processSerialNumber: interop.PointerConvertible, place: interop.Enum<typeof CGEventTapPlacement>, options: interop.Enum<typeof CGEventTapOptions>, eventsOfInterest: number, callback: (p1: interop.PointerConvertible, p2: interop.Enum<typeof CGEventType>, p3: interop.PointerConvertible, p4: interop.PointerConvertible) => interop.Pointer, userInfo: interop.PointerConvertible): interop.Object;

declare function CGEventTapCreateForPid(pid: number, place: interop.Enum<typeof CGEventTapPlacement>, options: interop.Enum<typeof CGEventTapOptions>, eventsOfInterest: number, callback: (p1: interop.PointerConvertible, p2: interop.Enum<typeof CGEventType>, p3: interop.PointerConvertible, p4: interop.PointerConvertible) => interop.Pointer, userInfo: interop.PointerConvertible): interop.Object;

declare function CGEventTapEnable(tap: interop.Object, enable: boolean): void;

declare function CGEventTapIsEnabled(tap: interop.Object): boolean;

declare function CGEventTapPostEvent(proxy: interop.PointerConvertible, event: interop.Object): void;

declare function CGEventPost(tap: interop.Enum<typeof CGEventTapLocation>, event: interop.Object): void;

declare function CGEventPostToPSN(processSerialNumber: interop.PointerConvertible, event: interop.Object): void;

declare function CGEventPostToPid(pid: number, event: interop.Object): void;

declare function CGGetEventTapList(maxNumberOfTaps: number, tapList: interop.PointerConvertible, eventTapCount: interop.PointerConvertible): interop.Enum<typeof CGError>;

declare function CGPreflightListenEventAccess(): boolean;

declare function CGRequestListenEventAccess(): boolean;

declare function CGPreflightPostEventAccess(): boolean;

declare function CGRequestPostEventAccess(): boolean;

declare function CGEventSourceGetTypeID(): number;

declare function CGEventSourceCreate(stateID: interop.Enum<typeof CGEventSourceStateID>): interop.Object;

declare function CGEventSourceGetKeyboardType(source: interop.Object): number;

declare function CGEventSourceSetKeyboardType(source: interop.Object, keyboardType: number): void;

declare function CGEventSourceGetPixelsPerLine(source: interop.Object): number;

declare function CGEventSourceSetPixelsPerLine(source: interop.Object, pixelsPerLine: number): void;

declare function CGEventSourceGetSourceStateID(source: interop.Object): interop.Enum<typeof CGEventSourceStateID>;

declare function CGEventSourceButtonState(stateID: interop.Enum<typeof CGEventSourceStateID>, button: interop.Enum<typeof CGMouseButton>): boolean;

declare function CGEventSourceKeyState(stateID: interop.Enum<typeof CGEventSourceStateID>, key: number): boolean;

declare function CGEventSourceFlagsState(stateID: interop.Enum<typeof CGEventSourceStateID>): interop.Enum<typeof CGEventFlags>;

declare function CGEventSourceSecondsSinceLastEventType(stateID: interop.Enum<typeof CGEventSourceStateID>, eventType: interop.Enum<typeof CGEventType>): number;

declare function CGEventSourceCounterForEventType(stateID: interop.Enum<typeof CGEventSourceStateID>, eventType: interop.Enum<typeof CGEventType>): number;

declare function CGEventSourceSetUserData(source: interop.Object, userData: number): void;

declare function CGEventSourceGetUserData(source: interop.Object): number;

declare function CGEventSourceSetLocalEventsFilterDuringSuppressionState(source: interop.Object, filter: interop.Enum<typeof CGEventFilterMask>, state: interop.Enum<typeof CGEventSuppressionState>): void;

declare function CGEventSourceGetLocalEventsFilterDuringSuppressionState(source: interop.Object, state: interop.Enum<typeof CGEventSuppressionState>): interop.Enum<typeof CGEventFilterMask>;

declare function CGEventSourceSetLocalEventsSuppressionInterval(source: interop.Object, seconds: number): void;

declare function CGEventSourceGetLocalEventsSuppressionInterval(source: interop.Object): number;

declare function CGPSConverterCreate(info: interop.PointerConvertible, callbacks: interop.PointerConvertible, options: interop.Object): interop.Object;

declare function CGPSConverterConvert(converter: interop.Object, provider: interop.Object, consumer: interop.Object, options: interop.Object): boolean;

declare function CGPSConverterAbort(converter: interop.Object): boolean;

declare function CGPSConverterIsConverting(converter: interop.Object): boolean;

declare function CGPSConverterGetTypeID(): number;

declare function CGSessionCopyCurrentDictionary(): interop.Object;

declare function CGDirectDisplayCopyCurrentMetalDevice(display: number): MTLDevice;

