Artifact da000ce43cc88313d2b9e4a896ab7543b3800eae

• File src/win32/ansi/winspool.d
  • 2011-02-23 12:53:16 - part of checkin [c2b7a98c21] on branch trunk - Initial import (user: kinaba) [annotate]

module win32.ansi.winspool;

// Translated from Microsoft Platform SDK August 2001 Edition
// by Y.Tomino (demoonlit@inter7.jp)

import win32.ansi.winbase, win32.ansi.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
// ...
// #else
alias PRINTER_INFO_1A PRINTER_INFO_1;
alias PPRINTER_INFO_1A PPRINTER_INFO_1;
alias LPPRINTER_INFO_1A LPPRINTER_INFO_1;
// #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
// ...
// #else
alias PRINTER_INFO_2A PRINTER_INFO_2;
alias PPRINTER_INFO_2A PPRINTER_INFO_2;
alias LPPRINTER_INFO_2A LPPRINTER_INFO_2;
// #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
// ...
// #else
alias PRINTER_INFO_4A PRINTER_INFO_4;
alias PPRINTER_INFO_4A PPRINTER_INFO_4;
alias LPPRINTER_INFO_4A LPPRINTER_INFO_4;
// #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
// ...
// #else
alias PRINTER_INFO_5A PRINTER_INFO_5;
alias PPRINTER_INFO_5A PPRINTER_INFO_5;
alias LPPRINTER_INFO_5A LPPRINTER_INFO_5;
// #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
// ...
// #else
alias PRINTER_INFO_7A PRINTER_INFO_7;
alias PPRINTER_INFO_7A PPRINTER_INFO_7;
alias LPPRINTER_INFO_7A LPPRINTER_INFO_7;
// #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
// ...
// #else
alias PRINTER_INFO_8A PRINTER_INFO_8;
alias PPRINTER_INFO_8A PPRINTER_INFO_8;
alias LPPRINTER_INFO_8A LPPRINTER_INFO_8;
// #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
// ...
// #else
alias PRINTER_INFO_9A PRINTER_INFO_9;
alias PPRINTER_INFO_9A PPRINTER_INFO_9;
alias LPPRINTER_INFO_9A LPPRINTER_INFO_9;
// #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
// ...
// #else
alias JOB_INFO_1A JOB_INFO_1;
alias PJOB_INFO_1A PJOB_INFO_1;
alias LPJOB_INFO_1A LPJOB_INFO_1;
// #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
// ...
// #else
alias JOB_INFO_2A JOB_INFO_2;
alias PJOB_INFO_2A PJOB_INFO_2;
alias LPJOB_INFO_2A LPJOB_INFO_2;
// #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
// ...
// #else
alias ADDJOB_INFO_1A ADDJOB_INFO_1;
alias PADDJOB_INFO_1A PADDJOB_INFO_1;
alias LPADDJOB_INFO_1A LPADDJOB_INFO_1;
// #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
// ...
// #else
alias DRIVER_INFO_1A DRIVER_INFO_1;
alias PDRIVER_INFO_1A PDRIVER_INFO_1;
alias LPDRIVER_INFO_1A LPDRIVER_INFO_1;
// #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
// ...
// #else
alias DRIVER_INFO_2A DRIVER_INFO_2;
alias PDRIVER_INFO_2A PDRIVER_INFO_2;
alias LPDRIVER_INFO_2A LPDRIVER_INFO_2;
// #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
// ...
// #else
alias DRIVER_INFO_3A DRIVER_INFO_3;
alias PDRIVER_INFO_3A PDRIVER_INFO_3;
alias LPDRIVER_INFO_3A LPDRIVER_INFO_3;
// #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
// ...
// #else
alias DRIVER_INFO_4A DRIVER_INFO_4;
alias PDRIVER_INFO_4A PDRIVER_INFO_4;
alias LPDRIVER_INFO_4A LPDRIVER_INFO_4;
// #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
// ...
// #else
alias DRIVER_INFO_5A DRIVER_INFO_5;
alias PDRIVER_INFO_5A PDRIVER_INFO_5;
alias LPDRIVER_INFO_5A LPDRIVER_INFO_5;
// #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
// ...
// #else
alias DRIVER_INFO_6A DRIVER_INFO_6;
alias PDRIVER_INFO_6A PDRIVER_INFO_6;
alias LPDRIVER_INFO_6A LPDRIVER_INFO_6;
// #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
// ...
// #else
alias DOC_INFO_1A DOC_INFO_1;
alias PDOC_INFO_1A PDOC_INFO_1;
alias LPDOC_INFO_1A LPDOC_INFO_1;
// #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
// ...
// #else
alias FORM_INFO_1A FORM_INFO_1;
alias PFORM_INFO_1A PFORM_INFO_1;
alias LPFORM_INFO_1A LPFORM_INFO_1;
// #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
// ...
// #else
alias DOC_INFO_2A DOC_INFO_2;
alias PDOC_INFO_2A PDOC_INFO_2;
alias LPDOC_INFO_2A LPDOC_INFO_2;
// #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
// ...
// #else
alias DOC_INFO_3A DOC_INFO_3;
alias PDOC_INFO_3A PDOC_INFO_3;
alias LPDOC_INFO_3A LPDOC_INFO_3;
// #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
// ...
// #else
alias PRINTPROCESSOR_INFO_1A PRINTPROCESSOR_INFO_1;
alias PPRINTPROCESSOR_INFO_1A PPRINTPROCESSOR_INFO_1;
alias LPPRINTPROCESSOR_INFO_1A LPPRINTPROCESSOR_INFO_1;
// #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
// ...
// #else
alias PORT_INFO_1A PORT_INFO_1;
alias PPORT_INFO_1A PPORT_INFO_1;
alias LPPORT_INFO_1A LPPORT_INFO_1;
// #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
// ...
// #else
alias PORT_INFO_2A PORT_INFO_2;
alias PPORT_INFO_2A PPORT_INFO_2;
alias LPPORT_INFO_2A LPPORT_INFO_2;
// #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
// ...
// #else
alias PORT_INFO_3A PORT_INFO_3;
alias PPORT_INFO_3A PPORT_INFO_3;
alias LPPORT_INFO_3A LPPORT_INFO_3;
// #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
// ...
// #else
alias MONITOR_INFO_1A MONITOR_INFO_1;
alias PMONITOR_INFO_1A PMONITOR_INFO_1;
alias LPMONITOR_INFO_1A LPMONITOR_INFO_1;
// #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
// ...
// #else
alias MONITOR_INFO_2A MONITOR_INFO_2;
alias PMONITOR_INFO_2A PMONITOR_INFO_2;
alias LPMONITOR_INFO_2A LPMONITOR_INFO_2;
// #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
// ...
// #else
alias DATATYPES_INFO_1A DATATYPES_INFO_1;
alias PDATATYPES_INFO_1A PDATATYPES_INFO_1;
alias LPDATATYPES_INFO_1A LPDATATYPES_INFO_1;
// #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
// ...
// #else
alias PRINTER_DEFAULTSA PRINTER_DEFAULTS;
alias PPRINTER_DEFAULTSA PPRINTER_DEFAULTS;
alias LPPRINTER_DEFAULTSA LPPRINTER_DEFAULTS;
// #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
// ...
// #else
alias PRINTER_ENUM_VALUESA PRINTER_ENUM_VALUES;
alias PPRINTER_ENUM_VALUESA PPRINTER_ENUM_VALUES;
alias LPPRINTER_ENUM_VALUESA LPPRINTER_ENUM_VALUES;
// #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
// #...
// #else
alias EnumPrintersA EnumPrinters;
// #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
// #...
// #else
alias OpenPrinterA OpenPrinter;
// #endif // !UNICODE

