/**
 * Copyright: Copyright (c) 2009 Jacob Carlborg.
 * Authors: Jacob Carlborg
 * Version: Initial created: Jul 21, 2009 
 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0)
 */
module dstep.coreservices.carboncore.Files;

//import dstep.AvailabilityMacros;
import dstep.coreservices.carboncore.Finder;
import dstep.coreservices.carboncore.MacTypes;
import dstep.coreservices.carboncore.MixedMode;
import dstep.coreservices.carboncore.OSUtils;
import dstep.coreservices.carboncore.TextCommon;
import dstep.coreservices.carboncore.UTCUtils;
import dstep.corefoundation.CFBase;
import dstep.corefoundation.CFDictionary;
import dstep.corefoundation.CFRunLoop;
import dstep.corefoundation.CFURL;
import dstep.corefoundation.CFUUID;
import dstep.diskarbitration.DADisk;
import dstep.objc.bridge.TypeEncoding;
import dstep.internal.Types;
/*import dstep.sys.acl;
import dstep.sys.fcntl;
import dstep.sys.types;*/


struct __FSFileOperation;
struct __FSFileSecurity;
struct OpaqueFSIterator;
struct OpaqueFNSubscriptionRef;
struct OpaqueFSVolumeOperation;
struct _acl;

alias _acl* acl_t;
alias int pid_t;
alias HFSUniStr255* ConstHFSUniStr255Param;
alias short FSVolumeRefNum;
alias int FSIORefNum;
alias FSRef* FSRefPtr;
alias __FSFileSecurity* FSFileSecurityRef;
alias FSSpec* FSSpecPtr;
alias FSSpecPtr* FSSpecHandle;
alias FSSpecPtr FSSpecArrayPtr;
alias FSSpec* ConstFSSpecPtr;
alias void* ParmBlkPtr;
alias IOCompletionProcPtr IOCompletionUPP;
alias uint FSCatalogInfoBitmap;
alias FSCatalogInfo* FSCatalogInfoPtr;
alias FSRefParam* FSRefParamPtr;
alias FSRefForkIOParam* FSRefForkIOParamPtr;
alias OpaqueFSIterator* FSIterator;
alias uint FSIteratorFlags;
alias FSSearchParams* FSSearchParamsPtr;
alias FSCatalogBulkParam* FSCatalogBulkParamPtr;
alias ushort FSAllocationFlags;
alias FSForkIOParam* FSForkIOParamPtr;
alias FSForkInfo* FSForkInfoPtr;
alias FSForkCBInfoParam* FSForkCBInfoParamPtr;
alias FSRangeLockParam* FSRangeLockParamPtr;
alias uint FSVolumeInfoBitmap;
alias FSVolumeInfo* FSVolumeInfoPtr;
alias FSVolumeInfoParam* FSVolumeInfoParamPtr;
alias uint VolumeType;
alias VolMountInfoHeader* VolMountInfoPtr;
alias VolumeMountInfoHeader* VolumeMountInfoHeaderPtr;
alias AFPVolMountInfo* AFPVolMountInfoPtr;
alias AFPXVolMountInfo* AFPXVolMountInfoPtr;
alias uint FNMessage;
alias OpaqueFNSubscriptionRef* FNSubscriptionRef;
alias FNSubscriptionProcPtr FNSubscriptionUPP;
alias uint FSMountStatus;
alias uint FSEjectStatus;
alias uint FSUnmountStatus;
alias OpaqueFSVolumeOperation* FSVolumeOperation;
alias FSVolumeMountProcPtr FSVolumeMountUPP;
alias FSVolumeUnmountProcPtr FSVolumeUnmountUPP;
alias FSVolumeEjectProcPtr FSVolumeEjectUPP;
alias __FSFileOperation* FSFileOperationRef;
alias uint FSFileOperationStage;

extern (C)
{
	alias void function (ParmBlkPtr) IOCompletionProcPtr;
	alias void function (FSFileOperationRef, FSRef*, uint, int, CFDictionaryRef, void*) FSFileOperationStatusProcPtr;
	alias void function (uint, uint, void*, FNSubscriptionRef) FNSubscriptionProcPtr;
	alias void function (FSFileOperationRef, char*, uint, int, CFDictionaryRef, void*) FSPathFileOperationStatusProcPtr;
	alias void function (FSVolumeOperation, void*, int, short, int) FSVolumeUnmountProcPtr;
	alias void function (FSVolumeOperation, void*, int, short, int) FSVolumeEjectProcPtr;
	alias void function (FSVolumeOperation, void*, int, short) FSVolumeMountProcPtr;
}

extern (C)
{
	extern
	{
		const CFStringRef kFSOperationTotalBytesKey;
		const CFStringRef kFSOperationBytesCompleteKey;
		const CFStringRef kFSOperationBytesRemainingKey;
		const CFStringRef kFSOperationTotalObjectsKey;
		const CFStringRef kFSOperationObjectsCompleteKey;
		const CFStringRef kFSOperationObjectsRemainingKey;
		const CFStringRef kFSOperationTotalUserVisibleObjectsKey;
		const CFStringRef kFSOperationUserVisibleObjectsCompleteKey;
		const CFStringRef kFSOperationUserVisibleObjectsRemainingKey;
		const CFStringRef kFSOperationThroughputKey;
	}
}

// This is needed otherwise the enums will fail compiling with gdc
version (GNU)
{
	private
	{
		const __AppleShareMediaType = getOSType!("afpm");

	}
}

enum
{
	fsCurPerm = 0x00,
	fsRdPerm = 0x01,
	fsWrPerm = 0x02,
	fsRdWrPerm = 0x03,
	fsRdWrShPerm = 0x04
}

enum
{
	fsRdAccessPerm = 0x01,
	fsWrAccessPerm = 0x02,
	fsRdDenyPerm = 0x10,
	fsWrDenyPerm = 0x20
}

enum
{
	fsRtParID = 1,
	fsRtDirID = 2
}

enum
{
	fsAtMark = 0,
	fsFromStart = 1,
	fsFromLEOF = 2,
	fsFromMark = 3
}

enum
{
	kFSAllowConcurrentAsyncIOBit = 3,
	kFSAllowConcurrentAsyncIOMask = 0x0008,
	kFSPleaseCacheBit = 4,
	kFSPleaseCacheMask = 0x0010,
	kFSNoCacheBit = 5,
	kFSNoCacheMask = 0x0020,
	kFSRdVerifyBit = 6,
	kFSRdVerifyMask = 0x0040,
	kFSForceReadBit = 6,
	kFSForceReadMask = 0x0040,
	kFSNewLineBit = 7,
	kFSNewLineMask = 0x0080,
	kFSNewLineCharMask = 0xFF00
}

