module win32.winspool;

// Translated from Microsoft Platform SDK August 2001 Edition
// by Y.Tomino

import win32.windef;
import win32.winbase;
import win32.wingdi;

// #ifndef _WINSPOOL_
// #define _WINSPOOL_

// #ifdef _WINUSER_
// #...
// #endif

// #ifdef __cplusplus
// extern "C" {
// #endif

struct _PRINTER_INFO_1A {
  DWORD Flags;
  LPSTR pDescription;
  LPSTR pName;
  LPSTR pComment;
}
alias _PRINTER_INFO_1A PRINTER_INFO_1A;
alias _PRINTER_INFO_1A* PPRINTER_INFO_1A;
alias _PRINTER_INFO_1A* LPPRINTER_INFO_1A;

struct _PRINTER_INFO_1W {
  DWORD Flags;
  LPWSTR pDescription;
  LPWSTR pName;
  LPWSTR pComment;
}
alias _PRINTER_INFO_1W PRINTER_INFO_1W;
alias _PRINTER_INFO_1W* PPRINTER_INFO_1W;
alias _PRINTER_INFO_1W* LPPRINTER_INFO_1W;

// #ifdef UNICODE
alias PRINTER_INFO_1W PRINTER_INFO_1;
alias PPRINTER_INFO_1W PPRINTER_INFO_1;
alias LPPRINTER_INFO_1W LPPRINTER_INFO_1;
// #else
// ...
// #endif // UNICODE

struct _PRINTER_INFO_2A {
  LPSTR pServerName;
  LPSTR pPrinterName;
  LPSTR pShareName;
  LPSTR pPortName;
  LPSTR pDriverName;
  LPSTR pComment;
  LPSTR pLocation;
  LPDEVMODEA pDevMode;
  LPSTR pSepFile;
  LPSTR pPrintProcessor;
  LPSTR pDatatype;
  LPSTR pParameters;
  PSECURITY_DESCRIPTOR pSecurityDescriptor;
  DWORD Attributes;
  DWORD Priority;
  DWORD DefaultPriority;
  DWORD StartTime;
  DWORD UntilTime;
  DWORD Status;
  DWORD cJobs;
  DWORD AveragePPM;
}
alias _PRINTER_INFO_2A PRINTER_INFO_2A;
alias _PRINTER_INFO_2A* PPRINTER_INFO_2A;
alias _PRINTER_INFO_2A* LPPRINTER_INFO_2A;

struct _PRINTER_INFO_2W {
  LPWSTR pServerName;
  LPWSTR pPrinterName;
  LPWSTR pShareName;
  LPWSTR pPortName;
  LPWSTR pDriverName;
  LPWSTR pComment;
  LPWSTR pLocation;
  LPDEVMODEW pDevMode;
  LPWSTR pSepFile;
  LPWSTR pPrintProcessor;
  LPWSTR pDatatype;
  LPWSTR pParameters;
  PSECURITY_DESCRIPTOR pSecurityDescriptor;
  DWORD Attributes;
  DWORD Priority;
  DWORD DefaultPriority;
  DWORD StartTime;
  DWORD UntilTime;
  DWORD Status;
  DWORD cJobs;
  DWORD AveragePPM;
}
alias _PRINTER_INFO_2W PRINTER_INFO_2W;
alias _PRINTER_INFO_2W* PPRINTER_INFO_2W;
alias _PRINTER_INFO_2W* LPPRINTER_INFO_2W;

// #ifdef UNICODE
alias PRINTER_INFO_2W PRINTER_INFO_2;
alias PPRINTER_INFO_2W PPRINTER_INFO_2;
alias LPPRINTER_INFO_2W LPPRINTER_INFO_2;
// #else
// ...
// #endif // UNICODE

struct _PRINTER_INFO_3 {
  PSECURITY_DESCRIPTOR pSecurityDescriptor;
}
alias _PRINTER_INFO_3 PRINTER_INFO_3;
alias _PRINTER_INFO_3* PPRINTER_INFO_3;
alias _PRINTER_INFO_3* LPPRINTER_INFO_3;

struct _PRINTER_INFO_4A {
  LPSTR pPrinterName;
  LPSTR pServerName;
  DWORD Attributes;
}
alias _PRINTER_INFO_4A PRINTER_INFO_4A;
alias _PRINTER_INFO_4A* PPRINTER_INFO_4A;
alias _PRINTER_INFO_4A* LPPRINTER_INFO_4A;

struct _PRINTER_INFO_4W {
  LPWSTR pPrinterName;
  LPWSTR pServerName;
  DWORD Attributes;
}
alias _PRINTER_INFO_4W PRINTER_INFO_4W;
alias _PRINTER_INFO_4W* PPRINTER_INFO_4W;
alias _PRINTER_INFO_4W* LPPRINTER_INFO_4W;

// #ifdef UNICODE
alias PRINTER_INFO_4W PRINTER_INFO_4;
alias PPRINTER_INFO_4W PPRINTER_INFO_4;
alias LPPRINTER_INFO_4W LPPRINTER_INFO_4;
// #else
// ...
// #endif // UNICODE

struct _PRINTER_INFO_5A {
  LPSTR pPrinterName;
  LPSTR pPortName;
  DWORD Attributes;
  DWORD DeviceNotSelectedTimeout;
  DWORD TransmissionRetryTimeout;
}
alias _PRINTER_INFO_5A PRINTER_INFO_5A;
alias _PRINTER_INFO_5A* PPRINTER_INFO_5A;
alias _PRINTER_INFO_5A* LPPRINTER_INFO_5A;

struct _PRINTER_INFO_5W {
  LPWSTR pPrinterName;
  LPWSTR pPortName;
  DWORD Attributes;
  DWORD DeviceNotSelectedTimeout;
  DWORD TransmissionRetryTimeout;
}
alias _PRINTER_INFO_5W PRINTER_INFO_5W;
alias _PRINTER_INFO_5W* PPRINTER_INFO_5W;
alias _PRINTER_INFO_5W* LPPRINTER_INFO_5W;

// #ifdef UNICODE
alias PRINTER_INFO_5W PRINTER_INFO_5;
alias PPRINTER_INFO_5W PPRINTER_INFO_5;
alias LPPRINTER_INFO_5W LPPRINTER_INFO_5;
// #else
// ...
// #endif // UNICODE

struct _PRINTER_INFO_6 {
  DWORD dwStatus;
}
alias _PRINTER_INFO_6 PRINTER_INFO_6;
alias _PRINTER_INFO_6* PPRINTER_INFO_6;
alias _PRINTER_INFO_6* LPPRINTER_INFO_6;

struct _PRINTER_INFO_7A {
  LPSTR pszObjectGUID;
  DWORD dwAction;
}
alias _PRINTER_INFO_7A PRINTER_INFO_7A;
alias _PRINTER_INFO_7A* PPRINTER_INFO_7A;
alias _PRINTER_INFO_7A* LPPRINTER_INFO_7A;

struct _PRINTER_INFO_7W {
  LPWSTR pszObjectGUID;
  DWORD dwAction;
}
alias _PRINTER_INFO_7W PRINTER_INFO_7W;
alias _PRINTER_INFO_7W* PPRINTER_INFO_7W;
alias _PRINTER_INFO_7W* LPPRINTER_INFO_7W;

// #ifdef UNICODE
alias PRINTER_INFO_7W PRINTER_INFO_7;
alias PPRINTER_INFO_7W PPRINTER_INFO_7;
alias LPPRINTER_INFO_7W LPPRINTER_INFO_7;
// #else
// ...
// #endif // UNICODE

enum : uint { DSPRINT_PUBLISH = 0x00000001 }
enum : uint { DSPRINT_UPDATE = 0x00000002 }
enum : uint { DSPRINT_UNPUBLISH = 0x00000004 }
enum : uint { DSPRINT_REPUBLISH = 0x00000008 }
enum : uint { DSPRINT_PENDING = 0x80000000 }

struct _PRINTER_INFO_8A {
  LPDEVMODEA pDevMode;
}
alias _PRINTER_INFO_8A PRINTER_INFO_8A;
alias _PRINTER_INFO_8A* PPRINTER_INFO_8A;
alias _PRINTER_INFO_8A* LPPRINTER_INFO_8A;

struct _PRINTER_INFO_8W {
  LPDEVMODEW pDevMode;
}
alias _PRINTER_INFO_8W PRINTER_INFO_8W;
alias _PRINTER_INFO_8W* PPRINTER_INFO_8W;
alias _PRINTER_INFO_8W* LPPRINTER_INFO_8W;

// #ifdef UNICODE
alias PRINTER_INFO_8W PRINTER_INFO_8;
alias PPRINTER_INFO_8W PPRINTER_INFO_8;
alias LPPRINTER_INFO_8W LPPRINTER_INFO_8;
// #else
// ...
// #endif // UNICODE

struct _PRINTER_INFO_9A {
  LPDEVMODEA pDevMode;
}
alias _PRINTER_INFO_9A PRINTER_INFO_9A;
alias _PRINTER_INFO_9A* PPRINTER_INFO_9A;
alias _PRINTER_INFO_9A* LPPRINTER_INFO_9A;

struct _PRINTER_INFO_9W {
  LPDEVMODEW pDevMode;
}
alias _PRINTER_INFO_9W PRINTER_INFO_9W;
alias _PRINTER_INFO_9W* PPRINTER_INFO_9W;
alias _PRINTER_INFO_9W* LPPRINTER_INFO_9W;

// #ifdef UNICODE
alias PRINTER_INFO_9W PRINTER_INFO_9;
alias PPRINTER_INFO_9W PPRINTER_INFO_9;
alias LPPRINTER_INFO_9W LPPRINTER_INFO_9;
// #else
// ...
// #endif // UNICODE

enum : uint { PRINTER_CONTROL_PAUSE = 1 }
enum : uint { PRINTER_CONTROL_RESUME = 2 }
enum : uint { PRINTER_CONTROL_PURGE = 3 }
enum : uint { PRINTER_CONTROL_SET_STATUS = 4 }

enum : uint { PRINTER_STATUS_PAUSED = 0x00000001 }
enum : uint { PRINTER_STATUS_ERROR = 0x00000002 }
enum : uint { PRINTER_STATUS_PENDING_DELETION = 0x00000004 }
enum : uint { PRINTER_STATUS_PAPER_JAM = 0x00000008 }
enum : uint { PRINTER_STATUS_PAPER_OUT = 0x00000010 }
enum : uint { PRINTER_STATUS_MANUAL_FEED = 0x00000020 }
enum : uint { PRINTER_STATUS_PAPER_PROBLEM = 0x00000040 }
enum : uint { PRINTER_STATUS_OFFLINE = 0x00000080 }
enum : uint { PRINTER_STATUS_IO_ACTIVE = 0x00000100 }
enum : uint { PRINTER_STATUS_BUSY = 0x00000200 }
enum : uint { PRINTER_STATUS_PRINTING = 0x00000400 }
enum : uint { PRINTER_STATUS_OUTPUT_BIN_FULL = 0x00000800 }
enum : uint { PRINTER_STATUS_NOT_AVAILABLE = 0x00001000 }
enum : uint { PRINTER_STATUS_WAITING = 0x00002000 }
enum : uint { PRINTER_STATUS_PROCESSING = 0x00004000 }
enum : uint { PRINTER_STATUS_INITIALIZING = 0x00008000 }
enum : uint { PRINTER_STATUS_WARMING_UP = 0x00010000 }
enum : uint { PRINTER_STATUS_TONER_LOW = 0x00020000 }
enum : uint { PRINTER_STATUS_NO_TONER = 0x00040000 }
enum : uint { PRINTER_STATUS_PAGE_PUNT = 0x00080000 }
enum : uint { PRINTER_STATUS_USER_INTERVENTION = 0x00100000 }
enum : uint { PRINTER_STATUS_OUT_OF_MEMORY = 0x00200000 }
enum : uint { PRINTER_STATUS_DOOR_OPEN = 0x00400000 }
enum : uint { PRINTER_STATUS_SERVER_UNKNOWN = 0x00800000 }
enum : uint { PRINTER_STATUS_POWER_SAVE = 0x01000000 }

