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_TLS: ErrorSource = ffi::GPG_ERR_SOURCE_TLS;
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 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 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);
}
