--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dstep/coreservices/carboncore/Files.d	Sat Aug 01 15:03:28 2009 +0200
@@ -0,0 +1,1279 @@
+/**
+ * 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);
+}
\ No newline at end of file