extern(Windows) export BOOL ResetPrinterA(
  HANDLE hPrinter,
  LPPRINTER_DEFAULTSA pDefault
);
extern(Windows) export BOOL ResetPrinterW(
  HANDLE hPrinter,
  LPPRINTER_DEFAULTSW pDefault
);
// #ifdef UNICODE
// #...
// #else
alias ResetPrinterA ResetPrinter;
// #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
// #...
// #else
alias SetJobA SetJob;
// #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
// #...
// #else
alias GetJobA GetJob;
// #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
// #...
// #else
alias EnumJobsA EnumJobs;
// #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
// #...
// #else
alias AddPrinterA AddPrinter;
// #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
// #...
// #else
alias SetPrinterA SetPrinter;
// #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
// #...
// #else
alias GetPrinterA GetPrinter;
// #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
// #...
// #else
alias AddPrinterDriverA AddPrinterDriver;
// #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
// #...
// #else
alias AddPrinterDriverExA AddPrinterDriverEx;
// #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
// #...
// #else
alias EnumPrinterDriversA EnumPrinterDrivers;
// #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
// #...
// #else
alias GetPrinterDriverA GetPrinterDriver;
// #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
// #...
// #else
alias GetPrinterDriverDirectoryA GetPrinterDriverDirectory;
// #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
// #...
// #else
alias DeletePrinterDriverA DeletePrinterDriver;
// #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
// #...
// #else
alias DeletePrinterDriverExA DeletePrinterDriverEx;
// #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
// #...
// #else
alias AddPrintProcessorA AddPrintProcessor;
// #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
// #...
// #else
alias EnumPrintProcessorsA EnumPrintProcessors;
// #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
// #...
// #else
alias GetPrintProcessorDirectoryA GetPrintProcessorDirectory;
// #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
// #...
// #else
alias EnumPrintProcessorDatatypesA EnumPrintProcessorDatatypes;
// #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
// #...
// #else
alias DeletePrintProcessorA DeletePrintProcessor;
// #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
// #...
// #else
alias StartDocPrinterA StartDocPrinter;
// #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
// #...
// #else
alias AddJobA AddJob;
// #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
// #...
// #else
alias DocumentPropertiesA DocumentProperties;
// #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
// #...
// #else
alias AdvancedDocumentPropertiesA AdvancedDocumentProperties;
// #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
// #...
// #else
alias GetPrinterDataA GetPrinterData;
// #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
// #...
// #else
alias GetPrinterDataExA GetPrinterDataEx;
// #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
// #...
// #else
alias EnumPrinterDataA EnumPrinterData;
// #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
// #...
// #else
alias EnumPrinterDataExA EnumPrinterDataEx;
// #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
// #...
// #else
alias EnumPrinterKeyA EnumPrinterKey;
// #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
// #...
// #else
alias SetPrinterDataA SetPrinterData;
// #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
// #...
// #else
alias SetPrinterDataExA SetPrinterDataEx;
// #endif // !UNICODE

