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

declare const kIOEventLinkMaxNameLength: number;

declare const IOCommandPool: number;

declare const IOUserServerInterface: number;

declare const IOUserServerMetaClass: number;

declare const gIOUserServerMetaClass: interop.Pointer;

declare const gIOCommandMetaClass: interop.Pointer;

declare const IOCommand: number;

declare const kOSCollectionTypeSerialization: number;

declare const kOSCollectionTypeBoolean: number;

declare const kOSCollectionTypeString: number;

declare const kOSCollectionTypeSymbol: number;

declare const kOSCollectionTypeArray: number;

declare const gOSDataMetaClass: interop.Pointer;

declare const OSString_Class: OSClassLoadInformation;

declare const OSOrderedSetMetaClass: number;

declare const OSOrderedSet_Class: OSClassLoadInformation;

declare const OSSerializationMetaClass: number;

declare const IOExtensiblePaniclogInterface: number;

declare const IOExtensiblePaniclogMetaClass: number;

declare const gIOExtensiblePaniclogMetaClass: interop.Pointer;

declare const kIOExtensiblePaniclogOptionsWithBuffer: number;

declare const OSBundle: number;

declare const OSBundleMetaClass: number;

declare const OSBundle_Class: OSClassLoadInformation;

declare const OSMappedFile_Class: OSClassLoadInformation;

declare const gOSMappedFileMetaClass: interop.Pointer;

declare const IODMACommandInterface: number;

declare const IODMACommand_Class: OSClassLoadInformation;

declare const gIODMACommandMetaClass: interop.Pointer;

declare const kIODMACommandSpecificationNoOptions: number;

declare const kIODMACommandCreateNoOptions: number;

declare const IODataQueueDispatchSource: number;

declare const IODataQueueDispatchSourceInterface: number;

declare const IODataQueueDispatchSourceMetaClass: number;

declare const IODataQueueDispatchSource_Class: OSClassLoadInformation;

declare const IOInterruptDispatchSourceMetaClass: number;

declare const IOInterruptDispatchSource_Class: OSClassLoadInformation;

declare const gIOInterruptDispatchSourceMetaClass: interop.Pointer;

declare const IOServiceStateNotificationDispatchSourceMetaClass: number;

declare const IOServiceStateNotificationDispatchSource_Class: OSClassLoadInformation;

declare const OSBooleanMetaClass: number;

declare const OSBoolean_Class: OSClassLoadInformation;

declare const kOSBooleanTrue: interop.Pointer;

declare const IOTimerDispatchSource: number;

declare const IOTimerDispatchSourceInterface: number;

declare const IOTimerDispatchSource_Class: OSClassLoadInformation;

declare const kIOTimerClockMachContinuousTime: number;

declare const kIOTimerClockRealTime: number;

declare const IOServiceNotificationDispatchSourceInterface: number;

declare const IOServiceNotificationDispatchSourceMetaClass: number;

declare const kIOServiceNotificationTypeMatched: number;

declare const kIOServiceNotificationTypeTerminated: number;

declare const IODispatchQueue_Class: OSClassLoadInformation;

declare const gIODispatchQueueMetaClass: interop.Pointer;

declare const kIODispatchQueueSleepReuseEvent: number;

declare const kIODispatchQueueWakeupAll: number;

declare const kIODispatchQueueReentrant: number;

declare const IODispatchSourceInterface: number;

declare const IODispatchSourceMetaClass: number;

declare const IOWorkGroup: number;

declare const IOWorkGroup_Class: OSClassLoadInformation;

declare const gIOWorkGroupMetaClass: interop.Pointer;

declare const gOSSetMetaClass: interop.Pointer;

declare const OSArrayMetaClass: number;

declare const operator: interop.Pointer;

declare const OSRetain: number;

declare const OSNoRetain: number;

declare const libkern: number;

declare const IOReportLegendInterface: number;

declare const IOStateReporter: number;

declare const IOStateReporterInterface: number;

