Initial commit

4 files changed, 1700 insertions, 0 deletions

diff --git a/vapi/gpg-error.vapi b/vapi/gpg-error.vapi
new file mode 100644
index 00000000..e7808f5e
--- /dev/null
+++ b/vapi/gpg-error.vapi
@@ -0,0 +1,407 @@
+/* gpg-error.vapi
+ *
+ * Copyright (C) 2009 Sebastian Reichel <sre@ring0.de>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+[CCode (cheader_filename = "gpg-error.h")]
+namespace GPGError {
+
+    [CCode (cname = "gpg_err_code_t", cprefix = "GPG_ERR_")]
+    public enum ErrorCode {
+        NO_ERROR,
+        GENERAL,
+        UNKNOWN_PACKET,
+        UNKNOWN_VERSION,
+        PUBKEY_ALGO,
+        DIGEST_ALGO,
+        BAD_PUBKEY,
+        BAD_SECKEY,
+        BAD_SIGNATURE,
+        NO_PUBKEY,
+        CHECKSUM,
+        BAD_PASSPHRASE,
+        CIPHER_ALGO,
+        KEYRING_OPEN,
+        INV_PACKET,
+        INV_ARMOR,
+        NO_USER_ID,
+        NO_SECKEY,
+        WRONG_SECKEY,
+        BAD_KEY,
+        COMPR_ALGO,
+        NO_PRIME,
+        NO_ENCODING_METHOD,
+        NO_ENCRYPTION_SCHEME,
+        NO_SIGNATURE_SCHEME,
+        INV_ATTR,
+        NO_VALUE,
+        NOT_FOUND,
+        VALUE_NOT_FOUND,
+        SYNTAX,
+        BAD_MPI,
+        INV_PASSPHRASE,
+        SIG_CLASS,
+        RESOURCE_LIMIT,
+        INV_KEYRING,
+        TRUSTDB,
+        BAD_CERT,
+        INV_USER_ID,
+        UNEXPECTED,
+        TIME_CONFLICT,
+        KEYSERVER,
+        WRONG_PUBKEY_ALGO,
+        TRIBUTE_TO_D_A,
+        WEAK_KEY,
+        INV_KEYLEN,
+        INV_ARG,
+        BAD_URI,
+        INV_URI,
+        NETWORK,
+        UNKNOWN_HOST,
+        SELFTEST_FAILED,
+        NOT_ENCRYPTED,
+        NOT_PROCESSED,
+        UNUSABLE_PUBKEY,
+        UNUSABLE_SECKEY,
+        INV_VALUE,
+        BAD_CERT_CHAIN,
+        MISSING_CERT,
+        NO_DATA,
+        BUG,
+        NOT_SUPPORTED,
+        INV_OP,
+        TIMEOUT,
+        INTERNAL,
+        EOF_GCRYPT,
+        INV_OBJ,
+        TOO_SHORT,
+        TOO_LARGE,
+        NO_OBJ,
+        NOT_IMPLEMENTED,
+        CONFLICT,
+        INV_CIPHER_MODE,
+        INV_FLAG,
+        INV_HANDLE,
+        TRUNCATED,
+        INCOMPLETE_LINE,
+        INV_RESPONSE,
+        NO_AGENT,
+        AGENT,
+        INV_DATA,
+        ASSUAN_SERVER_FAULT,
+        ASSUAN,
+        INV_SESSION_KEY,
+        INV_SEXP,
+        UNSUPPORTED_ALGORITHM,
+        NO_PIN_ENTRY,
+        PIN_ENTRY,
+        BAD_PIN,
+        INV_NAME,
+        BAD_DATA,
+        INV_PARAMETER,
+        WRONG_CARD,
+        NO_DIRMNGR,
+        DIRMNGR,
+        CERT_REVOKED,
+        NO_CRL_KNOWN,
+        CRL_TOO_OLD,
+        LINE_TOO_LONG,
+        NOT_TRUSTED,
+        CANCELED,
+        BAD_CA_CERT,
+        CERT_EXPIRED,
+        CERT_TOO_YOUNG,
+        UNSUPPORTED_CERT,
+        UNKNOWN_SEXP,
+        UNSUPPORTED_PROTECTION,
+        CORRUPTED_PROTECTION,
+        AMBIGUOUS_NAME,
+        CARD,
+        CARD_RESET,
+        CARD_REMOVED,
+        INV_CARD,
+        CARD_NOT_PRESENT,
+        NO_PKCS15_APP,
+        NOT_CONFIRMED,
+        CONFIGURATION,
+        NO_POLICY_MATCH,
+        INV_INDEX,
+        INV_ID,
+        NO_SCDAEMON,
+        SCDAEMON,
+        UNSUPPORTED_PROTOCOL,
+        BAD_PIN_METHOD,
+        CARD_NOT_INITIALIZED,
+        UNSUPPORTED_OPERATION,
+        WRONG_KEY_USAGE,
+        NOTHING_FOUND,
+        WRONG_BLOB_TYPE,
+        MISSING_VALUE,
+        HARDWARE,
+        PIN_BLOCKED,
+        USE_CONDITIONS,
+        PIN_NOT_SYNCED,
+        INV_CRL,
+        BAD_BER,
+        INV_BER,
+        ELEMENT_NOT_FOUND,
+        IDENTIFIER_NOT_FOUND,
+        INV_TAG,
+        INV_LENGTH,
+        INV_KEYINFO,
+        UNEXPECTED_TAG,
+        NOT_DER_ENCODED,
+        NO_CMS_OBJ,
+        INV_CMS_OBJ,
+        UNKNOWN_CMS_OBJ,
+        UNSUPPORTED_CMS_OBJ,
+        UNSUPPORTED_ENCODING,
+        UNSUPPORTED_CMS_VERSION,
+        UNKNOWN_ALGORITHM,
+        INV_ENGINE,
+        PUBKEY_NOT_TRUSTED,
+        DECRYPT_FAILED,
+        KEY_EXPIRED,
+        SIG_EXPIRED,
+        ENCODING_PROBLEM,
+        INV_STATE,
+        DUP_VALUE,
+        MISSING_ACTION,
+        MODULE_NOT_FOUND,
+        INV_OID_STRING,
+        INV_TIME,
+        INV_CRL_OBJ,
+        UNSUPPORTED_CRL_VERSION,
+        INV_CERT_OBJ,
+        UNKNOWN_NAME,
+        LOCALE_PROBLEM,
+        NOT_LOCKED,
+        PROTOCOL_VIOLATION,
+        INV_MAC,
+        INV_REQUEST,
+        UNKNOWN_EXTN,
+        UNKNOWN_CRIT_EXTN,
+        LOCKED,
+        UNKNOWN_OPTION,
+        UNKNOWN_COMMAND,
+        UNFINISHED,
+        BUFFER_TOO_SHORT,
+        SEXP_INV_LEN_SPEC,
+        SEXP_STRING_TOO_LONG,
+        SEXP_UNMATCHED_PAREN,
+        SEXP_NOT_CANONICAL,
+        SEXP_BAD_CHARACTER,
+        SEXP_BAD_QUOTATION,
+        SEXP_ZERO_PREFIX,
+        SEXP_NESTED_DH,
+        SEXP_UNMATCHED_DH,
+        SEXP_UNEXPECTED_PUNC,
+        SEXP_BAD_HEX_CHAR,
+        SEXP_ODD_HEX_NUMBERS,
+        SEXP_BAD_OCT_CHAR,
+        ASS_GENERAL,
+        ASS_ACCEPT_FAILED,
+        ASS_CONNECT_FAILED,
+        ASS_INV_RESPONSE,
+        ASS_INV_VALUE,
+        ASS_INCOMPLETE_LINE,
+        ASS_LINE_TOO_LONG,
+        ASS_NESTED_COMMANDS,
+        ASS_NO_DATA_CB,
+        ASS_NO_INQUIRE_CB,
+        ASS_NOT_A_SERVER,
+        ASS_NOT_A_CLIENT,
+        ASS_SERVER_START,
+        ASS_READ_ERROR,
+        ASS_WRITE_ERROR,
+        ASS_TOO_MUCH_DATA,
+        ASS_UNEXPECTED_CMD,
+        ASS_UNKNOWN_CMD,
+        ASS_SYNTAX,
+        ASS_CANCELED,
+        ASS_NO_INPUT,
+        ASS_NO_OUTPUT,
+        ASS_PARAMETER,
+        ASS_UNKNOWN_INQUIRE,
+        USER_1,
+        USER_2,
+        USER_3,
+        USER_4,
+        USER_5,
+        USER_6,
+        USER_7,
+        USER_8,
+        USER_9,
+        USER_10,
+        USER_11,
+        USER_12,
+        USER_13,
+        USER_14,
+        USER_15,
+        USER_16,
+        MISSING_ERRNO,
+        UNKNOWN_ERRNO,
+        EOF,
+        E2BIG,
+        EACCES,
+        EADDRINUSE,
+        EADDRNOTAVAIL,
+        EADV,
+        EAFNOSUPPORT,
+        EAGAIN,
+        EALREADY,
+        EAUTH,
+        EBACKGROUND,
+        EBADE,
+        EBADF,
+        EBADFD,
+        EBADMSG,
+        EBADR,
+        EBADRPC,
+        EBADRQC,
+        EBADSLT,
+        EBFONT,
+        EBUSY,
+        ECANCELED,
+        ECHILD,
+        ECHRNG,
+        ECOMM,
+        ECONNABORTED,
+        ECONNREFUSED,
+        ECONNRESET,
+        ED,
+        EDEADLK,
+        EDEADLOCK,
+        EDESTADDRREQ,
+        EDIED,
+        EDOM,
+        EDOTDOT,
+        EDQUOT,
+        EEXIST,
+        EFAULT,
+        EFBIG,
+        EFTYPE,
+        EGRATUITOUS,
+        EGREGIOUS,
+        EHOSTDOWN,
+        EHOSTUNREACH,
+        EIDRM,
+        EIEIO,
+        EILSEQ,
+        EINPROGRESS,
+        EINTR,
+        EINVAL,
+        EIO,
+        EISCONN,
+        EISDIR,
+        EISNAM,
+        EL2HLT,
+        EL2NSYNC,
+        EL3HLT,
+        EL3RST,
+        ELIBACC,
+        ELIBBAD,
+        ELIBEXEC,
+        ELIBMAX,
+        ELIBSCN,
+        ELNRNG,
+        ELOOP,
+        EMEDIUMTYPE,
+        EMFILE,
+        EMLINK,
+        EMSGSIZE,
+        EMULTIHOP,
+        ENAMETOOLONG,
+        ENAVAIL,
+        ENEEDAUTH,
+        ENETDOWN,
+        ENETRESET,
+        ENETUNREACH,
+        ENFILE,
+        ENOANO,
+        ENOBUFS,
+        ENOCSI,
+        ENODATA,
+        ENODEV,
+        ENOENT,
+        ENOEXEC,
+        ENOLCK,
+        ENOLINK,
+        ENOMEDIUM,
+        ENOMEM,
+        ENOMSG,
+        ENONET,
+        ENOPKG,
+        ENOPROTOOPT,
+        ENOSPC,
+        ENOSR,
+        ENOSTR,
+        ENOSYS,
+        ENOTBLK,
+        ENOTCONN,
+        ENOTDIR,
+        ENOTEMPTY,
+        ENOTNAM,
+        ENOTSOCK,
+        ENOTSUP,
+        ENOTTY,
+        ENOTUNIQ,
+        ENXIO,
+        EOPNOTSUPP,
+        EOVERFLOW,
+        EPERM,
+        EPFNOSUPPORT,
+        EPIPE,
+        EPROCLIM,
+        EPROCUNAVAIL,
+        EPROGMISMATCH,
+        EPROGUNAVAIL,
+        EPROTO,
+        EPROTONOSUPPORT,
+        EPROTOTYPE,
+        ERANGE,
+        EREMCHG,
+        EREMOTE,
+        EREMOTEIO,
+        ERESTART,
+        EROFS,
+        ERPCMISMATCH,
+        ESHUTDOWN,
+        ESOCKTNOSUPPORT,
+        ESPIPE,
+        ESRCH,
+        ESRMNT,
+        ESTALE,
+        ESTRPIPE,
+        ETIME,
+        ETIMEDOUT,
+        ETOOMANYREFS,
+        ETXTBSY,
+        EUCLEAN,
+        EUNATCH,
+        EUSERS,
+        EWOULDBLOCK,
+        EXDEV,
+        EXFULL,
+        CODE_DIM
+    }
+}
diff --git a/vapi/gpgme.deps b/vapi/gpgme.deps
new file mode 100644
index 00000000..a0f4f82b
--- /dev/null
+++ b/vapi/gpgme.deps
@@ -0,0 +1 @@
+gpg-error
diff --git a/vapi/gpgme.vapi b/vapi/gpgme.vapi
new file mode 100644
index 00000000..49fd2d78
--- /dev/null
+++ b/vapi/gpgme.vapi
@@ -0,0 +1,1224 @@
+/* libgpgme.vapi
+ *
+ * Copyright (C) 2009 Sebastian Reichel <sre@ring0.de>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+/**
+ * GPGME is an API wrapper around GnuPG, which parses the output of GnuPG.
+ */
+[CCode (lower_case_cprefix = "gpgme_", cheader_filename = "gpgme.h")]
+namespace GPG {
+    /**
+     * EngineInfo as List
+     */
+    [CCode (cname = "struct _gpgme_engine_info")]
+    public struct EngineInfo {
+        /**
+         * Next entry in the list
+         */
+        EngineInfo* next;
+
+        /**
+         * The protocol ID
+         */
+        Protocol protocol;
+
+        /**
+         * filename of the engine binary
+         */
+        string file_name;
+
+        /**
+         * version string of the installed binary
+         */
+        string version;
+
+        /**
+         * minimum version required for gpgme
+         */
+        string req_version;
+
+        /**
+         * home directory to be used or null for default
+         */
+        string? home_dir;
+    }
+
+    /**
+     * A Key from the Keyring
+     */
+    [CCode (cname = "struct _gpgme_key", ref_function = "gpgme_key_ref", ref_function_void = true, unref_function = "gpgme_key_unref", free_function = "gpgme_key_release")]
+    public class Key {
+        public bool revoked;
+        public bool expired;
+        public bool disabled;
+        public bool invalid;
+        public bool can_encrypt;
+        public bool can_sign;
+        public bool can_certify;
+        public bool secret;
+        public bool can_authenticate;
+        public bool is_qualified;
+        public Protocol protocol;
+
+        /**
+         * If protocol is CMS, this string contains the issuer's serial
+         */
+        public string issuer_serial;
+
+        /**
+         * If protocol is CMS, this string contains the issuer's name
+         */
+        public string issuer_name;
+
+        /**
+         * If protocol is CMS, this string contains the issuer's ID
+         */
+        public string issuer_id;
+
+        /**
+         * If protocol is OpenPGP, this field contains the owner trust level
+         */
+        public Validity owner_trust;
+
+        /**
+         * The key's subkeys
+         */
+        [CCode(array_null_terminated = true)]
+        public SubKey[] subkeys;
+
+        /**
+         * The key's user ids
+         */
+        [CCode(array_null_terminated = true)]
+        public UserID[] uids;
+
+        public KeylistMode keylist_mode;
+    }
+
+    /**
+     * A signature notation
+     */
+    [CCode (cname = "struct _gpgme_sig_notation")]
+    public struct SigNotation {
+        /**
+         * The next SigNotation from the list
+         */
+        SigNotation* next;
+
+        /**
+         * If name is a null pointer value contains a policy url rather than a notation
+         */
+        string? name;
+
+        /**
+         * The value of the notation data
+         */
+        string value;
+
+        /**
+         * The length of the name of the notation data
+         */
+        int name_len;
+
+        /**
+         * The length of the value of the notation data
+         */
+        int value_len;
+
+        /**
+         * The accumulated flags
+         */
+        SigNotationFlags flags;
+
+        /**
+         * notation data is human readable
+         */
+        bool human_readable;
+
+        /**
+         * notation data is critical
+         */
+        bool critical;
+    }
+
+    /**
+     * A subkey from a Key
+     */
+    [CCode (cname = "struct _gpgme_subkey")]
+    public struct SubKey {
+        SubKey* next;
+        bool revoked;
+        bool expired;
+        bool disabled;
+        bool invalid;
+        bool can_encrypt;
+        bool can_sign;
+        bool can_certify;
+        bool secret;
+        bool can_authenticate;
+        bool is_qualified;
+        bool is_cardkey;
+        PublicKeyAlgorithm algo;
+        uint length;
+        string keyid;
+
+        /**
+         * Fingerprint of the key in hex form
+         */
+        string fpr;
+
+        /**
+         * The creation timestamp.
+         * -1 = invalid,
+         * 0 = not available
+         */
+        long timestamp;
+
+        /**
+         * The expiration timestamp.
+         * 0 = key does not expire
+         */
+        long expires;
+
+        /**
+         * The serial number of the smartcard holding this key or null
+         */
+        string? cardnumber;
+    }
+
+    /**
+     * A signature on a UserID
+     */
+    [CCode (cname = "struct _gpgme_key_sig")]
+    public struct KeySig {
+        /**
+         * The next signature from the list
+         */
+        KeySig* next;
+        bool invoked;
+        bool expired;
+        bool invalid;
+        bool exportable;
+        PublicKeyAlgorithm algo;
+        string keyid;
+
+        /**
+         * The creation timestamp.
+         * -1 = invalid,
+         * 0 = not available
+         */
+        long timestamp;
+
+        /**
+         * The expiration timestamp.
+         * 0 = key does not expire
+         */
+        long expires;
+
+        GPGError.ErrorCode status;
+
+        string uid;
+        string name;
+        string email;
+        string comment;
+
+        /**
+         * Crypto backend specific signature class
+         */
+        uint sig_class;
+
+        SigNotation notations;
+    }
+
+    /**
+     * A UserID from a Key
+     */
+    [CCode (cname = "struct _gpgme_user_id")]
+    public struct UserID {
+        /**
+         * The next UserID from the list
+         */
+        UserID* next;
+
+        bool revoked;
+        bool invalid;
+        Validity validity;
+        string uid;
+        string name;
+        string email;
+        string comment;
+
+        KeySig signatures;
+    }
+
+    /**
+     * verify result of OP
+     */
+    [CCode (cname = "struct _gpgme_op_verify_result")]
+    public struct VerifyResult {
+        Signature* signatures;
+
+        /**
+         * The original file name of the plaintext message, if available
+         */
+        string? file_name;
+    }
+
+    /**
+     * sign result of OP
+     */
+    [CCode (cname = "struct _gpgme_op_sign_result")]
+    public struct SignResult {
+        InvalidKey invalid_signers;
+        Signature* signatures;
+    }
+
+    /**
+     * encrypt result of OP
+     */
+    [CCode (cname = "struct _gpgme_op_encrypt_result")]
+    public struct EncryptResult {
+        /**
+         * The list of invalid repipients
+         */
+        InvalidKey invalid_signers;
+    }
+
+    /**
+     * decrypt result of OP
+     */
+    [CCode (cname = "struct _gpgme_op_decrypt_result")]
+    public struct DecryptResult {
+        string unsupported_algorithm;
+        bool wrong_key_usage;
+        Recipient recipients;
+        string filename;
+    }
+
+    /**
+     * An receipient
+     */
+    [CCode (cname = "struct _gpgme_recipient")]
+    public struct Recipient {
+        Recipient *next;
+        string keyid;
+        PublicKeyAlgorithm pubkey_algo;
+        GPGError.ErrorCode status;
+    }
+
+    /**
+     * list of invalid keys
+     */
+    [CCode (cname = "struct _gpgme_invalid_key")]
+    public struct InvalidKey {
+        InvalidKey *next;
+        string fpr;
+        GPGError.ErrorCode reason;
+    }
+
+    /**
+     * A Signature
+     */
+    [CCode (cname = "struct _gpgme_signature")]
+    public struct Signature {
+        /**
+         * The next signature in the list
+         */
+        Signature *next;
+
+        /**
+         * A summary of the signature status
+         */
+        Sigsum summary;
+
+        /**
+         * Fingerprint or key ID of the signature
+         */
+        string fpr;
+
+        /**
+         * The Error status of the signature
+         */
+        GPGError.ErrorCode status;
+
+        /**
+         * Notation data and policy URLs
+         */
+        SigNotation notations;
+
+        /**
+         * Signature creation time
+         */
+        ulong timestamp;
+
+        /**
+         * Signature expiration time or 0
+         */
+        ulong exp_timestamp;
+
+        /**
+         * Key should not have been used for signing
+         */
+        bool wrong_key_usage;
+
+        /**
+         * PKA status
+         */
+        PKAStatus pka_trust;
+
+        /**
+         * Validity has been verified using the chain model
+         */
+        bool chain_model;
+
+        /**
+         * Validity
+         */
+        Validity validity;
+
+        /**
+         * Validity reason
+         */
+        GPGError.ErrorCode validity_reason;
+
+        /**
+         * public key algorithm used to create the signature
+         */
+        PublicKeyAlgorithm pubkey_algo;
+
+        /**
+         * The hash algorithm used to create the signature
+         */
+        HashAlgorithm hash_algo;
+
+        /**
+         * The mailbox from the PKA information or null
+         */
+        string? pka_adress;
+    }
+
+    /**
+     * PKA Status
+     */
+    public enum PKAStatus {
+        NOT_AVAILABLE,
+        BAD,
+        OKAY,
+        RFU
+    }
+
+    /**
+     * Flags used for the summary field in a Signature
+     */
+    [CCode (cname = "gpgme_sigsum_t", cprefix = "GPGME_SIGSUM_")]
+    public enum Sigsum {
+        /**
+         * The signature is fully valid
+         */
+        VALID,
+
+        /**
+         * The signature is good
+         */
+        GREEN,
+
+        /**
+         * The signature is bad
+         */
+        RED,
+
+        /**
+         * One key has been revoked
+         */
+        KEY_REVOKED,
+
+        /**
+         * One key has expired
+         */
+        KEY_EXPIRED,
+
+        /**
+         * The signature has expired
+         */
+        SIG_EXPIRED,
+
+        /**
+         * Can't verfiy - missing key
+         */
+        KEY_MISSING,
+
+        /**
+         * CRL not available
+         */
+        CRL_MISSING,
+
+        /**
+         * Available CRL is too old
+         */
+        CRL_TOO_OLD,
+
+        /**
+         * A policy was not met
+         */
+        BAD_POLICY,
+
+        /**
+         * A system error occured
+         */
+        SYS_ERROR
+    }
+
+    /**
+     * Encoding modes of Data objects
+     */
+    [CCode (cname = "gpgme_data_encoding_t", cprefix = "GPGME_DATA_ENCODING_")]
+    public enum DataEncoding {
+        /**
+         * Not specified
+         */
+        NONE,
+        /**
+         * Binary encoded
+         */
+        BINARY,
+        /**
+         * Base64 encoded
+         */
+        BASE64,
+        /**
+         * Either PEM or OpenPGP Armor
+         */
+        ARMOR,
+        /**
+         * LF delimited URL list
+         */
+        URL,
+        /**
+         * LF percent escaped, delimited URL list
+         */
+        URLESC,
+        /**
+         * Nul determined URL list
+         */
+        URL0
+    }
+
+    /**
+     * Public Key Algorithms from libgcrypt
+     */
+    [CCode (cname = "gpgme_pubkey_algo_t", cprefix = "GPGME_PK_")]
+    public enum PublicKeyAlgorithm {
+        RSA,
+        RSA_E,
+        RSA_S,
+        ELG_E,
+        DSA,
+        ELG
+    }
+
+    /**
+     * Hash Algorithms from libgcrypt
+     */
+    [CCode (cname = "gpgme_hash_algo_t", cprefix = "GPGME_MD_")]
+    public enum HashAlgorithm {
+        NONE,
+        MD5,
+        SHA1,
+        RMD160,
+        MD2,
+        TIGER,
+        HAVAL,
+        SHA256,
+        SHA384,
+        SHA512,
+        MD4,
+        MD_CRC32,
+        MD_CRC32_RFC1510,
+        MD_CRC24_RFC2440
+    }
+
+    /**
+     * Signature modes
+     */
+    [CCode (cname = "gpgme_sig_mode_t", cprefix = "GPGME_SIG_MODE_")]
+    public enum SigMode {
+        NORMAL,
+        DETACH,
+        CLEAR
+    }
+
+    /**
+     * Validities for a trust item or key
+     */
+    [CCode (cname = "gpgme_validity_t", cprefix = "GPGME_VALIDITY_")]
+    public enum Validity {
+        UNKNOWN,
+        UNDEFINED,
+        NEVER,
+        MARGINAL,
+        FULL,
+        ULTIMATE
+    }
+
+    /**
+     * Protocols
+     */
+    [CCode (cname = "gpgme_protocol_t", cprefix = "GPGME_PROTOCOL_")]
+    public enum Protocol {
+        /**
+         * Default Mode
+         */
+        OpenPGP,
+        /**
+         * Cryptographic Message Syntax
+         */
+        CMS,
+        /**
+         * Special code for gpgconf
+         */
+        GPGCONF,
+        /**
+         * Low-level access to an Assuan server
+         */
+        ASSUAN,
+        UNKNOWN
+    }
+
+    /**
+     * Keylist modes used by Context
+     */
+    [CCode (cname = "gpgme_keylist_mode_t", cprefix = "GPGME_KEYLIST_MODE_")]
+    public enum KeylistMode {
+        LOCAL,
+        EXTERN,
+        SIGS,
+        SIG_NOTATIONS,
+        EPHEMERAL,
+        VALIDATE
+    }
+
+    /**
+     * Export modes used by Context
+     */
+    [CCode (cname = "gpgme_export_mode_t", cprefix = "GPGME_EXPORT_MODE_")]
+    public enum ExportMode {
+        EXTERN
+    }
+
+    /**
+     * Audit log function flags
+     */
+    [CCode (cprefix = "GPGME_AUDITLOG_")]
+    public enum AuditLogFlag {
+        HTML,
+        WITH_HELP
+    }
+
+    /**
+     * Signature notation flags
+     */
+    [CCode (cname = "gpgme_sig_notation_flags_t", cprefix = "GPGME_SIG_NOTATION_")]
+    public enum SigNotationFlags {
+        HUMAN_READABLE,
+        CRITICAL
+    }
+
+    /**
+     * Encryption Flags
+     */
+    [CCode (cname = "gpgme_encrypt_flags_t", cprefix = "GPGME_ENCRYPT_")]
+    public enum EncryptFlags {
+        ALWAYS_TRUST,
+        NO_ENCRYPT_TO
+    }
+
+    /**
+     * Edit Operation Stati
+     */
+    [CCode (cname = "gpgme_status_code_t", cprefix = "GPGME_STATUS_")]
+    public enum StatusCode {
+        EOF,
+        ENTER,
+        LEAVE,
+        ABORT,
+        GOODSIG,
+        BADSIG,
+        ERRSIG,
+        BADARMOR,
+        RSA_OR_IDEA,
+        KEYEXPIRED,
+        KEYREVOKED,
+        TRUST_UNDEFINED,
+        TRUST_NEVER,
+        TRUST_MARGINAL,
+        TRUST_FULLY,
+        TRUST_ULTIMATE,
+        SHM_INFO,
+        SHM_GET,
+        SHM_GET_BOOL,
+        SHM_GET_HIDDEN,
+        NEED_PASSPHRASE,
+        VALIDSIG,
+        SIG_ID,
+        SIG_TO,
+        ENC_TO,
+        NODATA,
+        BAD_PASSPHRASE,
+        NO_PUBKEY,
+        NO_SECKEY,
+        NEED_PASSPHRASE_SYM,
+        DECRYPTION_FAILED,
+        DECRYPTION_OKAY,
+        MISSING_PASSPHRASE,
+        GOOD_PASSPHRASE,
+        GOODMDC,
+        BADMDC,
+        ERRMDC,
+        IMPORTED,
+        IMPORT_OK,
+        IMPORT_PROBLEM,
+        IMPORT_RES,
+        FILE_START,
+        FILE_DONE,
+        FILE_ERROR,
+        BEGIN_DECRYPTION,
+        END_DECRYPTION,
+        BEGIN_ENCRYPTION,
+        END_ENCRYPTION,
+        DELETE_PROBLEM,
+        GET_BOOL,
+        GET_LINE,
+        GET_HIDDEN,
+        GOT_IT,
+        PROGRESS,
+        SIG_CREATED,
+        SESSION_KEY,
+        NOTATION_NAME,
+        NOTATION_DATA,
+        POLICY_URL,
+        BEGIN_STREAM,
+        END_STREAM,
+        KEY_CREATED,
+        USERID_HINT,
+        UNEXPECTED,
+        INV_RECP,
+        NO_RECP,
+        ALREADY_SIGNED,
+        SIGEXPIRED,
+        EXPSIG,
+        EXPKEYSIG,
+        TRUNCATED,
+        ERROR,
+        NEWSIG,
+        REVKEYSIG,
+        SIG_SUBPACKET,
+        NEED_PASSPHRASE_PIN,
+        SC_OP_FAILURE,
+        SC_OP_SUCCESS,
+        CARDCTRL,
+        BACKUP_KEY_CREATED,
+        PKA_TRUST_BAD,
+        PKA_TRUST_GOOD,
+        PLAINTEXT
+    }
+
+    /**
+     * The Context object represents a GPG instance
+     */
+    [Compact]
+    [CCode (cname = "struct gpgme_context", free_function = "gpgme_release", cprefix = "gpgme_")]
+    public class Context {
+        /**
+         * Create a new context, returns Error Status Code
+         */
+        [CCode (cname = "gpgme_new")]
+        public static GPGError.ErrorCode Context(out Context ctx);
+
+        public GPGError.ErrorCode set_protocol(Protocol p);
+        public Protocol get_protocol();
+
+        public void set_armor(bool yes);
+        public bool get_armor();
+
+        public void set_textmode(bool yes);
+        public bool get_textmode();
+
+        public GPGError.ErrorCode set_keylist_mode(KeylistMode mode);
+        public KeylistMode get_keylist_mode();
+
+        /**
+         * Include up to nr_of_certs certificates in an S/MIME message,
+         * Use "-256" to use the backend's default.
+         */
+        public void set_include_certs(int nr_of_certs = -256);
+
+        /**
+         * Return the number of certs to include in an S/MIME message
+         */
+        public int get_include_certs();
+
+        /**
+         * Set callback function for requesting passphrase. hook_value will be
+         * passed as first argument.
+         */
+        public void set_passphrase_cb(passphrase_callback cb, void* hook_value = null);
+
+        /**
+         * Get callback function and hook_value
+         */
+        public void get_passphrase_cb(out passphrase_callback cb, out void* hook_value);
+
+        public GPGError.ErrorCode set_locale(int category, string val);
+
+        /**
+         * Get information about the configured engines. The returned data is valid
+         * until the next set_engine_info() call.
+         */
+        [CCode (cname = "gpgme_ctx_get_engine_info")]
+        public EngineInfo* get_engine_info();
+
+        /**
+         * Set information about the configured engines. The string parameters may not
+         * be free'd after this calls, because they are not copied.
+         */
+        [CCode (cname = "gpgme_ctx_set_engine_info")]
+        public GPGError.ErrorCode set_engine_info(Protocol proto, string file_name, string home_dir);
+
+        /**
+         * Delete all signers
+         */
+        public void signers_clear();
+
+        /**
+         * Add key to list of signers
+         */
+        public GPGError.ErrorCode signers_add(Key key);
+
+        /**
+         * Get the n-th signer's key
+         */
+        public Key* signers_enum(int n);
+
+        /**
+         * Clear all notation data
+         */
+        public void sig_notation_clear();
+
+        /**
+         * Add human readable notation data. If name is null,
+         * then value val should be a policy URL. The HUMAN_READABLE
+         * flag is forced to be true for notation data and false
+         * for policy URLs.
+         */
+        public GPGError.ErrorCode sig_notation_add(string name, string val, SigNotationFlags flags);
+
+        /**
+         * Get sig notations
+         */
+        public SigNotation* sig_notation_get();
+
+        /**
+         * Get key with the fingerprint FPR from the crypto backend.
+         * If SECRET is true, get the secret key.
+         */
+        public GPGError.ErrorCode get_key(string fpr, out Key key, bool secret);
+
+        /**
+         * process the pending operation and, if hang is true, wait for
+         * the pending operation to finish.
+         */
+        public Context* wait(out GPGError.ErrorCode status, bool hang);
+
+        /**
+         * Retrieve a pointer to the results of the signing operation
+         */
+        public SignResult* op_sign_result();
+
+        /**
+         * Sign the plaintext PLAIN and store the signature in SIG.
+         */
+        public GPGError.ErrorCode op_sign(Data plain, Data sig, SigMode mode);
+
+        /**
+         * Retrieve a pointer to the result of the verify operation
+         */
+        public VerifyResult* op_verify_result();
+
+        /**
+         * Verify that SIG is a valid signature for SIGNED_TEXT.
+         */
+        public GPGError.ErrorCode op_verify(Data sig, Data signed_text, Data? plaintext);
+
+        /**
+         * Retrieve a pointer to the result of the encrypt operation
+         */
+        public EncryptResult* op_encrypt_result();
+
+        /**
+         * Encrypt plaintext PLAIN for the recipients RECP and store the
+         * resulting ciphertext in CIPHER.
+         */
+        public GPGError.ErrorCode op_encrypt([CCode (array_length = false)] Key[] recp, EncryptFlags flags, Data plain, Data cipher);
+
+        /**
+         * Retrieve a pointer to the result of the decrypt operation
+         */
+        public DecryptResult* op_decrypt_result();
+
+        /**
+         * Decrypt ciphertext CIPHER and store the resulting plaintext
+         * in PLAIN.
+         */
+        public GPGError.ErrorCode op_decrypt(Data cipher, Data plain);
+
+        /**
+         * Export the keys found by PATTERN into KEYDATA. If PATTERN is
+         * NULL all keys will be exported.
+         */
+        public GPGError.ErrorCode op_export(string? pattern, ExportMode mode, Data keydata);
+
+        /**
+         * Import the keys in KEYDATA.
+         */
+        public GPGError.ErrorCode op_import(Data keydata);
+
+        /**
+         * Get result of last op_import.
+         */
+        public unowned ImportResult op_import_result();
+
+        /**
+         * Initiates a key listing operation. It sets everything up, so that
+         * subsequent invocations of op_keylist_next() return the keys in the list.
+         *
+         * If pattern is NULL, all available keys are returned. Otherwise, pattern
+         * contains an engine specific expression that is used to limit the list to
+         * all keys matching the pattern.
+         *
+         * If secret_only is not 0, the list is restricted to secret keys only.
+         *
+         * The context will be busy until either all keys are received (and
+         * op_keylist_next() returns GPG_ERR_EOF), or gpgme_op_keylist_end is called
+         * to finish the operation.
+         *
+         * The function returns the error code GPG_ERR_INV_VALUE if ctx is not a valid
+         * pointer, and passes through any errors that are reported by the crypto engine
+         * support routines.
+         */
+        public GPGError.ErrorCode op_keylist_start(string? pattern = null, int secret_only = 0);
+
+        /**
+         * returns the next key in the list created by a previous op_keylist_start()
+         * operation in the context ctx. The key will have one reference for the user.
+         *
+         * If the last key in the list has already been returned, op_keylist_next()
+         * returns GPG_ERR_EOF.
+         *
+         * The function returns the error code GPG_ERR_INV_VALUE if ctx or r_key is
+         * not a valid pointer, and GPG_ERR_ENOMEM if there is not enough memory for
+         * the operation.
+         */
+        public GPGError.ErrorCode op_keylist_next(out Key key);
+
+        /**
+         * ends a pending key list operation in the context.
+         *
+         * After the operation completed successfully, the result of the key listing
+         * operation can be retrieved with op_keylist_result().
+         *
+         * The function returns the error code GPG_ERR_INV_VALUE if ctx is not a valid
+         * pointer, and GPG_ERR_ENOMEM if at some time during the operation there was
+         * not enough memory available.
+         */
+        public GPGError.ErrorCode op_keylist_end();
+
+        /**
+         * The function op_keylist_result() returns a KeylistResult holding the result of
+         * a op_keylist_*() operation. The returned KeylistResult is only valid if the last
+         * operation on the context was a key listing operation, and if this operation
+         * finished successfully. The returned KeylistResult is only valid until the next
+         * operation is started on the context.
+         */
+        public KeylistResult op_keylist_result();
+    }
+
+    [Flags]
+    [CCode (cname="unsigned int")]
+    public enum ImportStatusFlags {
+        /**
+         * The key was new.
+         */
+        [CCode (cname = "GPGME_IMPORT_NEW")]
+        NEW,
+        /**
+         * The key contained new user IDs.
+         */
+        [CCode (cname = "GPGME_IMPORT_UID")]
+        UID,
+        /**
+         * The key contained new signatures.
+         */
+        [CCode (cname = "GPGME_IMPORT_SIG")]
+        SIG,
+        /**
+         * The key contained new sub keys.
+         */
+        [CCode (cname = "GPGME_IMPORT_SUBKEY")]
+        SUBKEY,
+        /**
+         * The key contained a secret key.
+         */
+        [CCode (cname = "GPGME_IMPORT_SECRET")]
+        SECRET
+    }
+
+    [Compact]
+    [CCode (cname = "struct _gpgme_import_status")]
+    public class ImportStatus {
+        /**
+         * This is a pointer to the next status structure in the linked list, or null
+         * if this is the last element.
+         */
+        public ImportStatus? next;
+
+        /**
+         * fingerprint of the key that was considered.
+         */
+        public string fpr;
+
+        /**
+         * If the import was not successful, this is the error value that caused the
+         * import to fail. Otherwise the error code is GPG_ERR_NO_ERROR.
+         */
+        public GPGError.ErrorCode result;
+
+        /**
+         * Flags what parts of the key have been imported. May be 0, if the key has
+         * already been known.
+         */
+        public ImportStatusFlags status;
+    }
+
+    [Compact]
+    [CCode (cname = "struct _gpgme_op_import_result")]
+    public class ImportResult {
+        /**
+         * The total number of considered keys.
+         */
+        public int considered;
+
+        /**
+         * The number of keys without user ID.
+         */
+        public int no_user_id;
+
+        /**
+         * The total number of imported keys.
+         */
+        public int imported;
+
+        /**
+         * The number of imported RSA keys.
+         */
+        public int imported_rsa;
+
+        /**
+         * The number of unchanged keys.
+         */
+        public int unchanged;
+
+        /**
+         * The number of new user IDs.
+         */
+        public int new_user_ids;
+
+        /**
+         * The number of new sub keys.
+         */
+        public int new_sub_keys;
+
+        /**
+         * The number of new signatures.
+         */
+        public int new_signatures;
+
+        /**
+         * The number of new revocations.
+         */
+        public int new_revocations;
+
+        /**
+         * The total number of secret keys read.
+         */
+        public int secret_read;
+
+        /**
+         * The number of imported secret keys.
+         */
+        public int secret_imported;
+
+        /**
+         * The number of unchanged secret keys.
+         */
+        public int secret_unchanged;
+
+        /**
+         * The number of keys not imported.
+         */
+        public int not_imported;
+
+        /*
+         * A linked list of ImportStatus objects which
+         * contains more information about the keys for
+         * which an import was attempted.
+         */
+        public ImportStatus imports;
+    }
+
+    [Compact]
+    [CCode (cname = "struct _gpgme_op_keylist_result")]
+    public class KeylistResult {
+        uint truncated;
+    }
+
+
+    /**
+     * Data Object, contains encrypted and/or unencrypted data
+     */
+    [Compact]
+    [CCode (cname = "struct gpgme_data", free_function = "gpgme_data_release", cprefix = "gpgme_data_")]
+    public class Data {
+        /**
+         * Create a new data buffer, returns Error Status Code.
+         */
+        [CCode (cname = "gpgme_data_new")]
+        public static GPGError.ErrorCode create(out Data d);
+
+        /**
+         * Create a new data buffer filled with SIZE bytes starting
+         * from BUFFER. If COPY is false, COPYING is delayed until
+         * necessary and the data is taken from the original location
+         * when needed. Returns Error Status Code.
+         */
+        [CCode (cname = "gpgme_data_new_from_mem")]
+        public static GPGError.ErrorCode create_from_memory(out Data d, uint8[] buffer, bool copy);
+
+        /**
+         * Create a new data buffer filled with the content of the file.
+         * COPY must be non-zero. For delayed read, please use
+         * create_from_fd or create_from stream instead.
+         */
+        [CCode (cname = "gpgme_data_new_from_file")]
+        public static GPGError.ErrorCode create_from_file(out Data d, string filename, int copy = 1);
+
+
+        /**
+         * Destroy the object and return a pointer to its content.
+         * It's size is returned in R_LEN.
+         */
+        [CCode (cname = "gpgme_data_release_and_get_mem")]
+        public string release_and_get_mem(out size_t len);
+
+        /**
+         * Read up to SIZE bytes into buffer BUFFER from the data object.
+         * Return the number of characters read, 0 on EOF and -1 on error.
+         * If an error occurs, errno is set.
+         */
+        public ssize_t read(uint8[] buf);
+
+        /**
+         * Write up to SIZE bytes from buffer BUFFER to the data object.
+         * Return the number of characters written, or -1 on error.
+         * If an error occurs, errno is set.
+         */
+        public ssize_t write(uint8[] buf);
+
+        /**
+         * Set the current position from where the next read or write
+         * starts in the data object to OFFSET, relativ to WHENCE.
+         */
+        public long seek(long offset, int whence=0);
+
+        /**
+         * Get the encoding attribute of the buffer
+         */
+        public DataEncoding *get_encoding();
+
+        /**
+         * Set the encoding attribute of the buffer to ENC
+         */
+        public GPGError.ErrorCode set_encoding(DataEncoding enc);
+    }
+
+    [CCode (cname = "gpgme_get_protocol_name")]
+    public unowned string get_protocol_name(Protocol p);
+
+    [CCode (cname = "gpgme_pubkey_algo_name")]
+    public unowned string get_public_key_algorithm_name(PublicKeyAlgorithm algo);
+
+    [CCode (cname = "gpgme_hash_algo_name")]
+    public unowned string get_hash_algorithm_name(HashAlgorithm algo);
+
+    [CCode (cname = "gpgme_passphrase_cb_t", has_target = false)]
+    public delegate GPGError.ErrorCode passphrase_callback(void* hook, string uid_hint, string passphrase_info, bool prev_was_bad, int fd);
+
+    /**
+     * Get version of libgpgme
+     * Always call this function before using gpgme, it initializes some stuff
+     */
+    [CCode (cname = "gpgme_check_version")]
+    public unowned string check_version(string? required_version = null);
+
+    /**
+     * Verify that the engine implementing proto is installed and
+     * available.
+     */
+    [CCode (cname = "gpgme_engine_check_version")]
+    public GPGError.ErrorCode engine_check_version(Protocol proto);
+
+    /**
+     * Get information about the configured engines. The returned data is valid
+     * until the next set_engine_info() call.
+     */
+    [CCode (cname = "gpgme_get_engine_information")]
+    public GPGError.ErrorCode get_engine_information(out EngineInfo engine_info);
+
+    /**
+     * Return the error string for ERR in the user-supplied buffer BUF
+     * of size BUFLEN. This function is thread-safe, if a thread-safe
+     * strerror_r() function is provided by the system. If the function
+     * succeeds, 0 is returned and BUF contains the string describing
+     * the error. If the buffer was not large enough, ERANGE is returned
+     * and BUF contains as much of the beginning of the error string as
+     * fits into the buffer. Returns Error Status Code.
+     */
+    [CCode (cname = "gpgme_strerror_r")]
+    public int strerror_r(GPGError.ErrorCode err, uint8[] buf);
+
+    /**
+     * Like strerror_r, but returns a pointer to the string. This method
+     * is not thread safe!
+     */
+    [CCode (cname = "gpgme_strerror")]
+    public unowned string strerror(GPGError.ErrorCode err);
+}
diff --git a/vapi/uuid.vapi b/vapi/uuid.vapi
new file mode 100644
index 00000000..038fcc33
--- /dev/null
+++ b/vapi/uuid.vapi
@@ -0,0 +1,68 @@
+/* libuuid Vala Bindings
+ * Copyright 2014 Evan Nemerson <evan@nemerson.com>
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy,
+ * modify, merge, publish, distribute, sublicense, and/or sell copies
+ * of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+[CCode (cheader_filename = "uuid.h", lower_case_cprefix = "uuid_")]
+namespace UUID {
+    [CCode (cname = "int", has_type_id = false)]
+    public enum Variant {
+        NCS,
+        DCE,
+        MICROSOFT,
+        OTHER
+    }
+
+    [CCode (cname = "int", has_type_id = false)]
+    public enum Type {
+        DCE_TIME,
+        DCE_RANDOM
+    }
+
+    public static void clear ([CCode (array_length = false)] uint8 uu[16]);
+    public static void copy (uint8 dst[16], uint8 src[16]);
+
+    public static void generate ([CCode (array_length = false)] uint8 @out[16]);
+    public static void generate_random ([CCode (array_length = false)] uint8 @out[16]);
+    public static void generate_time ([CCode (array_length = false)] uint8 @out[16]);
+    public static void generate_time_safe ([CCode (array_length = false)] uint8 @out[16]);
+
+    public static bool is_null ([CCode (array_length = false)] uint8 uu[16]);
+
+    public static int parse (string in, [CCode (array_length = false)] uint8 uu[16]);
+
+    public static void unparse ([CCode (array_length = false)] uint8 uu[16], [CCode (array_length = false)] char @out[37]);
+    public static void unparse_lower ([CCode (array_length = false)] uint8 uu[16], [CCode (array_length = false)] char @out[37]);
+    public static void unparse_upper ([CCode (array_length = false)] uint8 uu[16], [CCode (array_length = false)] char @out[37]);
+
+//    public static time_t time ([CCode (array_length = false)] uint8 uu[16], out Posix.timeval ret_tv);
+    public static UUID.Type type ([CCode (array_length = false)] uint8 uu[16]);
+    public static UUID.Variant variant ([CCode (array_length = false)] uint8 uu[16]);
+
+    public static string generate_random_unparsed() {
+        uint8[] rand = new uint8[16];
+        char[] str = new char[37];
+        generate_random(rand);
+        unparse_upper(rand, str);
+        return (string) str;
+    }
+}