extern(Windows) export DWORD DeletePrinterDataA(
  HANDLE hPrinter,
  LPSTR pValueName
);
extern(Windows) export DWORD DeletePrinterDataW(
  HANDLE hPrinter,
  LPWSTR pValueName
);
// #ifdef UNICODE
// #...
// #else
alias DeletePrinterDataA DeletePrinterData;
// #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
// #...
// #else
alias DeletePrinterDataExA DeletePrinterDataEx;
// #endif // !UNICODE

extern(Windows) export DWORD DeletePrinterKeyA(
  HANDLE hPrinter,
  LPCSTR pKeyName
);
extern(Windows) export DWORD DeletePrinterKeyW(
  HANDLE hPrinter,
  LPCWSTR pKeyName
);
// #ifdef UNICODE
// #...
// #else
alias DeletePrinterKeyA DeletePrinterKey;
// #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 }
enum : uint { ERROR_BIDI_STATUS_WARNING = ERROR_BIDI_ERROR_BASE + 1 }
enum : uint { ERROR_BIDI_SCHEMA_READ_ONLY = ERROR_BIDI_ERROR_BASE + 2 }
enum : uint { ERROR_BIDI_SERVER_OFFLINE = ERROR_BIDI_ERROR_BASE + 3 }
enum : uint { ERROR_BIDI_DEVICE_OFFLINE = ERROR_BIDI_ERROR_BASE + 4 }
enum : 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
// #...
// #else
alias PrinterMessageBoxA PrinterMessageBox;
// #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
// #...
// #else
alias AddFormA AddForm;
// #endif // !UNICODE