declare const IOStateReporter_Class: OSClassLoadInformation;

declare const gIOStateReporterMetaClass: interop.Pointer;

declare const IOSimpleReporterInterface: number;

declare const IOSimpleReporterMetaClass: number;

declare const gIOSimpleReporterMetaClass: interop.Pointer;

declare const gIOReporterMetaClass: interop.Pointer;

declare const OSDictionaryMetaClass: number;

declare const gOSCollectionMetaClass: interop.Pointer;

declare const gOSContainerMetaClass: interop.Pointer;

declare const OSAction_IOUserClient_KernelCompletion: number;

declare const OSAction_IOUserClient_KernelCompletionInterface: number;

declare const OSAction_IOUserClient_KernelCompletionMetaClass: number;

declare const OSAction_IOUserClient_KernelCompletion_Class: OSClassLoadInformation;

declare const IOUserClientInterface: number;

declare const gIOUserClientMetaClass: interop.Pointer;

declare const kIOUserClientAsyncReferenceCountMax: number;

declare const OSAction_Class: OSClassLoadInformation;

declare const gOSActionMetaClass: interop.Pointer;

declare const IOBufferMemoryDescriptorInterface: number;

declare const OSDataMetaClass: number;

declare const kIOServiceHaltStatePowerOff: number;

declare const _kIOPMWakeEventPossibleFullWake: number;

declare const _kIOPMWakeEventFullWake: number;

declare const kIOServicePowerCapabilityOn: number;

declare const kIOServicePowerCapabilityOff: number;

declare const IOServiceStateNotificationDispatchSource: number;

declare const OSAction: number;

declare const IOUserClient: number;

declare const IOBufferMemoryDescriptor: number;

declare const IOMemoryMap_Class: OSClassLoadInformation;

declare const IOMemoryDescriptor: number;

declare const IOMemoryDescriptorMetaClass: number;

declare const gIOMemoryDescriptorMetaClass: interop.Pointer;

declare const kIOMemoryMapCacheModeRealTime: number;

declare const kIOMemoryMapGuardedDefault: number;

declare const kIOMemoryMapFixedAddress: number;

declare const kIOMemoryDisableCopyOnWrite: number;

declare const kIOMemoryDirectionInOut: number;

declare const kIOMemoryDirectionIn: number;

declare const kIOMemoryDirectionNone: number;

declare const IOMemoryMap: number;

declare const OSObjectMetaClass: number;

declare const gOSObjectMetaClass: interop.Pointer;

declare const OSBoolean: number;

declare const kIOMemoryDirectionOut: number;

declare const IOBufferMemoryDescriptorMetaClass: number;

declare const OSOrderedSetInterface: number;

declare const OSBundleInterface: number;

declare const kIODMACommandCompleteDMANoOptions: number;

declare const kIOExtensiblePaniclogOptionsNone: number;

declare const OSActionMetaClass: number;

declare const OSData: number;

declare const IOReporter_Class: OSClassLoadInformation;

declare const IOService_Class: OSClassLoadInformation;

declare const OSSerialization: number;

declare const kIOUserClientAsyncArgumentsCountMax: number;

declare const IOTimerDispatchSourceMetaClass: number;

declare const IOSimpleReporter_Class: OSClassLoadInformation;

declare const IOReportLegend_Class: OSClassLoadInformation;

declare const gIODispatchSourceMetaClass: interop.Pointer;

declare const IOCommandPool_Class: OSClassLoadInformation;

declare const IOServiceInterface: number;

declare const kIOUserClientMemoryReadOnly: number;

declare const kIOInterruptSourceAbsoluteTime: number;

declare const kIOMemoryMapGuardedLarge: number;

declare const kIODMACommandPerformOperationOptionZero: number;

declare const OSNumberMetaClass: number;

declare const kOSCollectionTypeSet: number;

declare const kIOMemoryMapReadOnly: number;

declare const IOCommandInterface: number;

declare const kIOTimerClockMonotonicRaw: number;

declare const IODispatchQueueInterface: number;

