/**
 * Windows API header module
 *
 * Translated from MinGW Windows headers
 *
 * Authors: Stewart Gordon
 * License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
 * Source: $(DRUNTIMESRC core/sys/windows/_winnetwk.d)
 */
module core.sys.windows.winnetwk;
version (Windows):

version (ANSI) {} else version = Unicode;
pragma(lib, "mpr");

import core.sys.windows.winbase, core.sys.windows.winerror, core.sys.windows.winnt;

enum : DWORD {
    WNNC_NET_MSNET       = 0x00010000,
    WNNC_NET_LANMAN      = 0x00020000,
    WNNC_NET_NETWARE     = 0x00030000,
    WNNC_NET_VINES       = 0x00040000,
    WNNC_NET_10NET       = 0x00050000,
    WNNC_NET_LOCUS       = 0x00060000,
    WNNC_NET_SUN_PC_NFS  = 0x00070000,
    WNNC_NET_LANSTEP     = 0x00080000,
    WNNC_NET_9TILES      = 0x00090000,
    WNNC_NET_LANTASTIC   = 0x000A0000,
    WNNC_NET_AS400       = 0x000B0000,
    WNNC_NET_FTP_NFS     = 0x000C0000,
    WNNC_NET_PATHWORKS   = 0x000D0000,
    WNNC_NET_LIFENET     = 0x000E0000,
    WNNC_NET_POWERLAN    = 0x000F0000,
    WNNC_NET_BWNFS       = 0x00100000,
    WNNC_NET_COGENT      = 0x00110000,
    WNNC_NET_FARALLON    = 0x00120000,
    WNNC_NET_APPLETALK   = 0x00130000,
    WNNC_NET_INTERGRAPH  = 0x00140000,
    WNNC_NET_SYMFONET    = 0x00150000,
    WNNC_NET_CLEARCASE   = 0x00160000,
    WNNC_NET_FRONTIER    = 0x00170000,
    WNNC_NET_BMC         = 0x00180000,
    WNNC_NET_DCE         = 0x00190000,
    WNNC_NET_AVID        = 0x001A0000,
    WNNC_NET_DOCUSPACE   = 0x001B0000,
    WNNC_NET_MANGOSOFT   = 0x001C0000,
    WNNC_NET_SERNET      = 0x001D0000,
    WNNC_NET_DECORB      = 0x00200000,
    WNNC_NET_PROTSTOR    = 0x00210000,
    WNNC_NET_FJ_REDIR    = 0x00220000,
    WNNC_NET_DISTINCT    = 0x00230000,
    WNNC_NET_TWINS       = 0x00240000,
    WNNC_NET_RDR2SAMPLE  = 0x00250000,
    WNNC_NET_CSC         = 0x00260000,
    WNNC_NET_3IN1        = 0x00270000,
    WNNC_NET_EXTENDNET   = 0x00290000,
    WNNC_NET_OBJECT_DIRE = 0x00300000,
    WNNC_NET_MASFAX      = 0x00310000,
    WNNC_NET_HOB_NFS     = 0x00320000,
    WNNC_NET_SHIVA       = 0x00330000,
    WNNC_NET_IBMAL       = 0x00340000,
    WNNC_CRED_MANAGER    = 0xFFFF0000
}

enum : DWORD {
    RESOURCE_CONNECTED  = 1,
    RESOURCE_GLOBALNET  = 2,
    RESOURCE_REMEMBERED = 3,
    RESOURCE_RECENT     = 4,
    RESOURCE_CONTEXT    = 5
}

enum DWORD
    RESOURCETYPE_ANY      = 0,
    RESOURCETYPE_DISK     = 1,
    RESOURCETYPE_PRINT    = 2,
    RESOURCETYPE_RESERVED = 8,
    RESOURCETYPE_UNKNOWN  = 0xFFFFFFFF;