extern(Windows) export BOOL DeleteFormA(
  HANDLE hPrinter,
  LPSTR pFormName
);
extern(Windows) export BOOL DeleteFormW(
  HANDLE hPrinter,
  LPWSTR pFormName
);
// #ifdef UNICODE
// #...
// #else
alias DeleteFormA DeleteForm;
// #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
// #...
// #else
alias GetFormA GetForm;
// #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
// #...
// #else
alias SetFormA SetForm;
// #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
// #...
// #else
alias EnumFormsA EnumForms;
// #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
// #...
// #else
alias EnumMonitorsA EnumMonitors;
// #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
// #...
// #else
alias AddMonitorA AddMonitor;
// #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
// #...
// #else
alias DeleteMonitorA DeleteMonitor;
// #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
// #...
// #else
alias EnumPortsA EnumPorts;
// #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
// #...
// #else
alias AddPortA AddPort;
// #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
// #...
// #else
alias ConfigurePortA ConfigurePort;
// #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
// #...
// #else
alias DeletePortA DeletePort;
// #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
// #...
// #else
alias GetDefaultPrinterA GetDefaultPrinter;
// #endif // !UNICODE

extern(Windows) export BOOL SetDefaultPrinterA(
  LPCSTR pszPrinter);
extern(Windows) export BOOL SetDefaultPrinterW(
  LPCWSTR pszPrinter);
// #ifdef UNICODE
// #...
// #else
alias SetDefaultPrinterA SetDefaultPrinter;
// #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
// #...
// #else
alias SetPortA SetPort;
// #endif // !UNICODE

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

extern(Windows) export BOOL DeletePrinterConnectionA(
  LPSTR pName
);
extern(Windows) export BOOL DeletePrinterConnectionW(
  LPWSTR pName
);
// #ifdef UNICODE
// #...
// #else
alias DeletePrinterConnectionA DeletePrinterConnection;
// #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
// ...
// #else
alias PROVIDOR_INFO_1A PROVIDOR_INFO_1;
alias PPROVIDOR_INFO_1A PPROVIDOR_INFO_1;
alias LPPROVIDOR_INFO_1A LPPROVIDOR_INFO_1;
// #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
// ...
// #else
alias PROVIDOR_INFO_2A PROVIDOR_INFO_2;
alias PPROVIDOR_INFO_2A PPROVIDOR_INFO_2;
alias LPPROVIDOR_INFO_2A LPPROVIDOR_INFO_2;
// #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
// #...
// #else
alias AddPrintProvidorA AddPrintProvidor;
// #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
// #...
// #else
alias DeletePrintProvidorA DeletePrintProvidor;
// #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 }

enum : uint { SERVER_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE }

enum : uint { SERVER_READ = STANDARD_RIGHTS_READ | SERVER_ACCESS_ENUMERATE }

enum : uint { SERVER_WRITE = STANDARD_RIGHTS_WRITE | SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE }

enum : uint { SERVER_EXECUTE = STANDARD_RIGHTS_EXECUTE | SERVER_ACCESS_ENUMERATE }

enum : uint { PRINTER_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | PRINTER_ACCESS_ADMINISTER | PRINTER_ACCESS_USE }

enum : uint { PRINTER_READ = STANDARD_RIGHTS_READ | PRINTER_ACCESS_USE }

enum : uint { PRINTER_WRITE = STANDARD_RIGHTS_WRITE | PRINTER_ACCESS_USE }

enum : uint { PRINTER_EXECUTE = STANDARD_RIGHTS_EXECUTE | PRINTER_ACCESS_USE }

enum : uint { JOB_ALL_ACCESS = STANDARD_RIGHTS_REQUIRED | JOB_ACCESS_ADMINISTER }

enum : uint { JOB_READ = STANDARD_RIGHTS_READ | JOB_ACCESS_ADMINISTER }

enum : uint { JOB_WRITE = STANDARD_RIGHTS_WRITE | JOB_ACCESS_ADMINISTER }

enum : 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_