declare const gOSBundleMetaClass: interop.Pointer;

declare const kIOServiceHaltStateRestart: number;

declare const OSSerializationInterface: number;

declare const gOSSerializationMetaClass: interop.Pointer;

declare const kIOServicePowerCapabilityLPW: number;

declare const kIOMemoryMapGuardedNone: number;

declare const IODispatchSource_Class: OSClassLoadInformation;

declare const kIOMemoryMapGuardedMask: number;

declare const OSOrderedSet: number;

declare const kIOMemoryMapCacheModeInhibit: number;

declare const OSStringInterface: number;

declare const IOCommand_Class: OSClassLoadInformation;

declare const gOSOrderedSetMetaClass: interop.Pointer;

declare const kIOEventLinkAssociateCurrentThread: number;

declare const kIODMACommandPerformOperationOptionWrite: number;

declare const IODMACommandMetaClass: number;

declare const kOSArrayAppend: number;

declare const IOInterruptDispatchSource: number;

declare const kIOTimerClockUptimeRaw: number;

declare const IOEventLinkMetaClass: number;

declare const kIOUserClientScalarArrayCountMax: number;

declare const IOMemoryDescriptor_Class: OSClassLoadInformation;

declare const OSContainerInterface: number;

declare const IOUserServer_Class: OSClassLoadInformation;

declare const gOSDictionaryMetaClass: interop.Pointer;

declare const OSArrayInterface: number;

declare const kIOTimerClockWallTime: number;

declare const kIOMemoryDirectionOutIn: number;

declare const gIOBufferMemoryDescriptorMetaClass: interop.Pointer;

declare const gIOMemoryMapMetaClass: interop.Pointer;

declare const IOUserClientMetaClass: number;

declare const kIODispatchQueueMethodsNotSynchronized: number;

declare const IOServiceMetaClass: number;

declare const kIOTimerClockMachAbsoluteTime: number;

declare const IOService: number;

declare const OSCollectionMetaClass: number;

declare const OSObjectInterface: number;

declare const IOWorkGroupInterface: number;

declare const gIOServiceStateNotificationDispatchSourceMetaClass: interop.Pointer;

declare const IOBufferMemoryDescriptor_Class: OSClassLoadInformation;

declare const gIOHistogramReporterMetaClass: interop.Pointer;

declare const IOMemoryMapMetaClass: number;

declare const OSMappedFileInterface: number;

declare const gOSNumberMetaClass: interop.Pointer;

declare const OSNumberInterface: number;

declare const kIOMemoryMapCacheModeCopyback: number;

declare const IOSimpleReporter: number;

declare const kIOEventLinkClockMachAbsoluteTime: number;

declare const kIOServicePMAssertionCPUBit: number;

declare const IOServiceStateNotificationDispatchSourceInterface: number;

declare const OSObject_Class: OSClassLoadInformation;

declare const OSNumber: number;

declare const IOReporterMetaClass: number;

declare const IOEventLink: number;

declare const OSMappedFileMetaClass: number;

declare const OSCollectionInterface: number;

declare const OSSerialization_Class: OSClassLoadInformation;

declare const kIOServiceNotificationTypeNone: number;

declare const IOHistogramReporterMetaClass: number;

declare const IOMemoryDescriptorInterface: number;

declare const kIODMACommandPerformOperationOptionRead: number;

declare const IOReporter: number;

declare const OSAllocateMemory: number;

declare const OSContainerMetaClass: number;

declare const gIOTimerDispatchSourceMetaClass: interop.Pointer;

declare const IOWorkGroupMetaClass: number;

declare const IOExtensiblePaniclog: number;

declare const IOInterruptDispatchSourceInterface: number;

declare const IOServiceNotificationDispatchSource_Class: OSClassLoadInformation;

declare const OSArray_Class: OSClassLoadInformation;

declare const IOCommandPoolInterface: number;

declare const gIOServiceNotificationDispatchSourceMetaClass: interop.Pointer;

