public static int DirectoryClose(TypedPtr<AFCCommConnection> conn, IntPtr dir)
			{
				return AFCDirectoryClose((IntPtr)conn, dir);
			}

 /// <summary>
 /// Creates a new iPhone object. If an iPhone is connected to the computer, a connection will automatically be opened.
 /// </summary>
 public MobileDeviceInstance(TypedPtr<AppleMobileDeviceConnection> Connection)
 {
     iPhoneHandle = Connection;
     doConstruction();
 }

        /// <summary>
        /// Converts a CFDictionary into a Dictionary (keys and values are object)
        /// </summary>
        public static Dictionary<object, object> ConvertCFDictionaryToDictionary(TypedPtr<CFDictionary> Dict)
        {
            // Get the raw key-value pairs
            int NumPairs = CFDictionaryGetCount(Dict);

            IntPtr [] Keys = new IntPtr[NumPairs];
            IntPtr [] Values = new IntPtr[NumPairs];

            CFDictionaryGetKeysAndValues((IntPtr)Dict, Keys, Values);

            // Convert each key and value to a managed type
            Dictionary<object, object> Result = new Dictionary<object, object>();
            for (int i = 0; i < NumPairs; ++i)
            {
                try
                {
                    Result.Add(ConvertArbitraryCFType(Keys[i]), ConvertArbitraryCFType(Values[i]));
                }
                catch (Exception)
                {
                    Console.WriteLine("Unable to properly convert dictionary");
                }
            }

            return Result;
        }

        /// <summary>
        /// Converts an arbitrary CFNumber to a double
        /// </summary>
        public static double ConvertCFNumber(TypedPtr<CFNumber> Number)
        {
            CFNumberType TypeID = CFNumberGetType((IntPtr)Number);

            switch (TypeID)
            {
                case CFNumberType.kCFNumberFloat32Type:
                case CFNumberType.kCFNumberFloatType:
                    {
                        float Result;
                        CFNumberGetValue((IntPtr)Number, CFNumberType.kCFNumberFloat32Type, out Result);
                        return Result;
                    }

                case CFNumberType.kCFNumberFloat64Type:
                case CFNumberType.kCFNumberDoubleType:
                case CFNumberType.kCFNumberCGFloatType:
                    {
                        double Result;
                        CFNumberGetValue((IntPtr)Number, CFNumberType.kCFNumberFloat64Type, out Result);
                        return Result;
                    }

                case CFNumberType.kCFNumberSInt8Type:
                case CFNumberType.kCFNumberSInt16Type:
                case CFNumberType.kCFNumberSInt32Type:
                case CFNumberType.kCFNumberCharType:
                case CFNumberType.kCFNumberShortType:
                case CFNumberType.kCFNumberIntType:
                case CFNumberType.kCFNumberLongType:
                case CFNumberType.kCFNumberCFIndexType:
                    {
                        int Result;
                        CFNumberGetValue((IntPtr)Number, CFNumberType.kCFNumberIntType, out Result);
                        return Result;
                    }

                case CFNumberType.kCFNumberSInt64Type:
                case CFNumberType.kCFNumberLongLongType:
                case CFNumberType.kCFNumberNSIntegerType:
                    {
                        Int64 Result;
                        CFNumberGetValue((IntPtr)Number, CFNumberType.kCFNumberSInt64Type, out Result);
                        return Result;
                    }

                default:
                    return 0.0;
            }
        }

 public static void CFDictionaryAddHelper(TypedPtr<CFDictionary> InDict, string Key, string Value)
 {
     CFDictionarySetValue((IntPtr)InDict, (IntPtr)CFStringMakeConstantString(Key), (IntPtr)CFStringMakeConstantString(Value));
 }

        public static string CFStringGetCString(TypedPtr<CFString> InString)
        {
            byte[] bytes = new byte[2048];
            CFStringGetCString(InString.Handle, bytes, 2048, CFStringBuiltInEncodings.kCFStringEncodingUTF8);

            int ValidLength = 0;
            foreach (byte b in bytes)
            {
                if (b == 0)
                {
                    break;
                }
                else
                {
                    ValidLength++;
                }
            }

            return Encoding.UTF8.GetString(bytes, 0, ValidLength);
        }

			public static int FileRefOpen(TypedPtr<AFCCommConnection> conn, string path, Int64 mode, out Int64 handle)
			{
				return AFCFileRefOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), mode, out handle);
			}

			public static int FileRefRead(TypedPtr<AFCCommConnection> conn, Int64 handle, byte[] buffer, ref uint len)
			{
				return AFCFileRefRead((IntPtr)conn, handle, buffer, ref len);
			}

			public static int FileInfoOpen(TypedPtr<AFCCommConnection> conn, string path, out TypedPtr<AFCDictionary> OutDict)
			{
				IntPtr UntypedDict;
				int Result = AFCFileInfoOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), out UntypedDict);
				OutDict = UntypedDict;

				return Result;
			}

			public static int FileRefClose(TypedPtr<AFCCommConnection> conn, Int64 handle)
			{
				return AFCFileRefClose((IntPtr)conn, handle);
			}

			public static int DirectoryRead(TypedPtr<AFCCommConnection> conn, IntPtr dir, ref IntPtr dirent)
			{
				return AFCDirectoryRead((IntPtr)conn, dir, ref dirent);
			}

			public static int DirectoryOpen(TypedPtr<AFCCommConnection> conn, string path, ref IntPtr dir)
			{
				return AFCDirectoryOpen((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path), ref dir);
			}

			public static int DirectoryCreate(TypedPtr<AFCCommConnection> conn, string path)
			{
				return AFCDirectoryCreate((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path));
			}

			public static int RemovePath(TypedPtr<AFCCommConnection> conn, string path)
			{
				return AFCRemovePath((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(path));
			}

			public static int FileRefSetFileSize(TypedPtr<AFCCommConnection> conn, Int64 handle, uint size)
			{
				return AFCFileRefSetFileSize((IntPtr)conn, handle, size);
			}

			public static int RenamePath(TypedPtr<AFCCommConnection> conn, string OldPath, string NewPath)
			{
				return AFCRenamePath((IntPtr)conn, MobileDevice.StringToFileSystemRepresentation(OldPath), MobileDevice.StringToFileSystemRepresentation(NewPath));
			}

			public static int FileRefSeek(TypedPtr<AFCCommConnection> conn, Int64 handle, Int64 pos, Int64 origin)
			{
				return AFCFileRefSeek((IntPtr)conn, handle, pos, origin);
			}

 public static int CFDictionaryGetCount(TypedPtr<CFDictionary> Dict)
 {
     return CFDictionaryGetCount((IntPtr)Dict);
 }

			public static int FileRefTell(TypedPtr<AFCCommConnection> conn, Int64 handle, ref uint position)
			{
				return AFCFileRefTell((IntPtr)conn, handle, ref position);
			}

 public static TypedPtr<CFURL> CFURLCreateWithFileSystemPath(IntPtr Allocator, TypedPtr<CFString> FilePath, CFURLPathStyle PathStyle, int isDirectory)
 {
     return (TypedPtr<CFURL>)(CFURLCreateWithFileSystemPath(Allocator, FilePath.Handle, PathStyle, isDirectory));
 }