enum
{
	fsSBPartialName = 0x01,
	fsSBFullName = 0x02,
	fsSBFlAttrib = 0x04,
	fsSBFlFndrInfo = 0x08,
	fsSBFlLgLen = 0x20,
	fsSBFlPyLen = 0x40,
	fsSBFlRLgLen = 0x80,
	fsSBFlRPyLen = 0x0100,
	fsSBFlCrDat = 0x0200,
	fsSBFlMdDat = 0x0400,
	fsSBFlBkDat = 0x0800,
	fsSBFlXFndrInfo = 0x1000,
	fsSBFlParID = 0x2000,
	fsSBNegate = 0x4000,
	fsSBDrUsrWds = 0x08,
	fsSBDrNmFls = 0x10,
	fsSBDrCrDat = 0x0200,
	fsSBDrMdDat = 0x0400,
	fsSBDrBkDat = 0x0800,
	fsSBDrFndrInfo = 0x1000,
	fsSBDrParID = 0x2000,
	fsSBNodeID = 0x8000,
	fsSBAttributeModDate = 0x00010000,
	fsSBAccessDate = 0x00020000,
	fsSBPermissions = 0x00040000,
	fsSBSkipPackageContents = 0x00080000,
	fsSBSkipHiddenItems = 0x00100000,
	fsSBUserID = 0x00200000,
	fsSBGroupID = 0x00400000
}

enum
{
	fsSBPartialNameBit = 0,
	fsSBFullNameBit = 1,
	fsSBFlAttribBit = 2,
	fsSBFlFndrInfoBit = 3,
	fsSBFlLgLenBit = 5,
	fsSBFlPyLenBit = 6,
	fsSBFlRLgLenBit = 7,
	fsSBFlRPyLenBit = 8,
	fsSBFlCrDatBit = 9,
	fsSBFlMdDatBit = 10,
	fsSBFlBkDatBit = 11,
	fsSBFlXFndrInfoBit = 12,
	fsSBFlParIDBit = 13,
	fsSBNegateBit = 14,
	fsSBDrUsrWdsBit = 3,
	fsSBDrNmFlsBit = 4,
	fsSBDrCrDatBit = 9,
	fsSBDrMdDatBit = 10,
	fsSBDrBkDatBit = 11,
	fsSBDrFndrInfoBit = 12,
	fsSBDrParIDBit = 13,
	fsSBNodeIDBit = 15,
	fsSBAttributeModDateBit = 16,
	fsSBAccessDateBit = 17,
	fsSBPermissionsBit = 18,
	fsSBSkipPackageContentsBit = 19,
	fsSBSkipHiddenItemsBit = 20,
	fsSBUserIDBit = 21,
	fsSBGroupIDBit = 22
}

enum
{
	bLimitFCBs = 31,
	bLocalWList = 30,
	bNoMiniFndr = 29,
	bNoVNEdit = 28,
	bNoLclSync = 27,
	bTrshOffLine = 26,
	bNoSwitchTo = 25,
	bNoDeskItems = 20,
	bNoBootBlks = 19,
	bAccessCntl = 18,
	bNoSysDir = 17,
	bHasExtFSVol = 16,
	bHasOpenDeny = 15,
	bHasCopyFile = 14,
	bHasMoveRename = 13,
	bHasDesktopMgr = 12,
	bHasShortName = 11,
	bHasFolderLock = 10,
	bHasPersonalAccessPrivileges = 9,
	bHasUserGroupList = 8,
	bHasCatSearch = 7,
	bHasFileIDs = 6,
	bHasBTreeMgr = 5,
	bHasBlankAccessPrivileges = 4,
	bSupportsAsyncRequests = 3,
	bSupportsTrashVolumeCache = 2
}

enum
{
	bHasDirectIO = 1
}

enum
{
	bIsEjectable = 0,
	bSupportsHFSPlusAPIs = 1,
	bSupportsFSCatalogSearch = 2,
	bSupportsFSExchangeObjects = 3,
	bSupports2TBFiles = 4,
	bSupportsLongNames = 5,
	bSupportsMultiScriptNames = 6,
	bSupportsNamedForks = 7,
	bSupportsSubtreeIterators = 8,
	bL2PCanMapFileBlocks = 9,
	bParentModDateChanges = 10,
	bAncestorModDateChanges = 11,
	bSupportsSymbolicLinks = 13,
	bIsAutoMounted = 14,
	bAllowCDiDataHandler = 17,
	bSupportsExclusiveLocks = 18,
	bSupportsJournaling = 19,
	bNoVolumeSizes = 20,
	bIsOnInternalBus = 21,
	bIsCaseSensitive = 22,
	bIsCasePreserving = 23,
	bDoNotDisplay = 24,
	bIsRemovable = 25,
	bNoRootTimes = 26,
	bIsOnExternalBus = 27,
	bSupportsExtendedFileSecurity = 28
}

enum
{
	kWidePosOffsetBit = 8,
	kUseWidePositioning = (1 << kWidePosOffsetBit),
	kMaximumBlocksIn4GB = 0x007FFFFF
}

enum
{
	fsUnixPriv = 1
}

enum
{
	kNoUserAuthentication = 1,
	kPassword = 2,
	kEncryptPassword = 3,
	kTwoWayEncryptPassword = 6
}

enum
{
	knoUser = 0,
	kadministratorUser = 1
}

enum
{
	knoGroup = 0
}

enum
{
	kFSInvalidVolumeRefNum = 0
}

enum
{
	kFSCatInfoNone = 0x00000000,
	kFSCatInfoTextEncoding = 0x00000001,
	kFSCatInfoNodeFlags = 0x00000002,
	kFSCatInfoVolume = 0x00000004,
	kFSCatInfoParentDirID = 0x00000008,
	kFSCatInfoNodeID = 0x00000010,
	kFSCatInfoCreateDate = 0x00000020,
	kFSCatInfoContentMod = 0x00000040,
	kFSCatInfoAttrMod = 0x00000080,
	kFSCatInfoAccessDate = 0x00000100,
	kFSCatInfoBackupDate = 0x00000200,
	kFSCatInfoPermissions = 0x00000400,
	kFSCatInfoFinderInfo = 0x00000800,
	kFSCatInfoFinderXInfo = 0x00001000,
	kFSCatInfoValence = 0x00002000,
	kFSCatInfoDataSizes = 0x00004000,
	kFSCatInfoRsrcSizes = 0x00008000,
	kFSCatInfoSharingFlags = 0x00010000,
	kFSCatInfoUserPrivs = 0x00020000,
	kFSCatInfoUserAccess = 0x00080000,
	kFSCatInfoSetOwnership = 0x00100000,
	kFSCatInfoFSFileSecurityRef = 0x00400000,
	kFSCatInfoAllDates = 0x000003E0,
	kFSCatInfoGettableInfo = 0x0003FFFF,
	kFSCatInfoSettableInfo = 0x00001FE3,
	kFSCatInfoReserved = cast(c_long)0xFFFC0000
}