declare const IOReportLegendMetaClass: number;

declare const IODispatchQueueMetaClass: number;

declare const OSSet: number;

declare const kIOServiceSearchPropertyParents: number;

declare const OSDictionaryInterface: number;

declare const kIOUserClientMethodArgumentsCurrentVersion: number;

declare const _kIOPMWakeEventSource: number;

declare const IOUserServer: number;

declare const OSData_Class: OSClassLoadInformation;

declare const OSNumber_Class: OSClassLoadInformation;

declare const IOHistogramReporter: number;

declare const gOSBooleanMetaClass: interop.Pointer;

declare const IOExtensiblePaniclog_Class: OSClassLoadInformation;

declare const kIODMACommandPrepareForDMANoOptions: number;

declare const IOVMPageSize: number;

declare const kIOInterruptDispatchSourceTypeLevel: number;

declare const kIOInterruptSourceContinuousTime: number;

declare const IOHistogramReporterInterface: number;

declare const OSDataInterface: number;

declare const kOSCollectionTypeNumber: number;

declare const os_detail: number;

declare const IOReporterInterface: number;

declare const kIOInterruptSourceIndexMask: number;

declare const kOSCollectionTypeDictionary: number;

declare const kIOServicePowerCapabilityLow: number;

declare const IOReportLegend: number;

declare const OSSetMetaClass: number;

declare const kIOServicePMAssertionForceFullWakeupBit: number;

declare const IOCommandMetaClass: number;

declare const gIOReportLegendMetaClass: interop.Pointer;

declare const OSAllocateMemoryZero: number;

declare const gIODataQueueDispatchSourceMetaClass: interop.Pointer;

declare const IODispatchSource: number;

declare const OSBooleanInterface: number;

declare const gOSArrayMetaClass: interop.Pointer;

declare const gIOCommandPoolMetaClass: interop.Pointer;

declare const OSMappedFile: number;

declare const gIOEventLinkMetaClass: interop.Pointer;

declare const kIOMemoryMapGuardedSmall: number;

declare const IODispatchQueue: number;

declare const IOCommandPoolMetaClass: number;

declare const kIOEventLinkAssociateOnWait: number;

declare const IOEventLinkInterface: number;

declare const kIOMemoryMapCacheModeDefault: number;

declare const kOSCollectionTypeData: number;

declare const IOMemoryMapInterface: number;

declare const IOServiceNotificationDispatchSource: number;

declare const IOEventLink_Class: OSClassLoadInformation;

declare const kOSBooleanFalse: interop.Pointer;

declare const IOUserClient_Class: OSClassLoadInformation;

declare const OSActionInterface: number;

declare const OSCollection_Class: OSClassLoadInformation;

declare const kIOUserClientVariableStructureSize: number;

declare const kIOWorkGroupMaxNameLength: number;

declare const IOHistogramReporter_Class: OSClassLoadInformation;

declare const OSSetInterface: number;

declare const IOStateReporterMetaClass: number;

declare const gIOServiceMetaClass: interop.Pointer;

declare const gOSStringMetaClass: interop.Pointer;

declare const OSStringMetaClass: number;

declare const gOSAction_IOUserClient_KernelCompletionMetaClass: interop.Pointer;

declare const OSContainer: number;

declare const kIOServiceNotificationTypeLast: number;

declare const OSDictionary_Class: OSClassLoadInformation;

declare const OSAdoptMemory: number;

declare const kIOInterruptDispatchSourceTypeEdge: number;

declare const OSSet_Class: OSClassLoadInformation;

declare const kIOMemoryMapCacheModeWriteThrough: number;

declare const OSContainer_Class: OSClassLoadInformation;

declare const IOStateReporter_valueSelector: {
  InTransitions: 0,
  ResidencyTime: 1,
  LastTransitionTime: 2,
};

declare const IOLockAssertState: {
  kIOLockAssertOwned: 1,
  Not: 2,
};