enum DWORD
    RESOURCEUSAGE_CONNECTABLE   = 0x00000001,
    RESOURCEUSAGE_CONTAINER     = 0x00000002,
    RESOURCEUSAGE_NOLOCALDEVICE = 0x00000004,
    RESOURCEUSAGE_SIBLING       = 0x00000008,
    RESOURCEUSAGE_ATTACHED      = 0x00000010,
    RESOURCEUSAGE_ALL           = (RESOURCEUSAGE_CONNECTABLE
                                  | RESOURCEUSAGE_CONTAINER
                                  | RESOURCEUSAGE_ATTACHED),
    RESOURCEUSAGE_RESERVED      = 0x80000000;

enum : DWORD {
    RESOURCEDISPLAYTYPE_GENERIC,
    RESOURCEDISPLAYTYPE_DOMAIN,
    RESOURCEDISPLAYTYPE_SERVER,
    RESOURCEDISPLAYTYPE_SHARE,
    RESOURCEDISPLAYTYPE_FILE,
    RESOURCEDISPLAYTYPE_GROUP,
    RESOURCEDISPLAYTYPE_NETWORK,
    RESOURCEDISPLAYTYPE_ROOT,
    RESOURCEDISPLAYTYPE_SHAREADMIN,
    RESOURCEDISPLAYTYPE_DIRECTORY,
    RESOURCEDISPLAYTYPE_TREE // = 10
}

enum NETPROPERTY_PERSISTENT = 1;

enum DWORD
    CONNECT_UPDATE_PROFILE =   1,
    CONNECT_UPDATE_RECENT  =   2,
    CONNECT_TEMPORARY      =   4,
    CONNECT_INTERACTIVE    =   8,
    CONNECT_PROMPT         =  16,
    CONNECT_NEED_DRIVE     =  32,
    CONNECT_REFCOUNT       =  64,
    CONNECT_REDIRECT       = 128,
    CONNECT_LOCALDRIVE     = 256,
    CONNECT_CURRENT_MEDIA  = 512;

enum DWORD
    CONNDLG_RO_PATH     =  1,
    CONNDLG_CONN_POINT  =  2,
    CONNDLG_USE_MRU     =  4,
    CONNDLG_HIDE_BOX    =  8,
    CONNDLG_PERSIST     = 16,
    CONNDLG_NOT_PERSIST = 32;

enum DWORD
    DISC_UPDATE_PROFILE =  1,
    DISC_NO_FORCE       = 64;

enum DWORD
    WNFMT_MULTILINE   =  1,
    WNFMT_ABBREVIATED =  2,
    WNFMT_INENUM      = 16,
    WNFMT_CONNECTION  = 32;

