vendor/windows-sys/src/Windows/Devices/PointOfService/mod.rs

   1 #![allow(non_snake_case, non_camel_case_types, non_upper_case_globals, clashing_extern_declarations, clippy::all)]
   2 #[cfg(feature = "Devices_PointOfService_Provider")]
   3 pub mod Provider;
   4 pub type BarcodeScanner = *mut ::core::ffi::c_void;
   5 pub type BarcodeScannerCapabilities = *mut ::core::ffi::c_void;
   6 pub type BarcodeScannerDataReceivedEventArgs = *mut ::core::ffi::c_void;
   7 pub type BarcodeScannerErrorOccurredEventArgs = *mut ::core::ffi::c_void;
   8 pub type BarcodeScannerImagePreviewReceivedEventArgs = *mut ::core::ffi::c_void;
   9 pub type BarcodeScannerReport = *mut ::core::ffi::c_void;
  10 #[doc = "*Required features: 'Devices_PointOfService'*"]
  11 #[repr(transparent)]
  12 pub struct BarcodeScannerStatus(pub i32);
  13 impl BarcodeScannerStatus {
  14     pub const Online: Self = Self(0i32);
  15     pub const Off: Self = Self(1i32);
  16     pub const Offline: Self = Self(2i32);
  17     pub const OffOrOffline: Self = Self(3i32);
  18     pub const Extended: Self = Self(4i32);
  19 }
  20 impl ::core::marker::Copy for BarcodeScannerStatus {}
  21 impl ::core::clone::Clone for BarcodeScannerStatus {
  22     fn clone(&self) -> Self {
  23         *self
  24     }
  25 }
  26 pub type BarcodeScannerStatusUpdatedEventArgs = *mut ::core::ffi::c_void;
  27 pub type BarcodeSymbologyAttributes = *mut ::core::ffi::c_void;
  28 #[doc = "*Required features: 'Devices_PointOfService'*"]
  29 #[repr(transparent)]
  30 pub struct BarcodeSymbologyDecodeLengthKind(pub i32);
  31 impl BarcodeSymbologyDecodeLengthKind {
  32     pub const AnyLength: Self = Self(0i32);
  33     pub const Discrete: Self = Self(1i32);
  34     pub const Range: Self = Self(2i32);
  35 }
  36 impl ::core::marker::Copy for BarcodeSymbologyDecodeLengthKind {}
  37 impl ::core::clone::Clone for BarcodeSymbologyDecodeLengthKind {
  38     fn clone(&self) -> Self {
  39         *self
  40     }
  41 }
  42 pub type CashDrawer = *mut ::core::ffi::c_void;
  43 pub type CashDrawerCapabilities = *mut ::core::ffi::c_void;
  44 pub type CashDrawerCloseAlarm = *mut ::core::ffi::c_void;
  45 pub type CashDrawerClosedEventArgs = *mut ::core::ffi::c_void;
  46 pub type CashDrawerEventSource = *mut ::core::ffi::c_void;
  47 pub type CashDrawerOpenedEventArgs = *mut ::core::ffi::c_void;
  48 pub type CashDrawerStatus = *mut ::core::ffi::c_void;
  49 #[doc = "*Required features: 'Devices_PointOfService'*"]
  50 #[repr(transparent)]
  51 pub struct CashDrawerStatusKind(pub i32);
  52 impl CashDrawerStatusKind {
  53     pub const Online: Self = Self(0i32);
  54     pub const Off: Self = Self(1i32);
  55     pub const Offline: Self = Self(2i32);
  56     pub const OffOrOffline: Self = Self(3i32);
  57     pub const Extended: Self = Self(4i32);
  58 }
  59 impl ::core::marker::Copy for CashDrawerStatusKind {}
  60 impl ::core::clone::Clone for CashDrawerStatusKind {
  61     fn clone(&self) -> Self {
  62         *self
  63     }
  64 }
  65 pub type CashDrawerStatusUpdatedEventArgs = *mut ::core::ffi::c_void;
  66 pub type ClaimedBarcodeScanner = *mut ::core::ffi::c_void;
  67 pub type ClaimedBarcodeScannerClosedEventArgs = *mut ::core::ffi::c_void;
  68 pub type ClaimedCashDrawer = *mut ::core::ffi::c_void;
  69 pub type ClaimedCashDrawerClosedEventArgs = *mut ::core::ffi::c_void;
  70 pub type ClaimedJournalPrinter = *mut ::core::ffi::c_void;
  71 pub type ClaimedLineDisplay = *mut ::core::ffi::c_void;
  72 pub type ClaimedLineDisplayClosedEventArgs = *mut ::core::ffi::c_void;
  73 pub type ClaimedMagneticStripeReader = *mut ::core::ffi::c_void;
  74 pub type ClaimedMagneticStripeReaderClosedEventArgs = *mut ::core::ffi::c_void;
  75 pub type ClaimedPosPrinter = *mut ::core::ffi::c_void;
  76 pub type ClaimedPosPrinterClosedEventArgs = *mut ::core::ffi::c_void;
  77 pub type ClaimedReceiptPrinter = *mut ::core::ffi::c_void;
  78 pub type ClaimedSlipPrinter = *mut ::core::ffi::c_void;
  79 pub type ICashDrawerEventSourceEventArgs = *mut ::core::ffi::c_void;
  80 pub type ICommonClaimedPosPrinterStation = *mut ::core::ffi::c_void;
  81 pub type ICommonPosPrintStationCapabilities = *mut ::core::ffi::c_void;
  82 pub type ICommonReceiptSlipCapabilities = *mut ::core::ffi::c_void;
  83 pub type IPosPrinterJob = *mut ::core::ffi::c_void;
  84 pub type IReceiptOrSlipJob = *mut ::core::ffi::c_void;
  85 pub type JournalPrintJob = *mut ::core::ffi::c_void;
  86 pub type JournalPrinterCapabilities = *mut ::core::ffi::c_void;
  87 pub type LineDisplay = *mut ::core::ffi::c_void;
  88 pub type LineDisplayAttributes = *mut ::core::ffi::c_void;
  89 pub type LineDisplayCapabilities = *mut ::core::ffi::c_void;
  90 pub type LineDisplayCursor = *mut ::core::ffi::c_void;
  91 pub type LineDisplayCursorAttributes = *mut ::core::ffi::c_void;
  92 #[doc = "*Required features: 'Devices_PointOfService'*"]
  93 #[repr(transparent)]
  94 pub struct LineDisplayCursorType(pub i32);
  95 impl LineDisplayCursorType {
  96     pub const None: Self = Self(0i32);
  97     pub const Block: Self = Self(1i32);
  98     pub const HalfBlock: Self = Self(2i32);
  99     pub const Underline: Self = Self(3i32);
 100     pub const Reverse: Self = Self(4i32);
 101     pub const Other: Self = Self(5i32);
 102 }
 103 impl ::core::marker::Copy for LineDisplayCursorType {}
 104 impl ::core::clone::Clone for LineDisplayCursorType {
 105     fn clone(&self) -> Self {
 106         *self
 107     }
 108 }
 109 pub type LineDisplayCustomGlyphs = *mut ::core::ffi::c_void;
 110 #[doc = "*Required features: 'Devices_PointOfService'*"]
 111 #[repr(transparent)]
 112 pub struct LineDisplayDescriptorState(pub i32);
 113 impl LineDisplayDescriptorState {
 114     pub const Off: Self = Self(0i32);
 115     pub const On: Self = Self(1i32);
 116     pub const Blink: Self = Self(2i32);
 117 }
 118 impl ::core::marker::Copy for LineDisplayDescriptorState {}
 119 impl ::core::clone::Clone for LineDisplayDescriptorState {
 120     fn clone(&self) -> Self {
 121         *self
 122     }
 123 }
 124 #[doc = "*Required features: 'Devices_PointOfService'*"]
 125 #[repr(transparent)]
 126 pub struct LineDisplayHorizontalAlignment(pub i32);
 127 impl LineDisplayHorizontalAlignment {
 128     pub const Left: Self = Self(0i32);
 129     pub const Center: Self = Self(1i32);
 130     pub const Right: Self = Self(2i32);
 131 }
 132 impl ::core::marker::Copy for LineDisplayHorizontalAlignment {}
 133 impl ::core::clone::Clone for LineDisplayHorizontalAlignment {
 134     fn clone(&self) -> Self {
 135         *self
 136     }
 137 }
 138 pub type LineDisplayMarquee = *mut ::core::ffi::c_void;
 139 #[doc = "*Required features: 'Devices_PointOfService'*"]
 140 #[repr(transparent)]
 141 pub struct LineDisplayMarqueeFormat(pub i32);
 142 impl LineDisplayMarqueeFormat {
 143     pub const None: Self = Self(0i32);
 144     pub const Walk: Self = Self(1i32);
 145     pub const Place: Self = Self(2i32);
 146 }
 147 impl ::core::marker::Copy for LineDisplayMarqueeFormat {}
 148 impl ::core::clone::Clone for LineDisplayMarqueeFormat {
 149     fn clone(&self) -> Self {
 150         *self
 151     }
 152 }
 153 #[doc = "*Required features: 'Devices_PointOfService'*"]
 154 #[repr(transparent)]
 155 pub struct LineDisplayPowerStatus(pub i32);
 156 impl LineDisplayPowerStatus {
 157     pub const Unknown: Self = Self(0i32);
 158     pub const Online: Self = Self(1i32);
 159     pub const Off: Self = Self(2i32);
 160     pub const Offline: Self = Self(3i32);
 161     pub const OffOrOffline: Self = Self(4i32);
 162 }
 163 impl ::core::marker::Copy for LineDisplayPowerStatus {}
 164 impl ::core::clone::Clone for LineDisplayPowerStatus {
 165     fn clone(&self) -> Self {
 166         *self
 167     }
 168 }
 169 #[doc = "*Required features: 'Devices_PointOfService'*"]
 170 #[repr(transparent)]
 171 pub struct LineDisplayScrollDirection(pub i32);
 172 impl LineDisplayScrollDirection {
 173     pub const Up: Self = Self(0i32);
 174     pub const Down: Self = Self(1i32);
 175     pub const Left: Self = Self(2i32);
 176     pub const Right: Self = Self(3i32);
 177 }
 178 impl ::core::marker::Copy for LineDisplayScrollDirection {}
 179 impl ::core::clone::Clone for LineDisplayScrollDirection {
 180     fn clone(&self) -> Self {
 181         *self
 182     }
 183 }
 184 pub type LineDisplayStatisticsCategorySelector = *mut ::core::ffi::c_void;
 185 pub type LineDisplayStatusUpdatedEventArgs = *mut ::core::ffi::c_void;
 186 pub type LineDisplayStoredBitmap = *mut ::core::ffi::c_void;
 187 #[doc = "*Required features: 'Devices_PointOfService'*"]
 188 #[repr(transparent)]
 189 pub struct LineDisplayTextAttribute(pub i32);
 190 impl LineDisplayTextAttribute {
 191     pub const Normal: Self = Self(0i32);
 192     pub const Blink: Self = Self(1i32);
 193     pub const Reverse: Self = Self(2i32);
 194     pub const ReverseBlink: Self = Self(3i32);
 195 }
 196 impl ::core::marker::Copy for LineDisplayTextAttribute {}
 197 impl ::core::clone::Clone for LineDisplayTextAttribute {
 198     fn clone(&self) -> Self {
 199         *self
 200     }
 201 }
 202 #[doc = "*Required features: 'Devices_PointOfService'*"]
 203 #[repr(transparent)]
 204 pub struct LineDisplayTextAttributeGranularity(pub i32);
 205 impl LineDisplayTextAttributeGranularity {
 206     pub const NotSupported: Self = Self(0i32);
 207     pub const EntireDisplay: Self = Self(1i32);
 208     pub const PerCharacter: Self = Self(2i32);
 209 }
 210 impl ::core::marker::Copy for LineDisplayTextAttributeGranularity {}
 211 impl ::core::clone::Clone for LineDisplayTextAttributeGranularity {
 212     fn clone(&self) -> Self {
 213         *self
 214     }
 215 }
 216 #[doc = "*Required features: 'Devices_PointOfService'*"]
 217 #[repr(transparent)]
 218 pub struct LineDisplayVerticalAlignment(pub i32);
 219 impl LineDisplayVerticalAlignment {
 220     pub const Top: Self = Self(0i32);
 221     pub const Center: Self = Self(1i32);
 222     pub const Bottom: Self = Self(2i32);
 223 }
 224 impl ::core::marker::Copy for LineDisplayVerticalAlignment {}
 225 impl ::core::clone::Clone for LineDisplayVerticalAlignment {
 226     fn clone(&self) -> Self {
 227         *self
 228     }
 229 }
 230 pub type LineDisplayWindow = *mut ::core::ffi::c_void;
 231 pub type MagneticStripeReader = *mut ::core::ffi::c_void;
 232 pub type MagneticStripeReaderAamvaCardDataReceivedEventArgs = *mut ::core::ffi::c_void;
 233 #[doc = "*Required features: 'Devices_PointOfService'*"]
 234 #[repr(transparent)]
 235 pub struct MagneticStripeReaderAuthenticationLevel(pub i32);
 236 impl MagneticStripeReaderAuthenticationLevel {
 237     pub const NotSupported: Self = Self(0i32);
 238     pub const Optional: Self = Self(1i32);
 239     pub const Required: Self = Self(2i32);
 240 }
 241 impl ::core::marker::Copy for MagneticStripeReaderAuthenticationLevel {}
 242 impl ::core::clone::Clone for MagneticStripeReaderAuthenticationLevel {
 243     fn clone(&self) -> Self {
 244         *self
 245     }
 246 }
 247 #[doc = "*Required features: 'Devices_PointOfService'*"]
 248 #[repr(transparent)]
 249 pub struct MagneticStripeReaderAuthenticationProtocol(pub i32);
 250 impl MagneticStripeReaderAuthenticationProtocol {
 251     pub const None: Self = Self(0i32);
 252     pub const ChallengeResponse: Self = Self(1i32);
 253 }
 254 impl ::core::marker::Copy for MagneticStripeReaderAuthenticationProtocol {}
 255 impl ::core::clone::Clone for MagneticStripeReaderAuthenticationProtocol {
 256     fn clone(&self) -> Self {
 257         *self
 258     }
 259 }
 260 pub type MagneticStripeReaderBankCardDataReceivedEventArgs = *mut ::core::ffi::c_void;
 261 pub type MagneticStripeReaderCapabilities = *mut ::core::ffi::c_void;
 262 pub type MagneticStripeReaderErrorOccurredEventArgs = *mut ::core::ffi::c_void;
 263 #[doc = "*Required features: 'Devices_PointOfService'*"]
 264 #[repr(transparent)]
 265 pub struct MagneticStripeReaderErrorReportingType(pub i32);
 266 impl MagneticStripeReaderErrorReportingType {
 267     pub const CardLevel: Self = Self(0i32);
 268     pub const TrackLevel: Self = Self(1i32);
 269 }
 270 impl ::core::marker::Copy for MagneticStripeReaderErrorReportingType {}
 271 impl ::core::clone::Clone for MagneticStripeReaderErrorReportingType {
 272     fn clone(&self) -> Self {
 273         *self
 274     }
 275 }
 276 pub type MagneticStripeReaderReport = *mut ::core::ffi::c_void;
 277 #[doc = "*Required features: 'Devices_PointOfService'*"]
 278 #[repr(transparent)]
 279 pub struct MagneticStripeReaderStatus(pub i32);
 280 impl MagneticStripeReaderStatus {
 281     pub const Unauthenticated: Self = Self(0i32);
 282     pub const Authenticated: Self = Self(1i32);
 283     pub const Extended: Self = Self(2i32);
 284 }
 285 impl ::core::marker::Copy for MagneticStripeReaderStatus {}
 286 impl ::core::clone::Clone for MagneticStripeReaderStatus {
 287     fn clone(&self) -> Self {
 288         *self
 289     }
 290 }
 291 pub type MagneticStripeReaderStatusUpdatedEventArgs = *mut ::core::ffi::c_void;
 292 pub type MagneticStripeReaderTrackData = *mut ::core::ffi::c_void;
 293 #[doc = "*Required features: 'Devices_PointOfService'*"]
 294 #[repr(transparent)]
 295 pub struct MagneticStripeReaderTrackErrorType(pub i32);
 296 impl MagneticStripeReaderTrackErrorType {
 297     pub const None: Self = Self(0i32);
 298     pub const StartSentinelError: Self = Self(1i32);
 299     pub const EndSentinelError: Self = Self(2i32);
 300     pub const ParityError: Self = Self(3i32);
 301     pub const LrcError: Self = Self(4i32);
 302     pub const Unknown: Self = Self(-1i32);
 303 }
 304 impl ::core::marker::Copy for MagneticStripeReaderTrackErrorType {}
 305 impl ::core::clone::Clone for MagneticStripeReaderTrackErrorType {
 306     fn clone(&self) -> Self {
 307         *self
 308     }
 309 }
 310 #[doc = "*Required features: 'Devices_PointOfService'*"]
 311 #[repr(transparent)]
 312 pub struct MagneticStripeReaderTrackIds(pub i32);
 313 impl MagneticStripeReaderTrackIds {
 314     pub const None: Self = Self(0i32);
 315     pub const Track1: Self = Self(1i32);
 316     pub const Track2: Self = Self(2i32);
 317     pub const Track3: Self = Self(4i32);
 318     pub const Track4: Self = Self(8i32);
 319 }
 320 impl ::core::marker::Copy for MagneticStripeReaderTrackIds {}
 321 impl ::core::clone::Clone for MagneticStripeReaderTrackIds {
 322     fn clone(&self) -> Self {
 323         *self
 324     }
 325 }
 326 pub type MagneticStripeReaderVendorSpecificCardDataReceivedEventArgs = *mut ::core::ffi::c_void;
 327 #[doc = "*Required features: 'Devices_PointOfService'*"]
 328 #[repr(transparent)]
 329 pub struct PosConnectionTypes(pub u32);
 330 impl PosConnectionTypes {
 331     pub const Local: Self = Self(1u32);
 332     pub const IP: Self = Self(2u32);
 333     pub const Bluetooth: Self = Self(4u32);
 334     pub const All: Self = Self(4294967295u32);
 335 }
 336 impl ::core::marker::Copy for PosConnectionTypes {}
 337 impl ::core::clone::Clone for PosConnectionTypes {
 338     fn clone(&self) -> Self {
 339         *self
 340     }
 341 }
 342 pub type PosPrinter = *mut ::core::ffi::c_void;
 343 #[doc = "*Required features: 'Devices_PointOfService'*"]
 344 #[repr(transparent)]
 345 pub struct PosPrinterAlignment(pub i32);
 346 impl PosPrinterAlignment {
 347     pub const Left: Self = Self(0i32);
 348     pub const Center: Self = Self(1i32);
 349     pub const Right: Self = Self(2i32);
 350 }
 351 impl ::core::marker::Copy for PosPrinterAlignment {}
 352 impl ::core::clone::Clone for PosPrinterAlignment {
 353     fn clone(&self) -> Self {
 354         *self
 355     }
 356 }
 357 #[doc = "*Required features: 'Devices_PointOfService'*"]
 358 #[repr(transparent)]
 359 pub struct PosPrinterBarcodeTextPosition(pub i32);
 360 impl PosPrinterBarcodeTextPosition {
 361     pub const None: Self = Self(0i32);
 362     pub const Above: Self = Self(1i32);
 363     pub const Below: Self = Self(2i32);
 364 }
 365 impl ::core::marker::Copy for PosPrinterBarcodeTextPosition {}
 366 impl ::core::clone::Clone for PosPrinterBarcodeTextPosition {
 367     fn clone(&self) -> Self {
 368         *self
 369     }
 370 }
 371 pub type PosPrinterCapabilities = *mut ::core::ffi::c_void;
 372 #[doc = "*Required features: 'Devices_PointOfService'*"]
 373 #[repr(transparent)]
 374 pub struct PosPrinterCartridgeSensors(pub u32);
 375 impl PosPrinterCartridgeSensors {
 376     pub const None: Self = Self(0u32);
 377     pub const Removed: Self = Self(1u32);
 378     pub const Empty: Self = Self(2u32);
 379     pub const HeadCleaning: Self = Self(4u32);
 380     pub const NearEnd: Self = Self(8u32);
 381 }
 382 impl ::core::marker::Copy for PosPrinterCartridgeSensors {}
 383 impl ::core::clone::Clone for PosPrinterCartridgeSensors {
 384     fn clone(&self) -> Self {
 385         *self
 386     }
 387 }
 388 #[doc = "*Required features: 'Devices_PointOfService'*"]
 389 #[repr(transparent)]
 390 pub struct PosPrinterColorCapabilities(pub u32);
 391 impl PosPrinterColorCapabilities {
 392     pub const None: Self = Self(0u32);
 393     pub const Primary: Self = Self(1u32);
 394     pub const Custom1: Self = Self(2u32);
 395     pub const Custom2: Self = Self(4u32);
 396     pub const Custom3: Self = Self(8u32);
 397     pub const Custom4: Self = Self(16u32);
 398     pub const Custom5: Self = Self(32u32);
 399     pub const Custom6: Self = Self(64u32);
 400     pub const Cyan: Self = Self(128u32);
 401     pub const Magenta: Self = Self(256u32);
 402     pub const Yellow: Self = Self(512u32);
 403     pub const Full: Self = Self(1024u32);
 404 }
 405 impl ::core::marker::Copy for PosPrinterColorCapabilities {}
 406 impl ::core::clone::Clone for PosPrinterColorCapabilities {
 407     fn clone(&self) -> Self {
 408         *self
 409     }
 410 }
 411 #[doc = "*Required features: 'Devices_PointOfService'*"]
 412 #[repr(transparent)]
 413 pub struct PosPrinterColorCartridge(pub i32);
 414 impl PosPrinterColorCartridge {
 415     pub const Unknown: Self = Self(0i32);
 416     pub const Primary: Self = Self(1i32);
 417     pub const Custom1: Self = Self(2i32);
 418     pub const Custom2: Self = Self(3i32);
 419     pub const Custom3: Self = Self(4i32);
 420     pub const Custom4: Self = Self(5i32);
 421     pub const Custom5: Self = Self(6i32);
 422     pub const Custom6: Self = Self(7i32);
 423     pub const Cyan: Self = Self(8i32);
 424     pub const Magenta: Self = Self(9i32);
 425     pub const Yellow: Self = Self(10i32);
 426 }
 427 impl ::core::marker::Copy for PosPrinterColorCartridge {}
 428 impl ::core::clone::Clone for PosPrinterColorCartridge {
 429     fn clone(&self) -> Self {
 430         *self
 431     }
 432 }
 433 pub type PosPrinterFontProperty = *mut ::core::ffi::c_void;
 434 #[doc = "*Required features: 'Devices_PointOfService'*"]
 435 #[repr(transparent)]
 436 pub struct PosPrinterLineDirection(pub i32);
 437 impl PosPrinterLineDirection {
 438     pub const Horizontal: Self = Self(0i32);
 439     pub const Vertical: Self = Self(1i32);
 440 }
 441 impl ::core::marker::Copy for PosPrinterLineDirection {}
 442 impl ::core::clone::Clone for PosPrinterLineDirection {
 443     fn clone(&self) -> Self {
 444         *self
 445     }
 446 }
 447 #[doc = "*Required features: 'Devices_PointOfService'*"]
 448 #[repr(transparent)]
 449 pub struct PosPrinterLineStyle(pub i32);
 450 impl PosPrinterLineStyle {
 451     pub const SingleSolid: Self = Self(0i32);
 452     pub const DoubleSolid: Self = Self(1i32);
 453     pub const Broken: Self = Self(2i32);
 454     pub const Chain: Self = Self(3i32);
 455 }
 456 impl ::core::marker::Copy for PosPrinterLineStyle {}
 457 impl ::core::clone::Clone for PosPrinterLineStyle {
 458     fn clone(&self) -> Self {
 459         *self
 460     }
 461 }
 462 #[doc = "*Required features: 'Devices_PointOfService'*"]
 463 #[repr(transparent)]
 464 pub struct PosPrinterMapMode(pub i32);
 465 impl PosPrinterMapMode {
 466     pub const Dots: Self = Self(0i32);
 467     pub const Twips: Self = Self(1i32);
 468     pub const English: Self = Self(2i32);
 469     pub const Metric: Self = Self(3i32);
 470 }
 471 impl ::core::marker::Copy for PosPrinterMapMode {}
 472 impl ::core::clone::Clone for PosPrinterMapMode {
 473     fn clone(&self) -> Self {
 474         *self
 475     }
 476 }
 477 #[doc = "*Required features: 'Devices_PointOfService'*"]
 478 #[repr(transparent)]
 479 pub struct PosPrinterMarkFeedCapabilities(pub u32);
 480 impl PosPrinterMarkFeedCapabilities {
 481     pub const None: Self = Self(0u32);
 482     pub const ToTakeUp: Self = Self(1u32);
 483     pub const ToCutter: Self = Self(2u32);
 484     pub const ToCurrentTopOfForm: Self = Self(4u32);
 485     pub const ToNextTopOfForm: Self = Self(8u32);
 486 }
 487 impl ::core::marker::Copy for PosPrinterMarkFeedCapabilities {}
 488 impl ::core::clone::Clone for PosPrinterMarkFeedCapabilities {
 489     fn clone(&self) -> Self {
 490         *self
 491     }
 492 }
 493 #[doc = "*Required features: 'Devices_PointOfService'*"]
 494 #[repr(transparent)]
 495 pub struct PosPrinterMarkFeedKind(pub i32);
 496 impl PosPrinterMarkFeedKind {
 497     pub const ToTakeUp: Self = Self(0i32);
 498     pub const ToCutter: Self = Self(1i32);
 499     pub const ToCurrentTopOfForm: Self = Self(2i32);
 500     pub const ToNextTopOfForm: Self = Self(3i32);
 501 }
 502 impl ::core::marker::Copy for PosPrinterMarkFeedKind {}
 503 impl ::core::clone::Clone for PosPrinterMarkFeedKind {
 504     fn clone(&self) -> Self {
 505         *self
 506     }
 507 }
 508 pub type PosPrinterPrintOptions = *mut ::core::ffi::c_void;
 509 #[doc = "*Required features: 'Devices_PointOfService'*"]
 510 #[repr(transparent)]
 511 pub struct PosPrinterPrintSide(pub i32);
 512 impl PosPrinterPrintSide {
 513     pub const Unknown: Self = Self(0i32);
 514     pub const Side1: Self = Self(1i32);
 515     pub const Side2: Self = Self(2i32);
 516 }
 517 impl ::core::marker::Copy for PosPrinterPrintSide {}
 518 impl ::core::clone::Clone for PosPrinterPrintSide {
 519     fn clone(&self) -> Self {
 520         *self
 521     }
 522 }
 523 pub type PosPrinterReleaseDeviceRequestedEventArgs = *mut ::core::ffi::c_void;
 524 #[doc = "*Required features: 'Devices_PointOfService'*"]
 525 #[repr(transparent)]
 526 pub struct PosPrinterRotation(pub i32);
 527 impl PosPrinterRotation {
 528     pub const Normal: Self = Self(0i32);
 529     pub const Right90: Self = Self(1i32);
 530     pub const Left90: Self = Self(2i32);
 531     pub const Rotate180: Self = Self(3i32);
 532 }
 533 impl ::core::marker::Copy for PosPrinterRotation {}
 534 impl ::core::clone::Clone for PosPrinterRotation {
 535     fn clone(&self) -> Self {
 536         *self
 537     }
 538 }
 539 #[doc = "*Required features: 'Devices_PointOfService'*"]
 540 #[repr(transparent)]
 541 pub struct PosPrinterRuledLineCapabilities(pub u32);
 542 impl PosPrinterRuledLineCapabilities {
 543     pub const None: Self = Self(0u32);
 544     pub const Horizontal: Self = Self(1u32);
 545     pub const Vertical: Self = Self(2u32);
 546 }
 547 impl ::core::marker::Copy for PosPrinterRuledLineCapabilities {}
 548 impl ::core::clone::Clone for PosPrinterRuledLineCapabilities {
 549     fn clone(&self) -> Self {
 550         *self
 551     }
 552 }
 553 pub type PosPrinterStatus = *mut ::core::ffi::c_void;
 554 #[doc = "*Required features: 'Devices_PointOfService'*"]
 555 #[repr(transparent)]
 556 pub struct PosPrinterStatusKind(pub i32);
 557 impl PosPrinterStatusKind {
 558     pub const Online: Self = Self(0i32);
 559     pub const Off: Self = Self(1i32);
 560     pub const Offline: Self = Self(2i32);
 561     pub const OffOrOffline: Self = Self(3i32);
 562     pub const Extended: Self = Self(4i32);
 563 }
 564 impl ::core::marker::Copy for PosPrinterStatusKind {}
 565 impl ::core::clone::Clone for PosPrinterStatusKind {
 566     fn clone(&self) -> Self {
 567         *self
 568     }
 569 }
 570 pub type PosPrinterStatusUpdatedEventArgs = *mut ::core::ffi::c_void;
 571 pub type ReceiptPrintJob = *mut ::core::ffi::c_void;
 572 pub type ReceiptPrinterCapabilities = *mut ::core::ffi::c_void;
 573 #[repr(C)]
 574 #[doc = "*Required features: 'Devices_PointOfService'*"]
 575 pub struct SizeUInt32 {
 576     pub Width: u32,
 577     pub Height: u32,
 578 }
 579 impl ::core::marker::Copy for SizeUInt32 {}
 580 impl ::core::clone::Clone for SizeUInt32 {
 581     fn clone(&self) -> Self {
 582         *self
 583     }
 584 }
 585 pub type SlipPrintJob = *mut ::core::ffi::c_void;
 586 pub type SlipPrinterCapabilities = *mut ::core::ffi::c_void;
 587 pub type UnifiedPosErrorData = *mut ::core::ffi::c_void;
 588 #[doc = "*Required features: 'Devices_PointOfService'*"]
 589 #[repr(transparent)]
 590 pub struct UnifiedPosErrorReason(pub i32);
 591 impl UnifiedPosErrorReason {
 592     pub const UnknownErrorReason: Self = Self(0i32);
 593     pub const NoService: Self = Self(1i32);
 594     pub const Disabled: Self = Self(2i32);
 595     pub const Illegal: Self = Self(3i32);
 596     pub const NoHardware: Self = Self(4i32);
 597     pub const Closed: Self = Self(5i32);
 598     pub const Offline: Self = Self(6i32);
 599     pub const Failure: Self = Self(7i32);
 600     pub const Timeout: Self = Self(8i32);
 601     pub const Busy: Self = Self(9i32);
 602     pub const Extended: Self = Self(10i32);
 603 }
 604 impl ::core::marker::Copy for UnifiedPosErrorReason {}
 605 impl ::core::clone::Clone for UnifiedPosErrorReason {
 606     fn clone(&self) -> Self {
 607         *self
 608     }
 609 }
 610 #[doc = "*Required features: 'Devices_PointOfService'*"]
 611 #[repr(transparent)]
 612 pub struct UnifiedPosErrorSeverity(pub i32);
 613 impl UnifiedPosErrorSeverity {
 614     pub const UnknownErrorSeverity: Self = Self(0i32);
 615     pub const Warning: Self = Self(1i32);
 616     pub const Recoverable: Self = Self(2i32);
 617     pub const Unrecoverable: Self = Self(3i32);
 618     pub const AssistanceRequired: Self = Self(4i32);
 619     pub const Fatal: Self = Self(5i32);
 620 }
 621 impl ::core::marker::Copy for UnifiedPosErrorSeverity {}
 622 impl ::core::clone::Clone for UnifiedPosErrorSeverity {
 623     fn clone(&self) -> Self {
 624         *self
 625     }
 626 }
 627 #[doc = "*Required features: 'Devices_PointOfService'*"]
 628 #[repr(transparent)]
 629 pub struct UnifiedPosHealthCheckLevel(pub i32);
 630 impl UnifiedPosHealthCheckLevel {
 631     pub const UnknownHealthCheckLevel: Self = Self(0i32);
 632     pub const POSInternal: Self = Self(1i32);
 633     pub const External: Self = Self(2i32);
 634     pub const Interactive: Self = Self(3i32);
 635 }
 636 impl ::core::marker::Copy for UnifiedPosHealthCheckLevel {}
 637 impl ::core::clone::Clone for UnifiedPosHealthCheckLevel {
 638     fn clone(&self) -> Self {
 639         *self
 640     }
 641 }
 642 #[doc = "*Required features: 'Devices_PointOfService'*"]
 643 #[repr(transparent)]
 644 pub struct UnifiedPosPowerReportingType(pub i32);
 645 impl UnifiedPosPowerReportingType {
 646     pub const UnknownPowerReportingType: Self = Self(0i32);
 647     pub const Standard: Self = Self(1i32);
 648     pub const Advanced: Self = Self(2i32);
 649 }
 650 impl ::core::marker::Copy for UnifiedPosPowerReportingType {}
 651 impl ::core::clone::Clone for UnifiedPosPowerReportingType {
 652     fn clone(&self) -> Self {
 653         *self
 654     }
 655 }