enum : uint { PRINTER_ATTRIBUTE_QUEUED = 0x00000001 }
enum : uint { PRINTER_ATTRIBUTE_DIRECT = 0x00000002 }
enum : uint { PRINTER_ATTRIBUTE_DEFAULT = 0x00000004 }
enum : uint { PRINTER_ATTRIBUTE_SHARED = 0x00000008 }
enum : uint { PRINTER_ATTRIBUTE_NETWORK = 0x00000010 }
enum : uint { PRINTER_ATTRIBUTE_HIDDEN = 0x00000020 }
enum : uint { PRINTER_ATTRIBUTE_LOCAL = 0x00000040 }

enum : uint { PRINTER_ATTRIBUTE_ENABLE_DEVQ = 0x00000080 }
enum : uint { PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS = 0x00000100 }
enum : uint { PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST = 0x00000200 }

enum : uint { PRINTER_ATTRIBUTE_WORK_OFFLINE = 0x00000400 }
enum : uint { PRINTER_ATTRIBUTE_ENABLE_BIDI = 0x00000800 }
enum : uint { PRINTER_ATTRIBUTE_RAW_ONLY = 0x00001000 }
enum : uint { PRINTER_ATTRIBUTE_PUBLISHED = 0x00002000 }
enum : uint { PRINTER_ATTRIBUTE_FAX = 0x00004000 }

enum : uint { NO_PRIORITY = 0 }
enum : uint { MAX_PRIORITY = 99 }
enum : uint { MIN_PRIORITY = 1 }
enum : uint { DEF_PRIORITY = 1 }

struct _JOB_INFO_1A {
  DWORD JobId;
  LPSTR pPrinterName;
  LPSTR pMachineName;
  LPSTR pUserName;
  LPSTR pDocument;
  LPSTR pDatatype;
  LPSTR pStatus;
  DWORD Status;
  DWORD Priority;
  DWORD Position;
  DWORD TotalPages;
  DWORD PagesPrinted;
  SYSTEMTIME Submitted;
}
alias _JOB_INFO_1A JOB_INFO_1A;
alias _JOB_INFO_1A* PJOB_INFO_1A;
alias _JOB_INFO_1A* LPJOB_INFO_1A;

struct _JOB_INFO_1W {
  DWORD JobId;
  LPWSTR pPrinterName;
  LPWSTR pMachineName;
  LPWSTR pUserName;
  LPWSTR pDocument;
  LPWSTR pDatatype;
  LPWSTR pStatus;
  DWORD Status;
  DWORD Priority;
  DWORD Position;
  DWORD TotalPages;
  DWORD PagesPrinted;
  SYSTEMTIME Submitted;
}
alias _JOB_INFO_1W JOB_INFO_1W;
alias _JOB_INFO_1W* PJOB_INFO_1W;
alias _JOB_INFO_1W* LPJOB_INFO_1W;

// #ifdef UNICODE
alias JOB_INFO_1W JOB_INFO_1;
alias PJOB_INFO_1W PJOB_INFO_1;
alias LPJOB_INFO_1W LPJOB_INFO_1;
// #else
// ...
// #endif // UNICODE

struct _JOB_INFO_2A {
  DWORD JobId;
  LPSTR pPrinterName;
  LPSTR pMachineName;
  LPSTR pUserName;
  LPSTR pDocument;
  LPSTR pNotifyName;
  LPSTR pDatatype;
  LPSTR pPrintProcessor;
  LPSTR pParameters;
  LPSTR pDriverName;
  LPDEVMODEA pDevMode;
  LPSTR pStatus;
  PSECURITY_DESCRIPTOR pSecurityDescriptor;
  DWORD Status;
  DWORD Priority;
  DWORD Position;
  DWORD StartTime;
  DWORD UntilTime;
  DWORD TotalPages;
  DWORD Size;
  SYSTEMTIME Submitted;
  DWORD Time;
  DWORD PagesPrinted;
}
alias _JOB_INFO_2A JOB_INFO_2A;
alias _JOB_INFO_2A* PJOB_INFO_2A;
alias _JOB_INFO_2A* LPJOB_INFO_2A;

struct _JOB_INFO_2W {
  DWORD JobId;
  LPWSTR pPrinterName;
  LPWSTR pMachineName;
  LPWSTR pUserName;
  LPWSTR pDocument;
  LPWSTR pNotifyName;
  LPWSTR pDatatype;
  LPWSTR pPrintProcessor;
  LPWSTR pParameters;
  LPWSTR pDriverName;
  LPDEVMODEW pDevMode;
  LPWSTR pStatus;
  PSECURITY_DESCRIPTOR pSecurityDescriptor;
  DWORD Status;
  DWORD Priority;
  DWORD Position;
  DWORD StartTime;
  DWORD UntilTime;
  DWORD TotalPages;
  DWORD Size;
  SYSTEMTIME Submitted;
  DWORD Time;
  DWORD PagesPrinted;
}
alias _JOB_INFO_2W JOB_INFO_2W;
alias _JOB_INFO_2W* PJOB_INFO_2W;
alias _JOB_INFO_2W* LPJOB_INFO_2W;

// #ifdef UNICODE
alias JOB_INFO_2W JOB_INFO_2;
alias PJOB_INFO_2W PJOB_INFO_2;
alias LPJOB_INFO_2W LPJOB_INFO_2;
// #else
// ...
// #endif // UNICODE

struct _JOB_INFO_3 {
  DWORD JobId;
  DWORD NextJobId;
  DWORD Reserved;
}
alias _JOB_INFO_3 JOB_INFO_3;
alias _JOB_INFO_3* PJOB_INFO_3;
alias _JOB_INFO_3* LPJOB_INFO_3;

enum : uint { JOB_CONTROL_PAUSE = 1 }
enum : uint { JOB_CONTROL_RESUME = 2 }
enum : uint { JOB_CONTROL_CANCEL = 3 }
enum : uint { JOB_CONTROL_RESTART = 4 }
enum : uint { JOB_CONTROL_DELETE = 5 }
enum : uint { JOB_CONTROL_SENT_TO_PRINTER = 6 }
enum : uint { JOB_CONTROL_LAST_PAGE_EJECTED = 7 }

enum : uint { JOB_STATUS_PAUSED = 0x00000001 }
enum : uint { JOB_STATUS_ERROR = 0x00000002 }
enum : uint { JOB_STATUS_DELETING = 0x00000004 }
enum : uint { JOB_STATUS_SPOOLING = 0x00000008 }
enum : uint { JOB_STATUS_PRINTING = 0x00000010 }
enum : uint { JOB_STATUS_OFFLINE = 0x00000020 }
enum : uint { JOB_STATUS_PAPEROUT = 0x00000040 }
enum : uint { JOB_STATUS_PRINTED = 0x00000080 }
enum : uint { JOB_STATUS_DELETED = 0x00000100 }
enum : uint { JOB_STATUS_BLOCKED_DEVQ = 0x00000200 }
enum : uint { JOB_STATUS_USER_INTERVENTION = 0x00000400 }
enum : uint { JOB_STATUS_RESTART = 0x00000800 }
enum : uint { JOB_STATUS_COMPLETE = 0x00001000 }

enum : uint { JOB_POSITION_UNSPECIFIED = 0 }

struct _ADDJOB_INFO_1A {
  LPSTR Path;
  DWORD JobId;
}
alias _ADDJOB_INFO_1A ADDJOB_INFO_1A;
alias _ADDJOB_INFO_1A* PADDJOB_INFO_1A;
alias _ADDJOB_INFO_1A* LPADDJOB_INFO_1A;

struct _ADDJOB_INFO_1W {
  LPWSTR Path;
  DWORD JobId;
}
alias _ADDJOB_INFO_1W ADDJOB_INFO_1W;
alias _ADDJOB_INFO_1W* PADDJOB_INFO_1W;
alias _ADDJOB_INFO_1W* LPADDJOB_INFO_1W;

// #ifdef UNICODE
alias ADDJOB_INFO_1W ADDJOB_INFO_1;
alias PADDJOB_INFO_1W PADDJOB_INFO_1;
alias LPADDJOB_INFO_1W LPADDJOB_INFO_1;
// #else
// ...
// #endif // UNICODE

struct _DRIVER_INFO_1A {
  LPSTR pName;
}
alias _DRIVER_INFO_1A DRIVER_INFO_1A;
alias _DRIVER_INFO_1A* PDRIVER_INFO_1A;
alias _DRIVER_INFO_1A* LPDRIVER_INFO_1A;

struct _DRIVER_INFO_1W {
  LPWSTR pName;
}
alias _DRIVER_INFO_1W DRIVER_INFO_1W;
alias _DRIVER_INFO_1W* PDRIVER_INFO_1W;
alias _DRIVER_INFO_1W* LPDRIVER_INFO_1W;

// #ifdef UNICODE
alias DRIVER_INFO_1W DRIVER_INFO_1;
alias PDRIVER_INFO_1W PDRIVER_INFO_1;
alias LPDRIVER_INFO_1W LPDRIVER_INFO_1;
// #else
// ...
// #endif // UNICODE

struct _DRIVER_INFO_2A {
  DWORD cVersion;
  LPSTR pName;
  LPSTR pEnvironment;
  LPSTR pDriverPath;
  LPSTR pDataFile;
  LPSTR pConfigFile;
}
alias _DRIVER_INFO_2A DRIVER_INFO_2A;
alias _DRIVER_INFO_2A* PDRIVER_INFO_2A;
alias _DRIVER_INFO_2A* LPDRIVER_INFO_2A;

struct _DRIVER_INFO_2W {
  DWORD cVersion;
  LPWSTR pName;
  LPWSTR pEnvironment;
  LPWSTR pDriverPath;
  LPWSTR pDataFile;
  LPWSTR pConfigFile;
}
alias _DRIVER_INFO_2W DRIVER_INFO_2W;
alias _DRIVER_INFO_2W* PDRIVER_INFO_2W;
alias _DRIVER_INFO_2W* LPDRIVER_INFO_2W;

// #ifdef UNICODE
alias DRIVER_INFO_2W DRIVER_INFO_2;
alias PDRIVER_INFO_2W PDRIVER_INFO_2;
alias LPDRIVER_INFO_2W LPDRIVER_INFO_2;
// #else
// ...
// #endif // UNICODE

struct _DRIVER_INFO_3A {
  DWORD cVersion;
  LPSTR pName;
  LPSTR pEnvironment;
  LPSTR pDriverPath;
  LPSTR pDataFile;
  LPSTR pConfigFile;
  LPSTR pHelpFile;
  LPSTR pDependentFiles;
  LPSTR pMonitorName;
  LPSTR pDefaultDataType;
}
alias _DRIVER_INFO_3A DRIVER_INFO_3A;
alias _DRIVER_INFO_3A* PDRIVER_INFO_3A;
alias _DRIVER_INFO_3A* LPDRIVER_INFO_3A;

struct _DRIVER_INFO_3W {
  DWORD cVersion;
  LPWSTR pName;
  LPWSTR pEnvironment;
  LPWSTR pDriverPath;
  LPWSTR pDataFile;
  LPWSTR pConfigFile;
  LPWSTR pHelpFile;
  LPWSTR pDependentFiles;
  LPWSTR pMonitorName;
  LPWSTR pDefaultDataType;
}
alias _DRIVER_INFO_3W DRIVER_INFO_3W;
alias _DRIVER_INFO_3W* PDRIVER_INFO_3W;
alias _DRIVER_INFO_3W* LPDRIVER_INFO_3W;

// #ifdef UNICODE
alias DRIVER_INFO_3W DRIVER_INFO_3;
alias PDRIVER_INFO_3W PDRIVER_INFO_3;
alias LPDRIVER_INFO_3W LPDRIVER_INFO_3;
// #else
// ...
// #endif // UNICODE

struct _DRIVER_INFO_4A {
  DWORD cVersion;
  LPSTR pName;
  LPSTR pEnvironment;
  LPSTR pDriverPath;
  LPSTR pDataFile;
  LPSTR pConfigFile;
  LPSTR pHelpFile;
  LPSTR pDependentFiles;
  LPSTR pMonitorName;
  LPSTR pDefaultDataType;
  LPSTR pszzPreviousNames;
}
alias _DRIVER_INFO_4A DRIVER_INFO_4A;
alias _DRIVER_INFO_4A* PDRIVER_INFO_4A;
alias _DRIVER_INFO_4A* LPDRIVER_INFO_4A;