enum : DWORD {
    WN_SUCCESS                   = NO_ERROR,
    WN_NO_ERROR                  = NO_ERROR,
    WN_NOT_SUPPORTED             = ERROR_NOT_SUPPORTED,
    WN_CANCEL                    = ERROR_CANCELLED,
    WN_RETRY                     = ERROR_RETRY,
    WN_NET_ERROR                 = ERROR_UNEXP_NET_ERR,
    WN_MORE_DATA                 = ERROR_MORE_DATA,
    WN_BAD_POINTER               = ERROR_INVALID_ADDRESS,
    WN_BAD_VALUE                 = ERROR_INVALID_PARAMETER,
    WN_BAD_USER                  = ERROR_BAD_USERNAME,
    WN_BAD_PASSWORD              = ERROR_INVALID_PASSWORD,
    WN_ACCESS_DENIED             = ERROR_ACCESS_DENIED,
    WN_FUNCTION_BUSY             = ERROR_BUSY,
    WN_WINDOWS_ERROR             = ERROR_UNEXP_NET_ERR,
    WN_OUT_OF_MEMORY             = ERROR_NOT_ENOUGH_MEMORY,
    WN_NO_NETWORK                = ERROR_NO_NETWORK,
    WN_EXTENDED_ERROR            = ERROR_EXTENDED_ERROR,
    WN_BAD_LEVEL                 = ERROR_INVALID_LEVEL,
    WN_BAD_HANDLE                = ERROR_INVALID_HANDLE,
    WN_NOT_INITIALIZING          = ERROR_ALREADY_INITIALIZED,
    WN_NO_MORE_DEVICES           = ERROR_NO_MORE_DEVICES,
    WN_NOT_CONNECTED             = ERROR_NOT_CONNECTED,
    WN_OPEN_FILES                = ERROR_OPEN_FILES,
    WN_DEVICE_IN_USE             = ERROR_DEVICE_IN_USE,
    WN_BAD_NETNAME               = ERROR_BAD_NET_NAME,
    WN_BAD_LOCALNAME             = ERROR_BAD_DEVICE,
    WN_ALREADY_CONNECTED         = ERROR_ALREADY_ASSIGNED,
    WN_DEVICE_ERROR              = ERROR_GEN_FAILURE,
    WN_CONNECTION_CLOSED         = ERROR_CONNECTION_UNAVAIL,
    WN_NO_NET_OR_BAD_PATH        = ERROR_NO_NET_OR_BAD_PATH,
    WN_BAD_PROVIDER              = ERROR_BAD_PROVIDER,
    WN_CANNOT_OPEN_PROFILE       = ERROR_CANNOT_OPEN_PROFILE,
    WN_BAD_PROFILE               = ERROR_BAD_PROFILE,
    WN_BAD_DEV_TYPE              = ERROR_BAD_DEV_TYPE,
    WN_DEVICE_ALREADY_REMEMBERED = ERROR_DEVICE_ALREADY_REMEMBERED,
    WN_NO_MORE_ENTRIES           = ERROR_NO_MORE_ITEMS,
    WN_NOT_CONTAINER             = ERROR_NOT_CONTAINER,
    WN_NOT_AUTHENTICATED         = ERROR_NOT_AUTHENTICATED,
    WN_NOT_LOGGED_ON             = ERROR_NOT_LOGGED_ON,
    WN_NOT_VALIDATED             = ERROR_NO_LOGON_SERVERS
}

enum : DWORD {
    UNIVERSAL_NAME_INFO_LEVEL = 1,
    REMOTE_NAME_INFO_LEVEL
}

enum DWORD
    NETINFO_DLL16      = 1,
    NETINFO_DISKRED    = 4,
    NETINFO_PRINTERRED = 8;

enum DWORD
    RP_LOGON   = 1,
    RP_INIFILE = 2;

enum DWORD PP_DISPLAYERRORS = 1;

enum DWORD
    WNCON_FORNETCARD = 1,
    WNCON_NOTROUTED  = 2,
    WNCON_SLOWLINK   = 4,
    WNCON_DYNAMIC    = 8;

struct NETRESOURCEA {
    DWORD dwScope;
    DWORD dwType;
    DWORD dwDisplayType;
    DWORD dwUsage;
    LPSTR lpLocalName;
    LPSTR lpRemoteName;
    LPSTR lpComment;
    LPSTR lpProvider;
}
alias LPNETRESOURCEA = NETRESOURCEA*;

struct NETRESOURCEW {
    DWORD  dwScope;
    DWORD  dwType;
    DWORD  dwDisplayType;
    DWORD  dwUsage;
    LPWSTR lpLocalName;
    LPWSTR lpRemoteName;
    LPWSTR lpComment ;
    LPWSTR lpProvider;
}
alias LPNETRESOURCEW = NETRESOURCEW*;

struct CONNECTDLGSTRUCTA {
    DWORD          cbStructure;
    HWND           hwndOwner;
    LPNETRESOURCEA lpConnRes;
    DWORD          dwFlags;
    DWORD          dwDevNum;
}
alias LPCONNECTDLGSTRUCTA = CONNECTDLGSTRUCTA*;

struct CONNECTDLGSTRUCTW {
    DWORD          cbStructure;
    HWND           hwndOwner;
    LPNETRESOURCEW lpConnRes;
    DWORD          dwFlags;
    DWORD          dwDevNum;
}
alias LPCONNECTDLGSTRUCTW = CONNECTDLGSTRUCTW*;