enum
{
	kFSNodeLockedBit = 0,
	kFSNodeLockedMask = 0x0001,
	kFSNodeResOpenBit = 2,
	kFSNodeResOpenMask = 0x0004,
	kFSNodeDataOpenBit = 3,
	kFSNodeDataOpenMask = 0x0008,
	kFSNodeIsDirectoryBit = 4,
	kFSNodeIsDirectoryMask = 0x0010,
	kFSNodeCopyProtectBit = 6,
	kFSNodeCopyProtectMask = 0x0040,
	kFSNodeForkOpenBit = 7,
	kFSNodeForkOpenMask = 0x0080,
	kFSNodeHardLinkBit = 8,
	kFSNodeHardLinkMask = 0x00000100
}

enum
{
	kFSNodeInSharedBit = 2,
	kFSNodeInSharedMask = 0x0004,
	kFSNodeIsMountedBit = 3,
	kFSNodeIsMountedMask = 0x0008,
	kFSNodeIsSharePointBit = 5,
	kFSNodeIsSharePointMask = 0x0020
}

enum
{
	kFSIterateFlat = 0,
	kFSIterateSubtree = 1,
	kFSIterateDelete = 2,
	kFSIterateReserved = cast(c_long)0xFFFFFFFC
}

enum
{
	kFSAllocDefaultFlags = 0x0000,
	kFSAllocAllOrNothingMask = 0x0001,
	kFSAllocContiguousMask = 0x0002,
	kFSAllocNoRoundUpMask = 0x0004,
	kFSAllocReservedMask = 0xFFF8
}

enum
{
	kFSVolInfoNone = 0x0000,
	kFSVolInfoCreateDate = 0x0001,
	kFSVolInfoModDate = 0x0002,
	kFSVolInfoBackupDate = 0x0004,
	kFSVolInfoCheckedDate = 0x0008,
	kFSVolInfoFileCount = 0x0010,
	kFSVolInfoDirCount = 0x0020,
	kFSVolInfoSizes = 0x0040,
	kFSVolInfoBlocks = 0x0080,
	kFSVolInfoNextAlloc = 0x0100,
	kFSVolInfoRsrcClump = 0x0200,
	kFSVolInfoDataClump = 0x0400,
	kFSVolInfoNextID = 0x0800,
	kFSVolInfoFinderInfo = 0x1000,
	kFSVolInfoFlags = 0x2000,
	kFSVolInfoFSInfo = 0x4000,
	kFSVolInfoDriveInfo = 0x8000,
	kFSVolInfoGettableInfo = 0xFFFF,
	kFSVolInfoSettableInfo = 0x3004
}

enum
{
	kFSVolFlagDefaultVolumeBit = 5,
	kFSVolFlagDefaultVolumeMask = 0x0020,
	kFSVolFlagFilesOpenBit = 6,
	kFSVolFlagFilesOpenMask = 0x0040,
	kFSVolFlagHardwareLockedBit = 7,
	kFSVolFlagHardwareLockedMask = 0x0080,
	kFSVolFlagJournalingActiveBit = 14,
	kFSVolFlagJournalingActiveMask = 0x4000,
	kFSVolFlagSoftwareLockedBit = 15,
	kFSVolFlagSoftwareLockedMask = 0x8000
}

enum
{
	AppleShareMediaType = getOSType!("afpm")
}

enum
{
	volMountNoLoginMsgFlagBit = 0,
	volMountNoLoginMsgFlagMask = 0x0001,
	volMountExtendedFlagsBit = 7,
	volMountExtendedFlagsMask = 0x0080,
	volMountInteractBit = 15,
	volMountInteractMask = 0x8000,
	volMountChangedBit = 14,
	volMountChangedMask = 0x4000,
	volMountFSReservedMask = 0x00FF,
	volMountSysReservedMask = 0xFF00
}

enum
{
	kAFPExtendedFlagsAlternateAddressMask = 1
}

enum
{
	kAFPTagTypeIP = 0x01,
	kAFPTagTypeIPPort = 0x02,
	kAFPTagTypeDDP = 0x03,
	kAFPTagTypeDNS = 0x04
}

enum
{
	kAFPTagLengthIP = 0x06,
	kAFPTagLengthIPPort = 0x08,
	kAFPTagLengthDDP = 0x06
}

enum
{
	kLargeIconSize = 256,
	kLarge4BitIconSize = 512,
	kLarge8BitIconSize = 1024,
	kSmallIconSize = 64,
	kSmall4BitIconSize = 128,
	kSmall8BitIconSize = 256
}

enum
{
	kFSReplaceObjectDefaultOptions = 0,
	kFSReplaceObjectReplaceMetadata = 0x01,
	kFSReplaceObjectSaveOriginalAsABackup = 0x02,
	kFSReplaceObjectReplacePermissionInfo = 0x04,
	kFSReplaceObjectPreservePermissionInfo = 0x08,
	kFSReplaceObjectDoNotCheckObjectWriteAccess = 0x10
}

enum
{
	kFSPathMakeRefDefaultOptions = 0,
	kFSPathMakeRefDoNotFollowLeafSymlink = 0x01
}

enum
{
	kFNDirectoryModifiedMessage = 1
}

enum
{
	kFNNoImplicitAllSubscription = (1 << 0),
	kFNNotifyInBackground = (1 << 1)
}

enum
{
	kAsyncMountInProgress = 1,
	kAsyncMountComplete = 2,
	kAsyncUnmountInProgress = 3,
	kAsyncUnmountComplete = 4,
	kAsyncEjectInProgress = 5,
	kAsyncEjectComplete = 6
}

enum
{
	kFSMountServerMarkDoNotDisplay = (1 << 0),
	kFSMountServerMountOnMountDir = (1 << 2)
}

enum
{
	kFSMountServerMountWithoutNotification = (1 << 1)
}

enum
{
	kFSEjectVolumeForceEject = (1 << 0)
}

enum
{
	kFSUnmountVolumeForceUnmount = (1 << 0)
}

enum
{
	kFSFileOperationDefaultOptions = 0,
	kFSFileOperationOverwrite = 0x01,
	kFSFileOperationSkipSourcePermissionErrors = 0x02,
	kFSFileOperationDoNotMoveAcrossVolumes = 0x04,
	kFSFileOperationSkipPreflight = 0x08
}

enum
{
	kFSOperationStageUndefined = 0,
	kFSOperationStagePreflighting = 1,
	kFSOperationStageRunning = 2,
	kFSOperationStageComplete = 3
}

enum
{
	pleaseCacheBit = 4,
	pleaseCacheMask = 0x0010,
	noCacheBit = 5,
	noCacheMask = 0x0020,
	rdVerifyBit = 6,
	rdVerifyMask = 0x0040,
	rdVerify = 64,
	forceReadBit = 6,
	forceReadMask = 0x0040,
	newLineBit = 7,
	newLineMask = 0x0080,
	newLineCharMask = 0xFF00
}

enum
{
	kOwnerID2Name = 1,
	kGroupID2Name = 2,
	kOwnerName2ID = 3,
	kGroupName2ID = 4,
	kReturnNextUser = 1,
	kReturnNextGroup = 2,
	kReturnNextUG = 3
}