struct _DRIVER_INFO_4W {
  DWORD cVersion;
  LPWSTR pName;
  LPWSTR pEnvironment;
  LPWSTR pDriverPath;
  LPWSTR pDataFile;
  LPWSTR pConfigFile;
  LPWSTR pHelpFile;
  LPWSTR pDependentFiles;
  LPWSTR pMonitorName;
  LPWSTR pDefaultDataType;
  LPWSTR pszzPreviousNames;
}
alias _DRIVER_INFO_4W DRIVER_INFO_4W;
alias _DRIVER_INFO_4W* PDRIVER_INFO_4W;
alias _DRIVER_INFO_4W* LPDRIVER_INFO_4W;

// #ifdef UNICODE
alias DRIVER_INFO_4W DRIVER_INFO_4;
alias PDRIVER_INFO_4W PDRIVER_INFO_4;
alias LPDRIVER_INFO_4W LPDRIVER_INFO_4;
// #else
// ...
// #endif // UNICODE

struct _DRIVER_INFO_5A {
  DWORD cVersion;
  LPSTR pName;
  LPSTR pEnvironment;
  LPSTR pDriverPath;
  LPSTR pDataFile;
  LPSTR pConfigFile;
  DWORD dwDriverAttributes;
  DWORD dwConfigVersion;
  DWORD dwDriverVersion;
}
alias _DRIVER_INFO_5A DRIVER_INFO_5A;
alias _DRIVER_INFO_5A* PDRIVER_INFO_5A;
alias _DRIVER_INFO_5A* LPDRIVER_INFO_5A;

struct _DRIVER_INFO_5W {
  DWORD cVersion;
  LPWSTR pName;
  LPWSTR pEnvironment;
  LPWSTR pDriverPath;
  LPWSTR pDataFile;
  LPWSTR pConfigFile;
  DWORD dwDriverAttributes;
  DWORD dwConfigVersion;
  DWORD dwDriverVersion;
}
alias _DRIVER_INFO_5W DRIVER_INFO_5W;
alias _DRIVER_INFO_5W* PDRIVER_INFO_5W;
alias _DRIVER_INFO_5W* LPDRIVER_INFO_5W;

// #ifdef UNICODE
alias DRIVER_INFO_5W DRIVER_INFO_5;
alias PDRIVER_INFO_5W PDRIVER_INFO_5;
alias LPDRIVER_INFO_5W LPDRIVER_INFO_5;
// #else
// ...
// #endif // UNICODE

struct _DRIVER_INFO_6A {
  DWORD cVersion;
  LPSTR pName;
  LPSTR pEnvironment;
  LPSTR pDriverPath;
  LPSTR pDataFile;
  LPSTR pConfigFile;
  LPSTR pHelpFile;
  LPSTR pDependentFiles;
  LPSTR pMonitorName;
  LPSTR pDefaultDataType;
  LPSTR pszzPreviousNames;
  FILETIME ftDriverDate;
  DWORDLONG dwlDriverVersion;
  LPSTR pszMfgName;
  LPSTR pszOEMUrl;
  LPSTR pszHardwareID;
  LPSTR pszProvider;
}
alias _DRIVER_INFO_6A DRIVER_INFO_6A;
alias _DRIVER_INFO_6A* PDRIVER_INFO_6A;
alias _DRIVER_INFO_6A* LPDRIVER_INFO_6A;

struct _DRIVER_INFO_6W {
  DWORD cVersion;
  LPWSTR pName;
  LPWSTR pEnvironment;
  LPWSTR pDriverPath;
  LPWSTR pDataFile;
  LPWSTR pConfigFile;
  LPWSTR pHelpFile;
  LPWSTR pDependentFiles;
  LPWSTR pMonitorName;
  LPWSTR pDefaultDataType;
  LPWSTR pszzPreviousNames;
  FILETIME ftDriverDate;
  DWORDLONG dwlDriverVersion;
  LPWSTR pszMfgName;
  LPWSTR pszOEMUrl;
  LPWSTR pszHardwareID;
  LPWSTR pszProvider;
}
alias _DRIVER_INFO_6W DRIVER_INFO_6W;
alias _DRIVER_INFO_6W* PDRIVER_INFO_6W;
alias _DRIVER_INFO_6W* LPDRIVER_INFO_6W;

// #ifdef UNICODE
alias DRIVER_INFO_6W DRIVER_INFO_6;
alias PDRIVER_INFO_6W PDRIVER_INFO_6;
alias LPDRIVER_INFO_6W LPDRIVER_INFO_6;
// #else
// ...
// #endif // UNICODE

enum : uint { DRIVER_KERNELMODE = 0x00000001 }
enum : uint { DRIVER_USERMODE = 0x00000002 }

enum : uint { DPD_DELETE_UNUSED_FILES = 0x00000001 }
enum : uint { DPD_DELETE_SPECIFIC_VERSION = 0x00000002 }
enum : uint { DPD_DELETE_ALL_FILES = 0x00000004 }

enum : uint { APD_STRICT_UPGRADE = 0x00000001 }
enum : uint { APD_STRICT_DOWNGRADE = 0x00000002 }
enum : uint { APD_COPY_ALL_FILES = 0x00000004 }
enum : uint { APD_COPY_NEW_FILES = 0x00000008 }
enum : uint { APD_COPY_FROM_DIRECTORY = 0x00000010 }

struct _DOC_INFO_1A {
  LPSTR pDocName;
  LPSTR pOutputFile;
  LPSTR pDatatype;
}
alias _DOC_INFO_1A DOC_INFO_1A;
alias _DOC_INFO_1A* PDOC_INFO_1A;
alias _DOC_INFO_1A* LPDOC_INFO_1A;

struct _DOC_INFO_1W {
  LPWSTR pDocName;
  LPWSTR pOutputFile;
  LPWSTR pDatatype;
}
alias _DOC_INFO_1W DOC_INFO_1W;
alias _DOC_INFO_1W* PDOC_INFO_1W;
alias _DOC_INFO_1W* LPDOC_INFO_1W;

// #ifdef UNICODE
alias DOC_INFO_1W DOC_INFO_1;
alias PDOC_INFO_1W PDOC_INFO_1;
alias LPDOC_INFO_1W LPDOC_INFO_1;
// #else
// ...
// #endif // UNICODE

struct _FORM_INFO_1A {
  DWORD Flags;
  LPSTR pName;
  SIZEL Size;
  RECTL ImageableArea;
}
alias _FORM_INFO_1A FORM_INFO_1A;
alias _FORM_INFO_1A* PFORM_INFO_1A;
alias _FORM_INFO_1A* LPFORM_INFO_1A;

struct _FORM_INFO_1W {
  DWORD Flags;
  LPWSTR pName;
  SIZEL Size;
  RECTL ImageableArea;
}
alias _FORM_INFO_1W FORM_INFO_1W;
alias _FORM_INFO_1W* PFORM_INFO_1W;
alias _FORM_INFO_1W* LPFORM_INFO_1W;

// #ifdef UNICODE
alias FORM_INFO_1W FORM_INFO_1;
alias PFORM_INFO_1W PFORM_INFO_1;
alias LPFORM_INFO_1W LPFORM_INFO_1;
// #else
// ...
// #endif // UNICODE

struct _DOC_INFO_2A {
  LPSTR pDocName;
  LPSTR pOutputFile;
  LPSTR pDatatype;
  DWORD dwMode;
  DWORD JobId;
}
alias _DOC_INFO_2A DOC_INFO_2A;
alias _DOC_INFO_2A* PDOC_INFO_2A;
alias _DOC_INFO_2A* LPDOC_INFO_2A;

struct _DOC_INFO_2W {
  LPWSTR pDocName;
  LPWSTR pOutputFile;
  LPWSTR pDatatype;
  DWORD dwMode;
  DWORD JobId;
}
alias _DOC_INFO_2W DOC_INFO_2W;
alias _DOC_INFO_2W* PDOC_INFO_2W;
alias _DOC_INFO_2W* LPDOC_INFO_2W;

// #ifdef UNICODE
alias DOC_INFO_2W DOC_INFO_2;
alias PDOC_INFO_2W PDOC_INFO_2;
alias LPDOC_INFO_2W LPDOC_INFO_2;
// #else
// ...
// #endif // UNICODE

enum : uint { DI_CHANNEL = 1 }

enum : uint { DI_READ_SPOOL_JOB = 3 }

struct _DOC_INFO_3A {
  LPSTR pDocName;
  LPSTR pOutputFile;
  LPSTR pDatatype;
  DWORD dwFlags;
}
alias _DOC_INFO_3A DOC_INFO_3A;
alias _DOC_INFO_3A* PDOC_INFO_3A;
alias _DOC_INFO_3A* LPDOC_INFO_3A;

struct _DOC_INFO_3W {
  LPWSTR pDocName;
  LPWSTR pOutputFile;
  LPWSTR pDatatype;
  DWORD dwFlags;
}
alias _DOC_INFO_3W DOC_INFO_3W;
alias _DOC_INFO_3W* PDOC_INFO_3W;
alias _DOC_INFO_3W* LPDOC_INFO_3W;

// #ifdef UNICODE
alias DOC_INFO_3W DOC_INFO_3;
alias PDOC_INFO_3W PDOC_INFO_3;
alias LPDOC_INFO_3W LPDOC_INFO_3;
// #else
// ...
// #endif // UNICODE

enum : uint { DI_MEMORYMAP_WRITE = 0x00000001 }

enum : uint { FORM_USER = 0x00000000 }
enum : uint { FORM_BUILTIN = 0x00000001 }
enum : uint { FORM_PRINTER = 0x00000002 }

struct _PRINTPROCESSOR_INFO_1A {
  LPSTR pName;
}
alias _PRINTPROCESSOR_INFO_1A PRINTPROCESSOR_INFO_1A;
alias _PRINTPROCESSOR_INFO_1A* PPRINTPROCESSOR_INFO_1A;
alias _PRINTPROCESSOR_INFO_1A* LPPRINTPROCESSOR_INFO_1A;

struct _PRINTPROCESSOR_INFO_1W {
  LPWSTR pName;
}
alias _PRINTPROCESSOR_INFO_1W PRINTPROCESSOR_INFO_1W;
alias _PRINTPROCESSOR_INFO_1W* PPRINTPROCESSOR_INFO_1W;
alias _PRINTPROCESSOR_INFO_1W* LPPRINTPROCESSOR_INFO_1W;

// #ifdef UNICODE
alias PRINTPROCESSOR_INFO_1W PRINTPROCESSOR_INFO_1;
alias PPRINTPROCESSOR_INFO_1W PPRINTPROCESSOR_INFO_1;
alias LPPRINTPROCESSOR_INFO_1W LPPRINTPROCESSOR_INFO_1;
// #else
// ...
// #endif // UNICODE

struct _PRINTPROCESSOR_CAPS_1 {
  DWORD dwLevel;
  DWORD dwNupOptions;
  DWORD dwPageOrderFlags;
  DWORD dwNumberOfCopies;
}
alias _PRINTPROCESSOR_CAPS_1 PRINTPROCESSOR_CAPS_1;
alias _PRINTPROCESSOR_CAPS_1* PPRINTPROCESSOR_CAPS_1;

enum : uint { NORMAL_PRINT = 0x00000000 }
enum : uint { REVERSE_PRINT = 0x00000001 }

struct _PORT_INFO_1A {
  LPSTR pName;
}
alias _PORT_INFO_1A PORT_INFO_1A;
alias _PORT_INFO_1A* PPORT_INFO_1A;
alias _PORT_INFO_1A* LPPORT_INFO_1A;

struct _PORT_INFO_1W {
  LPWSTR pName;
}
alias _PORT_INFO_1W PORT_INFO_1W;
alias _PORT_INFO_1W* PPORT_INFO_1W;
alias _PORT_INFO_1W* LPPORT_INFO_1W;

// #ifdef UNICODE
alias PORT_INFO_1W PORT_INFO_1;
alias PPORT_INFO_1W PPORT_INFO_1;
alias LPPORT_INFO_1W LPPORT_INFO_1;
// #else
// ...
// #endif // UNICODE