struct DISCDLGSTRUCTA {
    DWORD cbStructure;
    HWND  hwndOwner;
    LPSTR lpLocalName;
    LPSTR lpRemoteName;
    DWORD dwFlags;
}
alias LPDISCDLGSTRUCTA = DISCDLGSTRUCTA*;

struct DISCDLGSTRUCTW {
    DWORD  cbStructure;
    HWND   hwndOwner;
    LPWSTR lpLocalName;
    LPWSTR lpRemoteName;
    DWORD  dwFlags;
}
alias LPDISCDLGSTRUCTW = DISCDLGSTRUCTW*;

struct UNIVERSAL_NAME_INFOA {
    LPSTR lpUniversalName;
}
alias LPUNIVERSAL_NAME_INFOA = UNIVERSAL_NAME_INFOA*;

struct UNIVERSAL_NAME_INFOW {
    LPWSTR lpUniversalName;
}
alias LPUNIVERSAL_NAME_INFOW = UNIVERSAL_NAME_INFOW*;

struct REMOTE_NAME_INFOA {
    LPSTR lpUniversalName;
    LPSTR lpConnectionName;
    LPSTR lpRemainingPath;
}
alias LPREMOTE_NAME_INFOA = REMOTE_NAME_INFOA*;

struct REMOTE_NAME_INFOW {
    LPWSTR lpUniversalName;
    LPWSTR lpConnectionName;
    LPWSTR lpRemainingPath;
}
alias LPREMOTE_NAME_INFOW = REMOTE_NAME_INFOW*;

struct NETINFOSTRUCT {
    DWORD cbStructure;
    DWORD dwProviderVersion;
    DWORD dwStatus;
    DWORD dwCharacteristics;
    ULONG_PTR dwHandle;
    WORD  wNetType;
    DWORD dwPrinters;
    DWORD dwDrives;
}
alias LPNETINFOSTRUCT = NETINFOSTRUCT*;

extern (Windows) {
    alias PFNGETPROFILEPATHA = UINT function(LPCSTR, LPSTR, UINT);
    alias PFNGETPROFILEPATHW = UINT function(LPCWSTR, LPWSTR, UINT);
    alias PFNRECONCILEPROFILEA = UINT function(LPCSTR, LPCSTR, DWORD);
    alias PFNRECONCILEPROFILEW = UINT function(LPCWSTR, LPCWSTR, DWORD);
    alias PFNPROCESSPOLICIESA = BOOL function(HWND, LPCSTR, LPCSTR, LPCSTR, DWORD);
    alias PFNPROCESSPOLICIESW = BOOL function(HWND, LPCWSTR, LPCWSTR, LPCWSTR, DWORD);
}

struct NETCONNECTINFOSTRUCT {
    DWORD cbStructure;
    DWORD dwFlags;
    DWORD dwSpeed;
    DWORD dwDelay;
    DWORD dwOptDataSize;
}
alias LPNETCONNECTINFOSTRUCT = NETCONNECTINFOSTRUCT*;