declare const IORWLockAssertState: {
  Read: 1,
  Write: 2,
  Held: 3,
  NotHeld: 4,
};

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

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

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

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

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

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

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

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

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

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

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

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

declare class IODMACommandSpecification {
  constructor(init?: IODMACommandSpecification);
  options: number;
  maxAddressBits: number;
  _resv: unknown /* const array */;
}

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

declare class IOInterruptDispatchSourcePayload {
  constructor(init?: IOInterruptDispatchSourcePayload);
  time: number;
  count: number;
}

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

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

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

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

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

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

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

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

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

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

declare class OS_retain_t {
  constructor(init?: OS_retain_t);
  constexpr: number;
}

declare class OS_no_retain_t {
  constructor(init?: OS_no_retain_t);
  constexpr: number;
}

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

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

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

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

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

declare class IOReporter_IVars {
  constructor(init?: IOReporter_IVars);
  channelType: IOReportChannelType;
  driver_id: number;
  elements: interop.Pointer;
  enableCounts: interop.Pointer;
  channelDimension: number;
  nElements: number;
  nChannels: number;
  channelNames: interop.Pointer;
  reporterIsLocked: boolean;
  reporterConfigIsLocked: boolean;
  swapElements: interop.Pointer;
  swapEnableCounts: interop.Pointer;
  unit: number;
  enabled: number;
  configLock: interop.Pointer;
  reporterLock: interop.Pointer;
  valid: unknown /* _Bool () (CXTypeKind: 110) */;
  : number;
  lockReporterConfig: () => void | null;
  unlockReporterConfig: () => void | null;
  lockReporter: () => void | null;
  unlockReporter: () => void | null;
  IOReturn: number;
  handleSwapCleanup: (p1: number) => number | null;
  OSSharedPtr: number;
  updateReportChannel: (p1: number, p2: number) => number | null;
  IOReportElementValues: number;
  : number;
  : number;
}

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

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

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

declare class IONormDistReportValues {
  constructor(init?: IONormDistReportValues);
  samples: number;
  mean: number;
  variance: number;
  reserved: number;
}

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

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

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

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

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

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

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

declare class IOUserClientMethodDispatch {
  constructor(init?: IOUserClientMethodDispatch);
  function: (p1: interop.PointerConvertible, p2: interop.PointerConvertible, p3: interop.PointerConvertible) => number | null;
  checkCompletionExists: number;
  checkScalarInputCount: number;
  checkStructureInputSize: number;
  checkScalarOutputCount: number;
  checkStructureOutputSize: number;
}

declare class IOUserClientMethodArguments {
  constructor(init?: IOUserClientMethodArguments);
  version: number;
  selector: number;
  completion: interop.Pointer;
  scalarInput: interop.Pointer;
  scalarInputCount: number;
  structureInput: interop.Pointer;
  structureInputDescriptor: interop.Pointer;
  scalarOutput: interop.Pointer;
  scalarOutputCount: number;
  structureOutput: interop.Pointer;
  structureOutputDescriptor: interop.Pointer;
  structureOutputMaximumSize: number;
  __reserved: unknown /* const array */;
}

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

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

declare class _IOMemoryMapPrivateState {
  constructor(init?: _IOMemoryMapPrivateState);
  length: number;
  offset: number;
  options: number;
  address: number;
}

declare class IOAddressSegment {
  constructor(init?: IOAddressSegment);
  address: number;
  length: number;
}

declare class IOCallOnceFlag {
  constructor(init?: IOCallOnceFlag);
  opaque: number;
}

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

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

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

declare class OSClassLoadInformation {
  constructor(init?: OSClassLoadInformation);
  description: interop.Pointer;
  metaPointer: interop.Pointer;
  version: number;
  instanceSize: number;
  resv2: unknown /* const array */;
  New: (p1: interop.PointerConvertible) => number | null;
  resv3: unknown /* const array */;
}

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

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

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

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

declare class __OSStringStatic {
  constructor(init?: __OSStringStatic);
  cString: string | null;
  osString: interop.Pointer;
}

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

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

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

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