struct _PORT_INFO_2A {
  LPSTR pPortName;
  LPSTR pMonitorName;
  LPSTR pDescription;
  DWORD fPortType;
  DWORD Reserved;
}
alias _PORT_INFO_2A PORT_INFO_2A;
alias _PORT_INFO_2A* PPORT_INFO_2A;
alias _PORT_INFO_2A* LPPORT_INFO_2A;

struct _PORT_INFO_2W {
  LPWSTR pPortName;
  LPWSTR pMonitorName;
  LPWSTR pDescription;
  DWORD fPortType;
  DWORD Reserved;
}
alias _PORT_INFO_2W PORT_INFO_2W;
alias _PORT_INFO_2W* PPORT_INFO_2W;
alias _PORT_INFO_2W* LPPORT_INFO_2W;

// #ifdef UNICODE
alias PORT_INFO_2W PORT_INFO_2;
alias PPORT_INFO_2W PPORT_INFO_2;
alias LPPORT_INFO_2W LPPORT_INFO_2;
// #else
// ...
// #endif // UNICODE

enum : uint { PORT_TYPE_WRITE = 0x0001 }
enum : uint { PORT_TYPE_READ = 0x0002 }
enum : uint { PORT_TYPE_REDIRECTED = 0x0004 }
enum : uint { PORT_TYPE_NET_ATTACHED = 0x0008 }

struct _PORT_INFO_3A {
  DWORD dwStatus;
  LPSTR pszStatus;
  DWORD dwSeverity;
}
alias _PORT_INFO_3A PORT_INFO_3A;
alias _PORT_INFO_3A* PPORT_INFO_3A;
alias _PORT_INFO_3A* LPPORT_INFO_3A;

struct _PORT_INFO_3W {
  DWORD dwStatus;
  LPWSTR pszStatus;
  DWORD dwSeverity;
}
alias _PORT_INFO_3W PORT_INFO_3W;
alias _PORT_INFO_3W* PPORT_INFO_3W;
alias _PORT_INFO_3W* LPPORT_INFO_3W;

// #ifdef UNICODE
alias PORT_INFO_3W PORT_INFO_3;
alias PPORT_INFO_3W PPORT_INFO_3;
alias LPPORT_INFO_3W LPPORT_INFO_3;
// #else
// ...
// #endif // UNICODE

enum : uint { PORT_STATUS_TYPE_ERROR = 1 }
enum : uint { PORT_STATUS_TYPE_WARNING = 2 }
enum : uint { PORT_STATUS_TYPE_INFO = 3 }

enum : uint { PORT_STATUS_OFFLINE = 1 }
enum : uint { PORT_STATUS_PAPER_JAM = 2 }
enum : uint { PORT_STATUS_PAPER_OUT = 3 }
enum : uint { PORT_STATUS_OUTPUT_BIN_FULL = 4 }
enum : uint { PORT_STATUS_PAPER_PROBLEM = 5 }
enum : uint { PORT_STATUS_NO_TONER = 6 }
enum : uint { PORT_STATUS_DOOR_OPEN = 7 }
enum : uint { PORT_STATUS_USER_INTERVENTION = 8 }
enum : uint { PORT_STATUS_OUT_OF_MEMORY = 9 }

enum : uint { PORT_STATUS_TONER_LOW = 10 }

enum : uint { PORT_STATUS_WARMING_UP = 11 }
enum : uint { PORT_STATUS_POWER_SAVE = 12 }

struct _MONITOR_INFO_1A {
  LPSTR pName;
}
alias _MONITOR_INFO_1A MONITOR_INFO_1A;
alias _MONITOR_INFO_1A* PMONITOR_INFO_1A;
alias _MONITOR_INFO_1A* LPMONITOR_INFO_1A;

struct _MONITOR_INFO_1W {
  LPWSTR pName;
}
alias _MONITOR_INFO_1W MONITOR_INFO_1W;
alias _MONITOR_INFO_1W* PMONITOR_INFO_1W;
alias _MONITOR_INFO_1W* LPMONITOR_INFO_1W;

// #ifdef UNICODE
alias MONITOR_INFO_1W MONITOR_INFO_1;
alias PMONITOR_INFO_1W PMONITOR_INFO_1;
alias LPMONITOR_INFO_1W LPMONITOR_INFO_1;
// #else
// ...
// #endif // UNICODE

struct _MONITOR_INFO_2A {
  LPSTR pName;
  LPSTR pEnvironment;
  LPSTR pDLLName;
}
alias _MONITOR_INFO_2A MONITOR_INFO_2A;
alias _MONITOR_INFO_2A* PMONITOR_INFO_2A;
alias _MONITOR_INFO_2A* LPMONITOR_INFO_2A;

struct _MONITOR_INFO_2W {
  LPWSTR pName;
  LPWSTR pEnvironment;
  LPWSTR pDLLName;
}
alias _MONITOR_INFO_2W MONITOR_INFO_2W;
alias _MONITOR_INFO_2W* PMONITOR_INFO_2W;
alias _MONITOR_INFO_2W* LPMONITOR_INFO_2W;

// #ifdef UNICODE
alias MONITOR_INFO_2W MONITOR_INFO_2;
alias PMONITOR_INFO_2W PMONITOR_INFO_2;
alias LPMONITOR_INFO_2W LPMONITOR_INFO_2;
// #else
// ...
// #endif // UNICODE

struct _DATATYPES_INFO_1A {
  LPSTR pName;
}
alias _DATATYPES_INFO_1A DATATYPES_INFO_1A;
alias _DATATYPES_INFO_1A* PDATATYPES_INFO_1A;
alias _DATATYPES_INFO_1A* LPDATATYPES_INFO_1A;

struct _DATATYPES_INFO_1W {
  LPWSTR pName;
}
alias _DATATYPES_INFO_1W DATATYPES_INFO_1W;
alias _DATATYPES_INFO_1W* PDATATYPES_INFO_1W;
alias _DATATYPES_INFO_1W* LPDATATYPES_INFO_1W;

// #ifdef UNICODE
alias DATATYPES_INFO_1W DATATYPES_INFO_1;
alias PDATATYPES_INFO_1W PDATATYPES_INFO_1;
alias LPDATATYPES_INFO_1W LPDATATYPES_INFO_1;
// #else
// ...
// #endif // UNICODE

struct _PRINTER_DEFAULTSA {
  LPSTR pDatatype;
  LPDEVMODEA pDevMode;
  ACCESS_MASK DesiredAccess;
}
alias _PRINTER_DEFAULTSA PRINTER_DEFAULTSA;
alias _PRINTER_DEFAULTSA* PPRINTER_DEFAULTSA;
alias _PRINTER_DEFAULTSA* LPPRINTER_DEFAULTSA;

struct _PRINTER_DEFAULTSW {
  LPWSTR pDatatype;
  LPDEVMODEW pDevMode;
  ACCESS_MASK DesiredAccess;
}
alias _PRINTER_DEFAULTSW PRINTER_DEFAULTSW;
alias _PRINTER_DEFAULTSW* PPRINTER_DEFAULTSW;
alias _PRINTER_DEFAULTSW* LPPRINTER_DEFAULTSW;

// #ifdef UNICODE
alias PRINTER_DEFAULTSW PRINTER_DEFAULTS;
alias PPRINTER_DEFAULTSW PPRINTER_DEFAULTS;
alias LPPRINTER_DEFAULTSW LPPRINTER_DEFAULTS;
// #else
// ...
// #endif // UNICODE

struct _PRINTER_ENUM_VALUESA {
  LPSTR pValueName;
  DWORD cbValueName;
  DWORD dwType;
  LPBYTE pData;
  DWORD cbData;
}
alias _PRINTER_ENUM_VALUESA PRINTER_ENUM_VALUESA;
alias _PRINTER_ENUM_VALUESA* PPRINTER_ENUM_VALUESA;
alias _PRINTER_ENUM_VALUESA* LPPRINTER_ENUM_VALUESA;

struct _PRINTER_ENUM_VALUESW {
  LPWSTR pValueName;
  DWORD cbValueName;
  DWORD dwType;
  LPBYTE pData;
  DWORD cbData;
}
alias _PRINTER_ENUM_VALUESW PRINTER_ENUM_VALUESW;
alias _PRINTER_ENUM_VALUESW* PPRINTER_ENUM_VALUESW;
alias _PRINTER_ENUM_VALUESW* LPPRINTER_ENUM_VALUESW;

// #ifdef UNICODE
alias PRINTER_ENUM_VALUESW PRINTER_ENUM_VALUES;
alias PPRINTER_ENUM_VALUESW PPRINTER_ENUM_VALUES;
alias LPPRINTER_ENUM_VALUESW LPPRINTER_ENUM_VALUES;
// #else
// ...
// #endif // UNICODE