extern (Windows) nothrow @nogc {
    DWORD WNetAddConnection2A(LPNETRESOURCEA, LPCSTR, LPCSTR, DWORD);
    DWORD WNetAddConnection2W(LPNETRESOURCEW, LPCWSTR, LPCWSTR, DWORD);
    DWORD WNetAddConnection3A(HWND, LPNETRESOURCEA, LPCSTR, LPCSTR, DWORD);
    DWORD WNetAddConnection3W(HWND, LPNETRESOURCEW, LPCWSTR, LPCWSTR, DWORD);
    DWORD WNetCancelConnection2A(LPCSTR, DWORD, BOOL);
    DWORD WNetCancelConnection2W(LPCWSTR, DWORD, BOOL);
    DWORD WNetGetConnectionA(LPCSTR, LPSTR, PDWORD);
    DWORD WNetGetConnectionW(LPCWSTR, LPWSTR, PDWORD);
    DWORD WNetUseConnectionA(HWND, LPNETRESOURCEA, LPCSTR, LPCSTR, DWORD,
      LPSTR, PDWORD, PDWORD);
    DWORD WNetUseConnectionW(HWND, LPNETRESOURCEW, LPCWSTR, LPCWSTR, DWORD,
      LPWSTR, PDWORD, PDWORD);
    DWORD WNetSetConnectionA(LPCSTR, DWORD, PVOID);
    DWORD WNetSetConnectionW(LPCWSTR, DWORD, PVOID);
    DWORD WNetConnectionDialog(HWND, DWORD);
    DWORD WNetDisconnectDialog(HWND, DWORD);
    DWORD WNetConnectionDialog1A(LPCONNECTDLGSTRUCTA);
    DWORD WNetConnectionDialog1W(LPCONNECTDLGSTRUCTW);
    DWORD WNetDisconnectDialog1A(LPDISCDLGSTRUCTA);
    DWORD WNetDisconnectDialog1W(LPDISCDLGSTRUCTW);
    DWORD WNetOpenEnumA(DWORD, DWORD, DWORD, LPNETRESOURCEA, LPHANDLE);
    DWORD WNetOpenEnumW(DWORD, DWORD, DWORD, LPNETRESOURCEW, LPHANDLE);
    DWORD WNetEnumResourceA(HANDLE, PDWORD, PVOID, PDWORD);
    DWORD WNetEnumResourceW(HANDLE, PDWORD, PVOID, PDWORD);
    DWORD WNetCloseEnum(HANDLE);
    DWORD WNetGetUniversalNameA(LPCSTR, DWORD, PVOID, PDWORD);
    DWORD WNetGetUniversalNameW(LPCWSTR, DWORD, PVOID, PDWORD);
    DWORD WNetGetUserA(LPCSTR, LPSTR, PDWORD);
    DWORD WNetGetUserW(LPCWSTR, LPWSTR, PDWORD);
    DWORD WNetGetProviderNameA(DWORD, LPSTR, PDWORD);
    DWORD WNetGetProviderNameW(DWORD, LPWSTR, PDWORD);
    DWORD WNetGetNetworkInformationA(LPCSTR, LPNETINFOSTRUCT);
    DWORD WNetGetNetworkInformationW(LPCWSTR, LPNETINFOSTRUCT);
    DWORD WNetGetResourceInformationA(LPNETRESOURCEA, LPVOID, LPDWORD,
      LPSTR*);
    DWORD WNetGetResourceInformationW(LPNETRESOURCEA, LPVOID, LPDWORD,
      LPWSTR*);
    DWORD WNetGetResourceParentA(LPNETRESOURCEA, LPVOID, LPDWORD);
    DWORD WNetGetResourceParentW(LPNETRESOURCEW, LPVOID, LPDWORD);
    DWORD WNetGetLastErrorA(PDWORD, LPSTR, DWORD, LPSTR, DWORD);
    DWORD WNetGetLastErrorW(PDWORD, LPWSTR, DWORD, LPWSTR, DWORD);
    DWORD MultinetGetConnectionPerformanceA(LPNETRESOURCEA,
      LPNETCONNECTINFOSTRUCT);
    DWORD MultinetGetConnectionPerformanceW(LPNETRESOURCEW,
      LPNETCONNECTINFOSTRUCT);
    deprecated {
        DWORD WNetAddConnectionA(LPCSTR, LPCSTR, LPCSTR);
        DWORD WNetAddConnectionW(LPCWSTR, LPCWSTR, LPCWSTR);
        DWORD WNetCancelConnectionA(LPCSTR, BOOL);
        DWORD WNetCancelConnectionW(LPCWSTR, BOOL);
    }
}