enum
{
	kVCBFlagsIdleFlushBit = 3,
	kVCBFlagsIdleFlushMask = 0x0008,
	kVCBFlagsHFSPlusAPIsBit = 4,
	kVCBFlagsHFSPlusAPIsMask = 0x0010,
	kVCBFlagsHardwareGoneBit = 5,
	kVCBFlagsHardwareGoneMask = 0x0020,
	kVCBFlagsVolumeDirtyBit = 15,
	kVCBFlagsVolumeDirtyMask = 0x8000
}

enum
{
	kioVAtrbDefaultVolumeBit = 5,
	kioVAtrbDefaultVolumeMask = 0x0020,
	kioVAtrbFilesOpenBit = 6,
	kioVAtrbFilesOpenMask = 0x0040,
	kioVAtrbHardwareLockedBit = 7,
	kioVAtrbHardwareLockedMask = 0x0080,
	kioVAtrbSoftwareLockedBit = 15,
	kioVAtrbSoftwareLockedMask = 0x8000
}

enum
{
	kioFlAttribLockedBit = 0,
	kioFlAttribLockedMask = 0x01,
	kioFlAttribResOpenBit = 2,
	kioFlAttribResOpenMask = 0x04,
	kioFlAttribDataOpenBit = 3,
	kioFlAttribDataOpenMask = 0x08,
	kioFlAttribDirBit = 4,
	kioFlAttribDirMask = 0x10,
	ioDirFlg = 4,
	ioDirMask = 0x10,
	kioFlAttribCopyProtBit = 6,
	kioFlAttribCopyProtMask = 0x40,
	kioFlAttribFileOpenBit = 7,
	kioFlAttribFileOpenMask = 0x80,
	kioFlAttribInSharedBit = 2,
	kioFlAttribInSharedMask = 0x04,
	kioFlAttribMountedBit = 3,
	kioFlAttribMountedMask = 0x08,
	kioFlAttribSharePointBit = 5,
	kioFlAttribSharePointMask = 0x20
}

enum
{
	kioFCBWriteBit = 8,
	kioFCBWriteMask = 0x0100,
	kioFCBResourceBit = 9,
	kioFCBResourceMask = 0x0200,
	kioFCBWriteLockedBit = 10,
	kioFCBWriteLockedMask = 0x0400,
	kioFCBLargeFileBit = 11,
	kioFCBLargeFileMask = 0x0800,
	kioFCBSharedWriteBit = 12,
	kioFCBSharedWriteMask = 0x1000,
	kioFCBFileLockedBit = 13,
	kioFCBFileLockedMask = 0x2000,
	kioFCBOwnClumpBit = 14,
	kioFCBOwnClumpMask = 0x4000,
	kioFCBModifiedBit = 15,
	kioFCBModifiedMask = 0x8000
}

enum
{
	kioACUserNoSeeFolderBit = 0,
	kioACUserNoSeeFolderMask = 0x01,
	kioACUserNoSeeFilesBit = 1,
	kioACUserNoSeeFilesMask = 0x02,
	kioACUserNoMakeChangesBit = 2,
	kioACUserNoMakeChangesMask = 0x04,
	kioACUserNotOwnerBit = 7,
	kioACUserNotOwnerMask = 0x80
}

enum
{
	kioACAccessOwnerBit = 31,
	kioACAccessOwnerMask = cast(c_long)0x80000000,
	kioACAccessBlankAccessBit = 28,
	kioACAccessBlankAccessMask = 0x10000000,
	kioACAccessUserWriteBit = 26,
	kioACAccessUserWriteMask = 0x04000000,
	kioACAccessUserReadBit = 25,
	kioACAccessUserReadMask = 0x02000000,
	kioACAccessUserSearchBit = 24,
	kioACAccessUserSearchMask = 0x01000000,
	kioACAccessEveryoneWriteBit = 18,
	kioACAccessEveryoneWriteMask = 0x00040000,
	kioACAccessEveryoneReadBit = 17,
	kioACAccessEveryoneReadMask = 0x00020000,
	kioACAccessEveryoneSearchBit = 16,
	kioACAccessEveryoneSearchMask = 0x00010000,
	kioACAccessGroupWriteBit = 10,
	kioACAccessGroupWriteMask = 0x00000400,
	kioACAccessGroupReadBit = 9,
	kioACAccessGroupReadMask = 0x00000200,
	kioACAccessGroupSearchBit = 8,
	kioACAccessGroupSearchMask = 0x00000100,
	kioACAccessOwnerWriteBit = 2,
	kioACAccessOwnerWriteMask = 0x00000004,
	kioACAccessOwnerReadBit = 1,
	kioACAccessOwnerReadMask = 0x00000002,
	kioACAccessOwnerSearchBit = 0,
	kioACAccessOwnerSearchMask = 0x00000001,
	kfullPrivileges = 0x00070007,
	kownerPrivileges = 0x00000007
}

struct HFSUniStr255
{
	ushort length;
	wchar* unicode;
}


struct FSRef
{
	ubyte[80] hidden;
}


struct CatPositionRec
{
	int initialize;
	short[6] priv;
}


struct FSSpec
{
	ubyte[70] hidden;
}


struct FSPermissionInfo
{
	uint userID;
	uint groupID;
	ubyte reserved1;
	ubyte userAccess;
	ushort mode;
	FSFileSecurityRef fileSec;
}


struct FSCatalogInfo
{
	ushort nodeFlags;
	short volume;
	uint parentDirID;
	uint nodeID;
	ubyte sharingFlags;
	ubyte userPrivileges;
	ubyte reserved1;
	ubyte reserved2;
	UTCDateTime createDate;
	UTCDateTime contentModDate;
	UTCDateTime attributeModDate;
	UTCDateTime accessDate;
	UTCDateTime backupDate;
	FSPermissionInfo permissions;
	char* finderInfo;
	char* extFinderInfo;
	ulong dataLogicalSize;
	ulong dataPhysicalSize;
	ulong rsrcLogicalSize;
	ulong rsrcPhysicalSize;
	uint valence;
	uint textEncodingHint;
}


struct FSRefParam
{
	QElemPtr qLink;
	short qType;
	short ioTrap;
	char* ioCmdAddr;
	IOCompletionUPP ioCompletion;
	short ioResult;
	char* ioNamePtr;
	short ioVRefNum;
	short reserved1;
	ubyte reserved2;
	ubyte reserved3;
	FSRef* ref_;
	uint whichInfo;
	FSCatalogInfo* catInfo;
	uint nameLength;
	wchar* name;
	uint ioDirID;
	FSSpecPtr spec;
	FSRef* parentRef;
	FSRef* newRef;
	uint textEncodingHint;
	HFSUniStr255* outName;
}


