gpg-error 0.6.2

Libgpg-error bindings for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608

impl Error{
pub const SOURCE_UNKNOWN: ErrorSource = ffi::GPG_ERR_SOURCE_UNKNOWN;
pub const SOURCE_GCRYPT: ErrorSource = ffi::GPG_ERR_SOURCE_GCRYPT;
pub const SOURCE_GPG: ErrorSource = ffi::GPG_ERR_SOURCE_GPG;
pub const SOURCE_GPGSM: ErrorSource = ffi::GPG_ERR_SOURCE_GPGSM;
pub const SOURCE_GPGAGENT: ErrorSource = ffi::GPG_ERR_SOURCE_GPGAGENT;
pub const SOURCE_PINENTRY: ErrorSource = ffi::GPG_ERR_SOURCE_PINENTRY;
pub const SOURCE_SCD: ErrorSource = ffi::GPG_ERR_SOURCE_SCD;
pub const SOURCE_GPGME: ErrorSource = ffi::GPG_ERR_SOURCE_GPGME;
pub const SOURCE_KEYBOX: ErrorSource = ffi::GPG_ERR_SOURCE_KEYBOX;
pub const SOURCE_KSBA: ErrorSource = ffi::GPG_ERR_SOURCE_KSBA;
pub const SOURCE_DIRMNGR: ErrorSource = ffi::GPG_ERR_SOURCE_DIRMNGR;
pub const SOURCE_GSTI: ErrorSource = ffi::GPG_ERR_SOURCE_GSTI;
pub const SOURCE_GPA: ErrorSource = ffi::GPG_ERR_SOURCE_GPA;
pub const SOURCE_KLEO: ErrorSource = ffi::GPG_ERR_SOURCE_KLEO;
pub const SOURCE_G13: ErrorSource = ffi::GPG_ERR_SOURCE_G13;
pub const SOURCE_ASSUAN: ErrorSource = ffi::GPG_ERR_SOURCE_ASSUAN;
pub const SOURCE_TPM2D: ErrorSource = ffi::GPG_ERR_SOURCE_TPM2D;
pub const SOURCE_TLS: ErrorSource = ffi::GPG_ERR_SOURCE_TLS;
pub const SOURCE_TKD: ErrorSource = ffi::GPG_ERR_SOURCE_TKD;
pub const SOURCE_ANY: ErrorSource = ffi::GPG_ERR_SOURCE_ANY;
pub const SOURCE_USER_1: ErrorSource = ffi::GPG_ERR_SOURCE_USER_1;
pub const SOURCE_USER_2: ErrorSource = ffi::GPG_ERR_SOURCE_USER_2;
pub const SOURCE_USER_3: ErrorSource = ffi::GPG_ERR_SOURCE_USER_3;
pub const SOURCE_USER_4: ErrorSource = ffi::GPG_ERR_SOURCE_USER_4;
pub const NO_ERROR: Self = Self(ffi::GPG_ERR_NO_ERROR);
pub const GENERAL: Self = Self(ffi::GPG_ERR_GENERAL);
pub const UNKNOWN_PACKET: Self = Self(ffi::GPG_ERR_UNKNOWN_PACKET);
pub const UNKNOWN_VERSION: Self = Self(ffi::GPG_ERR_UNKNOWN_VERSION);
pub const PUBKEY_ALGO: Self = Self(ffi::GPG_ERR_PUBKEY_ALGO);
pub const DIGEST_ALGO: Self = Self(ffi::GPG_ERR_DIGEST_ALGO);
pub const BAD_PUBKEY: Self = Self(ffi::GPG_ERR_BAD_PUBKEY);
pub const BAD_SECKEY: Self = Self(ffi::GPG_ERR_BAD_SECKEY);
pub const BAD_SIGNATURE: Self = Self(ffi::GPG_ERR_BAD_SIGNATURE);
pub const NO_PUBKEY: Self = Self(ffi::GPG_ERR_NO_PUBKEY);
pub const CHECKSUM: Self = Self(ffi::GPG_ERR_CHECKSUM);
pub const BAD_PASSPHRASE: Self = Self(ffi::GPG_ERR_BAD_PASSPHRASE);
pub const CIPHER_ALGO: Self = Self(ffi::GPG_ERR_CIPHER_ALGO);
pub const KEYRING_OPEN: Self = Self(ffi::GPG_ERR_KEYRING_OPEN);
pub const INV_PACKET: Self = Self(ffi::GPG_ERR_INV_PACKET);
pub const INV_ARMOR: Self = Self(ffi::GPG_ERR_INV_ARMOR);
pub const NO_USER_ID: Self = Self(ffi::GPG_ERR_NO_USER_ID);
pub const NO_SECKEY: Self = Self(ffi::GPG_ERR_NO_SECKEY);
pub const WRONG_SECKEY: Self = Self(ffi::GPG_ERR_WRONG_SECKEY);
pub const BAD_KEY: Self = Self(ffi::GPG_ERR_BAD_KEY);
pub const COMPR_ALGO: Self = Self(ffi::GPG_ERR_COMPR_ALGO);
pub const NO_PRIME: Self = Self(ffi::GPG_ERR_NO_PRIME);
pub const NO_ENCODING_METHOD: Self = Self(ffi::GPG_ERR_NO_ENCODING_METHOD);
pub const NO_ENCRYPTION_SCHEME: Self = Self(ffi::GPG_ERR_NO_ENCRYPTION_SCHEME);
pub const NO_SIGNATURE_SCHEME: Self = Self(ffi::GPG_ERR_NO_SIGNATURE_SCHEME);
pub const INV_ATTR: Self = Self(ffi::GPG_ERR_INV_ATTR);
pub const NO_VALUE: Self = Self(ffi::GPG_ERR_NO_VALUE);
pub const NOT_FOUND: Self = Self(ffi::GPG_ERR_NOT_FOUND);
pub const VALUE_NOT_FOUND: Self = Self(ffi::GPG_ERR_VALUE_NOT_FOUND);
pub const SYNTAX: Self = Self(ffi::GPG_ERR_SYNTAX);
pub const BAD_MPI: Self = Self(ffi::GPG_ERR_BAD_MPI);
pub const INV_PASSPHRASE: Self = Self(ffi::GPG_ERR_INV_PASSPHRASE);
pub const SIG_CLASS: Self = Self(ffi::GPG_ERR_SIG_CLASS);
pub const RESOURCE_LIMIT: Self = Self(ffi::GPG_ERR_RESOURCE_LIMIT);
pub const INV_KEYRING: Self = Self(ffi::GPG_ERR_INV_KEYRING);
pub const TRUSTDB: Self = Self(ffi::GPG_ERR_TRUSTDB);
pub const BAD_CERT: Self = Self(ffi::GPG_ERR_BAD_CERT);
pub const INV_USER_ID: Self = Self(ffi::GPG_ERR_INV_USER_ID);
pub const UNEXPECTED: Self = Self(ffi::GPG_ERR_UNEXPECTED);
pub const TIME_CONFLICT: Self = Self(ffi::GPG_ERR_TIME_CONFLICT);
pub const KEYSERVER: Self = Self(ffi::GPG_ERR_KEYSERVER);
pub const WRONG_PUBKEY_ALGO: Self = Self(ffi::GPG_ERR_WRONG_PUBKEY_ALGO);
pub const TRIBUTE_TO_D_A: Self = Self(ffi::GPG_ERR_TRIBUTE_TO_D_A);
pub const WEAK_KEY: Self = Self(ffi::GPG_ERR_WEAK_KEY);
pub const INV_KEYLEN: Self = Self(ffi::GPG_ERR_INV_KEYLEN);
pub const INV_ARG: Self = Self(ffi::GPG_ERR_INV_ARG);
pub const BAD_URI: Self = Self(ffi::GPG_ERR_BAD_URI);
pub const INV_URI: Self = Self(ffi::GPG_ERR_INV_URI);
pub const NETWORK: Self = Self(ffi::GPG_ERR_NETWORK);
pub const UNKNOWN_HOST: Self = Self(ffi::GPG_ERR_UNKNOWN_HOST);
pub const SELFTEST_FAILED: Self = Self(ffi::GPG_ERR_SELFTEST_FAILED);
pub const NOT_ENCRYPTED: Self = Self(ffi::GPG_ERR_NOT_ENCRYPTED);
pub const NOT_PROCESSED: Self = Self(ffi::GPG_ERR_NOT_PROCESSED);
pub const UNUSABLE_PUBKEY: Self = Self(ffi::GPG_ERR_UNUSABLE_PUBKEY);
pub const UNUSABLE_SECKEY: Self = Self(ffi::GPG_ERR_UNUSABLE_SECKEY);
pub const INV_VALUE: Self = Self(ffi::GPG_ERR_INV_VALUE);
pub const BAD_CERT_CHAIN: Self = Self(ffi::GPG_ERR_BAD_CERT_CHAIN);
pub const MISSING_CERT: Self = Self(ffi::GPG_ERR_MISSING_CERT);
pub const NO_DATA: Self = Self(ffi::GPG_ERR_NO_DATA);
pub const BUG: Self = Self(ffi::GPG_ERR_BUG);
pub const NOT_SUPPORTED: Self = Self(ffi::GPG_ERR_NOT_SUPPORTED);
pub const INV_OP: Self = Self(ffi::GPG_ERR_INV_OP);
pub const TIMEOUT: Self = Self(ffi::GPG_ERR_TIMEOUT);
pub const INTERNAL: Self = Self(ffi::GPG_ERR_INTERNAL);
pub const EOF_GCRYPT: Self = Self(ffi::GPG_ERR_EOF_GCRYPT);
pub const INV_OBJ: Self = Self(ffi::GPG_ERR_INV_OBJ);
pub const TOO_SHORT: Self = Self(ffi::GPG_ERR_TOO_SHORT);
pub const TOO_LARGE: Self = Self(ffi::GPG_ERR_TOO_LARGE);
pub const NO_OBJ: Self = Self(ffi::GPG_ERR_NO_OBJ);
pub const NOT_IMPLEMENTED: Self = Self(ffi::GPG_ERR_NOT_IMPLEMENTED);
pub const CONFLICT: Self = Self(ffi::GPG_ERR_CONFLICT);
pub const INV_CIPHER_MODE: Self = Self(ffi::GPG_ERR_INV_CIPHER_MODE);
pub const INV_FLAG: Self = Self(ffi::GPG_ERR_INV_FLAG);
pub const INV_HANDLE: Self = Self(ffi::GPG_ERR_INV_HANDLE);
pub const TRUNCATED: Self = Self(ffi::GPG_ERR_TRUNCATED);
pub const INCOMPLETE_LINE: Self = Self(ffi::GPG_ERR_INCOMPLETE_LINE);
pub const INV_RESPONSE: Self = Self(ffi::GPG_ERR_INV_RESPONSE);
pub const NO_AGENT: Self = Self(ffi::GPG_ERR_NO_AGENT);
pub const AGENT: Self = Self(ffi::GPG_ERR_AGENT);
pub const INV_DATA: Self = Self(ffi::GPG_ERR_INV_DATA);
pub const ASSUAN_SERVER_FAULT: Self = Self(ffi::GPG_ERR_ASSUAN_SERVER_FAULT);
pub const ASSUAN: Self = Self(ffi::GPG_ERR_ASSUAN);
pub const INV_SESSION_KEY: Self = Self(ffi::GPG_ERR_INV_SESSION_KEY);
pub const INV_SEXP: Self = Self(ffi::GPG_ERR_INV_SEXP);
pub const UNSUPPORTED_ALGORITHM: Self = Self(ffi::GPG_ERR_UNSUPPORTED_ALGORITHM);
pub const NO_PIN_ENTRY: Self = Self(ffi::GPG_ERR_NO_PIN_ENTRY);
pub const PIN_ENTRY: Self = Self(ffi::GPG_ERR_PIN_ENTRY);
pub const BAD_PIN: Self = Self(ffi::GPG_ERR_BAD_PIN);
pub const INV_NAME: Self = Self(ffi::GPG_ERR_INV_NAME);
pub const BAD_DATA: Self = Self(ffi::GPG_ERR_BAD_DATA);
pub const INV_PARAMETER: Self = Self(ffi::GPG_ERR_INV_PARAMETER);
pub const WRONG_CARD: Self = Self(ffi::GPG_ERR_WRONG_CARD);
pub const NO_DIRMNGR: Self = Self(ffi::GPG_ERR_NO_DIRMNGR);
pub const DIRMNGR: Self = Self(ffi::GPG_ERR_DIRMNGR);
pub const CERT_REVOKED: Self = Self(ffi::GPG_ERR_CERT_REVOKED);
pub const NO_CRL_KNOWN: Self = Self(ffi::GPG_ERR_NO_CRL_KNOWN);
pub const CRL_TOO_OLD: Self = Self(ffi::GPG_ERR_CRL_TOO_OLD);
pub const LINE_TOO_LONG: Self = Self(ffi::GPG_ERR_LINE_TOO_LONG);
pub const NOT_TRUSTED: Self = Self(ffi::GPG_ERR_NOT_TRUSTED);
pub const CANCELED: Self = Self(ffi::GPG_ERR_CANCELED);
pub const BAD_CA_CERT: Self = Self(ffi::GPG_ERR_BAD_CA_CERT);
pub const CERT_EXPIRED: Self = Self(ffi::GPG_ERR_CERT_EXPIRED);
pub const CERT_TOO_YOUNG: Self = Self(ffi::GPG_ERR_CERT_TOO_YOUNG);
pub const UNSUPPORTED_CERT: Self = Self(ffi::GPG_ERR_UNSUPPORTED_CERT);
pub const UNKNOWN_SEXP: Self = Self(ffi::GPG_ERR_UNKNOWN_SEXP);
pub const UNSUPPORTED_PROTECTION: Self = Self(ffi::GPG_ERR_UNSUPPORTED_PROTECTION);
pub const CORRUPTED_PROTECTION: Self = Self(ffi::GPG_ERR_CORRUPTED_PROTECTION);
pub const AMBIGUOUS_NAME: Self = Self(ffi::GPG_ERR_AMBIGUOUS_NAME);
pub const CARD: Self = Self(ffi::GPG_ERR_CARD);
pub const CARD_RESET: Self = Self(ffi::GPG_ERR_CARD_RESET);
pub const CARD_REMOVED: Self = Self(ffi::GPG_ERR_CARD_REMOVED);
pub const INV_CARD: Self = Self(ffi::GPG_ERR_INV_CARD);
pub const CARD_NOT_PRESENT: Self = Self(ffi::GPG_ERR_CARD_NOT_PRESENT);
pub const NO_PKCS15_APP: Self = Self(ffi::GPG_ERR_NO_PKCS15_APP);
pub const NOT_CONFIRMED: Self = Self(ffi::GPG_ERR_NOT_CONFIRMED);
pub const CONFIGURATION: Self = Self(ffi::GPG_ERR_CONFIGURATION);
pub const NO_POLICY_MATCH: Self = Self(ffi::GPG_ERR_NO_POLICY_MATCH);
pub const INV_INDEX: Self = Self(ffi::GPG_ERR_INV_INDEX);
pub const INV_ID: Self = Self(ffi::GPG_ERR_INV_ID);
pub const NO_SCDAEMON: Self = Self(ffi::GPG_ERR_NO_SCDAEMON);
pub const SCDAEMON: Self = Self(ffi::GPG_ERR_SCDAEMON);
pub const UNSUPPORTED_PROTOCOL: Self = Self(ffi::GPG_ERR_UNSUPPORTED_PROTOCOL);
pub const BAD_PIN_METHOD: Self = Self(ffi::GPG_ERR_BAD_PIN_METHOD);
pub const CARD_NOT_INITIALIZED: Self = Self(ffi::GPG_ERR_CARD_NOT_INITIALIZED);
pub const UNSUPPORTED_OPERATION: Self = Self(ffi::GPG_ERR_UNSUPPORTED_OPERATION);
pub const WRONG_KEY_USAGE: Self = Self(ffi::GPG_ERR_WRONG_KEY_USAGE);
pub const NOTHING_FOUND: Self = Self(ffi::GPG_ERR_NOTHING_FOUND);
pub const WRONG_BLOB_TYPE: Self = Self(ffi::GPG_ERR_WRONG_BLOB_TYPE);
pub const MISSING_VALUE: Self = Self(ffi::GPG_ERR_MISSING_VALUE);
pub const HARDWARE: Self = Self(ffi::GPG_ERR_HARDWARE);
pub const PIN_BLOCKED: Self = Self(ffi::GPG_ERR_PIN_BLOCKED);
pub const USE_CONDITIONS: Self = Self(ffi::GPG_ERR_USE_CONDITIONS);
pub const PIN_NOT_SYNCED: Self = Self(ffi::GPG_ERR_PIN_NOT_SYNCED);
pub const INV_CRL: Self = Self(ffi::GPG_ERR_INV_CRL);
pub const BAD_BER: Self = Self(ffi::GPG_ERR_BAD_BER);
pub const INV_BER: Self = Self(ffi::GPG_ERR_INV_BER);
pub const ELEMENT_NOT_FOUND: Self = Self(ffi::GPG_ERR_ELEMENT_NOT_FOUND);
pub const IDENTIFIER_NOT_FOUND: Self = Self(ffi::GPG_ERR_IDENTIFIER_NOT_FOUND);
pub const INV_TAG: Self = Self(ffi::GPG_ERR_INV_TAG);
pub const INV_LENGTH: Self = Self(ffi::GPG_ERR_INV_LENGTH);
pub const INV_KEYINFO: Self = Self(ffi::GPG_ERR_INV_KEYINFO);
pub const UNEXPECTED_TAG: Self = Self(ffi::GPG_ERR_UNEXPECTED_TAG);
pub const NOT_DER_ENCODED: Self = Self(ffi::GPG_ERR_NOT_DER_ENCODED);
pub const NO_CMS_OBJ: Self = Self(ffi::GPG_ERR_NO_CMS_OBJ);
pub const INV_CMS_OBJ: Self = Self(ffi::GPG_ERR_INV_CMS_OBJ);
pub const UNKNOWN_CMS_OBJ: Self = Self(ffi::GPG_ERR_UNKNOWN_CMS_OBJ);
pub const UNSUPPORTED_CMS_OBJ: Self = Self(ffi::GPG_ERR_UNSUPPORTED_CMS_OBJ);
pub const UNSUPPORTED_ENCODING: Self = Self(ffi::GPG_ERR_UNSUPPORTED_ENCODING);
pub const UNSUPPORTED_CMS_VERSION: Self = Self(ffi::GPG_ERR_UNSUPPORTED_CMS_VERSION);
pub const UNKNOWN_ALGORITHM: Self = Self(ffi::GPG_ERR_UNKNOWN_ALGORITHM);
pub const INV_ENGINE: Self = Self(ffi::GPG_ERR_INV_ENGINE);
pub const PUBKEY_NOT_TRUSTED: Self = Self(ffi::GPG_ERR_PUBKEY_NOT_TRUSTED);
pub const DECRYPT_FAILED: Self = Self(ffi::GPG_ERR_DECRYPT_FAILED);
pub const KEY_EXPIRED: Self = Self(ffi::GPG_ERR_KEY_EXPIRED);
pub const SIG_EXPIRED: Self = Self(ffi::GPG_ERR_SIG_EXPIRED);
pub const ENCODING_PROBLEM: Self = Self(ffi::GPG_ERR_ENCODING_PROBLEM);
pub const INV_STATE: Self = Self(ffi::GPG_ERR_INV_STATE);
pub const DUP_VALUE: Self = Self(ffi::GPG_ERR_DUP_VALUE);
pub const MISSING_ACTION: Self = Self(ffi::GPG_ERR_MISSING_ACTION);
pub const MODULE_NOT_FOUND: Self = Self(ffi::GPG_ERR_MODULE_NOT_FOUND);
pub const INV_OID_STRING: Self = Self(ffi::GPG_ERR_INV_OID_STRING);
pub const INV_TIME: Self = Self(ffi::GPG_ERR_INV_TIME);
pub const INV_CRL_OBJ: Self = Self(ffi::GPG_ERR_INV_CRL_OBJ);
pub const UNSUPPORTED_CRL_VERSION: Self = Self(ffi::GPG_ERR_UNSUPPORTED_CRL_VERSION);
pub const INV_CERT_OBJ: Self = Self(ffi::GPG_ERR_INV_CERT_OBJ);
pub const UNKNOWN_NAME: Self = Self(ffi::GPG_ERR_UNKNOWN_NAME);
pub const LOCALE_PROBLEM: Self = Self(ffi::GPG_ERR_LOCALE_PROBLEM);
pub const NOT_LOCKED: Self = Self(ffi::GPG_ERR_NOT_LOCKED);
pub const PROTOCOL_VIOLATION: Self = Self(ffi::GPG_ERR_PROTOCOL_VIOLATION);
pub const INV_MAC: Self = Self(ffi::GPG_ERR_INV_MAC);
pub const INV_REQUEST: Self = Self(ffi::GPG_ERR_INV_REQUEST);
pub const UNKNOWN_EXTN: Self = Self(ffi::GPG_ERR_UNKNOWN_EXTN);
pub const UNKNOWN_CRIT_EXTN: Self = Self(ffi::GPG_ERR_UNKNOWN_CRIT_EXTN);
pub const LOCKED: Self = Self(ffi::GPG_ERR_LOCKED);
pub const UNKNOWN_OPTION: Self = Self(ffi::GPG_ERR_UNKNOWN_OPTION);
pub const UNKNOWN_COMMAND: Self = Self(ffi::GPG_ERR_UNKNOWN_COMMAND);
pub const NOT_OPERATIONAL: Self = Self(ffi::GPG_ERR_NOT_OPERATIONAL);
pub const NO_PASSPHRASE: Self = Self(ffi::GPG_ERR_NO_PASSPHRASE);
pub const NO_PIN: Self = Self(ffi::GPG_ERR_NO_PIN);
pub const NOT_ENABLED: Self = Self(ffi::GPG_ERR_NOT_ENABLED);
pub const NO_ENGINE: Self = Self(ffi::GPG_ERR_NO_ENGINE);
pub const MISSING_KEY: Self = Self(ffi::GPG_ERR_MISSING_KEY);
pub const TOO_MANY: Self = Self(ffi::GPG_ERR_TOO_MANY);
pub const LIMIT_REACHED: Self = Self(ffi::GPG_ERR_LIMIT_REACHED);
pub const NOT_INITIALIZED: Self = Self(ffi::GPG_ERR_NOT_INITIALIZED);
pub const MISSING_ISSUER_CERT: Self = Self(ffi::GPG_ERR_MISSING_ISSUER_CERT);
pub const NO_KEYSERVER: Self = Self(ffi::GPG_ERR_NO_KEYSERVER);
pub const INV_CURVE: Self = Self(ffi::GPG_ERR_INV_CURVE);
pub const UNKNOWN_CURVE: Self = Self(ffi::GPG_ERR_UNKNOWN_CURVE);
pub const DUP_KEY: Self = Self(ffi::GPG_ERR_DUP_KEY);
pub const AMBIGUOUS: Self = Self(ffi::GPG_ERR_AMBIGUOUS);
pub const NO_CRYPT_CTX: Self = Self(ffi::GPG_ERR_NO_CRYPT_CTX);
pub const WRONG_CRYPT_CTX: Self = Self(ffi::GPG_ERR_WRONG_CRYPT_CTX);
pub const BAD_CRYPT_CTX: Self = Self(ffi::GPG_ERR_BAD_CRYPT_CTX);
pub const CRYPT_CTX_CONFLICT: Self = Self(ffi::GPG_ERR_CRYPT_CTX_CONFLICT);
pub const BROKEN_PUBKEY: Self = Self(ffi::GPG_ERR_BROKEN_PUBKEY);
pub const BROKEN_SECKEY: Self = Self(ffi::GPG_ERR_BROKEN_SECKEY);
pub const MAC_ALGO: Self = Self(ffi::GPG_ERR_MAC_ALGO);
pub const FULLY_CANCELED: Self = Self(ffi::GPG_ERR_FULLY_CANCELED);
pub const UNFINISHED: Self = Self(ffi::GPG_ERR_UNFINISHED);
pub const BUFFER_TOO_SHORT: Self = Self(ffi::GPG_ERR_BUFFER_TOO_SHORT);
pub const SEXP_INV_LEN_SPEC: Self = Self(ffi::GPG_ERR_SEXP_INV_LEN_SPEC);
pub const SEXP_STRING_TOO_LONG: Self = Self(ffi::GPG_ERR_SEXP_STRING_TOO_LONG);
pub const SEXP_UNMATCHED_PAREN: Self = Self(ffi::GPG_ERR_SEXP_UNMATCHED_PAREN);
pub const SEXP_NOT_CANONICAL: Self = Self(ffi::GPG_ERR_SEXP_NOT_CANONICAL);
pub const SEXP_BAD_CHARACTER: Self = Self(ffi::GPG_ERR_SEXP_BAD_CHARACTER);
pub const SEXP_BAD_QUOTATION: Self = Self(ffi::GPG_ERR_SEXP_BAD_QUOTATION);
pub const SEXP_ZERO_PREFIX: Self = Self(ffi::GPG_ERR_SEXP_ZERO_PREFIX);
pub const SEXP_NESTED_DH: Self = Self(ffi::GPG_ERR_SEXP_NESTED_DH);
pub const SEXP_UNMATCHED_DH: Self = Self(ffi::GPG_ERR_SEXP_UNMATCHED_DH);
pub const SEXP_UNEXPECTED_PUNC: Self = Self(ffi::GPG_ERR_SEXP_UNEXPECTED_PUNC);
pub const SEXP_BAD_HEX_CHAR: Self = Self(ffi::GPG_ERR_SEXP_BAD_HEX_CHAR);
pub const SEXP_ODD_HEX_NUMBERS: Self = Self(ffi::GPG_ERR_SEXP_ODD_HEX_NUMBERS);
pub const SEXP_BAD_OCT_CHAR: Self = Self(ffi::GPG_ERR_SEXP_BAD_OCT_CHAR);
pub const SUBKEYS_EXP_OR_REV: Self = Self(ffi::GPG_ERR_SUBKEYS_EXP_OR_REV);
pub const DB_CORRUPTED: Self = Self(ffi::GPG_ERR_DB_CORRUPTED);
pub const SERVER_FAILED: Self = Self(ffi::GPG_ERR_SERVER_FAILED);
pub const NO_NAME: Self = Self(ffi::GPG_ERR_NO_NAME);
pub const NO_KEY: Self = Self(ffi::GPG_ERR_NO_KEY);
pub const LEGACY_KEY: Self = Self(ffi::GPG_ERR_LEGACY_KEY);
pub const REQUEST_TOO_SHORT: Self = Self(ffi::GPG_ERR_REQUEST_TOO_SHORT);
pub const REQUEST_TOO_LONG: Self = Self(ffi::GPG_ERR_REQUEST_TOO_LONG);
pub const OBJ_TERM_STATE: Self = Self(ffi::GPG_ERR_OBJ_TERM_STATE);
pub const NO_CERT_CHAIN: Self = Self(ffi::GPG_ERR_NO_CERT_CHAIN);
pub const CERT_TOO_LARGE: Self = Self(ffi::GPG_ERR_CERT_TOO_LARGE);
pub const INV_RECORD: Self = Self(ffi::GPG_ERR_INV_RECORD);
pub const BAD_MAC: Self = Self(ffi::GPG_ERR_BAD_MAC);
pub const UNEXPECTED_MSG: Self = Self(ffi::GPG_ERR_UNEXPECTED_MSG);
pub const COMPR_FAILED: Self = Self(ffi::GPG_ERR_COMPR_FAILED);
pub const WOULD_WRAP: Self = Self(ffi::GPG_ERR_WOULD_WRAP);
pub const FATAL_ALERT: Self = Self(ffi::GPG_ERR_FATAL_ALERT);
pub const NO_CIPHER: Self = Self(ffi::GPG_ERR_NO_CIPHER);
pub const MISSING_CLIENT_CERT: Self = Self(ffi::GPG_ERR_MISSING_CLIENT_CERT);
pub const CLOSE_NOTIFY: Self = Self(ffi::GPG_ERR_CLOSE_NOTIFY);
pub const TICKET_EXPIRED: Self = Self(ffi::GPG_ERR_TICKET_EXPIRED);
pub const BAD_TICKET: Self = Self(ffi::GPG_ERR_BAD_TICKET);
pub const UNKNOWN_IDENTITY: Self = Self(ffi::GPG_ERR_UNKNOWN_IDENTITY);
pub const BAD_HS_CERT: Self = Self(ffi::GPG_ERR_BAD_HS_CERT);
pub const BAD_HS_CERT_REQ: Self = Self(ffi::GPG_ERR_BAD_HS_CERT_REQ);
pub const BAD_HS_CERT_VER: Self = Self(ffi::GPG_ERR_BAD_HS_CERT_VER);
pub const BAD_HS_CHANGE_CIPHER: Self = Self(ffi::GPG_ERR_BAD_HS_CHANGE_CIPHER);
pub const BAD_HS_CLIENT_HELLO: Self = Self(ffi::GPG_ERR_BAD_HS_CLIENT_HELLO);
pub const BAD_HS_SERVER_HELLO: Self = Self(ffi::GPG_ERR_BAD_HS_SERVER_HELLO);
pub const BAD_HS_SERVER_HELLO_DONE: Self = Self(ffi::GPG_ERR_BAD_HS_SERVER_HELLO_DONE);
pub const BAD_HS_FINISHED: Self = Self(ffi::GPG_ERR_BAD_HS_FINISHED);
pub const BAD_HS_SERVER_KEX: Self = Self(ffi::GPG_ERR_BAD_HS_SERVER_KEX);
pub const BAD_HS_CLIENT_KEX: Self = Self(ffi::GPG_ERR_BAD_HS_CLIENT_KEX);
pub const BOGUS_STRING: Self = Self(ffi::GPG_ERR_BOGUS_STRING);
pub const FORBIDDEN: Self = Self(ffi::GPG_ERR_FORBIDDEN);
pub const KEY_DISABLED: Self = Self(ffi::GPG_ERR_KEY_DISABLED);
pub const KEY_ON_CARD: Self = Self(ffi::GPG_ERR_KEY_ON_CARD);
pub const INV_LOCK_OBJ: Self = Self(ffi::GPG_ERR_INV_LOCK_OBJ);
pub const TRUE: Self = Self(ffi::GPG_ERR_TRUE);
pub const FALSE: Self = Self(ffi::GPG_ERR_FALSE);
pub const ASS_GENERAL: Self = Self(ffi::GPG_ERR_ASS_GENERAL);
pub const ASS_ACCEPT_FAILED: Self = Self(ffi::GPG_ERR_ASS_ACCEPT_FAILED);
pub const ASS_CONNECT_FAILED: Self = Self(ffi::GPG_ERR_ASS_CONNECT_FAILED);
pub const ASS_INV_RESPONSE: Self = Self(ffi::GPG_ERR_ASS_INV_RESPONSE);
pub const ASS_INV_VALUE: Self = Self(ffi::GPG_ERR_ASS_INV_VALUE);
pub const ASS_INCOMPLETE_LINE: Self = Self(ffi::GPG_ERR_ASS_INCOMPLETE_LINE);
pub const ASS_LINE_TOO_LONG: Self = Self(ffi::GPG_ERR_ASS_LINE_TOO_LONG);
pub const ASS_NESTED_COMMANDS: Self = Self(ffi::GPG_ERR_ASS_NESTED_COMMANDS);
pub const ASS_NO_DATA_CB: Self = Self(ffi::GPG_ERR_ASS_NO_DATA_CB);
pub const ASS_NO_INQUIRE_CB: Self = Self(ffi::GPG_ERR_ASS_NO_INQUIRE_CB);
pub const ASS_NOT_A_SERVER: Self = Self(ffi::GPG_ERR_ASS_NOT_A_SERVER);
pub const ASS_NOT_A_CLIENT: Self = Self(ffi::GPG_ERR_ASS_NOT_A_CLIENT);
pub const ASS_SERVER_START: Self = Self(ffi::GPG_ERR_ASS_SERVER_START);
pub const ASS_READ_ERROR: Self = Self(ffi::GPG_ERR_ASS_READ_ERROR);
pub const ASS_WRITE_ERROR: Self = Self(ffi::GPG_ERR_ASS_WRITE_ERROR);
pub const ASS_TOO_MUCH_DATA: Self = Self(ffi::GPG_ERR_ASS_TOO_MUCH_DATA);
pub const ASS_UNEXPECTED_CMD: Self = Self(ffi::GPG_ERR_ASS_UNEXPECTED_CMD);
pub const ASS_UNKNOWN_CMD: Self = Self(ffi::GPG_ERR_ASS_UNKNOWN_CMD);
pub const ASS_SYNTAX: Self = Self(ffi::GPG_ERR_ASS_SYNTAX);
pub const ASS_CANCELED: Self = Self(ffi::GPG_ERR_ASS_CANCELED);
pub const ASS_NO_INPUT: Self = Self(ffi::GPG_ERR_ASS_NO_INPUT);
pub const ASS_NO_OUTPUT: Self = Self(ffi::GPG_ERR_ASS_NO_OUTPUT);
pub const ASS_PARAMETER: Self = Self(ffi::GPG_ERR_ASS_PARAMETER);
pub const ASS_UNKNOWN_INQUIRE: Self = Self(ffi::GPG_ERR_ASS_UNKNOWN_INQUIRE);
pub const ENGINE_TOO_OLD: Self = Self(ffi::GPG_ERR_ENGINE_TOO_OLD);
pub const WINDOW_TOO_SMALL: Self = Self(ffi::GPG_ERR_WINDOW_TOO_SMALL);
pub const WINDOW_TOO_LARGE: Self = Self(ffi::GPG_ERR_WINDOW_TOO_LARGE);
pub const MISSING_ENVVAR: Self = Self(ffi::GPG_ERR_MISSING_ENVVAR);
pub const USER_ID_EXISTS: Self = Self(ffi::GPG_ERR_USER_ID_EXISTS);
pub const NAME_EXISTS: Self = Self(ffi::GPG_ERR_NAME_EXISTS);
pub const DUP_NAME: Self = Self(ffi::GPG_ERR_DUP_NAME);
pub const TOO_YOUNG: Self = Self(ffi::GPG_ERR_TOO_YOUNG);
pub const TOO_OLD: Self = Self(ffi::GPG_ERR_TOO_OLD);
pub const UNKNOWN_FLAG: Self = Self(ffi::GPG_ERR_UNKNOWN_FLAG);
pub const INV_ORDER: Self = Self(ffi::GPG_ERR_INV_ORDER);
pub const ALREADY_FETCHED: Self = Self(ffi::GPG_ERR_ALREADY_FETCHED);
pub const TRY_LATER: Self = Self(ffi::GPG_ERR_TRY_LATER);
pub const WRONG_NAME: Self = Self(ffi::GPG_ERR_WRONG_NAME);
pub const NO_AUTH: Self = Self(ffi::GPG_ERR_NO_AUTH);
pub const BAD_AUTH: Self = Self(ffi::GPG_ERR_BAD_AUTH);
pub const NO_KEYBOXD: Self = Self(ffi::GPG_ERR_NO_KEYBOXD);
pub const KEYBOXD: Self = Self(ffi::GPG_ERR_KEYBOXD);
pub const NO_SERVICE: Self = Self(ffi::GPG_ERR_NO_SERVICE);
pub const SERVICE: Self = Self(ffi::GPG_ERR_SERVICE);
pub const BAD_PUK: Self = Self(ffi::GPG_ERR_BAD_PUK);
pub const NO_RESET_CODE: Self = Self(ffi::GPG_ERR_NO_RESET_CODE);
pub const BAD_RESET_CODE: Self = Self(ffi::GPG_ERR_BAD_RESET_CODE);
pub const SYSTEM_BUG: Self = Self(ffi::GPG_ERR_SYSTEM_BUG);
pub const DNS_UNKNOWN: Self = Self(ffi::GPG_ERR_DNS_UNKNOWN);
pub const DNS_SECTION: Self = Self(ffi::GPG_ERR_DNS_SECTION);
pub const DNS_ADDRESS: Self = Self(ffi::GPG_ERR_DNS_ADDRESS);
pub const DNS_NO_QUERY: Self = Self(ffi::GPG_ERR_DNS_NO_QUERY);
pub const DNS_NO_ANSWER: Self = Self(ffi::GPG_ERR_DNS_NO_ANSWER);
pub const DNS_CLOSED: Self = Self(ffi::GPG_ERR_DNS_CLOSED);
pub const DNS_VERIFY: Self = Self(ffi::GPG_ERR_DNS_VERIFY);
pub const DNS_TIMEOUT: Self = Self(ffi::GPG_ERR_DNS_TIMEOUT);
pub const LDAP_GENERAL: Self = Self(ffi::GPG_ERR_LDAP_GENERAL);
pub const LDAP_ATTR_GENERAL: Self = Self(ffi::GPG_ERR_LDAP_ATTR_GENERAL);
pub const LDAP_NAME_GENERAL: Self = Self(ffi::GPG_ERR_LDAP_NAME_GENERAL);
pub const LDAP_SECURITY_GENERAL: Self = Self(ffi::GPG_ERR_LDAP_SECURITY_GENERAL);
pub const LDAP_SERVICE_GENERAL: Self = Self(ffi::GPG_ERR_LDAP_SERVICE_GENERAL);
pub const LDAP_UPDATE_GENERAL: Self = Self(ffi::GPG_ERR_LDAP_UPDATE_GENERAL);
pub const LDAP_E_GENERAL: Self = Self(ffi::GPG_ERR_LDAP_E_GENERAL);
pub const LDAP_X_GENERAL: Self = Self(ffi::GPG_ERR_LDAP_X_GENERAL);
pub const LDAP_OTHER_GENERAL: Self = Self(ffi::GPG_ERR_LDAP_OTHER_GENERAL);
pub const LDAP_X_CONNECTING: Self = Self(ffi::GPG_ERR_LDAP_X_CONNECTING);
pub const LDAP_REFERRAL_LIMIT: Self = Self(ffi::GPG_ERR_LDAP_REFERRAL_LIMIT);
pub const LDAP_CLIENT_LOOP: Self = Self(ffi::GPG_ERR_LDAP_CLIENT_LOOP);
pub const LDAP_NO_RESULTS: Self = Self(ffi::GPG_ERR_LDAP_NO_RESULTS);
pub const LDAP_CONTROL_NOT_FOUND: Self = Self(ffi::GPG_ERR_LDAP_CONTROL_NOT_FOUND);
pub const LDAP_NOT_SUPPORTED: Self = Self(ffi::GPG_ERR_LDAP_NOT_SUPPORTED);
pub const LDAP_CONNECT: Self = Self(ffi::GPG_ERR_LDAP_CONNECT);
pub const LDAP_NO_MEMORY: Self = Self(ffi::GPG_ERR_LDAP_NO_MEMORY);
pub const LDAP_PARAM: Self = Self(ffi::GPG_ERR_LDAP_PARAM);
pub const LDAP_USER_CANCELLED: Self = Self(ffi::GPG_ERR_LDAP_USER_CANCELLED);
pub const LDAP_FILTER: Self = Self(ffi::GPG_ERR_LDAP_FILTER);
pub const LDAP_AUTH_UNKNOWN: Self = Self(ffi::GPG_ERR_LDAP_AUTH_UNKNOWN);
pub const LDAP_TIMEOUT: Self = Self(ffi::GPG_ERR_LDAP_TIMEOUT);
pub const LDAP_DECODING: Self = Self(ffi::GPG_ERR_LDAP_DECODING);
pub const LDAP_ENCODING: Self = Self(ffi::GPG_ERR_LDAP_ENCODING);
pub const LDAP_LOCAL: Self = Self(ffi::GPG_ERR_LDAP_LOCAL);
pub const LDAP_SERVER_DOWN: Self = Self(ffi::GPG_ERR_LDAP_SERVER_DOWN);
pub const LDAP_SUCCESS: Self = Self(ffi::GPG_ERR_LDAP_SUCCESS);
pub const LDAP_OPERATIONS: Self = Self(ffi::GPG_ERR_LDAP_OPERATIONS);
pub const LDAP_PROTOCOL: Self = Self(ffi::GPG_ERR_LDAP_PROTOCOL);
pub const LDAP_TIMELIMIT: Self = Self(ffi::GPG_ERR_LDAP_TIMELIMIT);
pub const LDAP_SIZELIMIT: Self = Self(ffi::GPG_ERR_LDAP_SIZELIMIT);
pub const LDAP_COMPARE_FALSE: Self = Self(ffi::GPG_ERR_LDAP_COMPARE_FALSE);
pub const LDAP_COMPARE_TRUE: Self = Self(ffi::GPG_ERR_LDAP_COMPARE_TRUE);
pub const LDAP_UNSUPPORTED_AUTH: Self = Self(ffi::GPG_ERR_LDAP_UNSUPPORTED_AUTH);
pub const LDAP_STRONG_AUTH_RQRD: Self = Self(ffi::GPG_ERR_LDAP_STRONG_AUTH_RQRD);
pub const LDAP_PARTIAL_RESULTS: Self = Self(ffi::GPG_ERR_LDAP_PARTIAL_RESULTS);
pub const LDAP_REFERRAL: Self = Self(ffi::GPG_ERR_LDAP_REFERRAL);
pub const LDAP_ADMINLIMIT: Self = Self(ffi::GPG_ERR_LDAP_ADMINLIMIT);
pub const LDAP_UNAVAIL_CRIT_EXTN: Self = Self(ffi::GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN);
pub const LDAP_CONFIDENT_RQRD: Self = Self(ffi::GPG_ERR_LDAP_CONFIDENT_RQRD);
pub const LDAP_SASL_BIND_INPROG: Self = Self(ffi::GPG_ERR_LDAP_SASL_BIND_INPROG);
pub const LDAP_NO_SUCH_ATTRIBUTE: Self = Self(ffi::GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE);
pub const LDAP_UNDEFINED_TYPE: Self = Self(ffi::GPG_ERR_LDAP_UNDEFINED_TYPE);
pub const LDAP_BAD_MATCHING: Self = Self(ffi::GPG_ERR_LDAP_BAD_MATCHING);
pub const LDAP_CONST_VIOLATION: Self = Self(ffi::GPG_ERR_LDAP_CONST_VIOLATION);
pub const LDAP_TYPE_VALUE_EXISTS: Self = Self(ffi::GPG_ERR_LDAP_TYPE_VALUE_EXISTS);
pub const LDAP_INV_SYNTAX: Self = Self(ffi::GPG_ERR_LDAP_INV_SYNTAX);
pub const LDAP_NO_SUCH_OBJ: Self = Self(ffi::GPG_ERR_LDAP_NO_SUCH_OBJ);
pub const LDAP_ALIAS_PROBLEM: Self = Self(ffi::GPG_ERR_LDAP_ALIAS_PROBLEM);
pub const LDAP_INV_DN_SYNTAX: Self = Self(ffi::GPG_ERR_LDAP_INV_DN_SYNTAX);
pub const LDAP_IS_LEAF: Self = Self(ffi::GPG_ERR_LDAP_IS_LEAF);
pub const LDAP_ALIAS_DEREF: Self = Self(ffi::GPG_ERR_LDAP_ALIAS_DEREF);
pub const LDAP_X_PROXY_AUTH_FAIL: Self = Self(ffi::GPG_ERR_LDAP_X_PROXY_AUTH_FAIL);
pub const LDAP_BAD_AUTH: Self = Self(ffi::GPG_ERR_LDAP_BAD_AUTH);
pub const LDAP_INV_CREDENTIALS: Self = Self(ffi::GPG_ERR_LDAP_INV_CREDENTIALS);
pub const LDAP_INSUFFICIENT_ACC: Self = Self(ffi::GPG_ERR_LDAP_INSUFFICIENT_ACC);
pub const LDAP_BUSY: Self = Self(ffi::GPG_ERR_LDAP_BUSY);
pub const LDAP_UNAVAILABLE: Self = Self(ffi::GPG_ERR_LDAP_UNAVAILABLE);
pub const LDAP_UNWILL_TO_PERFORM: Self = Self(ffi::GPG_ERR_LDAP_UNWILL_TO_PERFORM);
pub const LDAP_LOOP_DETECT: Self = Self(ffi::GPG_ERR_LDAP_LOOP_DETECT);
pub const LDAP_NAMING_VIOLATION: Self = Self(ffi::GPG_ERR_LDAP_NAMING_VIOLATION);
pub const LDAP_OBJ_CLS_VIOLATION: Self = Self(ffi::GPG_ERR_LDAP_OBJ_CLS_VIOLATION);
pub const LDAP_NOT_ALLOW_NONLEAF: Self = Self(ffi::GPG_ERR_LDAP_NOT_ALLOW_NONLEAF);
pub const LDAP_NOT_ALLOW_ON_RDN: Self = Self(ffi::GPG_ERR_LDAP_NOT_ALLOW_ON_RDN);
pub const LDAP_ALREADY_EXISTS: Self = Self(ffi::GPG_ERR_LDAP_ALREADY_EXISTS);
pub const LDAP_NO_OBJ_CLASS_MODS: Self = Self(ffi::GPG_ERR_LDAP_NO_OBJ_CLASS_MODS);
pub const LDAP_RESULTS_TOO_LARGE: Self = Self(ffi::GPG_ERR_LDAP_RESULTS_TOO_LARGE);
pub const LDAP_AFFECTS_MULT_DSAS: Self = Self(ffi::GPG_ERR_LDAP_AFFECTS_MULT_DSAS);
pub const LDAP_VLV: Self = Self(ffi::GPG_ERR_LDAP_VLV);
pub const LDAP_OTHER: Self = Self(ffi::GPG_ERR_LDAP_OTHER);
pub const LDAP_CUP_RESOURCE_LIMIT: Self = Self(ffi::GPG_ERR_LDAP_CUP_RESOURCE_LIMIT);
pub const LDAP_CUP_SEC_VIOLATION: Self = Self(ffi::GPG_ERR_LDAP_CUP_SEC_VIOLATION);
pub const LDAP_CUP_INV_DATA: Self = Self(ffi::GPG_ERR_LDAP_CUP_INV_DATA);
pub const LDAP_CUP_UNSUP_SCHEME: Self = Self(ffi::GPG_ERR_LDAP_CUP_UNSUP_SCHEME);
pub const LDAP_CUP_RELOAD: Self = Self(ffi::GPG_ERR_LDAP_CUP_RELOAD);
pub const LDAP_CANCELLED: Self = Self(ffi::GPG_ERR_LDAP_CANCELLED);
pub const LDAP_NO_SUCH_OPERATION: Self = Self(ffi::GPG_ERR_LDAP_NO_SUCH_OPERATION);
pub const LDAP_TOO_LATE: Self = Self(ffi::GPG_ERR_LDAP_TOO_LATE);
pub const LDAP_CANNOT_CANCEL: Self = Self(ffi::GPG_ERR_LDAP_CANNOT_CANCEL);
pub const LDAP_ASSERTION_FAILED: Self = Self(ffi::GPG_ERR_LDAP_ASSERTION_FAILED);
pub const LDAP_PROX_AUTH_DENIED: Self = Self(ffi::GPG_ERR_LDAP_PROX_AUTH_DENIED);
pub const USER_1: Self = Self(ffi::GPG_ERR_USER_1);
pub const USER_2: Self = Self(ffi::GPG_ERR_USER_2);
pub const USER_3: Self = Self(ffi::GPG_ERR_USER_3);
pub const USER_4: Self = Self(ffi::GPG_ERR_USER_4);
pub const USER_5: Self = Self(ffi::GPG_ERR_USER_5);
pub const USER_6: Self = Self(ffi::GPG_ERR_USER_6);
pub const USER_7: Self = Self(ffi::GPG_ERR_USER_7);
pub const USER_8: Self = Self(ffi::GPG_ERR_USER_8);
pub const USER_9: Self = Self(ffi::GPG_ERR_USER_9);
pub const USER_10: Self = Self(ffi::GPG_ERR_USER_10);
pub const USER_11: Self = Self(ffi::GPG_ERR_USER_11);
pub const USER_12: Self = Self(ffi::GPG_ERR_USER_12);
pub const USER_13: Self = Self(ffi::GPG_ERR_USER_13);
pub const USER_14: Self = Self(ffi::GPG_ERR_USER_14);
pub const USER_15: Self = Self(ffi::GPG_ERR_USER_15);
pub const USER_16: Self = Self(ffi::GPG_ERR_USER_16);
pub const SQL_OK: Self = Self(ffi::GPG_ERR_SQL_OK);
pub const SQL_ERROR: Self = Self(ffi::GPG_ERR_SQL_ERROR);
pub const SQL_INTERNAL: Self = Self(ffi::GPG_ERR_SQL_INTERNAL);
pub const SQL_PERM: Self = Self(ffi::GPG_ERR_SQL_PERM);
pub const SQL_ABORT: Self = Self(ffi::GPG_ERR_SQL_ABORT);
pub const SQL_BUSY: Self = Self(ffi::GPG_ERR_SQL_BUSY);
pub const SQL_LOCKED: Self = Self(ffi::GPG_ERR_SQL_LOCKED);
pub const SQL_NOMEM: Self = Self(ffi::GPG_ERR_SQL_NOMEM);
pub const SQL_READONLY: Self = Self(ffi::GPG_ERR_SQL_READONLY);
pub const SQL_INTERRUPT: Self = Self(ffi::GPG_ERR_SQL_INTERRUPT);
pub const SQL_IOERR: Self = Self(ffi::GPG_ERR_SQL_IOERR);
pub const SQL_CORRUPT: Self = Self(ffi::GPG_ERR_SQL_CORRUPT);
pub const SQL_NOTFOUND: Self = Self(ffi::GPG_ERR_SQL_NOTFOUND);
pub const SQL_FULL: Self = Self(ffi::GPG_ERR_SQL_FULL);
pub const SQL_CANTOPEN: Self = Self(ffi::GPG_ERR_SQL_CANTOPEN);
pub const SQL_PROTOCOL: Self = Self(ffi::GPG_ERR_SQL_PROTOCOL);
pub const SQL_EMPTY: Self = Self(ffi::GPG_ERR_SQL_EMPTY);
pub const SQL_SCHEMA: Self = Self(ffi::GPG_ERR_SQL_SCHEMA);
pub const SQL_TOOBIG: Self = Self(ffi::GPG_ERR_SQL_TOOBIG);
pub const SQL_CONSTRAINT: Self = Self(ffi::GPG_ERR_SQL_CONSTRAINT);
pub const SQL_MISMATCH: Self = Self(ffi::GPG_ERR_SQL_MISMATCH);
pub const SQL_MISUSE: Self = Self(ffi::GPG_ERR_SQL_MISUSE);
pub const SQL_NOLFS: Self = Self(ffi::GPG_ERR_SQL_NOLFS);
pub const SQL_AUTH: Self = Self(ffi::GPG_ERR_SQL_AUTH);
pub const SQL_FORMAT: Self = Self(ffi::GPG_ERR_SQL_FORMAT);
pub const SQL_RANGE: Self = Self(ffi::GPG_ERR_SQL_RANGE);
pub const SQL_NOTADB: Self = Self(ffi::GPG_ERR_SQL_NOTADB);
pub const SQL_NOTICE: Self = Self(ffi::GPG_ERR_SQL_NOTICE);
pub const SQL_WARNING: Self = Self(ffi::GPG_ERR_SQL_WARNING);
pub const SQL_ROW: Self = Self(ffi::GPG_ERR_SQL_ROW);
pub const SQL_DONE: Self = Self(ffi::GPG_ERR_SQL_DONE);
pub const MISSING_ERRNO: Self = Self(ffi::GPG_ERR_MISSING_ERRNO);
pub const UNKNOWN_ERRNO: Self = Self(ffi::GPG_ERR_UNKNOWN_ERRNO);
pub const EOF: Self = Self(ffi::GPG_ERR_EOF);
pub const E2BIG: Self = Self(ffi::GPG_ERR_E2BIG);
pub const EACCES: Self = Self(ffi::GPG_ERR_EACCES);
pub const EADDRINUSE: Self = Self(ffi::GPG_ERR_EADDRINUSE);
pub const EADDRNOTAVAIL: Self = Self(ffi::GPG_ERR_EADDRNOTAVAIL);
pub const EADV: Self = Self(ffi::GPG_ERR_EADV);
pub const EAFNOSUPPORT: Self = Self(ffi::GPG_ERR_EAFNOSUPPORT);
pub const EAGAIN: Self = Self(ffi::GPG_ERR_EAGAIN);
pub const EALREADY: Self = Self(ffi::GPG_ERR_EALREADY);
pub const EAUTH: Self = Self(ffi::GPG_ERR_EAUTH);
pub const EBACKGROUND: Self = Self(ffi::GPG_ERR_EBACKGROUND);
pub const EBADE: Self = Self(ffi::GPG_ERR_EBADE);
pub const EBADF: Self = Self(ffi::GPG_ERR_EBADF);
pub const EBADFD: Self = Self(ffi::GPG_ERR_EBADFD);
pub const EBADMSG: Self = Self(ffi::GPG_ERR_EBADMSG);
pub const EBADR: Self = Self(ffi::GPG_ERR_EBADR);
pub const EBADRPC: Self = Self(ffi::GPG_ERR_EBADRPC);
pub const EBADRQC: Self = Self(ffi::GPG_ERR_EBADRQC);
pub const EBADSLT: Self = Self(ffi::GPG_ERR_EBADSLT);
pub const EBFONT: Self = Self(ffi::GPG_ERR_EBFONT);
pub const EBUSY: Self = Self(ffi::GPG_ERR_EBUSY);
pub const ECANCELED: Self = Self(ffi::GPG_ERR_ECANCELED);
pub const ECHILD: Self = Self(ffi::GPG_ERR_ECHILD);
pub const ECHRNG: Self = Self(ffi::GPG_ERR_ECHRNG);
pub const ECOMM: Self = Self(ffi::GPG_ERR_ECOMM);
pub const ECONNABORTED: Self = Self(ffi::GPG_ERR_ECONNABORTED);
pub const ECONNREFUSED: Self = Self(ffi::GPG_ERR_ECONNREFUSED);
pub const ECONNRESET: Self = Self(ffi::GPG_ERR_ECONNRESET);
pub const ED: Self = Self(ffi::GPG_ERR_ED);
pub const EDEADLK: Self = Self(ffi::GPG_ERR_EDEADLK);
pub const EDEADLOCK: Self = Self(ffi::GPG_ERR_EDEADLOCK);
pub const EDESTADDRREQ: Self = Self(ffi::GPG_ERR_EDESTADDRREQ);
pub const EDIED: Self = Self(ffi::GPG_ERR_EDIED);
pub const EDOM: Self = Self(ffi::GPG_ERR_EDOM);
pub const EDOTDOT: Self = Self(ffi::GPG_ERR_EDOTDOT);
pub const EDQUOT: Self = Self(ffi::GPG_ERR_EDQUOT);
pub const EEXIST: Self = Self(ffi::GPG_ERR_EEXIST);
pub const EFAULT: Self = Self(ffi::GPG_ERR_EFAULT);
pub const EFBIG: Self = Self(ffi::GPG_ERR_EFBIG);
pub const EFTYPE: Self = Self(ffi::GPG_ERR_EFTYPE);
pub const EGRATUITOUS: Self = Self(ffi::GPG_ERR_EGRATUITOUS);
pub const EGREGIOUS: Self = Self(ffi::GPG_ERR_EGREGIOUS);
pub const EHOSTDOWN: Self = Self(ffi::GPG_ERR_EHOSTDOWN);
pub const EHOSTUNREACH: Self = Self(ffi::GPG_ERR_EHOSTUNREACH);
pub const EIDRM: Self = Self(ffi::GPG_ERR_EIDRM);
pub const EIEIO: Self = Self(ffi::GPG_ERR_EIEIO);
pub const EILSEQ: Self = Self(ffi::GPG_ERR_EILSEQ);
pub const EINPROGRESS: Self = Self(ffi::GPG_ERR_EINPROGRESS);
pub const EINTR: Self = Self(ffi::GPG_ERR_EINTR);
pub const EINVAL: Self = Self(ffi::GPG_ERR_EINVAL);
pub const EIO: Self = Self(ffi::GPG_ERR_EIO);
pub const EISCONN: Self = Self(ffi::GPG_ERR_EISCONN);
pub const EISDIR: Self = Self(ffi::GPG_ERR_EISDIR);
pub const EISNAM: Self = Self(ffi::GPG_ERR_EISNAM);
pub const EL2HLT: Self = Self(ffi::GPG_ERR_EL2HLT);
pub const EL2NSYNC: Self = Self(ffi::GPG_ERR_EL2NSYNC);
pub const EL3HLT: Self = Self(ffi::GPG_ERR_EL3HLT);
pub const EL3RST: Self = Self(ffi::GPG_ERR_EL3RST);
pub const ELIBACC: Self = Self(ffi::GPG_ERR_ELIBACC);
pub const ELIBBAD: Self = Self(ffi::GPG_ERR_ELIBBAD);
pub const ELIBEXEC: Self = Self(ffi::GPG_ERR_ELIBEXEC);
pub const ELIBMAX: Self = Self(ffi::GPG_ERR_ELIBMAX);
pub const ELIBSCN: Self = Self(ffi::GPG_ERR_ELIBSCN);
pub const ELNRNG: Self = Self(ffi::GPG_ERR_ELNRNG);
pub const ELOOP: Self = Self(ffi::GPG_ERR_ELOOP);
pub const EMEDIUMTYPE: Self = Self(ffi::GPG_ERR_EMEDIUMTYPE);
pub const EMFILE: Self = Self(ffi::GPG_ERR_EMFILE);
pub const EMLINK: Self = Self(ffi::GPG_ERR_EMLINK);
pub const EMSGSIZE: Self = Self(ffi::GPG_ERR_EMSGSIZE);
pub const EMULTIHOP: Self = Self(ffi::GPG_ERR_EMULTIHOP);
pub const ENAMETOOLONG: Self = Self(ffi::GPG_ERR_ENAMETOOLONG);
pub const ENAVAIL: Self = Self(ffi::GPG_ERR_ENAVAIL);
pub const ENEEDAUTH: Self = Self(ffi::GPG_ERR_ENEEDAUTH);
pub const ENETDOWN: Self = Self(ffi::GPG_ERR_ENETDOWN);
pub const ENETRESET: Self = Self(ffi::GPG_ERR_ENETRESET);
pub const ENETUNREACH: Self = Self(ffi::GPG_ERR_ENETUNREACH);
pub const ENFILE: Self = Self(ffi::GPG_ERR_ENFILE);
pub const ENOANO: Self = Self(ffi::GPG_ERR_ENOANO);
pub const ENOBUFS: Self = Self(ffi::GPG_ERR_ENOBUFS);
pub const ENOCSI: Self = Self(ffi::GPG_ERR_ENOCSI);
pub const ENODATA: Self = Self(ffi::GPG_ERR_ENODATA);
pub const ENODEV: Self = Self(ffi::GPG_ERR_ENODEV);
pub const ENOENT: Self = Self(ffi::GPG_ERR_ENOENT);
pub const ENOEXEC: Self = Self(ffi::GPG_ERR_ENOEXEC);
pub const ENOLCK: Self = Self(ffi::GPG_ERR_ENOLCK);
pub const ENOLINK: Self = Self(ffi::GPG_ERR_ENOLINK);
pub const ENOMEDIUM: Self = Self(ffi::GPG_ERR_ENOMEDIUM);
pub const ENOMEM: Self = Self(ffi::GPG_ERR_ENOMEM);
pub const ENOMSG: Self = Self(ffi::GPG_ERR_ENOMSG);
pub const ENONET: Self = Self(ffi::GPG_ERR_ENONET);
pub const ENOPKG: Self = Self(ffi::GPG_ERR_ENOPKG);
pub const ENOPROTOOPT: Self = Self(ffi::GPG_ERR_ENOPROTOOPT);
pub const ENOSPC: Self = Self(ffi::GPG_ERR_ENOSPC);
pub const ENOSR: Self = Self(ffi::GPG_ERR_ENOSR);
pub const ENOSTR: Self = Self(ffi::GPG_ERR_ENOSTR);
pub const ENOSYS: Self = Self(ffi::GPG_ERR_ENOSYS);
pub const ENOTBLK: Self = Self(ffi::GPG_ERR_ENOTBLK);
pub const ENOTCONN: Self = Self(ffi::GPG_ERR_ENOTCONN);
pub const ENOTDIR: Self = Self(ffi::GPG_ERR_ENOTDIR);
pub const ENOTEMPTY: Self = Self(ffi::GPG_ERR_ENOTEMPTY);
pub const ENOTNAM: Self = Self(ffi::GPG_ERR_ENOTNAM);
pub const ENOTSOCK: Self = Self(ffi::GPG_ERR_ENOTSOCK);
pub const ENOTSUP: Self = Self(ffi::GPG_ERR_ENOTSUP);
pub const ENOTTY: Self = Self(ffi::GPG_ERR_ENOTTY);
pub const ENOTUNIQ: Self = Self(ffi::GPG_ERR_ENOTUNIQ);
pub const ENXIO: Self = Self(ffi::GPG_ERR_ENXIO);
pub const EOPNOTSUPP: Self = Self(ffi::GPG_ERR_EOPNOTSUPP);
pub const EOVERFLOW: Self = Self(ffi::GPG_ERR_EOVERFLOW);
pub const EPERM: Self = Self(ffi::GPG_ERR_EPERM);
pub const EPFNOSUPPORT: Self = Self(ffi::GPG_ERR_EPFNOSUPPORT);
pub const EPIPE: Self = Self(ffi::GPG_ERR_EPIPE);
pub const EPROCLIM: Self = Self(ffi::GPG_ERR_EPROCLIM);
pub const EPROCUNAVAIL: Self = Self(ffi::GPG_ERR_EPROCUNAVAIL);
pub const EPROGMISMATCH: Self = Self(ffi::GPG_ERR_EPROGMISMATCH);
pub const EPROGUNAVAIL: Self = Self(ffi::GPG_ERR_EPROGUNAVAIL);
pub const EPROTO: Self = Self(ffi::GPG_ERR_EPROTO);
pub const EPROTONOSUPPORT: Self = Self(ffi::GPG_ERR_EPROTONOSUPPORT);
pub const EPROTOTYPE: Self = Self(ffi::GPG_ERR_EPROTOTYPE);
pub const ERANGE: Self = Self(ffi::GPG_ERR_ERANGE);
pub const EREMCHG: Self = Self(ffi::GPG_ERR_EREMCHG);
pub const EREMOTE: Self = Self(ffi::GPG_ERR_EREMOTE);
pub const EREMOTEIO: Self = Self(ffi::GPG_ERR_EREMOTEIO);
pub const ERESTART: Self = Self(ffi::GPG_ERR_ERESTART);
pub const EROFS: Self = Self(ffi::GPG_ERR_EROFS);
pub const ERPCMISMATCH: Self = Self(ffi::GPG_ERR_ERPCMISMATCH);
pub const ESHUTDOWN: Self = Self(ffi::GPG_ERR_ESHUTDOWN);
pub const ESOCKTNOSUPPORT: Self = Self(ffi::GPG_ERR_ESOCKTNOSUPPORT);
pub const ESPIPE: Self = Self(ffi::GPG_ERR_ESPIPE);
pub const ESRCH: Self = Self(ffi::GPG_ERR_ESRCH);
pub const ESRMNT: Self = Self(ffi::GPG_ERR_ESRMNT);
pub const ESTALE: Self = Self(ffi::GPG_ERR_ESTALE);
pub const ESTRPIPE: Self = Self(ffi::GPG_ERR_ESTRPIPE);
pub const ETIME: Self = Self(ffi::GPG_ERR_ETIME);
pub const ETIMEDOUT: Self = Self(ffi::GPG_ERR_ETIMEDOUT);
pub const ETOOMANYREFS: Self = Self(ffi::GPG_ERR_ETOOMANYREFS);
pub const ETXTBSY: Self = Self(ffi::GPG_ERR_ETXTBSY);
pub const EUCLEAN: Self = Self(ffi::GPG_ERR_EUCLEAN);
pub const EUNATCH: Self = Self(ffi::GPG_ERR_EUNATCH);
pub const EUSERS: Self = Self(ffi::GPG_ERR_EUSERS);
pub const EWOULDBLOCK: Self = Self(ffi::GPG_ERR_EWOULDBLOCK);
pub const EXDEV: Self = Self(ffi::GPG_ERR_EXDEV);
pub const EXFULL: Self = Self(ffi::GPG_ERR_EXFULL);
}