version (Unicode) {
    alias PFNGETPROFILEPATH = PFNGETPROFILEPATHW;
    alias PFNRECONCILEPROFILE = PFNRECONCILEPROFILEW;
    alias PFNPROCESSPOLICIES = PFNPROCESSPOLICIESW;
    alias NETRESOURCE = NETRESOURCEW;
    alias CONNECTDLGSTRUCT = CONNECTDLGSTRUCTW;
    alias DISCDLGSTRUCT = DISCDLGSTRUCTW;
    alias REMOTE_NAME_INFO = REMOTE_NAME_INFOW;
    alias UNIVERSAL_NAME_INFO = UNIVERSAL_NAME_INFOW;
    alias WNetAddConnection2 = WNetAddConnection2W;
    alias WNetAddConnection3 = WNetAddConnection3W;
    alias WNetCancelConnection2 = WNetCancelConnection2W;
    alias WNetGetConnection = WNetGetConnectionW;
    alias WNetUseConnection = WNetUseConnectionW;
    alias WNetSetConnection = WNetSetConnectionW;
    alias WNetConnectionDialog1 = WNetConnectionDialog1W;
    alias WNetDisconnectDialog1 = WNetDisconnectDialog1W;
    alias WNetOpenEnum = WNetOpenEnumW;
    alias WNetEnumResource = WNetEnumResourceW;
    alias WNetGetUniversalName = WNetGetUniversalNameW;
    alias WNetGetUser = WNetGetUserW;
    alias WNetGetProviderName = WNetGetProviderNameW;
    alias WNetGetNetworkInformation = WNetGetNetworkInformationW;
    alias WNetGetResourceInformation = WNetGetResourceInformationW;
    alias WNetGetResourceParent = WNetGetResourceParentW;
    alias WNetGetLastError = WNetGetLastErrorW;
    alias MultinetGetConnectionPerformance = MultinetGetConnectionPerformanceW;
    deprecated {
        alias WNetAddConnection = WNetAddConnectionW;
        alias WNetCancelConnection = WNetCancelConnectionW;
    }
} else {
    alias PFNGETPROFILEPATH = PFNGETPROFILEPATHA;
    alias PFNRECONCILEPROFILE = PFNRECONCILEPROFILEA;
    alias PFNPROCESSPOLICIES = PFNPROCESSPOLICIESA;
    alias NETRESOURCE = NETRESOURCEA;
    alias CONNECTDLGSTRUCT = CONNECTDLGSTRUCTA;
    alias DISCDLGSTRUCT = DISCDLGSTRUCTA;
    alias REMOTE_NAME_INFO = REMOTE_NAME_INFOA;
    alias UNIVERSAL_NAME_INFO = UNIVERSAL_NAME_INFOA;
    alias WNetAddConnection2 = WNetAddConnection2A;
    alias WNetAddConnection3 = WNetAddConnection3A;
    alias WNetCancelConnection2 = WNetCancelConnection2A;
    alias WNetGetConnection = WNetGetConnectionA;
    alias WNetUseConnection = WNetUseConnectionA;
    alias WNetSetConnection = WNetSetConnectionA;
    alias WNetConnectionDialog1 = WNetConnectionDialog1A;
    alias WNetDisconnectDialog1 = WNetDisconnectDialog1A;
    alias WNetOpenEnum = WNetOpenEnumA;
    alias WNetEnumResource = WNetEnumResourceA;
    alias WNetGetUniversalName = WNetGetUniversalNameA;
    alias WNetGetUser = WNetGetUserA;
    alias WNetGetProviderName = WNetGetProviderNameA;
    alias WNetGetNetworkInformation = WNetGetNetworkInformationA;
    alias WNetGetResourceInformation = WNetGetResourceInformationA;
    alias WNetGetResourceParent = WNetGetResourceParentA;
    alias WNetGetLastError = WNetGetLastErrorA;
    alias MultinetGetConnectionPerformance = MultinetGetConnectionPerformanceA;
    deprecated {
        alias WNetAddConnection = WNetAddConnectionA;
        alias WNetCancelConnection = WNetCancelConnectionA;
    }
}

alias LPNETRESOURCE = NETRESOURCE*;
alias LPCONNECTDLGSTRUCT = CONNECTDLGSTRUCT*;
alias LPDISCDLGSTRUCT = DISCDLGSTRUCT*;
alias LPREMOTE_NAME_INFO = REMOTE_NAME_INFO*;
alias LPUNIVERSAL_NAME_INFO = UNIVERSAL_NAME_INFO*;