struct FSRefForkIOParam
{
	QElemPtr qLink;
	short qType;
	short ioTrap;
	char* ioCmdAddr;
	IOCompletionUPP ioCompletion;
	short ioResult;
	FSRef* parentRef;
	uint nameLength;
	wchar* name;
	uint whichInfo;
	FSCatalogInfo* catInfo;
	uint forkNameLength;
	wchar* forkName;
	byte permissions;
	ubyte reserved1;
	short forkRefNum;
	FSRef* newRef;
}


struct FSSearchParams
{
	int searchTime;
	uint searchBits;
	uint searchNameLength;
	wchar* searchName;
	FSCatalogInfo* searchInfo1;
	FSCatalogInfo* searchInfo2;
}


struct FSCatalogBulkParam
{
	QElemPtr qLink;
	short qType;
	short ioTrap;
	char* ioCmdAddr;
	IOCompletionUPP ioCompletion;
	short ioResult;
	ubyte containerChanged;
	ubyte reserved;
	uint iteratorFlags;
	FSIterator iterator;
	FSRef* container;
	uint maximumItems;
	uint actualItems;
	uint whichInfo;
	FSCatalogInfo* catalogInfo;
	FSRef* refs;
	FSSpecPtr specs;
	HFSUniStr255* names;
	FSSearchParams* searchParams;
}


struct FSForkIOParam
{
	QElemPtr qLink;
	short qType;
	short ioTrap;
	char* ioCmdAddr;
	IOCompletionUPP ioCompletion;
	short ioResult;
	void* reserved1;
	short reserved2;
	short forkRefNum;
	ubyte reserved3;
	byte permissions;
	FSRef* ref_;
	char* buffer;
	uint requestCount;
	uint actualCount;
	ushort positionMode;
	long positionOffset;
	ushort allocationFlags;
	ulong allocationAmount;
	uint forkNameLength;
	wchar* forkName;
	CatPositionRec forkIterator;
	HFSUniStr255* outForkName;
}


struct FSForkInfo
{
	byte flags;
	byte permissions;
	short volume;
	uint reserved2;
	uint nodeID;
	uint forkID;
	ulong currentPosition;
	ulong logicalEOF;
	ulong physicalEOF;
	ulong process;
}


struct FSForkCBInfoParam
{
	QElemPtr qLink;
	short qType;
	short ioTrap;
	char* ioCmdAddr;
	IOCompletionUPP ioCompletion;
	short ioResult;
	short desiredRefNum;
	short volumeRefNum;
	short iterator;
	short actualRefNum;
	FSRef* ref_;
	FSForkInfo* forkInfo;
	HFSUniStr255* forkName;
}


struct FSRangeLockParam
{
	QElemPtr qLink;
	short qType;
	short ioTrap;
	char* ioCmdAddr;
	IOCompletionUPP ioCompletion;
	short ioResult;
	short forkRefNum;
	ulong requestCount;
	ushort positionMode;
	long positionOffset;
	ulong rangeStart;
}


struct FSVolumeInfo
{
	UTCDateTime createDate;
	UTCDateTime modifyDate;
	UTCDateTime backupDate;
	UTCDateTime checkedDate;
	uint fileCount;
	uint folderCount;
	ulong totalBytes;
	ulong freeBytes;
	uint blockSize;
	uint totalBlocks;
	uint freeBlocks;
	uint nextAllocation;
	uint rsrcClumpSize;
	uint dataClumpSize;
	uint nextCatalogID;
	char* finderInfo;
	ushort flags;
	ushort filesystemID;
	ushort signature;
	ushort driveNumber;
	short driverRefNum;
}


struct FSVolumeInfoParam
{
	QElemPtr qLink;
	short qType;
	short ioTrap;
	char* ioCmdAddr;
	IOCompletionUPP ioCompletion;
	short ioResult;
	char* ioNamePtr;
	short ioVRefNum;
	uint volumeIndex;
	uint whichInfo;
	FSVolumeInfo* volumeInfo;
	HFSUniStr255* volumeName;
	FSRef* ref_;
}


struct GetVolParmsInfoBuffer
{
	short vMVersion;
	int vMAttrib;
	Handle vMLocalHand;
	int vMServerAdr;
	int vMVolumeGrade;
	short vMForeignPrivID;
	int vMExtendedAttributes;
	void* vMDeviceID;
	uint vMMaxNameLength;
}


struct VolMountInfoHeader
{
	short length;
	uint media;
}


struct VolumeMountInfoHeader
{
	short length;
	uint media;
	short flags;
}


struct AFPVolMountInfo
{
	short length;
	uint media;
	short flags;
	byte nbpInterval;
	byte nbpCount;
	short uamType;
	short zoneNameOffset;
	short serverNameOffset;
	short volNameOffset;
	short userNameOffset;
	short userPasswordOffset;
	short volPasswordOffset;
	char* AFPData;
}


struct AFPXVolMountInfo
{
	short length;
	uint media;
	short flags;
	byte nbpInterval;
	byte nbpCount;
	short uamType;
	short zoneNameOffset;
	short serverNameOffset;
	short volNameOffset;
	short userNameOffset;
	short userPasswordOffset;
	short volPasswordOffset;
	short extendedFlags;
	short uamNameOffset;
	short alternateAddressOffset;
	char* AFPData;
}


struct AFPTagData
{
	ubyte fLength;
	ubyte fType;
	char* fData;
}


struct AFPAlternateAddress
{
	ubyte fVersion;
	ubyte fAddressCount;
	char* fAddressList;
}


struct FSFileOperationClientContext
{
	int version_;
	void* info;
	CFAllocatorRetainCallBack retain;
	CFAllocatorReleaseCallBack release;
	CFAllocatorCopyDescriptionCallBack copyDescription;
}