extern(Windows) export BOOL EnumPrintersA(
     DWORD   Flags,
     LPSTR Name,
     DWORD   Level,
     LPBYTE  pPrinterEnum,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
extern(Windows) export BOOL EnumPrintersW(
     DWORD   Flags,
     LPWSTR Name,
     DWORD   Level,
     LPBYTE  pPrinterEnum,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
// #ifdef UNICODE
alias EnumPrintersW EnumPrinters;
// #else
// #...
// #endif // !UNICODE

enum : uint { PRINTER_ENUM_DEFAULT = 0x00000001 }
enum : uint { PRINTER_ENUM_LOCAL = 0x00000002 }
enum : uint { PRINTER_ENUM_CONNECTIONS = 0x00000004 }
enum : uint { PRINTER_ENUM_FAVORITE = 0x00000004 }
enum : uint { PRINTER_ENUM_NAME = 0x00000008 }
enum : uint { PRINTER_ENUM_REMOTE = 0x00000010 }
enum : uint { PRINTER_ENUM_SHARED = 0x00000020 }
enum : uint { PRINTER_ENUM_NETWORK = 0x00000040 }

enum : uint { PRINTER_ENUM_EXPAND = 0x00004000 }
enum : uint { PRINTER_ENUM_CONTAINER = 0x00008000 }

enum : uint { PRINTER_ENUM_ICONMASK = 0x00ff0000 }
enum : uint { PRINTER_ENUM_ICON1 = 0x00010000 }
enum : uint { PRINTER_ENUM_ICON2 = 0x00020000 }
enum : uint { PRINTER_ENUM_ICON3 = 0x00040000 }
enum : uint { PRINTER_ENUM_ICON4 = 0x00080000 }
enum : uint { PRINTER_ENUM_ICON5 = 0x00100000 }
enum : uint { PRINTER_ENUM_ICON6 = 0x00200000 }
enum : uint { PRINTER_ENUM_ICON7 = 0x00400000 }
enum : uint { PRINTER_ENUM_ICON8 = 0x00800000 }
enum : uint { PRINTER_ENUM_HIDE = 0x01000000 }

enum : uint { SPOOL_FILE_PERSISTENT = 0x00000001 }
enum : uint { SPOOL_FILE_TEMPORARY = 0x00000002 }

extern(Windows) export BOOL OpenPrinterA(
    LPSTR    pPrinterName,
    LPHANDLE phPrinter,
    LPPRINTER_DEFAULTSA pDefault
);
extern(Windows) export BOOL OpenPrinterW(
    LPWSTR    pPrinterName,
    LPHANDLE phPrinter,
    LPPRINTER_DEFAULTSW pDefault
);
// #ifdef UNICODE
alias OpenPrinterW OpenPrinter;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL ResetPrinterA(
    HANDLE   hPrinter,
    LPPRINTER_DEFAULTSA pDefault
);
extern(Windows) export BOOL ResetPrinterW(
    HANDLE   hPrinter,
    LPPRINTER_DEFAULTSW pDefault
);
// #ifdef UNICODE
alias ResetPrinterW ResetPrinter;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL SetJobA(
     HANDLE  hPrinter,
     DWORD   JobId,
     DWORD   Level,
     LPBYTE  pJob,
     DWORD   Command
);
extern(Windows) export BOOL SetJobW(
     HANDLE  hPrinter,
     DWORD   JobId,
     DWORD   Level,
     LPBYTE  pJob,
     DWORD   Command
);
// #ifdef UNICODE
alias SetJobW SetJob;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL GetJobA(
    HANDLE   hPrinter,
    DWORD    JobId,
    DWORD    Level,
    LPBYTE   pJob,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded
);
extern(Windows) export BOOL GetJobW(
    HANDLE   hPrinter,
    DWORD    JobId,
    DWORD    Level,
    LPBYTE   pJob,
    DWORD    cbBuf,
    LPDWORD  pcbNeeded
);
// #ifdef UNICODE
alias GetJobW GetJob;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL EnumJobsA(
     HANDLE  hPrinter,
     DWORD   FirstJob,
     DWORD   NoJobs,
     DWORD   Level,
     LPBYTE  pJob,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
extern(Windows) export BOOL EnumJobsW(
     HANDLE  hPrinter,
     DWORD   FirstJob,
     DWORD   NoJobs,
     DWORD   Level,
     LPBYTE  pJob,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
// #ifdef UNICODE
alias EnumJobsW EnumJobs;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export HANDLE AddPrinterA(
     LPSTR   pName,
     DWORD   Level,
     LPBYTE  pPrinter
);
extern(Windows) export HANDLE AddPrinterW(
     LPWSTR   pName,
     DWORD   Level,
     LPBYTE  pPrinter
);
// #ifdef UNICODE
alias AddPrinterW AddPrinter;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL DeletePrinter(
     HANDLE   hPrinter
);

extern(Windows) export BOOL SetPrinterA(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pPrinter,
     DWORD   Command
);
extern(Windows) export BOOL SetPrinterW(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pPrinter,
     DWORD   Command
);
// #ifdef UNICODE
alias SetPrinterW SetPrinter;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL GetPrinterA(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pPrinter,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
extern(Windows) export BOOL GetPrinterW(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pPrinter,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
// #ifdef UNICODE
alias GetPrinterW GetPrinter;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL AddPrinterDriverA(
     LPSTR   pName,
      DWORD   Level,
     LPBYTE  pDriverInfo
);
extern(Windows) export BOOL AddPrinterDriverW(
     LPWSTR   pName,
      DWORD   Level,
     LPBYTE  pDriverInfo
);
// #ifdef UNICODE
alias AddPrinterDriverW AddPrinterDriver;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL AddPrinterDriverExA(
     LPSTR   pName,
     DWORD     Level,
      LPBYTE pDriverInfo,
     DWORD     dwFileCopyFlags
);
extern(Windows) export BOOL AddPrinterDriverExW(
     LPWSTR   pName,
     DWORD     Level,
      LPBYTE pDriverInfo,
     DWORD     dwFileCopyFlags
);
// #ifdef UNICODE
alias AddPrinterDriverExW AddPrinterDriverEx;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL EnumPrinterDriversA(
     LPSTR   pName,
     LPSTR   pEnvironment,
     DWORD   Level,
     LPBYTE  pDriverInfo,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
extern(Windows) export BOOL EnumPrinterDriversW(
     LPWSTR   pName,
     LPWSTR   pEnvironment,
     DWORD   Level,
     LPBYTE  pDriverInfo,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
// #ifdef UNICODE
alias EnumPrinterDriversW EnumPrinterDrivers;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL GetPrinterDriverA(
     HANDLE  hPrinter,
     LPSTR   pEnvironment,
     DWORD   Level,
     LPBYTE  pDriverInfo,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
extern(Windows) export BOOL GetPrinterDriverW(
     HANDLE  hPrinter,
     LPWSTR   pEnvironment,
     DWORD   Level,
     LPBYTE  pDriverInfo,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
// #ifdef UNICODE
alias GetPrinterDriverW GetPrinterDriver;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL GetPrinterDriverDirectoryA(
     LPSTR   pName,
     LPSTR   pEnvironment,
     DWORD   Level,
     LPBYTE  pDriverDirectory,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
extern(Windows) export BOOL GetPrinterDriverDirectoryW(
     LPWSTR   pName,
     LPWSTR   pEnvironment,
     DWORD   Level,
     LPBYTE  pDriverDirectory,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
// #ifdef UNICODE
alias GetPrinterDriverDirectoryW GetPrinterDriverDirectory;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL DeletePrinterDriverA(
    LPSTR    pName,
    LPSTR    pEnvironment,
    LPSTR    pDriverName
);
extern(Windows) export BOOL DeletePrinterDriverW(
    LPWSTR    pName,
    LPWSTR    pEnvironment,
    LPWSTR    pDriverName
);
// #ifdef UNICODE
alias DeletePrinterDriverW DeletePrinterDriver;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL DeletePrinterDriverExA(
    LPSTR    pName,
    LPSTR    pEnvironment,
    LPSTR    pDriverName,
    DWORD      dwDeleteFlag,
    DWORD      dwVersionFlag
);
extern(Windows) export BOOL DeletePrinterDriverExW(
    LPWSTR    pName,
    LPWSTR    pEnvironment,
    LPWSTR    pDriverName,
    DWORD      dwDeleteFlag,
    DWORD      dwVersionFlag
);
// #ifdef UNICODE
alias DeletePrinterDriverExW DeletePrinterDriverEx;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL AddPrintProcessorA(
     LPSTR   pName,
     LPSTR   pEnvironment,
     LPSTR   pPathName,
     LPSTR   pPrintProcessorName
);
extern(Windows) export BOOL AddPrintProcessorW(
     LPWSTR   pName,
     LPWSTR   pEnvironment,
     LPWSTR   pPathName,
     LPWSTR   pPrintProcessorName
);
// #ifdef UNICODE
alias AddPrintProcessorW AddPrintProcessor;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL EnumPrintProcessorsA(
     LPSTR   pName,
     LPSTR   pEnvironment,
     DWORD   Level,
     LPBYTE  pPrintProcessorInfo,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
extern(Windows) export BOOL EnumPrintProcessorsW(
     LPWSTR   pName,
     LPWSTR   pEnvironment,
     DWORD   Level,
     LPBYTE  pPrintProcessorInfo,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
// #ifdef UNICODE
alias EnumPrintProcessorsW EnumPrintProcessors;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL GetPrintProcessorDirectoryA(
     LPSTR   pName,
     LPSTR   pEnvironment,
     DWORD   Level,
     LPBYTE  pPrintProcessorInfo,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
extern(Windows) export BOOL GetPrintProcessorDirectoryW(
     LPWSTR   pName,
     LPWSTR   pEnvironment,
     DWORD   Level,
     LPBYTE  pPrintProcessorInfo,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
// #ifdef UNICODE
alias GetPrintProcessorDirectoryW GetPrintProcessorDirectory;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL EnumPrintProcessorDatatypesA(
     LPSTR   pName,
     LPSTR   pPrintProcessorName,
     DWORD   Level,
     LPBYTE  pDatatypes,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
extern(Windows) export BOOL EnumPrintProcessorDatatypesW(
     LPWSTR   pName,
     LPWSTR   pPrintProcessorName,
     DWORD   Level,
     LPBYTE  pDatatypes,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
// #ifdef UNICODE
alias EnumPrintProcessorDatatypesW EnumPrintProcessorDatatypes;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL DeletePrintProcessorA(
     LPSTR   pName,
     LPSTR   pEnvironment,
     LPSTR   pPrintProcessorName
);
extern(Windows) export BOOL DeletePrintProcessorW(
     LPWSTR   pName,
     LPWSTR   pEnvironment,
     LPWSTR   pPrintProcessorName
);
// #ifdef UNICODE
alias DeletePrintProcessorW DeletePrintProcessor;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export DWORD StartDocPrinterA(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pDocInfo
);
extern(Windows) export DWORD StartDocPrinterW(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pDocInfo
);
// #ifdef UNICODE
alias StartDocPrinterW StartDocPrinter;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL StartPagePrinter(
     HANDLE  hPrinter
);

extern(Windows) export BOOL WritePrinter(
     HANDLE  hPrinter,
     LPVOID  pBuf,
     DWORD   cbBuf,
     LPDWORD pcWritten
);

extern(Windows) export BOOL FlushPrinter(
     HANDLE   hPrinter,
     LPVOID   pBuf,
     DWORD    cbBuf,
     LPDWORD pcWritten,
     DWORD    cSleep
);

extern(Windows) export BOOL EndPagePrinter(
    HANDLE   hPrinter
);

extern(Windows) export BOOL AbortPrinter(
    HANDLE   hPrinter
);

extern(Windows) export BOOL ReadPrinter(
     HANDLE  hPrinter,
     LPVOID  pBuf,
     DWORD   cbBuf,
     LPDWORD pNoBytesRead
);

extern(Windows) export BOOL EndDocPrinter(
    HANDLE   hPrinter
);

extern(Windows) export BOOL AddJobA(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pData,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
extern(Windows) export BOOL AddJobW(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pData,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
// #ifdef UNICODE
alias AddJobW AddJob;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL ScheduleJob(
     HANDLE  hPrinter,
     DWORD   JobId
);

extern(Windows) export BOOL PrinterProperties(
     HWND    hWnd,
     HANDLE  hPrinter
);

extern(Windows) export LONG DocumentPropertiesA(
     HWND      hWnd,
     HANDLE    hPrinter,
     LPSTR   pDeviceName,
     PDEVMODEA pDevModeOutput,
     PDEVMODEA pDevModeInput,
     DWORD     fMode
);
extern(Windows) export LONG DocumentPropertiesW(
     HWND      hWnd,
     HANDLE    hPrinter,
     LPWSTR   pDeviceName,
     PDEVMODEW pDevModeOutput,
     PDEVMODEW pDevModeInput,
     DWORD     fMode
);
// #ifdef UNICODE
alias DocumentPropertiesW DocumentProperties;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export LONG AdvancedDocumentPropertiesA(
     HWND    hWnd,
     HANDLE  hPrinter,
     LPSTR   pDeviceName,
     PDEVMODEA pDevModeOutput,
     PDEVMODEA pDevModeInput
);
extern(Windows) export LONG AdvancedDocumentPropertiesW(
     HWND    hWnd,
     HANDLE  hPrinter,
     LPWSTR   pDeviceName,
     PDEVMODEW pDevModeOutput,
     PDEVMODEW pDevModeInput
);
// #ifdef UNICODE
alias AdvancedDocumentPropertiesW AdvancedDocumentProperties;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export DWORD GetPrinterDataA(
     HANDLE   hPrinter,
     LPSTR  pValueName,
     LPDWORD  pType,
     LPBYTE   pData,
     DWORD    nSize,
     LPDWORD  pcbNeeded
);
extern(Windows) export DWORD GetPrinterDataW(
     HANDLE   hPrinter,
     LPWSTR  pValueName,
     LPDWORD  pType,
     LPBYTE   pData,
     DWORD    nSize,
     LPDWORD  pcbNeeded
);
// #ifdef UNICODE
alias GetPrinterDataW GetPrinterData;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export DWORD GetPrinterDataExA(
     HANDLE   hPrinter,
     LPCSTR pKeyName,
     LPCSTR pValueName,
     LPDWORD  pType,
     LPBYTE   pData,
     DWORD    nSize,
     LPDWORD  pcbNeeded
);
extern(Windows) export DWORD GetPrinterDataExW(
     HANDLE   hPrinter,
     LPCWSTR pKeyName,
     LPCWSTR pValueName,
     LPDWORD  pType,
     LPBYTE   pData,
     DWORD    nSize,
     LPDWORD  pcbNeeded
);
// #ifdef UNICODE
alias GetPrinterDataExW GetPrinterDataEx;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export DWORD EnumPrinterDataA(
     HANDLE   hPrinter,
     DWORD    dwIndex,
     LPSTR  pValueName,
     DWORD    cbValueName,
     LPDWORD  pcbValueName,
     LPDWORD  pType,
     LPBYTE   pData,
     DWORD    cbData,
     LPDWORD  pcbData
);
extern(Windows) export DWORD EnumPrinterDataW(
     HANDLE   hPrinter,
     DWORD    dwIndex,
     LPWSTR  pValueName,
     DWORD    cbValueName,
     LPDWORD  pcbValueName,
     LPDWORD  pType,
     LPBYTE   pData,
     DWORD    cbData,
     LPDWORD  pcbData
);
// #ifdef UNICODE
alias EnumPrinterDataW EnumPrinterData;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export DWORD EnumPrinterDataExA(
     HANDLE   hPrinter,
     LPCSTR pKeyName,
     LPBYTE   pEnumValues,
     DWORD    cbEnumValues,
     LPDWORD  pcbEnumValues,
     LPDWORD  pnEnumValues
);
extern(Windows) export DWORD EnumPrinterDataExW(
     HANDLE   hPrinter,
     LPCWSTR pKeyName,
     LPBYTE   pEnumValues,
     DWORD    cbEnumValues,
     LPDWORD  pcbEnumValues,
     LPDWORD  pnEnumValues
);
// #ifdef UNICODE
alias EnumPrinterDataExW EnumPrinterDataEx;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export DWORD EnumPrinterKeyA(
     HANDLE   hPrinter,
     LPCSTR pKeyName,
     LPSTR  pSubkey,
     DWORD    cbSubkey,
     LPDWORD  pcbSubkey
);
extern(Windows) export DWORD EnumPrinterKeyW(
     HANDLE   hPrinter,
     LPCWSTR pKeyName,
     LPWSTR  pSubkey,
     DWORD    cbSubkey,
     LPDWORD  pcbSubkey
);
// #ifdef UNICODE
alias EnumPrinterKeyW EnumPrinterKey;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export DWORD SetPrinterDataA(
     HANDLE  hPrinter,
     LPSTR pValueName,
     DWORD   Type,
     LPBYTE  pData,
     DWORD   cbData
);
extern(Windows) export DWORD SetPrinterDataW(
     HANDLE  hPrinter,
     LPWSTR pValueName,
     DWORD   Type,
     LPBYTE  pData,
     DWORD   cbData
);
// #ifdef UNICODE
alias SetPrinterDataW SetPrinterData;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export DWORD SetPrinterDataExA(
     HANDLE   hPrinter,
     LPCSTR pKeyName,
     LPCSTR pValueName,
     DWORD    Type,
     LPBYTE   pData,
     DWORD    cbData
);
extern(Windows) export DWORD SetPrinterDataExW(
     HANDLE   hPrinter,
     LPCWSTR pKeyName,
     LPCWSTR pValueName,
     DWORD    Type,
     LPBYTE   pData,
     DWORD    cbData
);
// #ifdef UNICODE
alias SetPrinterDataExW SetPrinterDataEx;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export DWORD DeletePrinterDataA(
     HANDLE  hPrinter,
     LPSTR pValueName
);
extern(Windows) export DWORD DeletePrinterDataW(
     HANDLE  hPrinter,
     LPWSTR pValueName
);
// #ifdef UNICODE
alias DeletePrinterDataW DeletePrinterData;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export DWORD DeletePrinterDataExA(
     HANDLE   hPrinter,
     LPCSTR pKeyName,
     LPCSTR pValueName
);
extern(Windows) export DWORD DeletePrinterDataExW(
     HANDLE   hPrinter,
     LPCWSTR pKeyName,
     LPCWSTR pValueName
);
// #ifdef UNICODE
alias DeletePrinterDataExW DeletePrinterDataEx;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export DWORD DeletePrinterKeyA(
     HANDLE   hPrinter,
     LPCSTR pKeyName
);
extern(Windows) export DWORD DeletePrinterKeyW(
     HANDLE   hPrinter,
     LPCWSTR pKeyName
);
// #ifdef UNICODE
alias DeletePrinterKeyW DeletePrinterKey;
// #else
// #...
// #endif // !UNICODE

enum : uint { PRINTER_NOTIFY_TYPE = 0x00 }
enum : uint { JOB_NOTIFY_TYPE = 0x01 }

enum : uint { PRINTER_NOTIFY_FIELD_SERVER_NAME = 0x00 }
enum : uint { PRINTER_NOTIFY_FIELD_PRINTER_NAME = 0x01 }
enum : uint { PRINTER_NOTIFY_FIELD_SHARE_NAME = 0x02 }
enum : uint { PRINTER_NOTIFY_FIELD_PORT_NAME = 0x03 }
enum : uint { PRINTER_NOTIFY_FIELD_DRIVER_NAME = 0x04 }
enum : uint { PRINTER_NOTIFY_FIELD_COMMENT = 0x05 }
enum : uint { PRINTER_NOTIFY_FIELD_LOCATION = 0x06 }
enum : uint { PRINTER_NOTIFY_FIELD_DEVMODE = 0x07 }
enum : uint { PRINTER_NOTIFY_FIELD_SEPFILE = 0x08 }
enum : uint { PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR = 0x09 }
enum : uint { PRINTER_NOTIFY_FIELD_PARAMETERS = 0x0A }
enum : uint { PRINTER_NOTIFY_FIELD_DATATYPE = 0x0B }
enum : uint { PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR = 0x0C }
enum : uint { PRINTER_NOTIFY_FIELD_ATTRIBUTES = 0x0D }
enum : uint { PRINTER_NOTIFY_FIELD_PRIORITY = 0x0E }
enum : uint { PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY = 0x0F }
enum : uint { PRINTER_NOTIFY_FIELD_START_TIME = 0x10 }
enum : uint { PRINTER_NOTIFY_FIELD_UNTIL_TIME = 0x11 }
enum : uint { PRINTER_NOTIFY_FIELD_STATUS = 0x12 }
enum : uint { PRINTER_NOTIFY_FIELD_STATUS_STRING = 0x13 }
enum : uint { PRINTER_NOTIFY_FIELD_CJOBS = 0x14 }
enum : uint { PRINTER_NOTIFY_FIELD_AVERAGE_PPM = 0x15 }
enum : uint { PRINTER_NOTIFY_FIELD_TOTAL_PAGES = 0x16 }
enum : uint { PRINTER_NOTIFY_FIELD_PAGES_PRINTED = 0x17 }
enum : uint { PRINTER_NOTIFY_FIELD_TOTAL_BYTES = 0x18 }
enum : uint { PRINTER_NOTIFY_FIELD_BYTES_PRINTED = 0x19 }
enum : uint { PRINTER_NOTIFY_FIELD_OBJECT_GUID = 0x1A }

enum : uint { JOB_NOTIFY_FIELD_PRINTER_NAME = 0x00 }
enum : uint { JOB_NOTIFY_FIELD_MACHINE_NAME = 0x01 }
enum : uint { JOB_NOTIFY_FIELD_PORT_NAME = 0x02 }
enum : uint { JOB_NOTIFY_FIELD_USER_NAME = 0x03 }
enum : uint { JOB_NOTIFY_FIELD_NOTIFY_NAME = 0x04 }
enum : uint { JOB_NOTIFY_FIELD_DATATYPE = 0x05 }
enum : uint { JOB_NOTIFY_FIELD_PRINT_PROCESSOR = 0x06 }
enum : uint { JOB_NOTIFY_FIELD_PARAMETERS = 0x07 }
enum : uint { JOB_NOTIFY_FIELD_DRIVER_NAME = 0x08 }
enum : uint { JOB_NOTIFY_FIELD_DEVMODE = 0x09 }
enum : uint { JOB_NOTIFY_FIELD_STATUS = 0x0A }
enum : uint { JOB_NOTIFY_FIELD_STATUS_STRING = 0x0B }
enum : uint { JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR = 0x0C }
enum : uint { JOB_NOTIFY_FIELD_DOCUMENT = 0x0D }
enum : uint { JOB_NOTIFY_FIELD_PRIORITY = 0x0E }
enum : uint { JOB_NOTIFY_FIELD_POSITION = 0x0F }
enum : uint { JOB_NOTIFY_FIELD_SUBMITTED = 0x10 }
enum : uint { JOB_NOTIFY_FIELD_START_TIME = 0x11 }
enum : uint { JOB_NOTIFY_FIELD_UNTIL_TIME = 0x12 }
enum : uint { JOB_NOTIFY_FIELD_TIME = 0x13 }
enum : uint { JOB_NOTIFY_FIELD_TOTAL_PAGES = 0x14 }
enum : uint { JOB_NOTIFY_FIELD_PAGES_PRINTED = 0x15 }
enum : uint { JOB_NOTIFY_FIELD_TOTAL_BYTES = 0x16 }
enum : uint { JOB_NOTIFY_FIELD_BYTES_PRINTED = 0x17 }

struct _PRINTER_NOTIFY_OPTIONS_TYPE {
  WORD Type;
  WORD Reserved0;
  DWORD Reserved1;
  DWORD Reserved2;
  DWORD Count;
  PWORD pFields;
}
alias _PRINTER_NOTIFY_OPTIONS_TYPE PRINTER_NOTIFY_OPTIONS_TYPE;
alias _PRINTER_NOTIFY_OPTIONS_TYPE* PPRINTER_NOTIFY_OPTIONS_TYPE;
alias _PRINTER_NOTIFY_OPTIONS_TYPE* LPPRINTER_NOTIFY_OPTIONS_TYPE;

enum : uint { PRINTER_NOTIFY_OPTIONS_REFRESH = 0x01 }

struct _PRINTER_NOTIFY_OPTIONS {
  DWORD Version;
  DWORD Flags;
  DWORD Count;
  PPRINTER_NOTIFY_OPTIONS_TYPE pTypes;
}
alias _PRINTER_NOTIFY_OPTIONS PRINTER_NOTIFY_OPTIONS;
alias _PRINTER_NOTIFY_OPTIONS* PPRINTER_NOTIFY_OPTIONS;
alias _PRINTER_NOTIFY_OPTIONS* LPPRINTER_NOTIFY_OPTIONS;

enum : uint { PRINTER_NOTIFY_INFO_DISCARDED = 0x01 }

struct _PRINTER_NOTIFY_INFO_DATA {
  WORD Type;
  WORD Field;
  DWORD Reserved;
  DWORD Id;
union {
  DWORD adwData[2];
struct {
  DWORD cbBuf;
  LPVOID pBuf;
}

}

}
alias _PRINTER_NOTIFY_INFO_DATA PRINTER_NOTIFY_INFO_DATA;
alias _PRINTER_NOTIFY_INFO_DATA* PPRINTER_NOTIFY_INFO_DATA;
alias _PRINTER_NOTIFY_INFO_DATA* LPPRINTER_NOTIFY_INFO_DATA;

struct _PRINTER_NOTIFY_INFO {
  DWORD Version;
  DWORD Flags;
  DWORD Count;
  PRINTER_NOTIFY_INFO_DATA aData[1];
}
alias _PRINTER_NOTIFY_INFO PRINTER_NOTIFY_INFO;
alias _PRINTER_NOTIFY_INFO* PPRINTER_NOTIFY_INFO;
alias _PRINTER_NOTIFY_INFO* LPPRINTER_NOTIFY_INFO;

struct _BINARY_CONTAINER {
  DWORD cbBuf;
  LPBYTE pData;
}
alias _BINARY_CONTAINER BINARY_CONTAINER;
alias _BINARY_CONTAINER* PBINARY_CONTAINER;

struct _BIDI_DATA {
  DWORD dwBidiType;
union {
  BOOL bData;
  LONG iData;
  LPWSTR sData;
  FLOAT fData;
  BINARY_CONTAINER biData;
}

}
alias _BIDI_DATA BIDI_DATA;
alias _BIDI_DATA* PBIDI_DATA;
alias _BIDI_DATA* LPBIDI_DATA;

struct _BIDI_REQUEST_DATA {
  DWORD dwReqNumber;
  LPWSTR pSchema;
  BIDI_DATA data;
}
alias _BIDI_REQUEST_DATA BIDI_REQUEST_DATA;
alias _BIDI_REQUEST_DATA* PBIDI_REQUEST_DATA;
alias _BIDI_REQUEST_DATA* LPBIDI_REQUEST_DATA;

struct _BIDI_REQUEST_CONTAINER {
  DWORD Version;
  DWORD Flags;
  DWORD Count;
  BIDI_REQUEST_DATA aData[ 1 ];
}
alias _BIDI_REQUEST_CONTAINER BIDI_REQUEST_CONTAINER;
alias _BIDI_REQUEST_CONTAINER* PBIDI_REQUEST_CONTAINER;
alias _BIDI_REQUEST_CONTAINER* LPBIDI_REQUEST_CONTAINER;

struct _BIDI_RESPONSE_DATA {
  DWORD dwResult;
  DWORD dwReqNumber;
  LPWSTR pSchema;
  BIDI_DATA data;
}
alias _BIDI_RESPONSE_DATA BIDI_RESPONSE_DATA;
alias _BIDI_RESPONSE_DATA* PBIDI_RESPONSE_DATA;
alias _BIDI_RESPONSE_DATA* LPBIDI_RESPONSE_DATA;

struct _BIDI_RESPONSE_CONTAINER {
  DWORD Version;
  DWORD Flags;
  DWORD Count;
  BIDI_RESPONSE_DATA aData[ 1 ];
}
alias _BIDI_RESPONSE_CONTAINER BIDI_RESPONSE_CONTAINER;
alias _BIDI_RESPONSE_CONTAINER* PBIDI_RESPONSE_CONTAINER;
alias _BIDI_RESPONSE_CONTAINER* LPBIDI_RESPONSE_CONTAINER;

const wchar[] BIDI_ACTION_ENUM_SCHEMA = "EnumSchema";
const wchar[] BIDI_ACTION_GET = "Get";
const wchar[] BIDI_ACTION_SET = "Set";
const wchar[] BIDI_ACTION_GET_ALL = "GetAll";

enum _0 {
  BIDI_NULL = 0,
  BIDI_INT = 1,
  BIDI_FLOAT = 2,
  BIDI_BOOL = 3,
  BIDI_STRING = 4,
  BIDI_TEXT = 5,
  BIDI_ENUM = 6,
  BIDI_BLOB = 7,
}
alias _0 BIDI_TYPE;

enum : uint { BIDI_ACCESS_ADMINISTRATOR = 0x1 }
enum : uint { BIDI_ACCESS_USER = 0x2 }

enum : uint { ERROR_BIDI_STATUS_OK = 0 }
alias ERROR_NOT_SUPPORTED ERROR_BIDI_NOT_SUPPORTED;

enum : uint { ERROR_BIDI_ERROR_BASE = 13000 }
const uint ERROR_BIDI_STATUS_WARNING = ERROR_BIDI_ERROR_BASE + 1;
const uint ERROR_BIDI_SCHEMA_READ_ONLY = ERROR_BIDI_ERROR_BASE + 2;
const uint ERROR_BIDI_SERVER_OFFLINE = ERROR_BIDI_ERROR_BASE + 3;
const uint ERROR_BIDI_DEVICE_OFFLINE = ERROR_BIDI_ERROR_BASE + 4;
const uint ERROR_BIDI_SCHEMA_NOT_SUPPORTED = ERROR_BIDI_ERROR_BASE + 5;

extern(Windows) export DWORD WaitForPrinterChange(
     HANDLE  hPrinter,
     DWORD   Flags
);

extern(Windows) export HANDLE FindFirstPrinterChangeNotification(
     HANDLE  hPrinter,
     DWORD   fdwFlags,
     DWORD   fdwOptions,
     LPVOID  pPrinterNotifyOptions
);

extern(Windows) export BOOL FindNextPrinterChangeNotification(
     HANDLE hChange,
     PDWORD pdwChange,
     LPVOID pvReserved,
     LPVOID *ppPrinterNotifyInfo
);

extern(Windows) export BOOL FreePrinterNotifyInfo(
     PPRINTER_NOTIFY_INFO pPrinterNotifyInfo
);

extern(Windows) export BOOL FindClosePrinterChangeNotification(
     HANDLE hChange
);

enum : uint { PRINTER_CHANGE_ADD_PRINTER = 0x00000001 }
enum : uint { PRINTER_CHANGE_SET_PRINTER = 0x00000002 }
enum : uint { PRINTER_CHANGE_DELETE_PRINTER = 0x00000004 }
enum : uint { PRINTER_CHANGE_FAILED_CONNECTION_PRINTER = 0x00000008 }
enum : uint { PRINTER_CHANGE_PRINTER = 0x000000FF }
enum : uint { PRINTER_CHANGE_ADD_JOB = 0x00000100 }
enum : uint { PRINTER_CHANGE_SET_JOB = 0x00000200 }
enum : uint { PRINTER_CHANGE_DELETE_JOB = 0x00000400 }
enum : uint { PRINTER_CHANGE_WRITE_JOB = 0x00000800 }
enum : uint { PRINTER_CHANGE_JOB = 0x0000FF00 }
enum : uint { PRINTER_CHANGE_ADD_FORM = 0x00010000 }
enum : uint { PRINTER_CHANGE_SET_FORM = 0x00020000 }
enum : uint { PRINTER_CHANGE_DELETE_FORM = 0x00040000 }
enum : uint { PRINTER_CHANGE_FORM = 0x00070000 }
enum : uint { PRINTER_CHANGE_ADD_PORT = 0x00100000 }
enum : uint { PRINTER_CHANGE_CONFIGURE_PORT = 0x00200000 }
enum : uint { PRINTER_CHANGE_DELETE_PORT = 0x00400000 }
enum : uint { PRINTER_CHANGE_PORT = 0x00700000 }
enum : uint { PRINTER_CHANGE_ADD_PRINT_PROCESSOR = 0x01000000 }
enum : uint { PRINTER_CHANGE_DELETE_PRINT_PROCESSOR = 0x04000000 }
enum : uint { PRINTER_CHANGE_PRINT_PROCESSOR = 0x07000000 }
enum : uint { PRINTER_CHANGE_ADD_PRINTER_DRIVER = 0x10000000 }
enum : uint { PRINTER_CHANGE_SET_PRINTER_DRIVER = 0x20000000 }
enum : uint { PRINTER_CHANGE_DELETE_PRINTER_DRIVER = 0x40000000 }
enum : uint { PRINTER_CHANGE_PRINTER_DRIVER = 0x70000000 }
enum : uint { PRINTER_CHANGE_TIMEOUT = 0x80000000 }
enum : uint { PRINTER_CHANGE_ALL = 0x7777FFFF }

extern(Windows) export DWORD PrinterMessageBoxA(
     HANDLE  hPrinter,
     DWORD   Error,
     HWND    hWnd,
     LPSTR   pText,
     LPSTR   pCaption,
     DWORD   dwType
);
extern(Windows) export DWORD PrinterMessageBoxW(
     HANDLE  hPrinter,
     DWORD   Error,
     HWND    hWnd,
     LPWSTR   pText,
     LPWSTR   pCaption,
     DWORD   dwType
);
// #ifdef UNICODE
alias PrinterMessageBoxW PrinterMessageBox;
// #else
// #...
// #endif // !UNICODE

enum : uint { PRINTER_ERROR_INFORMATION = 0x80000000 }
enum : uint { PRINTER_ERROR_WARNING = 0x40000000 }
enum : uint { PRINTER_ERROR_SEVERE = 0x20000000 }

enum : uint { PRINTER_ERROR_OUTOFPAPER = 0x00000001 }
enum : uint { PRINTER_ERROR_JAM = 0x00000002 }
enum : uint { PRINTER_ERROR_OUTOFTONER = 0x00000004 }

extern(Windows) export BOOL ClosePrinter(
     HANDLE hPrinter
);

extern(Windows) export BOOL AddFormA(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pForm
);
extern(Windows) export BOOL AddFormW(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pForm
);
// #ifdef UNICODE
alias AddFormW AddForm;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL DeleteFormA(
     HANDLE  hPrinter,
     LPSTR   pFormName
);
extern(Windows) export BOOL DeleteFormW(
     HANDLE  hPrinter,
     LPWSTR   pFormName
);
// #ifdef UNICODE
alias DeleteFormW DeleteForm;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL GetFormA(
     HANDLE  hPrinter,
     LPSTR   pFormName,
     DWORD   Level,
     LPBYTE  pForm,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
extern(Windows) export BOOL GetFormW(
     HANDLE  hPrinter,
     LPWSTR   pFormName,
     DWORD   Level,
     LPBYTE  pForm,
     DWORD   cbBuf,
     LPDWORD pcbNeeded
);
// #ifdef UNICODE
alias GetFormW GetForm;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL SetFormA(
     HANDLE  hPrinter,
     LPSTR   pFormName,
     DWORD   Level,
     LPBYTE  pForm
);
extern(Windows) export BOOL SetFormW(
     HANDLE  hPrinter,
     LPWSTR   pFormName,
     DWORD   Level,
     LPBYTE  pForm
);
// #ifdef UNICODE
alias SetFormW SetForm;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL EnumFormsA(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pForm,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
extern(Windows) export BOOL EnumFormsW(
     HANDLE  hPrinter,
     DWORD   Level,
     LPBYTE  pForm,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
// #ifdef UNICODE
alias EnumFormsW EnumForms;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL EnumMonitorsA(
     LPSTR   pName,
     DWORD   Level,
     LPBYTE  pMonitors,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
extern(Windows) export BOOL EnumMonitorsW(
     LPWSTR   pName,
     DWORD   Level,
     LPBYTE  pMonitors,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
// #ifdef UNICODE
alias EnumMonitorsW EnumMonitors;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL AddMonitorA(
     LPSTR   pName,
     DWORD   Level,
     LPBYTE  pMonitors
);
extern(Windows) export BOOL AddMonitorW(
     LPWSTR   pName,
     DWORD   Level,
     LPBYTE  pMonitors
);
// #ifdef UNICODE
alias AddMonitorW AddMonitor;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL DeleteMonitorA(
     LPSTR   pName,
     LPSTR   pEnvironment,
     LPSTR   pMonitorName
);
extern(Windows) export BOOL DeleteMonitorW(
     LPWSTR   pName,
     LPWSTR   pEnvironment,
     LPWSTR   pMonitorName
);
// #ifdef UNICODE
alias DeleteMonitorW DeleteMonitor;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL EnumPortsA(
     LPSTR   pName,
     DWORD   Level,
     LPBYTE  pPorts,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
extern(Windows) export BOOL EnumPortsW(
     LPWSTR   pName,
     DWORD   Level,
     LPBYTE  pPorts,
     DWORD   cbBuf,
     LPDWORD pcbNeeded,
     LPDWORD pcReturned
);
// #ifdef UNICODE
alias EnumPortsW EnumPorts;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL AddPortA(
     LPSTR   pName,
     HWND    hWnd,
     LPSTR   pMonitorName
);
extern(Windows) export BOOL AddPortW(
     LPWSTR   pName,
     HWND    hWnd,
     LPWSTR   pMonitorName
);
// #ifdef UNICODE
alias AddPortW AddPort;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL ConfigurePortA(
     LPSTR   pName,
     HWND    hWnd,
     LPSTR   pPortName
);
extern(Windows) export BOOL ConfigurePortW(
     LPWSTR   pName,
     HWND    hWnd,
     LPWSTR   pPortName
);
// #ifdef UNICODE
alias ConfigurePortW ConfigurePort;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL DeletePortA(
     LPSTR pName,
     HWND    hWnd,
     LPSTR pPortName
);
extern(Windows) export BOOL DeletePortW(
     LPWSTR pName,
     HWND    hWnd,
     LPWSTR pPortName
);
// #ifdef UNICODE
alias DeletePortW DeletePort;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL XcvDataW(
     HANDLE  hXcv,
     PCWSTR  pszDataName,
     PBYTE   pInputData,
     DWORD   cbInputData,
     PBYTE   pOutputData,
     DWORD   cbOutputData,
     PDWORD  pcbOutputNeeded,
     PDWORD  pdwStatus
);
alias XcvDataW XcvData;

extern(Windows) export BOOL GetDefaultPrinterA(
     LPSTR   pszBuffer,
     LPDWORD  pcchBuffer
    );
extern(Windows) export BOOL GetDefaultPrinterW(
     LPWSTR   pszBuffer,
     LPDWORD  pcchBuffer
    );
// #ifdef UNICODE
alias GetDefaultPrinterW GetDefaultPrinter;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL SetDefaultPrinterA(
     LPCSTR pszPrinter
    );
extern(Windows) export BOOL SetDefaultPrinterW(
     LPCWSTR pszPrinter
    );
// #ifdef UNICODE
alias SetDefaultPrinterW SetDefaultPrinter;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL SetPortA(
     LPSTR     pName,
     LPSTR     pPortName,
     DWORD       dwLevel,
     LPBYTE      pPortInfo
);
extern(Windows) export BOOL SetPortW(
     LPWSTR     pName,
     LPWSTR     pPortName,
     DWORD       dwLevel,
     LPBYTE      pPortInfo
);
// #ifdef UNICODE
alias SetPortW SetPort;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL AddPrinterConnectionA(
     LPSTR   pName
);
extern(Windows) export BOOL AddPrinterConnectionW(
     LPWSTR   pName
);
// #ifdef UNICODE
alias AddPrinterConnectionW AddPrinterConnection;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL DeletePrinterConnectionA(
     LPSTR   pName
);
extern(Windows) export BOOL DeletePrinterConnectionW(
     LPWSTR   pName
);
// #ifdef UNICODE
alias DeletePrinterConnectionW DeletePrinterConnection;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export HANDLE ConnectToPrinterDlg(
     HWND    hwnd,
     DWORD   Flags
);

struct _PROVIDOR_INFO_1A {
  LPSTR pName;
  LPSTR pEnvironment;
  LPSTR pDLLName;
}
alias _PROVIDOR_INFO_1A PROVIDOR_INFO_1A;
alias _PROVIDOR_INFO_1A* PPROVIDOR_INFO_1A;
alias _PROVIDOR_INFO_1A* LPPROVIDOR_INFO_1A;

struct _PROVIDOR_INFO_1W {
  LPWSTR pName;
  LPWSTR pEnvironment;
  LPWSTR pDLLName;
}
alias _PROVIDOR_INFO_1W PROVIDOR_INFO_1W;
alias _PROVIDOR_INFO_1W* PPROVIDOR_INFO_1W;
alias _PROVIDOR_INFO_1W* LPPROVIDOR_INFO_1W;

// #ifdef UNICODE
alias PROVIDOR_INFO_1W PROVIDOR_INFO_1;
alias PPROVIDOR_INFO_1W PPROVIDOR_INFO_1;
alias LPPROVIDOR_INFO_1W LPPROVIDOR_INFO_1;
// #else
// ...
// #endif // UNICODE

struct _PROVIDOR_INFO_2A {
  LPSTR pOrder;
}
alias _PROVIDOR_INFO_2A PROVIDOR_INFO_2A;
alias _PROVIDOR_INFO_2A* PPROVIDOR_INFO_2A;
alias _PROVIDOR_INFO_2A* LPPROVIDOR_INFO_2A;

struct _PROVIDOR_INFO_2W {
  LPWSTR pOrder;
}
alias _PROVIDOR_INFO_2W PROVIDOR_INFO_2W;
alias _PROVIDOR_INFO_2W* PPROVIDOR_INFO_2W;
alias _PROVIDOR_INFO_2W* LPPROVIDOR_INFO_2W;

// #ifdef UNICODE
alias PROVIDOR_INFO_2W PROVIDOR_INFO_2;
alias PPROVIDOR_INFO_2W PPROVIDOR_INFO_2;
alias LPPROVIDOR_INFO_2W LPPROVIDOR_INFO_2;
// #else
// ...
// #endif // UNICODE

extern(Windows) export BOOL AddPrintProvidorA(
     LPSTR  pName,
     DWORD    level,
     LPBYTE   pProvidorInfo
);
extern(Windows) export BOOL AddPrintProvidorW(
     LPWSTR  pName,
     DWORD    level,
     LPBYTE   pProvidorInfo
);
// #ifdef UNICODE
alias AddPrintProvidorW AddPrintProvidor;
// #else
// #...
// #endif // !UNICODE

extern(Windows) export BOOL DeletePrintProvidorA(
     LPSTR   pName,
     LPSTR   pEnvironment,
     LPSTR   pPrintProvidorName
);
extern(Windows) export BOOL DeletePrintProvidorW(
     LPWSTR   pName,
     LPWSTR   pEnvironment,
     LPWSTR   pPrintProvidorName
);
// #ifdef UNICODE
alias DeletePrintProvidorW DeletePrintProvidor;
// #else
// #...
// #endif // !UNICODE

const TCHAR[] SPLREG_DEFAULT_SPOOL_DIRECTORY = "DefaultSpoolDirectory";
const TCHAR[] SPLREG_PORT_THREAD_PRIORITY_DEFAULT = "PortThreadPriorityDefault";
const TCHAR[] SPLREG_PORT_THREAD_PRIORITY = "PortThreadPriority";
const TCHAR[] SPLREG_SCHEDULER_THREAD_PRIORITY_DEFAULT = "SchedulerThreadPriorityDefault";
const TCHAR[] SPLREG_SCHEDULER_THREAD_PRIORITY = "SchedulerThreadPriority";
const TCHAR[] SPLREG_BEEP_ENABLED = "BeepEnabled";
const TCHAR[] SPLREG_NET_POPUP = "NetPopup";
const TCHAR[] SPLREG_RETRY_POPUP = "RetryPopup";
const TCHAR[] SPLREG_NET_POPUP_TO_COMPUTER = "NetPopupToComputer";
const TCHAR[] SPLREG_EVENT_LOG = "EventLog";
const TCHAR[] SPLREG_MAJOR_VERSION = "MajorVersion";
const TCHAR[] SPLREG_MINOR_VERSION = "MinorVersion";
const TCHAR[] SPLREG_ARCHITECTURE = "Architecture";
const TCHAR[] SPLREG_OS_VERSION = "OSVersion";
const TCHAR[] SPLREG_OS_VERSIONEX = "OSVersionEx";
const TCHAR[] SPLREG_DS_PRESENT = "DsPresent";
const TCHAR[] SPLREG_DS_PRESENT_FOR_USER = "DsPresentForUser";
const TCHAR[] SPLREG_REMOTE_FAX = "RemoteFax";
const TCHAR[] SPLREG_RESTART_JOB_ON_POOL_ERROR = "RestartJobOnPoolError";
const TCHAR[] SPLREG_RESTART_JOB_ON_POOL_ENABLED = "RestartJobOnPoolEnabled";
const TCHAR[] SPLREG_DNS_MACHINE_NAME = "DNSMachineName";

enum : uint { SERVER_ACCESS_ADMINISTER = 0x00000001 }
enum : uint { SERVER_ACCESS_ENUMERATE = 0x00000002 }

enum : uint { PRINTER_ACCESS_ADMINISTER = 0x00000004 }
enum : uint { PRINTER_ACCESS_USE = 0x00000008 }

enum : uint { JOB_ACCESS_ADMINISTER = 0x00000010 }

const uint SERVER_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE;

const uint SERVER_READ = STANDARD_RIGHTS_READ | SERVER_ACCESS_ENUMERATE;

const uint SERVER_WRITE = STANDARD_RIGHTS_WRITE | SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE;

const uint SERVER_EXECUTE = STANDARD_RIGHTS_EXECUTE | SERVER_ACCESS_ENUMERATE;

const uint PRINTER_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | PRINTER_ACCESS_ADMINISTER | PRINTER_ACCESS_USE;

const uint PRINTER_READ = STANDARD_RIGHTS_READ | PRINTER_ACCESS_USE;

const uint PRINTER_WRITE = STANDARD_RIGHTS_WRITE | PRINTER_ACCESS_USE;

const uint PRINTER_EXECUTE = STANDARD_RIGHTS_EXECUTE | PRINTER_ACCESS_USE;

const uint JOB_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | JOB_ACCESS_ADMINISTER;

const uint JOB_READ = STANDARD_RIGHTS_READ | JOB_ACCESS_ADMINISTER;

const uint JOB_WRITE = STANDARD_RIGHTS_WRITE | JOB_ACCESS_ADMINISTER;

const uint JOB_EXECUTE = STANDARD_RIGHTS_EXECUTE | JOB_ACCESS_ADMINISTER;

const TCHAR[] SPLDS_SPOOLER_KEY = "DsSpooler";
const TCHAR[] SPLDS_DRIVER_KEY = "DsDriver";
const TCHAR[] SPLDS_USER_KEY = "DsUser";

const TCHAR[] SPLDS_ASSET_NUMBER = "assetNumber";
const TCHAR[] SPLDS_BYTES_PER_MINUTE = "bytesPerMinute";
const TCHAR[] SPLDS_DESCRIPTION = "description";
const TCHAR[] SPLDS_DRIVER_NAME = "driverName";
const TCHAR[] SPLDS_DRIVER_VERSION = "driverVersion";
const TCHAR[] SPLDS_LOCATION = "location";
const TCHAR[] SPLDS_PORT_NAME = "portName";
const TCHAR[] SPLDS_PRINT_ATTRIBUTES = "printAttributes";
const TCHAR[] SPLDS_PRINT_BIN_NAMES = "printBinNames";
const TCHAR[] SPLDS_PRINT_COLLATE = "printCollate";
const TCHAR[] SPLDS_PRINT_COLOR = "printColor";
const TCHAR[] SPLDS_PRINT_DUPLEX_SUPPORTED = "printDuplexSupported";
const TCHAR[] SPLDS_PRINT_END_TIME = "printEndTime";
const TCHAR[] SPLDS_PRINTER_CLASS = "printQueue";
const TCHAR[] SPLDS_PRINTER_NAME = "printerName";
const TCHAR[] SPLDS_PRINT_KEEP_PRINTED_JOBS = "printKeepPrintedJobs";
const TCHAR[] SPLDS_PRINT_LANGUAGE = "printLanguage";
const TCHAR[] SPLDS_PRINT_MAC_ADDRESS = "printMACAddress";
const TCHAR[] SPLDS_PRINT_MAX_X_EXTENT = "printMaxXExtent";
const TCHAR[] SPLDS_PRINT_MAX_Y_EXTENT = "printMaxYExtent";
const TCHAR[] SPLDS_PRINT_MAX_RESOLUTION_SUPPORTED = "printMaxResolutionSupported";
const TCHAR[] SPLDS_PRINT_MEDIA_READY = "printMediaReady";
const TCHAR[] SPLDS_PRINT_MEDIA_SUPPORTED = "printMediaSupported";
const TCHAR[] SPLDS_PRINT_MEMORY = "printMemory";
const TCHAR[] SPLDS_PRINT_MIN_X_EXTENT = "printMinXExtent";
const TCHAR[] SPLDS_PRINT_MIN_Y_EXTENT = "printMinYExtent";
const TCHAR[] SPLDS_PRINT_NETWORK_ADDRESS = "printNetworkAddress";
const TCHAR[] SPLDS_PRINT_NOTIFY = "printNotify";
const TCHAR[] SPLDS_PRINT_NUMBER_UP = "printNumberUp";
const TCHAR[] SPLDS_PRINT_ORIENTATIONS_SUPPORTED = "printOrientationsSupported";
const TCHAR[] SPLDS_PRINT_OWNER = "printOwner";
const TCHAR[] SPLDS_PRINT_PAGES_PER_MINUTE = "printPagesPerMinute";
const TCHAR[] SPLDS_PRINT_RATE = "printRate";
const TCHAR[] SPLDS_PRINT_RATE_UNIT = "printRateUnit";
const TCHAR[] SPLDS_PRINT_SEPARATOR_FILE = "printSeparatorFile";
const TCHAR[] SPLDS_PRINT_SHARE_NAME = "printShareName";
const TCHAR[] SPLDS_PRINT_SPOOLING = "printSpooling";
const TCHAR[] SPLDS_PRINT_STAPLING_SUPPORTED = "printStaplingSupported";
const TCHAR[] SPLDS_PRINT_START_TIME = "printStartTime";
const TCHAR[] SPLDS_PRINT_STATUS = "printStatus";
const TCHAR[] SPLDS_PRIORITY = "priority";
const TCHAR[] SPLDS_SERVER_NAME = "serverName";
const TCHAR[] SPLDS_SHORT_SERVER_NAME = "shortServerName";
const TCHAR[] SPLDS_UNC_NAME = "uNCName";
const TCHAR[] SPLDS_URL = "url";
const TCHAR[] SPLDS_FLAGS = "flags";
const TCHAR[] SPLDS_VERSION_NUMBER = "versionNumber";

const TCHAR[] SPLDS_PRINTER_NAME_ALIASES = "printerNameAliases";
const TCHAR[] SPLDS_PRINTER_LOCATIONS = "printerLocations";
const TCHAR[] SPLDS_PRINTER_MODEL = "printerModel";

// #ifdef __cplusplus
// }
// #endif

// #endif // _WINSPOOL_