declare class _IOMDPrivateState {
  constructor(init?: _IOMDPrivateState);
  length: number;
  options: number;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare class IOHistogramSegmentConfig {
  constructor(init?: IOHistogramSegmentConfig);
  base_bucket_width: number;
  scale_flag: number;
  segment_idx: number;
  segment_bucket_count: number;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

declare class IVarsInvalidator {
  constructor(init?: IVarsInvalidator);
  ivars: interop.Pointer;
  IVarsInvalidator: (p1: IOReporter_IVars) => number | null;
}

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

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

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

declare function OSObjectAllocate(meta: interop.PointerConvertible, pObject: interop.PointerConvertible): number;

declare function IOLogBuffer(title: string, buffer: interop.PointerConvertible, size: number): void;

declare function crc32(crc: number, buf: interop.PointerConvertible, size: number): number;

declare function IOLog(format: string): number;

declare function IOLogv(format: string, ap: string): number;

declare function IOMallocTyped(length: number, type_id: number): interop.Pointer;

declare function IOMalloc(length: number): interop.Pointer;

declare function IOMallocZeroTyped(length: number, type_id: number): interop.Pointer;

declare function IOMallocZero(length: number): interop.Pointer;

declare function IOFree(address: interop.PointerConvertible, length: number): void;

declare function IOSleep(ms: number): void;

declare function IODelay(us: number): void;

declare function OSSynchronizeIO(): void;

declare function IOParseBootArgNumber(arg_string: string, arg_ptr: interop.PointerConvertible, max_len: number): boolean;

declare function IOParseBootArgString(arg_string: string, arg_ptr: string, strlen: number): boolean;

declare function OSReportWithBacktrace(str: string): void;

declare function panic(string: string): void;

declare function IOLockAlloc(): interop.Pointer;

declare function IOLockFree(lock: interop.PointerConvertible): void;

declare function IOLockLock(lock: interop.PointerConvertible): void;

declare function IOLockUnlock(lock: interop.PointerConvertible): void;

declare function IOLockTryLock(lock: interop.PointerConvertible): boolean;

declare function IOLockAssert(lock: interop.PointerConvertible, type: interop.Enum<typeof IOLockAssertState>): void;

declare function IORecursiveLockAlloc(): interop.Pointer;

declare function IORecursiveLockFree(lock: interop.PointerConvertible): void;

declare function IORecursiveLockLock(lock: interop.PointerConvertible): void;

declare function IORecursiveLockTryLock(lock: interop.PointerConvertible): boolean;

declare function IORecursiveLockUnlock(lock: interop.PointerConvertible): void;

declare function IORecursiveLockHaveLock(lock: interop.PointerConvertible): boolean;

declare function IORWLockAlloc(): interop.Pointer;

declare function IORWLockFree(lock: interop.PointerConvertible): void;

declare function IORWLockRead(lock: interop.PointerConvertible): void;

declare function IORWLockWrite(lock: interop.PointerConvertible): void;

declare function IORWLockUnlock(lock: interop.PointerConvertible): void;

declare function IORecursiveConditionLockAlloc(): interop.Pointer;

declare function IORecursiveConditionLockFree(lock: interop.PointerConvertible): void;

declare function IORecursiveConditionLockLock(lock: interop.PointerConvertible): void;

declare function IORecursiveConditionLockUnlock(lock: interop.PointerConvertible): void;

declare function IORecursiveConditionLockHaveLock(lock: interop.PointerConvertible): boolean;

declare function IORecursiveConditionLockTryLock(lock: interop.PointerConvertible): boolean;

declare function read_random(buffer: interop.PointerConvertible, numBytes: number): void;

declare function IOThreadLocalStorageKeyCreate(key: interop.PointerConvertible): number;

declare function IOThreadLocalStorageKeyDelete(key: number): number;

declare function IOThreadLocalStorageSet(key: number, value: interop.PointerConvertible): number;

declare function IOThreadLocalStorageGet(key: number): interop.Pointer;

declare function IOCallOnce(flag: interop.PointerConvertible, block: () => void): void;

declare function OSCollectionTypeName(t: number): string;

declare function OSCollectionTypeID(obj: interop.PointerConvertible): number;

declare function OSObjectRetain(container: interop.PointerConvertible): void;

declare function OSObjectRelease(container: interop.PointerConvertible): void;

declare function OSCollectionsInitialize(): void;

declare function OSStringGetStringPtr(obj: interop.PointerConvertible): string;

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

declare function OSStringCreate(cstring: string, length: number): interop.Pointer;

declare function OSDataGetLength(obj: interop.PointerConvertible): number;

declare function OSDataGetBytesPtr(obj: interop.PointerConvertible, offset: number, length: number): interop.Pointer;

declare function OSDataGetBytes(obj: interop.PointerConvertible, buffer: interop.PointerConvertible, offset: number, length: number): number;

declare function OSDataCreate(bytes: interop.PointerConvertible, length: number): interop.Pointer;

declare function OSDataAppendBytes(data: interop.PointerConvertible, bytes: interop.PointerConvertible, length: number): boolean;

declare function OSNumberGetUInt64Value(obj: interop.PointerConvertible): number;

declare function OSNumberCreateWithUInt64Value(value: number): interop.Pointer;

declare function OSDictionaryCreate(): interop.Pointer;

declare function OSDictionaryGetCount(obj: interop.PointerConvertible): number;

declare function OSDictionaryApply(obj: interop.PointerConvertible, applier: (p1: string, p2: interop.PointerConvertible) => boolean): boolean;

declare function OSDictionarySetValue(obj: interop.PointerConvertible, key: string, value: interop.PointerConvertible): boolean;

declare function OSDictionaryGetValue(obj: interop.PointerConvertible, key: string): interop.Pointer;

declare function OSDictionaryGetStringValue(obj: interop.PointerConvertible, key: string): string;

declare function OSDictionaryGetUInt64Value(obj: interop.PointerConvertible, key: string): number;

declare function OSDictionarySetStringValue(obj: interop.PointerConvertible, key: string, value: string): void;

declare function OSDictionarySetUInt64Value(obj: interop.PointerConvertible, key: string, value: number): void;

declare function OSArrayCreate(): interop.Pointer;

declare function OSArrayGetCount(obj: interop.PointerConvertible): number;

declare function OSArrayApply(obj: interop.PointerConvertible, applier: (p1: interop.PointerConvertible) => boolean): boolean;

declare function OSArraySetValue(obj: interop.PointerConvertible, index: number, value: interop.PointerConvertible): boolean;

declare function OSArrayReplaceValue(obj: interop.PointerConvertible, index: number, value: interop.PointerConvertible): boolean;

declare function OSArrayAppendValue(obj: interop.PointerConvertible, value: interop.PointerConvertible): boolean;

declare function OSArrayGetValue(obj: interop.PointerConvertible, index: number): interop.Pointer;

declare function OSArrayGetStringValue(obj: interop.PointerConvertible, index: number): string;

declare function OSArraySetStringValue(obj: interop.PointerConvertible, index: number, value: string): void;

declare function OSArrayGetUInt64Value(obj: interop.PointerConvertible, index: number): number;

declare function OSArraySetUInt64Value(obj: interop.PointerConvertible, index: number, value: number): void;

declare function OSCreateObjectFromSerialization(serial: interop.PointerConvertible): interop.Pointer;

declare function OSCreateSerializationFromObject(obj: interop.PointerConvertible): interop.Pointer;

declare function OSCreateSerializationFromBytes(bytes: interop.PointerConvertible, length: number, freeBuffer: (p1: interop.PointerConvertible, p2: number) => void): interop.Pointer;

declare function OSSerializationGetBytes(serial: interop.PointerConvertible, length: interop.PointerConvertible): interop.Pointer;

declare function OSObjectLog(obj: interop.PointerConvertible): void;

declare function panic(string: string): void;