extern (C)
{
	IOCompletionUPP NewIOCompletionUPP (IOCompletionProcPtr userRoutine);
	void DisposeIOCompletionUPP (IOCompletionUPP userUPP);
	void InvokeIOCompletionUPP (ParmBlkPtr paramBlock, IOCompletionUPP userUPP);
	short FSMakeFSRefUnicode (FSRef* parentRef, uint nameLength, wchar* name, uint textEncodingHint, FSRef* newRef);
	short PBMakeFSRefUnicodeSync (FSRefParam* paramBlock);
	void PBMakeFSRefUnicodeAsync (FSRefParam* paramBlock);
	short FSCompareFSRefs (FSRef* ref1, FSRef* ref2);
	short PBCompareFSRefsSync (FSRefParam* paramBlock);
	void PBCompareFSRefsAsync (FSRefParam* paramBlock);
	short FSCreateFileUnicode (FSRef* parentRef, uint nameLength, wchar* name, uint whichInfo, FSCatalogInfo* catalogInfo, FSRef* newRef, FSSpecPtr newSpec);
	short PBCreateFileUnicodeSync (FSRefParam* paramBlock);
	void PBCreateFileUnicodeAsync (FSRefParam* paramBlock);
	short FSCreateDirectoryUnicode (FSRef* parentRef, uint nameLength, wchar* name, uint whichInfo, FSCatalogInfo* catalogInfo, FSRef* newRef, FSSpecPtr newSpec, UInt32* newDirID);
	short PBCreateDirectoryUnicodeSync (FSRefParam* paramBlock);
	void PBCreateDirectoryUnicodeAsync (FSRefParam* paramBlock);
	short FSDeleteObject (FSRef* ref_);
	short PBDeleteObjectSync (FSRefParam* paramBlock);
	void PBDeleteObjectAsync (FSRefParam* paramBlock);
	short FSUnlinkObject (FSRef* ref_);
	short PBUnlinkObjectSync (FSRefParam* paramBlock);
	void PBUnlinkObjectAsync (FSRefParam* paramBlock);
	short FSMoveObject (FSRef* ref_, FSRef* destDirectory, FSRef* newRef);
	short PBMoveObjectSync (FSRefParam* paramBlock);
	void PBMoveObjectAsync (FSRefParam* paramBlock);
	short FSExchangeObjects (FSRef* ref_, FSRef* destRef);
	short PBExchangeObjectsSync (FSRefParam* paramBlock);
	void PBExchangeObjectsAsync (FSRefParam* paramBlock);
	int FSReplaceObject (FSRef* originalObject, FSRef* replacementObject, CFStringRef newName, CFStringRef temporaryName, FSRef* temporaryDirectory, uint flags, FSRef* resultObject);
	int FSPathReplaceObject (char* originalObjectPath, char* replacementObjectPath, CFStringRef newName, CFStringRef temporaryName, char* temporaryDirectoryPath, uint flags);
	int FSGetTemporaryDirectoryForReplaceObject (FSRef* originalObject, FSRef* temporaryDirectory, uint flags);
	int FSPathGetTemporaryDirectoryForReplaceObject (char* originalObjectPath, char* temporaryDirectoryPath, uint maxPathSize, uint flags);
	short FSRenameUnicode (FSRef* ref_, uint nameLength, wchar* name, uint textEncodingHint, FSRef* newRef);
	short PBRenameUnicodeSync (FSRefParam* paramBlock);
	void PBRenameUnicodeAsync (FSRefParam* paramBlock);
	short FSGetCatalogInfo (FSRef* ref_, uint whichInfo, FSCatalogInfo* catalogInfo, HFSUniStr255* outName, FSSpecPtr fsSpec, FSRef* parentRef);
	short PBGetCatalogInfoSync (FSRefParam* paramBlock);
	void PBGetCatalogInfoAsync (FSRefParam* paramBlock);
	short FSSetCatalogInfo (FSRef* ref_, uint whichInfo, FSCatalogInfo* catalogInfo);
	short PBSetCatalogInfoSync (FSRefParam* paramBlock);
	void PBSetCatalogInfoAsync (FSRefParam* paramBlock);
	short FSOpenIterator (FSRef* container, uint iteratorFlags, FSIterator* iterator);
	short PBOpenIteratorSync (FSCatalogBulkParam* paramBlock);
	void PBOpenIteratorAsync (FSCatalogBulkParam* paramBlock);
	short FSCloseIterator (FSIterator iterator);
	short PBCloseIteratorSync (FSCatalogBulkParam* paramBlock);
	void PBCloseIteratorAsync (FSCatalogBulkParam* paramBlock);
	short FSGetCatalogInfoBulk (FSIterator iterator, uint maximumObjects, ItemCount* actualObjects, char* containerChanged, uint whichInfo, FSCatalogInfo* catalogInfos, FSRef* refs, FSSpecPtr specs, HFSUniStr255* names);
	short PBGetCatalogInfoBulkSync (FSCatalogBulkParam* paramBlock);
	void PBGetCatalogInfoBulkAsync (FSCatalogBulkParam* paramBlock);
	short FSCatalogSearch (FSIterator iterator, FSSearchParams* searchCriteria, uint maximumObjects, ItemCount* actualObjects, char* containerChanged, uint whichInfo, FSCatalogInfo* catalogInfos, FSRef* refs, FSSpecPtr specs, HFSUniStr255* names);
	short PBCatalogSearchSync (FSCatalogBulkParam* paramBlock);
	void PBCatalogSearchAsync (FSCatalogBulkParam* paramBlock);
	int FSCreateFileAndOpenForkUnicode (FSRef* parentRef, uint nameLength, wchar* name, uint whichInfo, FSCatalogInfo* catalogInfo, uint forkNameLength, wchar* forkName, byte permissions, FSIORefNum* forkRefNum, FSRef* newRef);
	int PBCreateFileAndOpenForkUnicodeSync (FSRefForkIOParamPtr paramBlock);
	void PBCreateFileAndOpenForkUnicodeAsync (FSRefForkIOParamPtr paramBlock);
	short FSCreateFork (FSRef* ref_, uint forkNameLength, wchar* forkName);
	short PBCreateForkSync (FSForkIOParam* paramBlock);
	void PBCreateForkAsync (FSForkIOParam* paramBlock);
	short FSDeleteFork (FSRef* ref_, uint forkNameLength, wchar* forkName);
	short PBDeleteForkSync (FSForkIOParam* paramBlock);
	void PBDeleteForkAsync (FSForkIOParam* paramBlock);
	short FSIterateForks (FSRef* ref_, CatPositionRec* forkIterator, HFSUniStr255* forkName, SInt64* forkSize, UInt64* forkPhysicalSize);
	short PBIterateForksSync (FSForkIOParam* paramBlock);
	void PBIterateForksAsync (FSForkIOParam* paramBlock);
	short FSOpenFork (FSRef* ref_, uint forkNameLength, wchar* forkName, byte permissions, FSIORefNum* forkRefNum);
	short PBOpenForkSync (FSForkIOParam* paramBlock);
	void PBOpenForkAsync (FSForkIOParam* paramBlock);
	short FSReadFork (short forkRefNum, ushort positionMode, long positionOffset, uint requestCount, void* buffer, ByteCount* actualCount);
	short PBReadForkSync (FSForkIOParam* paramBlock);
	void PBReadForkAsync (FSForkIOParam* paramBlock);
	short FSWriteFork (short forkRefNum, ushort positionMode, long positionOffset, uint requestCount, void* buffer, ByteCount* actualCount);
	short PBWriteForkSync (FSForkIOParam* paramBlock);
	void PBWriteForkAsync (FSForkIOParam* paramBlock);
	short FSGetForkPosition (short forkRefNum, SInt64* position);
	short PBGetForkPositionSync (FSForkIOParam* paramBlock);
	void PBGetForkPositionAsync (FSForkIOParam* paramBlock);
	short FSSetForkPosition (short forkRefNum, ushort positionMode, long positionOffset);
	short PBSetForkPositionSync (FSForkIOParam* paramBlock);
	void PBSetForkPositionAsync (FSForkIOParam* paramBlock);
	short FSGetForkSize (short forkRefNum, SInt64* forkSize);
	short PBGetForkSizeSync (FSForkIOParam* paramBlock);
	void PBGetForkSizeAsync (FSForkIOParam* paramBlock);
	short FSSetForkSize (short forkRefNum, ushort positionMode, long positionOffset);
	short PBSetForkSizeSync (FSForkIOParam* paramBlock);
	void PBSetForkSizeAsync (FSForkIOParam* paramBlock);
	short FSAllocateFork (short forkRefNum, ushort flags, ushort positionMode, long positionOffset, ulong requestCount, UInt64* actualCount);
	short PBAllocateForkSync (FSForkIOParam* paramBlock);
	void PBAllocateForkAsync (FSForkIOParam* paramBlock);
	short FSFlushFork (short forkRefNum);
	short PBFlushForkSync (FSForkIOParam* paramBlock);
	void PBFlushForkAsync (FSForkIOParam* paramBlock);
	short FSCloseFork (short forkRefNum);
	short PBCloseForkSync (FSForkIOParam* paramBlock);
	void PBCloseForkAsync (FSForkIOParam* paramBlock);
	short FSGetForkCBInfo (short desiredRefNum, short volume, short* iterator, FSIORefNum* actualRefNum, FSForkInfo* forkInfo, FSRef* ref_, HFSUniStr255* outForkName);
	short PBGetForkCBInfoSync (FSForkCBInfoParam* paramBlock);
	void PBGetForkCBInfoAsync (FSForkCBInfoParam* paramBlock);
	int FSLockRange (short forkRefNum, ushort positionMode, long positionOffset, ulong requestCount, UInt64* rangeStart);
	int PBXLockRangeSync (FSRangeLockParamPtr paramBlock);
	int PBXLockRangeAsync (FSRangeLockParamPtr paramBlock);
	int FSUnlockRange (short forkRefNum, ushort positionMode, long positionOffset, ulong requestCount, UInt64* rangeStart);
	int PBXUnlockRangeSync (FSRangeLockParamPtr paramBlock);
	int PBXUnlockRangeAsync (FSRangeLockParamPtr paramBlock);
	short FSGetVolumeInfo (short volume, uint volumeIndex, FSVolumeRefNum* actualVolume, uint whichInfo, FSVolumeInfo* info, HFSUniStr255* volumeName, FSRef* rootDirectory);
	short PBGetVolumeInfoSync (FSVolumeInfoParam* paramBlock);
	void PBGetVolumeInfoAsync (FSVolumeInfoParam* paramBlock);
	short FSSetVolumeInfo (short volume, uint whichInfo, FSVolumeInfo* info);
	short PBSetVolumeInfoSync (FSVolumeInfoParam* paramBlock);
	void PBSetVolumeInfoAsync (FSVolumeInfoParam* paramBlock);
	short FSGetDataForkName (HFSUniStr255* dataForkName);
	short FSGetResourceForkName (HFSUniStr255* resourceForkName);
	int FSRefMakePath (FSRef* ref_, char* path, uint pathBufferSize);
	int FSPathMakeRef (char* path, FSRef* ref_, char* isDirectory);
	int FSPathMakeRefWithOptions (char* path, uint options, FSRef* ref_, char* isDirectory);
	ubyte FSIsFSRefValid (FSRef* ref_);
	int FNNotify (FSRef* ref_, uint message, uint flags);
	int FNNotifyByPath (char* path, uint message, uint flags);
	int FNNotifyAll (uint message, uint flags);
	FNSubscriptionUPP NewFNSubscriptionUPP (FNSubscriptionProcPtr userRoutine);
	void DisposeFNSubscriptionUPP (FNSubscriptionUPP userUPP);
	void InvokeFNSubscriptionUPP (uint message, uint flags, void* refcon, FNSubscriptionRef subscription, FNSubscriptionUPP userUPP);
	int FNSubscribe (FSRef* directoryRef, FNSubscriptionUPP callback, void* refcon, uint flags, FNSubscriptionRef* subscription);
	int FNSubscribeByPath (char* directoryPath, FNSubscriptionUPP callback, void* refcon, uint flags, FNSubscriptionRef* subscription);
	int FNUnsubscribe (FNSubscriptionRef subscription);
	int FNGetDirectoryForSubscription (FNSubscriptionRef subscription, FSRef* ref_);
	FSVolumeMountUPP NewFSVolumeMountUPP (FSVolumeMountProcPtr userRoutine);
	FSVolumeUnmountUPP NewFSVolumeUnmountUPP (FSVolumeUnmountProcPtr userRoutine);
	FSVolumeEjectUPP NewFSVolumeEjectUPP (FSVolumeEjectProcPtr userRoutine);
	void DisposeFSVolumeMountUPP (FSVolumeMountUPP userUPP);
	void DisposeFSVolumeUnmountUPP (FSVolumeUnmountUPP userUPP);
	void DisposeFSVolumeEjectUPP (FSVolumeEjectUPP userUPP);
	void InvokeFSVolumeMountUPP (FSVolumeOperation volumeOp, void* clientData, int err, short mountedVolumeRefNum, FSVolumeMountUPP userUPP);
	void InvokeFSVolumeUnmountUPP (FSVolumeOperation volumeOp, void* clientData, int err, short volumeRefNum, int dissenter, FSVolumeUnmountUPP userUPP);
	void InvokeFSVolumeEjectUPP (FSVolumeOperation volumeOp, void* clientData, int err, short volumeRefNum, int dissenter, FSVolumeEjectUPP userUPP);
	int FSCreateVolumeOperation (FSVolumeOperation* volumeOp);
	int FSDisposeVolumeOperation (FSVolumeOperation volumeOp);
	int FSMountLocalVolumeSync (CFStringRef diskID, CFURLRef mountDir, FSVolumeRefNum* mountedVolumeRefNum, uint flags);
	int FSMountLocalVolumeAsync (CFStringRef diskID, CFURLRef mountDir, FSVolumeOperation volumeOp, void* clientData, uint flags, FSVolumeMountUPP callback, CFRunLoopRef runloop, CFStringRef runloopMode);
	int FSMountServerVolumeSync (CFURLRef url, CFURLRef mountDir, CFStringRef user, CFStringRef password, FSVolumeRefNum* mountedVolumeRefNum, uint flags);
	int FSMountServerVolumeAsync (CFURLRef url, CFURLRef mountDir, CFStringRef user, CFStringRef password, FSVolumeOperation volumeOp, void* clientData, uint flags, FSVolumeMountUPP callback, CFRunLoopRef runloop, CFStringRef runloopMode);
	int FSGetAsyncMountStatus (FSVolumeOperation volumeOp, FSMountStatus* status, OSStatus* volumeOpStatus, FSVolumeRefNum* mountedVolumeRefNum, void** clientData);
	int FSUnmountVolumeSync (short vRefNum, uint flags, pid_t* dissenter);
	int FSUnmountVolumeAsync (short vRefNum, uint flags, FSVolumeOperation volumeOp, void* clientData, FSVolumeUnmountUPP callback, CFRunLoopRef runloop, CFStringRef runloopMode);
	int FSGetAsyncUnmountStatus (FSVolumeOperation volumeOp, FSUnmountStatus* status, OSStatus* volumeOpStatus, FSVolumeRefNum* volumeRefNum, pid_t* dissenter, void** clientData);
	int FSCancelVolumeOperation (FSVolumeOperation volumeOp);
	int FSEjectVolumeSync (short vRefNum, uint flags, pid_t* dissenter);
	int FSEjectVolumeAsync (short vRefNum, uint flags, FSVolumeOperation volumeOp, void* clientData, FSVolumeEjectUPP callback, CFRunLoopRef runloop, CFStringRef runloopMode);
	int FSGetAsyncEjectStatus (FSVolumeOperation volumeOp, FSEjectStatus* status, OSStatus* volumeOpStatus, FSVolumeRefNum* volumeRefNum, pid_t* dissenter, void** clientData);
	int FSCopyDiskIDForVolume (short vRefNum, CFStringRef* diskID);
	int FSCopyURLForVolume (short vRefNum, CFURLRef* url);
	int FSGetVolumeForDiskID (CFStringRef diskID, FSVolumeRefNum* vRefNum);
	int FSCopyDADiskForVolume (short vRefNum, DADiskRef* disk);
	int FSGetVolumeForDADisk (DADiskRef disk, FSVolumeRefNum* vRefNum);
	int FSCopyObjectSync (FSRef* source, FSRef* destDir, CFStringRef destName, FSRef* target, uint options);
	int FSMoveObjectSync (FSRef* source, FSRef* destDir, CFStringRef destName, FSRef* target, uint options);
	int FSMoveObjectToTrashSync (FSRef* source, FSRef* target, uint options);
	int FSPathCopyObjectSync (char* sourcePath, char* destDirPath, CFStringRef destName, char** targetPath, uint options);
	int FSPathMoveObjectSync (char* sourcePath, char* destDirPath, CFStringRef destName, char** targetPath, uint options);
	int FSPathMoveObjectToTrashSync (char* sourcePath, char** targetPath, uint options);
	uint FSFileOperationGetTypeID ();
	FSFileOperationRef FSFileOperationCreate (CFAllocatorRef alloc);
	int FSFileOperationScheduleWithRunLoop (FSFileOperationRef fileOp, CFRunLoopRef runLoop, CFStringRef runLoopMode);
	int FSFileOperationUnscheduleFromRunLoop (FSFileOperationRef fileOp, CFRunLoopRef runLoop, CFStringRef runLoopMode);
	int FSCopyObjectAsync (FSFileOperationRef fileOp, FSRef* source, FSRef* destDir, CFStringRef destName, uint flags, FSFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
	int FSMoveObjectAsync (FSFileOperationRef fileOp, FSRef* source, FSRef* destDir, CFStringRef destName, uint flags, FSFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
	int FSMoveObjectToTrashAsync (FSFileOperationRef fileOp, FSRef* source, uint flags, FSFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
	int FSPathCopyObjectAsync (FSFileOperationRef fileOp, char* sourcePath, char* destDirPath, CFStringRef destName, uint flags, FSPathFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
	int FSPathMoveObjectAsync (FSFileOperationRef fileOp, char* sourcePath, char* destDirPath, CFStringRef destName, uint flags, FSPathFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
	int FSPathMoveObjectToTrashAsync (FSFileOperationRef fileOp, char* sourcePath, uint flags, FSPathFileOperationStatusProcPtr callback, double statusChangeInterval, FSFileOperationClientContext* clientContext);
	int FSFileOperationCancel (FSFileOperationRef fileOp);
	int FSFileOperationCopyStatus (FSFileOperationRef fileOp, FSRef* currentItem, FSFileOperationStage* stage, OSStatus* error, CFDictionaryRef* statusDictionary, void** info);
	int FSPathFileOperationCopyStatus (FSFileOperationRef fileOp, char** currentItem, FSFileOperationStage* stage, OSStatus* error, CFDictionaryRef* statusDictionary, void** info);
	CFStringRef FSCreateStringFromHFSUniStr (CFAllocatorRef alloc, HFSUniStr255* uniStr);
	int FSGetHFSUniStrFromString (CFStringRef theString, HFSUniStr255* uniStr);
	uint FSFileSecurityGetTypeID ();
	FSFileSecurityRef FSFileSecurityCreate (CFAllocatorRef alloc);
	FSFileSecurityRef FSFileSecurityCreateWithFSPermissionInfo (CFAllocatorRef alloc, FSPermissionInfo* permissions);
	FSFileSecurityRef FSFileSecurityRefCreateCopy (CFAllocatorRef alloc, FSFileSecurityRef fileSec);
	int FSFileSecurityGetOwnerUUID (FSFileSecurityRef fileSec, CFUUIDBytes* owner);
	int FSFileSecuritySetOwnerUUID (FSFileSecurityRef fileSec, CFUUIDBytes* owner);
	int FSFileSecurityGetGroupUUID (FSFileSecurityRef fileSec, CFUUIDBytes* group);
	int FSFileSecuritySetGroupUUID (FSFileSecurityRef fileSec, CFUUIDBytes* group);
	int FSFileSecurityCopyAccessControlList (FSFileSecurityRef fileSec, acl_t* accessControlList);
	int FSFileSecuritySetAccessControlList (FSFileSecurityRef fileSec, acl_t accessControlList);
	int FSFileSecurityGetOwner (FSFileSecurityRef fileSec, UInt32* owner);
	int FSFileSecuritySetOwner (FSFileSecurityRef fileSec, uint owner);
	int FSFileSecurityGetGroup (FSFileSecurityRef fileSec, UInt32* group);
	int FSFileSecuritySetGroup (FSFileSecurityRef fileSec, uint group);
	int FSFileSecurityGetMode (FSFileSecurityRef fileSec, UInt16* mode);
	int FSFileSecuritySetMode (FSFileSecurityRef fileSec, ushort mode);
	int FSGetVolumeParms (short volume, GetVolParmsInfoBuffer* buffer, uint bufferSize);
	int FSGetVolumeMountInfoSize (short volume, ByteCount* size);
	int FSGetVolumeMountInfo (short volume, char* buffer, uint bufferSize, ByteCount* actualSize);
	int FSVolumeMount (char* buffer, FSVolumeRefNum* mountedVolume);
	int FSFlushVolume (short vRefNum);
	int PBFlushVolumeSync (FSRefParamPtr paramBlock);
	int PBFlushVolumeAsync (FSRefParamPtr paramBlock);
	int PBFSCopyFileSync (FSRefParamPtr paramBlock);
	int PBFSCopyFileAsync (FSRefParamPtr paramBlock);
	int FSResolveNodeID (short volume, uint nodeID, FSRefPtr newRef);
	int PBFSResolveNodeIDSync (FSRefParamPtr paramBlock);
	int PBFSResolveNodeIDAsync (FSRefParamPtr paramBlock);
}