module bindings.curl;

import core.stdc.config;
import core.sys.posix.sys.select;
import core.sys.posix.sys.socket;

extern (C):

alias curl_off_t = long;
alias CURL = void;
alias CURLSH = void;

alias curl_socket_t = int;
enum CURL_SOCKET_BAD = -1;

enum curl_sslbackend
{
    CURLSSLBACKEND_NONE = 0,
    CURLSSLBACKEND_OPENSSL = 1,
    CURLSSLBACKEND_GNUTLS = 2,
    CURLSSLBACKEND_NSS = 3,
    CURLSSLBACKEND_OBSOLETE4 = 4,
    CURLSSLBACKEND_GSKIT = 5,
    CURLSSLBACKEND_POLARSSL = 6,
    CURLSSLBACKEND_WOLFSSL = 7,
    CURLSSLBACKEND_SCHANNEL = 8,
    CURLSSLBACKEND_SECURETRANSPORT = 9,
    CURLSSLBACKEND_AXTLS = 10,
    CURLSSLBACKEND_MBEDTLS = 11,
    CURLSSLBACKEND_MESALINK = 12,
    CURLSSLBACKEND_BEARSSL = 13,
    CURLSSLBACKEND_RUSTLS = 14
}

alias CURLSSLBACKEND_NONE = curl_sslbackend.CURLSSLBACKEND_NONE;
alias CURLSSLBACKEND_OPENSSL = curl_sslbackend.CURLSSLBACKEND_OPENSSL;
alias CURLSSLBACKEND_GNUTLS = curl_sslbackend.CURLSSLBACKEND_GNUTLS;
alias CURLSSLBACKEND_NSS = curl_sslbackend.CURLSSLBACKEND_NSS;
alias CURLSSLBACKEND_OBSOLETE4 = curl_sslbackend.CURLSSLBACKEND_OBSOLETE4;
alias CURLSSLBACKEND_GSKIT = curl_sslbackend.CURLSSLBACKEND_GSKIT;
alias CURLSSLBACKEND_POLARSSL = curl_sslbackend.CURLSSLBACKEND_POLARSSL;
alias CURLSSLBACKEND_WOLFSSL = curl_sslbackend.CURLSSLBACKEND_WOLFSSL;
alias CURLSSLBACKEND_SCHANNEL = curl_sslbackend.CURLSSLBACKEND_SCHANNEL;
alias CURLSSLBACKEND_SECURETRANSPORT = curl_sslbackend.CURLSSLBACKEND_SECURETRANSPORT;
alias CURLSSLBACKEND_AXTLS = curl_sslbackend.CURLSSLBACKEND_AXTLS;
alias CURLSSLBACKEND_MBEDTLS = curl_sslbackend.CURLSSLBACKEND_MBEDTLS;
alias CURLSSLBACKEND_MESALINK = curl_sslbackend.CURLSSLBACKEND_MESALINK;
alias CURLSSLBACKEND_BEARSSL = curl_sslbackend.CURLSSLBACKEND_BEARSSL;
alias CURLSSLBACKEND_RUSTLS = curl_sslbackend.CURLSSLBACKEND_RUSTLS;

enum CURLSSLBACKEND_AWSLC = curl_sslbackend.CURLSSLBACKEND_OPENSSL;
enum CURLSSLBACKEND_BORINGSSL = curl_sslbackend.CURLSSLBACKEND_OPENSSL;
enum CURLSSLBACKEND_LIBRESSL = curl_sslbackend.CURLSSLBACKEND_OPENSSL;

enum CURLSSLBACKEND_CYASSL = curl_sslbackend.CURLSSLBACKEND_WOLFSSL;
enum CURLSSLBACKEND_DARWINSSL = curl_sslbackend.CURLSSLBACKEND_SECURETRANSPORT;

struct curl_httppost
{
    curl_httppost* next;
    char* name;
    c_long namelength;
    char* contents;
    c_long contentslength;

    char* buffer;
    c_long bufferlength;
    char* contenttype;

    struct curl_slist
    {
        char* data;
        curl_slist* next;
    }

    curl_slist* contentheader;
    curl_httppost* more;
    c_long flags;
    char* showfilename;
    void* userp;
    alias curl_off_t = c_long;
    curl_off_t contentlen;
}

enum CURL_HTTPPOST_FILENAME = 1 << 0;
enum CURL_HTTPPOST_READFILE = 1 << 1;
enum CURL_HTTPPOST_PTRNAME = 1 << 2;
enum CURL_HTTPPOST_PTRCONTENTS = 1 << 3;
enum CURL_HTTPPOST_BUFFER = 1 << 4;
enum CURL_HTTPPOST_PTRBUFFER = 1 << 5;
enum CURL_HTTPPOST_CALLBACK = 1 << 6;
enum CURL_HTTPPOST_LARGE = 1 << 7;
enum CURL_PROGRESSFUNC_CONTINUE = 0x10000001;
alias curl_progress_callback = int function (void* clientp, double dltotal, double dlnow, double ultotal, double ulnow);
alias curl_xferinfo_callback = int function (void* clientp, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow);
enum CURL_MAX_READ_SIZE = 10 * 1024 * 1024;
enum CURL_MAX_WRITE_SIZE = 16384;
enum CURL_MAX_HTTP_HEADER = 100 * 1024;
enum CURL_WRITEFUNC_PAUSE = 0x10000001;
enum CURL_WRITEFUNC_ERROR = 0xFFFFFFFF;
alias curl_write_callback = c_ulong function (char* buffer, size_t size, size_t nitems, void* outstream);
alias curl_resolver_start_callback = int function (void* resolver_state, void* reserved, void* userdata);

enum curlfiletype
{
    CURLFILETYPE_FILE = 0,
    CURLFILETYPE_DIRECTORY = 1,
    CURLFILETYPE_SYMLINK = 2,
    CURLFILETYPE_DEVICE_BLOCK = 3,
    CURLFILETYPE_DEVICE_CHAR = 4,
    CURLFILETYPE_NAMEDPIPE = 5,
    CURLFILETYPE_SOCKET = 6,
    CURLFILETYPE_DOOR = 7,
    CURLFILETYPE_UNKNOWN = 8
}

alias CURLFILETYPE_FILE = curlfiletype.CURLFILETYPE_FILE;
alias CURLFILETYPE_DIRECTORY = curlfiletype.CURLFILETYPE_DIRECTORY;
alias CURLFILETYPE_SYMLINK = curlfiletype.CURLFILETYPE_SYMLINK;
alias CURLFILETYPE_DEVICE_BLOCK = curlfiletype.CURLFILETYPE_DEVICE_BLOCK;
alias CURLFILETYPE_DEVICE_CHAR = curlfiletype.CURLFILETYPE_DEVICE_CHAR;
alias CURLFILETYPE_NAMEDPIPE = curlfiletype.CURLFILETYPE_NAMEDPIPE;
alias CURLFILETYPE_SOCKET = curlfiletype.CURLFILETYPE_SOCKET;
alias CURLFILETYPE_DOOR = curlfiletype.CURLFILETYPE_DOOR;
alias CURLFILETYPE_UNKNOWN = curlfiletype.CURLFILETYPE_UNKNOWN;

enum CURLFINFOFLAG_KNOWN_FILENAME = 1 << 0;
enum CURLFINFOFLAG_KNOWN_FILETYPE = 1 << 1;
enum CURLFINFOFLAG_KNOWN_TIME = 1 << 2;
enum CURLFINFOFLAG_KNOWN_PERM = 1 << 3;
enum CURLFINFOFLAG_KNOWN_UID = 1 << 4;
enum CURLFINFOFLAG_KNOWN_GID = 1 << 5;
enum CURLFINFOFLAG_KNOWN_SIZE = 1 << 6;
enum CURLFINFOFLAG_KNOWN_HLINKCOUNT = 1 << 7;

struct curl_fileinfo
{
    char* filename;
    curlfiletype filetype;
    alias time_t = c_long;
    time_t time;
    uint perm;
    int uid;
    int gid;
    curl_off_t size;
    c_long hardlinks;

    struct idk
    {
        char* time;
        char* perm;
        char* user;
        char* group;
        char* target;
    }

    idk strings;
    uint flags;
    char* b_data;
    alias size_t = c_ulong;
    size_t b_size;
    size_t b_used;
}

enum CURL_CHUNK_BGN_FUNC_OK = 0;
enum CURL_CHUNK_BGN_FUNC_FAIL = 1;
enum CURL_CHUNK_BGN_FUNC_SKIP = 2;
alias curl_chunk_bgn_callback = c_long function (const(void)* transfer_info, void* ptr, int remains);
enum CURL_CHUNK_END_FUNC_OK = 0;
enum CURL_CHUNK_END_FUNC_FAIL = 1;
alias curl_chunk_end_callback = c_long function (void* ptr);
enum CURL_FNMATCHFUNC_MATCH = 0;
enum CURL_FNMATCHFUNC_NOMATCH = 1;
enum CURL_FNMATCHFUNC_FAIL = 2;
alias curl_fnmatch_callback = int function (void* ptr, const(char)* pattern, const(char)* string);
enum CURL_SEEKFUNC_OK = 0;
enum CURL_SEEKFUNC_FAIL = 1;
enum CURL_SEEKFUNC_CANTSEEK = 2;
alias curl_seek_callback = int function (void* instream, curl_off_t offset, int origin);
enum CURL_READFUNC_ABORT = 0x10000000;
enum CURL_READFUNC_PAUSE = 0x10000001;
enum CURL_TRAILERFUNC_OK = 0;
enum CURL_TRAILERFUNC_ABORT = 1;
alias curl_read_callback = c_ulong function (char* buffer, size_t size, size_t nitems, void* instream);
alias curl_trailer_callback = int function (curl_slist** list, void* userdata);

enum curlsocktype
{
    CURLSOCKTYPE_IPCXN = 0,
    CURLSOCKTYPE_ACCEPT = 1,
    CURLSOCKTYPE_LAST = 2
}

alias CURLSOCKTYPE_IPCXN = curlsocktype.CURLSOCKTYPE_IPCXN;
alias CURLSOCKTYPE_ACCEPT = curlsocktype.CURLSOCKTYPE_ACCEPT;
alias CURLSOCKTYPE_LAST = curlsocktype.CURLSOCKTYPE_LAST;

enum CURL_SOCKOPT_OK = 0;
enum CURL_SOCKOPT_ERROR = 1;
enum CURL_SOCKOPT_ALREADY_CONNECTED = 2;
alias curl_sockopt_callback = int function (void* clientp, curl_socket_t curlfd, curlsocktype purpose);

struct curl_sockaddr
{
    int family;
    int socktype;
    int protocol;
    uint addrlen;

    struct sockaddr
    {
        alias sa_family_t = ushort;
        sa_family_t sa_family;
        char[14] sa_data;
    }

    sockaddr addr;
}

alias curl_opensocket_callback = int function (void* clientp, curlsocktype purpose, curl_sockaddr* address);
alias curl_closesocket_callback = int function (void* clientp, curl_socket_t item);

enum curlioerr
{
    CURLIOE_OK = 0,
    CURLIOE_UNKNOWNCMD = 1,
    CURLIOE_FAILRESTART = 2,
    CURLIOE_LAST = 3
}

alias CURLIOE_OK = curlioerr.CURLIOE_OK;
alias CURLIOE_UNKNOWNCMD = curlioerr.CURLIOE_UNKNOWNCMD;
alias CURLIOE_FAILRESTART = curlioerr.CURLIOE_FAILRESTART;
alias CURLIOE_LAST = curlioerr.CURLIOE_LAST;

enum curliocmd
{
    CURLIOCMD_NOP = 0,
    CURLIOCMD_RESTARTREAD = 1,
    CURLIOCMD_LAST = 2
}

alias CURLIOCMD_NOP = curliocmd.CURLIOCMD_NOP;
alias CURLIOCMD_RESTARTREAD = curliocmd.CURLIOCMD_RESTARTREAD;
alias CURLIOCMD_LAST = curliocmd.CURLIOCMD_LAST;

alias curl_ioctl_callback = curlioerr function (CURL* handle, int cmd, void* clientp);
alias curl_malloc_callback = void* function (size_t size);
alias curl_free_callback = void function (void* ptr);
alias curl_realloc_callback = void* function (void* ptr, size_t size);
alias curl_strdup_callback = char* function (const(char)* str);
alias curl_calloc_callback = void* function (size_t nmemb, size_t size);

enum curl_infotype
{
    CURLINFO_TEXT = 0,
    CURLINFO_HEADER_IN = 1,
    CURLINFO_HEADER_OUT = 2,
    CURLINFO_DATA_IN = 3,
    CURLINFO_DATA_OUT = 4,
    CURLINFO_SSL_DATA_IN = 5,
    CURLINFO_SSL_DATA_OUT = 6,
    CURLINFO_END = 7
}

alias CURLINFO_TEXT = curl_infotype.CURLINFO_TEXT;
alias CURLINFO_HEADER_IN = curl_infotype.CURLINFO_HEADER_IN;
alias CURLINFO_HEADER_OUT = curl_infotype.CURLINFO_HEADER_OUT;
alias CURLINFO_DATA_IN = curl_infotype.CURLINFO_DATA_IN;
alias CURLINFO_DATA_OUT = curl_infotype.CURLINFO_DATA_OUT;
alias CURLINFO_SSL_DATA_IN = curl_infotype.CURLINFO_SSL_DATA_IN;
alias CURLINFO_SSL_DATA_OUT = curl_infotype.CURLINFO_SSL_DATA_OUT;
alias CURLINFO_END = curl_infotype.CURLINFO_END;

alias curl_debug_callback = int function (CURL* handle, curl_infotype type, char* data, size_t size, void* userptr);
alias curl_prereq_callback = int function (void* clientp, char* conn_primary_ip, char* conn_local_ip, int conn_primary_port, int conn_local_port);
enum CURL_PREREQFUNC_OK = 0;
enum CURL_PREREQFUNC_ABORT = 1;

enum CURLcode
{
    CURLE_OK = 0,
    CURLE_UNSUPPORTED_PROTOCOL = 1,
    CURLE_FAILED_INIT = 2,
    CURLE_URL_MALFORMAT = 3,
    CURLE_NOT_BUILT_IN = 4,
    CURLE_COULDNT_RESOLVE_PROXY = 5,
    CURLE_COULDNT_RESOLVE_HOST = 6,
    CURLE_COULDNT_CONNECT = 7,
    CURLE_WEIRD_SERVER_REPLY = 8,
    CURLE_REMOTE_ACCESS_DENIED = 9,
    CURLE_FTP_ACCEPT_FAILED = 10,
    CURLE_FTP_WEIRD_PASS_REPLY = 11,
    CURLE_FTP_ACCEPT_TIMEOUT = 12,
    CURLE_FTP_WEIRD_PASV_REPLY = 13,
    CURLE_FTP_WEIRD_227_FORMAT = 14,
    CURLE_FTP_CANT_GET_HOST = 15,
    CURLE_HTTP2 = 16,
    CURLE_FTP_COULDNT_SET_TYPE = 17,
    CURLE_PARTIAL_FILE = 18,
    CURLE_FTP_COULDNT_RETR_FILE = 19,
    CURLE_OBSOLETE20 = 20,
    CURLE_QUOTE_ERROR = 21,
    CURLE_HTTP_RETURNED_ERROR = 22,
    CURLE_WRITE_ERROR = 23,
    CURLE_OBSOLETE24 = 24,
    CURLE_UPLOAD_FAILED = 25,
    CURLE_READ_ERROR = 26,
    CURLE_OUT_OF_MEMORY = 27,
    CURLE_OPERATION_TIMEDOUT = 28,
    CURLE_OBSOLETE29 = 29,
    CURLE_FTP_PORT_FAILED = 30,
    CURLE_FTP_COULDNT_USE_REST = 31,
    CURLE_OBSOLETE32 = 32,
    CURLE_RANGE_ERROR = 33,
    CURLE_OBSOLETE34 = 34,
    CURLE_SSL_CONNECT_ERROR = 35,
    CURLE_BAD_DOWNLOAD_RESUME = 36,
    CURLE_FILE_COULDNT_READ_FILE = 37,
    CURLE_LDAP_CANNOT_BIND = 38,
    CURLE_LDAP_SEARCH_FAILED = 39,
    CURLE_OBSOLETE40 = 40,
    CURLE_OBSOLETE41 = 41,
    CURLE_ABORTED_BY_CALLBACK = 42,
    CURLE_BAD_FUNCTION_ARGUMENT = 43,
    CURLE_OBSOLETE44 = 44,
    CURLE_INTERFACE_FAILED = 45,
    CURLE_OBSOLETE46 = 46,
    CURLE_TOO_MANY_REDIRECTS = 47,
    CURLE_UNKNOWN_OPTION = 48,
    CURLE_SETOPT_OPTION_SYNTAX = 49,
    CURLE_OBSOLETE50 = 50,
    CURLE_OBSOLETE51 = 51,
    CURLE_GOT_NOTHING = 52,
    CURLE_SSL_ENGINE_NOTFOUND = 53,
    CURLE_SSL_ENGINE_SETFAILED = 54,
    CURLE_SEND_ERROR = 55,
    CURLE_RECV_ERROR = 56,
    CURLE_OBSOLETE57 = 57,
    CURLE_SSL_CERTPROBLEM = 58,
    CURLE_SSL_CIPHER = 59,
    CURLE_PEER_FAILED_VERIFICATION = 60,
    CURLE_BAD_CONTENT_ENCODING = 61,
    CURLE_OBSOLETE62 = 62,
    CURLE_FILESIZE_EXCEEDED = 63,
    CURLE_USE_SSL_FAILED = 64,
    CURLE_SEND_FAIL_REWIND = 65,
    CURLE_SSL_ENGINE_INITFAILED = 66,
    CURLE_LOGIN_DENIED = 67,
    CURLE_TFTP_NOTFOUND = 68,
    CURLE_TFTP_PERM = 69,
    CURLE_REMOTE_DISK_FULL = 70,
    CURLE_TFTP_ILLEGAL = 71,
    CURLE_TFTP_UNKNOWNID = 72,
    CURLE_REMOTE_FILE_EXISTS = 73,
    CURLE_TFTP_NOSUCHUSER = 74,
    CURLE_OBSOLETE75 = 75,
    CURLE_OBSOLETE76 = 76,
    CURLE_SSL_CACERT_BADFILE = 77,
    CURLE_REMOTE_FILE_NOT_FOUND = 78,
    CURLE_SSH = 79,
    CURLE_SSL_SHUTDOWN_FAILED = 80,
    CURLE_AGAIN = 81,
    CURLE_SSL_CRL_BADFILE = 82,
    CURLE_SSL_ISSUER_ERROR = 83,
    CURLE_FTP_PRET_FAILED = 84,
    CURLE_RTSP_CSEQ_ERROR = 85,
    CURLE_RTSP_SESSION_ERROR = 86,
    CURLE_FTP_BAD_FILE_LIST = 87,
    CURLE_CHUNK_FAILED = 88,
    CURLE_NO_CONNECTION_AVAILABLE = 89,
    CURLE_SSL_PINNEDPUBKEYNOTMATCH = 90,
    CURLE_SSL_INVALIDCERTSTATUS = 91,
    CURLE_HTTP2_STREAM = 92,
    CURLE_RECURSIVE_API_CALL = 93,
    CURLE_AUTH_ERROR = 94,
    CURLE_HTTP3 = 95,
    CURLE_QUIC_CONNECT_ERROR = 96,
    CURLE_PROXY = 97,
    CURLE_SSL_CLIENTCERT = 98,
    CURLE_UNRECOVERABLE_POLL = 99,
    CURLE_TOO_LARGE = 100,
    CURLE_ECH_REQUIRED = 101,
    CURL_LAST = 102
}

alias CURLE_OK = CURLcode.CURLE_OK;
alias CURLE_UNSUPPORTED_PROTOCOL = CURLcode.CURLE_UNSUPPORTED_PROTOCOL;
alias CURLE_FAILED_INIT = CURLcode.CURLE_FAILED_INIT;
alias CURLE_URL_MALFORMAT = CURLcode.CURLE_URL_MALFORMAT;
alias CURLE_NOT_BUILT_IN = CURLcode.CURLE_NOT_BUILT_IN;
alias CURLE_COULDNT_RESOLVE_PROXY = CURLcode.CURLE_COULDNT_RESOLVE_PROXY;
alias CURLE_COULDNT_RESOLVE_HOST = CURLcode.CURLE_COULDNT_RESOLVE_HOST;
alias CURLE_COULDNT_CONNECT = CURLcode.CURLE_COULDNT_CONNECT;
alias CURLE_WEIRD_SERVER_REPLY = CURLcode.CURLE_WEIRD_SERVER_REPLY;
alias CURLE_REMOTE_ACCESS_DENIED = CURLcode.CURLE_REMOTE_ACCESS_DENIED;
alias CURLE_FTP_ACCEPT_FAILED = CURLcode.CURLE_FTP_ACCEPT_FAILED;
alias CURLE_FTP_WEIRD_PASS_REPLY = CURLcode.CURLE_FTP_WEIRD_PASS_REPLY;
alias CURLE_FTP_ACCEPT_TIMEOUT = CURLcode.CURLE_FTP_ACCEPT_TIMEOUT;
alias CURLE_FTP_WEIRD_PASV_REPLY = CURLcode.CURLE_FTP_WEIRD_PASV_REPLY;
alias CURLE_FTP_WEIRD_227_FORMAT = CURLcode.CURLE_FTP_WEIRD_227_FORMAT;
alias CURLE_FTP_CANT_GET_HOST = CURLcode.CURLE_FTP_CANT_GET_HOST;
alias CURLE_HTTP2 = CURLcode.CURLE_HTTP2;
alias CURLE_FTP_COULDNT_SET_TYPE = CURLcode.CURLE_FTP_COULDNT_SET_TYPE;
alias CURLE_PARTIAL_FILE = CURLcode.CURLE_PARTIAL_FILE;
alias CURLE_FTP_COULDNT_RETR_FILE = CURLcode.CURLE_FTP_COULDNT_RETR_FILE;
alias CURLE_OBSOLETE20 = CURLcode.CURLE_OBSOLETE20;
alias CURLE_QUOTE_ERROR = CURLcode.CURLE_QUOTE_ERROR;
alias CURLE_HTTP_RETURNED_ERROR = CURLcode.CURLE_HTTP_RETURNED_ERROR;
alias CURLE_WRITE_ERROR = CURLcode.CURLE_WRITE_ERROR;
alias CURLE_OBSOLETE24 = CURLcode.CURLE_OBSOLETE24;
alias CURLE_UPLOAD_FAILED = CURLcode.CURLE_UPLOAD_FAILED;
alias CURLE_READ_ERROR = CURLcode.CURLE_READ_ERROR;
alias CURLE_OUT_OF_MEMORY = CURLcode.CURLE_OUT_OF_MEMORY;
alias CURLE_OPERATION_TIMEDOUT = CURLcode.CURLE_OPERATION_TIMEDOUT;
alias CURLE_OBSOLETE29 = CURLcode.CURLE_OBSOLETE29;
alias CURLE_FTP_PORT_FAILED = CURLcode.CURLE_FTP_PORT_FAILED;
alias CURLE_FTP_COULDNT_USE_REST = CURLcode.CURLE_FTP_COULDNT_USE_REST;
alias CURLE_OBSOLETE32 = CURLcode.CURLE_OBSOLETE32;
alias CURLE_RANGE_ERROR = CURLcode.CURLE_RANGE_ERROR;
alias CURLE_OBSOLETE34 = CURLcode.CURLE_OBSOLETE34;
alias CURLE_SSL_CONNECT_ERROR = CURLcode.CURLE_SSL_CONNECT_ERROR;
alias CURLE_BAD_DOWNLOAD_RESUME = CURLcode.CURLE_BAD_DOWNLOAD_RESUME;
alias CURLE_FILE_COULDNT_READ_FILE = CURLcode.CURLE_FILE_COULDNT_READ_FILE;
alias CURLE_LDAP_CANNOT_BIND = CURLcode.CURLE_LDAP_CANNOT_BIND;
alias CURLE_LDAP_SEARCH_FAILED = CURLcode.CURLE_LDAP_SEARCH_FAILED;
alias CURLE_OBSOLETE40 = CURLcode.CURLE_OBSOLETE40;
alias CURLE_OBSOLETE41 = CURLcode.CURLE_OBSOLETE41;
alias CURLE_ABORTED_BY_CALLBACK = CURLcode.CURLE_ABORTED_BY_CALLBACK;
alias CURLE_BAD_FUNCTION_ARGUMENT = CURLcode.CURLE_BAD_FUNCTION_ARGUMENT;
alias CURLE_OBSOLETE44 = CURLcode.CURLE_OBSOLETE44;
alias CURLE_INTERFACE_FAILED = CURLcode.CURLE_INTERFACE_FAILED;
alias CURLE_OBSOLETE46 = CURLcode.CURLE_OBSOLETE46;
alias CURLE_TOO_MANY_REDIRECTS = CURLcode.CURLE_TOO_MANY_REDIRECTS;
alias CURLE_UNKNOWN_OPTION = CURLcode.CURLE_UNKNOWN_OPTION;
alias CURLE_SETOPT_OPTION_SYNTAX = CURLcode.CURLE_SETOPT_OPTION_SYNTAX;
alias CURLE_OBSOLETE50 = CURLcode.CURLE_OBSOLETE50;
alias CURLE_OBSOLETE51 = CURLcode.CURLE_OBSOLETE51;
alias CURLE_GOT_NOTHING = CURLcode.CURLE_GOT_NOTHING;
alias CURLE_SSL_ENGINE_NOTFOUND = CURLcode.CURLE_SSL_ENGINE_NOTFOUND;
alias CURLE_SSL_ENGINE_SETFAILED = CURLcode.CURLE_SSL_ENGINE_SETFAILED;
alias CURLE_SEND_ERROR = CURLcode.CURLE_SEND_ERROR;
alias CURLE_RECV_ERROR = CURLcode.CURLE_RECV_ERROR;
alias CURLE_OBSOLETE57 = CURLcode.CURLE_OBSOLETE57;
alias CURLE_SSL_CERTPROBLEM = CURLcode.CURLE_SSL_CERTPROBLEM;
alias CURLE_SSL_CIPHER = CURLcode.CURLE_SSL_CIPHER;
alias CURLE_PEER_FAILED_VERIFICATION = CURLcode.CURLE_PEER_FAILED_VERIFICATION;
alias CURLE_BAD_CONTENT_ENCODING = CURLcode.CURLE_BAD_CONTENT_ENCODING;
alias CURLE_OBSOLETE62 = CURLcode.CURLE_OBSOLETE62;
alias CURLE_FILESIZE_EXCEEDED = CURLcode.CURLE_FILESIZE_EXCEEDED;
alias CURLE_USE_SSL_FAILED = CURLcode.CURLE_USE_SSL_FAILED;
alias CURLE_SEND_FAIL_REWIND = CURLcode.CURLE_SEND_FAIL_REWIND;
alias CURLE_SSL_ENGINE_INITFAILED = CURLcode.CURLE_SSL_ENGINE_INITFAILED;
alias CURLE_LOGIN_DENIED = CURLcode.CURLE_LOGIN_DENIED;
alias CURLE_TFTP_NOTFOUND = CURLcode.CURLE_TFTP_NOTFOUND;
alias CURLE_TFTP_PERM = CURLcode.CURLE_TFTP_PERM;
alias CURLE_REMOTE_DISK_FULL = CURLcode.CURLE_REMOTE_DISK_FULL;
alias CURLE_TFTP_ILLEGAL = CURLcode.CURLE_TFTP_ILLEGAL;
alias CURLE_TFTP_UNKNOWNID = CURLcode.CURLE_TFTP_UNKNOWNID;
alias CURLE_REMOTE_FILE_EXISTS = CURLcode.CURLE_REMOTE_FILE_EXISTS;
alias CURLE_TFTP_NOSUCHUSER = CURLcode.CURLE_TFTP_NOSUCHUSER;
alias CURLE_OBSOLETE75 = CURLcode.CURLE_OBSOLETE75;
alias CURLE_OBSOLETE76 = CURLcode.CURLE_OBSOLETE76;
alias CURLE_SSL_CACERT_BADFILE = CURLcode.CURLE_SSL_CACERT_BADFILE;
alias CURLE_REMOTE_FILE_NOT_FOUND = CURLcode.CURLE_REMOTE_FILE_NOT_FOUND;
alias CURLE_SSH = CURLcode.CURLE_SSH;
alias CURLE_SSL_SHUTDOWN_FAILED = CURLcode.CURLE_SSL_SHUTDOWN_FAILED;
alias CURLE_AGAIN = CURLcode.CURLE_AGAIN;
alias CURLE_SSL_CRL_BADFILE = CURLcode.CURLE_SSL_CRL_BADFILE;
alias CURLE_SSL_ISSUER_ERROR = CURLcode.CURLE_SSL_ISSUER_ERROR;
alias CURLE_FTP_PRET_FAILED = CURLcode.CURLE_FTP_PRET_FAILED;
alias CURLE_RTSP_CSEQ_ERROR = CURLcode.CURLE_RTSP_CSEQ_ERROR;
alias CURLE_RTSP_SESSION_ERROR = CURLcode.CURLE_RTSP_SESSION_ERROR;
alias CURLE_FTP_BAD_FILE_LIST = CURLcode.CURLE_FTP_BAD_FILE_LIST;
alias CURLE_CHUNK_FAILED = CURLcode.CURLE_CHUNK_FAILED;
alias CURLE_NO_CONNECTION_AVAILABLE = CURLcode.CURLE_NO_CONNECTION_AVAILABLE;
alias CURLE_SSL_PINNEDPUBKEYNOTMATCH = CURLcode.CURLE_SSL_PINNEDPUBKEYNOTMATCH;
alias CURLE_SSL_INVALIDCERTSTATUS = CURLcode.CURLE_SSL_INVALIDCERTSTATUS;
alias CURLE_HTTP2_STREAM = CURLcode.CURLE_HTTP2_STREAM;
alias CURLE_RECURSIVE_API_CALL = CURLcode.CURLE_RECURSIVE_API_CALL;
alias CURLE_AUTH_ERROR = CURLcode.CURLE_AUTH_ERROR;
alias CURLE_HTTP3 = CURLcode.CURLE_HTTP3;
alias CURLE_QUIC_CONNECT_ERROR = CURLcode.CURLE_QUIC_CONNECT_ERROR;
alias CURLE_PROXY = CURLcode.CURLE_PROXY;
alias CURLE_SSL_CLIENTCERT = CURLcode.CURLE_SSL_CLIENTCERT;
alias CURLE_UNRECOVERABLE_POLL = CURLcode.CURLE_UNRECOVERABLE_POLL;
alias CURLE_TOO_LARGE = CURLcode.CURLE_TOO_LARGE;
alias CURLE_ECH_REQUIRED = CURLcode.CURLE_ECH_REQUIRED;
alias CURL_LAST = CURLcode.CURL_LAST;

enum CURLE_FUNCTION_NOT_FOUND = CURLcode.CURLE_OBSOLETE41;
enum CURLE_HTTP_POST_ERROR = CURLcode.CURLE_OBSOLETE34;
enum CURLE_OBSOLETE16 = CURLcode.CURLE_HTTP2;
enum CURLE_OBSOLETE10 = CURLcode.CURLE_FTP_ACCEPT_FAILED;
enum CURLE_OBSOLETE12 = CURLcode.CURLE_FTP_ACCEPT_TIMEOUT;
enum CURLOPT_ENCODING = CURLoption.CURLOPT_ACCEPT_ENCODING;
enum CURLE_FTP_WEIRD_SERVER_REPLY = CURLcode.CURLE_WEIRD_SERVER_REPLY;
enum CURLE_SSL_CACERT = CURLcode.CURLE_PEER_FAILED_VERIFICATION;
enum CURLE_UNKNOWN_TELNET_OPTION = CURLcode.CURLE_UNKNOWN_OPTION;
enum CURLE_TELNET_OPTION_SYNTAX = CURLcode.CURLE_SETOPT_OPTION_SYNTAX;
enum CURLE_SSL_PEER_CERTIFICATE = CURLcode.CURLE_PEER_FAILED_VERIFICATION;
enum CURLE_OBSOLETE = CURLcode.CURLE_OBSOLETE50;
enum CURLE_BAD_PASSWORD_ENTERED = CURLcode.CURLE_OBSOLETE46;
enum CURLE_BAD_CALLING_ORDER = CURLcode.CURLE_OBSOLETE44;
enum CURLE_FTP_USER_PASSWORD_INCORRECT = CURLE_OBSOLETE10;
enum CURLE_FTP_CANT_RECONNECT = CURLE_OBSOLETE16;
enum CURLE_FTP_COULDNT_GET_SIZE = CURLcode.CURLE_OBSOLETE32;
enum CURLE_FTP_COULDNT_SET_ASCII = CURLcode.CURLE_OBSOLETE29;
enum CURLE_FTP_WEIRD_USER_REPLY = CURLE_OBSOLETE12;
enum CURLE_FTP_WRITE_ERROR = CURLcode.CURLE_OBSOLETE20;
enum CURLE_LIBRARY_NOT_FOUND = CURLcode.CURLE_OBSOLETE40;
enum CURLE_MALFORMAT_USER = CURLcode.CURLE_OBSOLETE24;
enum CURLE_SHARE_IN_USE = CURLcode.CURLE_OBSOLETE57;
enum CURLE_URL_MALFORMAT_USER = CURLcode.CURLE_NOT_BUILT_IN;
enum CURLE_FTP_ACCESS_DENIED = CURLcode.CURLE_REMOTE_ACCESS_DENIED;
enum CURLE_FTP_COULDNT_SET_BINARY = CURLcode.CURLE_FTP_COULDNT_SET_TYPE;
enum CURLE_FTP_QUOTE_ERROR = CURLcode.CURLE_QUOTE_ERROR;
enum CURLE_TFTP_DISKFULL = CURLcode.CURLE_REMOTE_DISK_FULL;
enum CURLE_TFTP_EXISTS = CURLcode.CURLE_REMOTE_FILE_EXISTS;
enum CURLE_HTTP_RANGE_ERROR = CURLcode.CURLE_RANGE_ERROR;
enum CURLE_FTP_SSL_FAILED = CURLcode.CURLE_USE_SSL_FAILED;
enum CURLE_OPERATION_TIMEOUTED = CURLcode.CURLE_OPERATION_TIMEDOUT;
enum CURLE_HTTP_NOT_FOUND = CURLcode.CURLE_HTTP_RETURNED_ERROR;
enum CURLE_HTTP_PORT_FAILED = CURLcode.CURLE_INTERFACE_FAILED;
enum CURLE_FTP_COULDNT_STOR_FILE = CURLcode.CURLE_UPLOAD_FAILED;
enum CURLE_FTP_PARTIAL_FILE = CURLcode.CURLE_PARTIAL_FILE;
enum CURLE_FTP_BAD_DOWNLOAD_RESUME = CURLcode.CURLE_BAD_DOWNLOAD_RESUME;
enum CURLE_LDAP_INVALID_URL = CURLcode.CURLE_OBSOLETE62;
enum CURLE_CONV_REQD = CURLcode.CURLE_OBSOLETE76;
enum CURLE_CONV_FAILED = CURLcode.CURLE_OBSOLETE75;
enum CURLE_ALREADY_COMPLETE = 99999;
enum CURLOPT_FILE = CURLoption.CURLOPT_WRITEDATA;
enum CURLOPT_INFILE = CURLoption.CURLOPT_READDATA;
enum CURLOPT_WRITEHEADER = CURLoption.CURLOPT_HEADERDATA;
enum CURLOPT_WRITEINFO = CURLOPT_OBSOLETE40;
enum CURLOPT_CLOSEPOLICY = CURLOPT_OBSOLETE72;
enum CURLOPT_OBSOLETE72 = 9999;
enum CURLOPT_OBSOLETE40 = 9999;

enum CURLproxycode
{
    CURLPX_OK = 0,
    CURLPX_BAD_ADDRESS_TYPE = 1,
    CURLPX_BAD_VERSION = 2,
    CURLPX_CLOSED = 3,
    CURLPX_GSSAPI = 4,
    CURLPX_GSSAPI_PERMSG = 5,
    CURLPX_GSSAPI_PROTECTION = 6,
    CURLPX_IDENTD = 7,
    CURLPX_IDENTD_DIFFER = 8,
    CURLPX_LONG_HOSTNAME = 9,
    CURLPX_LONG_PASSWD = 10,
    CURLPX_LONG_USER = 11,
    CURLPX_NO_AUTH = 12,
    CURLPX_RECV_ADDRESS = 13,
    CURLPX_RECV_AUTH = 14,
    CURLPX_RECV_CONNECT = 15,
    CURLPX_RECV_REQACK = 16,
    CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED = 17,
    CURLPX_REPLY_COMMAND_NOT_SUPPORTED = 18,
    CURLPX_REPLY_CONNECTION_REFUSED = 19,
    CURLPX_REPLY_GENERAL_SERVER_FAILURE = 20,
    CURLPX_REPLY_HOST_UNREACHABLE = 21,
    CURLPX_REPLY_NETWORK_UNREACHABLE = 22,
    CURLPX_REPLY_NOT_ALLOWED = 23,
    CURLPX_REPLY_TTL_EXPIRED = 24,
    CURLPX_REPLY_UNASSIGNED = 25,
    CURLPX_REQUEST_FAILED = 26,
    CURLPX_RESOLVE_HOST = 27,
    CURLPX_SEND_AUTH = 28,
    CURLPX_SEND_CONNECT = 29,
    CURLPX_SEND_REQUEST = 30,
    CURLPX_UNKNOWN_FAIL = 31,
    CURLPX_UNKNOWN_MODE = 32,
    CURLPX_USER_REJECTED = 33,
    CURLPX_LAST = 34
}

alias CURLPX_OK = CURLproxycode.CURLPX_OK;
alias CURLPX_BAD_ADDRESS_TYPE = CURLproxycode.CURLPX_BAD_ADDRESS_TYPE;
alias CURLPX_BAD_VERSION = CURLproxycode.CURLPX_BAD_VERSION;
alias CURLPX_CLOSED = CURLproxycode.CURLPX_CLOSED;
alias CURLPX_GSSAPI = CURLproxycode.CURLPX_GSSAPI;
alias CURLPX_GSSAPI_PERMSG = CURLproxycode.CURLPX_GSSAPI_PERMSG;
alias CURLPX_GSSAPI_PROTECTION = CURLproxycode.CURLPX_GSSAPI_PROTECTION;
alias CURLPX_IDENTD = CURLproxycode.CURLPX_IDENTD;
alias CURLPX_IDENTD_DIFFER = CURLproxycode.CURLPX_IDENTD_DIFFER;
alias CURLPX_LONG_HOSTNAME = CURLproxycode.CURLPX_LONG_HOSTNAME;
alias CURLPX_LONG_PASSWD = CURLproxycode.CURLPX_LONG_PASSWD;
alias CURLPX_LONG_USER = CURLproxycode.CURLPX_LONG_USER;
alias CURLPX_NO_AUTH = CURLproxycode.CURLPX_NO_AUTH;
alias CURLPX_RECV_ADDRESS = CURLproxycode.CURLPX_RECV_ADDRESS;
alias CURLPX_RECV_AUTH = CURLproxycode.CURLPX_RECV_AUTH;
alias CURLPX_RECV_CONNECT = CURLproxycode.CURLPX_RECV_CONNECT;
alias CURLPX_RECV_REQACK = CURLproxycode.CURLPX_RECV_REQACK;
alias CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED = CURLproxycode.CURLPX_REPLY_ADDRESS_TYPE_NOT_SUPPORTED;
alias CURLPX_REPLY_COMMAND_NOT_SUPPORTED = CURLproxycode.CURLPX_REPLY_COMMAND_NOT_SUPPORTED;
alias CURLPX_REPLY_CONNECTION_REFUSED = CURLproxycode.CURLPX_REPLY_CONNECTION_REFUSED;
alias CURLPX_REPLY_GENERAL_SERVER_FAILURE = CURLproxycode.CURLPX_REPLY_GENERAL_SERVER_FAILURE;
alias CURLPX_REPLY_HOST_UNREACHABLE = CURLproxycode.CURLPX_REPLY_HOST_UNREACHABLE;
alias CURLPX_REPLY_NETWORK_UNREACHABLE = CURLproxycode.CURLPX_REPLY_NETWORK_UNREACHABLE;
alias CURLPX_REPLY_NOT_ALLOWED = CURLproxycode.CURLPX_REPLY_NOT_ALLOWED;
alias CURLPX_REPLY_TTL_EXPIRED = CURLproxycode.CURLPX_REPLY_TTL_EXPIRED;
alias CURLPX_REPLY_UNASSIGNED = CURLproxycode.CURLPX_REPLY_UNASSIGNED;
alias CURLPX_REQUEST_FAILED = CURLproxycode.CURLPX_REQUEST_FAILED;
alias CURLPX_RESOLVE_HOST = CURLproxycode.CURLPX_RESOLVE_HOST;
alias CURLPX_SEND_AUTH = CURLproxycode.CURLPX_SEND_AUTH;
alias CURLPX_SEND_CONNECT = CURLproxycode.CURLPX_SEND_CONNECT;
alias CURLPX_SEND_REQUEST = CURLproxycode.CURLPX_SEND_REQUEST;
alias CURLPX_UNKNOWN_FAIL = CURLproxycode.CURLPX_UNKNOWN_FAIL;
alias CURLPX_UNKNOWN_MODE = CURLproxycode.CURLPX_UNKNOWN_MODE;
alias CURLPX_USER_REJECTED = CURLproxycode.CURLPX_USER_REJECTED;
alias CURLPX_LAST = CURLproxycode.CURLPX_LAST;

alias curl_conv_callback = CURLcode function (char* buffer, size_t length);
alias curl_ssl_ctx_callback = CURLcode function (CURL* curl, void* ssl_ctx, void* userptr);

enum curl_proxytype
{
    CURLPROXY_HTTP = 0,
    CURLPROXY_HTTP_1_0 = 1,
    CURLPROXY_HTTPS = 2,
    CURLPROXY_HTTPS2 = 3,
    CURLPROXY_SOCKS4 = 4,
    CURLPROXY_SOCKS5 = 5,
    CURLPROXY_SOCKS4A = 6,
    CURLPROXY_SOCKS5_HOSTNAME = 7
}

alias CURLPROXY_HTTP = curl_proxytype.CURLPROXY_HTTP;
alias CURLPROXY_HTTP_1_0 = curl_proxytype.CURLPROXY_HTTP_1_0;
alias CURLPROXY_HTTPS = curl_proxytype.CURLPROXY_HTTPS;
alias CURLPROXY_HTTPS2 = curl_proxytype.CURLPROXY_HTTPS2;
alias CURLPROXY_SOCKS4 = curl_proxytype.CURLPROXY_SOCKS4;
alias CURLPROXY_SOCKS5 = curl_proxytype.CURLPROXY_SOCKS5;
alias CURLPROXY_SOCKS4A = curl_proxytype.CURLPROXY_SOCKS4A;
alias CURLPROXY_SOCKS5_HOSTNAME = curl_proxytype.CURLPROXY_SOCKS5_HOSTNAME;

enum CURLAUTH_NONE = cast(c_ulong) 0;
enum CURLAUTH_BASIC = (cast(c_ulong) 1) << 0;
enum CURLAUTH_DIGEST = (cast(c_ulong) 1) << 1;
enum CURLAUTH_NEGOTIATE = (cast(c_ulong) 1) << 2;
enum CURLAUTH_GSSNEGOTIATE = CURLAUTH_NEGOTIATE;
enum CURLAUTH_GSSAPI = CURLAUTH_NEGOTIATE;
enum CURLAUTH_NTLM = (cast(c_ulong) 1) << 3;
enum CURLAUTH_DIGEST_IE = (cast(c_ulong) 1) << 4;
enum CURLAUTH_NTLM_WB = (cast(c_ulong) 1) << 5;
enum CURLAUTH_BEARER = (cast(c_ulong) 1) << 6;
enum CURLAUTH_AWS_SIGV4 = (cast(c_ulong) 1) << 7;
enum CURLAUTH_ONLY = (cast(c_ulong) 1) << 31;
enum CURLAUTH_ANY = ~CURLAUTH_DIGEST_IE;
enum CURLAUTH_ANYSAFE = ~(CURLAUTH_BASIC | CURLAUTH_DIGEST_IE);
enum CURLSSH_AUTH_ANY = ~0;
enum CURLSSH_AUTH_NONE = 0;
enum CURLSSH_AUTH_PUBLICKEY = 1 << 0;
enum CURLSSH_AUTH_PASSWORD = 1 << 1;
enum CURLSSH_AUTH_HOST = 1 << 2;
enum CURLSSH_AUTH_KEYBOARD = 1 << 3;
enum CURLSSH_AUTH_AGENT = 1 << 4;
enum CURLSSH_AUTH_GSSAPI = 1 << 5;
enum CURLSSH_AUTH_DEFAULT = CURLSSH_AUTH_ANY;
enum CURLGSSAPI_DELEGATION_NONE = 0;
enum CURLGSSAPI_DELEGATION_POLICY_FLAG = 1 << 0;
enum CURLGSSAPI_DELEGATION_FLAG = 1 << 1;
enum CURL_ERROR_SIZE = 256;

enum curl_khtype
{
    CURLKHTYPE_UNKNOWN = 0,
    CURLKHTYPE_RSA1 = 1,
    CURLKHTYPE_RSA = 2,
    CURLKHTYPE_DSS = 3,
    CURLKHTYPE_ECDSA = 4,
    CURLKHTYPE_ED25519 = 5
}

alias CURLKHTYPE_UNKNOWN = curl_khtype.CURLKHTYPE_UNKNOWN;
alias CURLKHTYPE_RSA1 = curl_khtype.CURLKHTYPE_RSA1;
alias CURLKHTYPE_RSA = curl_khtype.CURLKHTYPE_RSA;
alias CURLKHTYPE_DSS = curl_khtype.CURLKHTYPE_DSS;
alias CURLKHTYPE_ECDSA = curl_khtype.CURLKHTYPE_ECDSA;
alias CURLKHTYPE_ED25519 = curl_khtype.CURLKHTYPE_ED25519;

struct curl_khkey
{
    const(char)* key;
    size_t len;
    curl_khtype keytype;
}

enum curl_khstat
{
    CURLKHSTAT_FINE_ADD_TO_FILE = 0,
    CURLKHSTAT_FINE = 1,
    CURLKHSTAT_REJECT = 2,
    CURLKHSTAT_DEFER = 3,
    CURLKHSTAT_FINE_REPLACE = 4,
    CURLKHSTAT_LAST = 5
}

alias CURLKHSTAT_FINE_ADD_TO_FILE = curl_khstat.CURLKHSTAT_FINE_ADD_TO_FILE;
alias CURLKHSTAT_FINE = curl_khstat.CURLKHSTAT_FINE;
alias CURLKHSTAT_REJECT = curl_khstat.CURLKHSTAT_REJECT;
alias CURLKHSTAT_DEFER = curl_khstat.CURLKHSTAT_DEFER;
alias CURLKHSTAT_FINE_REPLACE = curl_khstat.CURLKHSTAT_FINE_REPLACE;
alias CURLKHSTAT_LAST = curl_khstat.CURLKHSTAT_LAST;

enum curl_khmatch
{
    CURLKHMATCH_OK = 0,
    CURLKHMATCH_MISMATCH = 1,
    CURLKHMATCH_MISSING = 2,
    CURLKHMATCH_LAST = 3
}

alias CURLKHMATCH_OK = curl_khmatch.CURLKHMATCH_OK;
alias CURLKHMATCH_MISMATCH = curl_khmatch.CURLKHMATCH_MISMATCH;
alias CURLKHMATCH_MISSING = curl_khmatch.CURLKHMATCH_MISSING;
alias CURLKHMATCH_LAST = curl_khmatch.CURLKHMATCH_LAST;

alias curl_sshkeycallback = int function (CURL* easy, const(curl_khkey)* knownkey, const(curl_khkey)* foundkey, curl_khmatch, void* clientp);
alias curl_sshhostkeycallback = int function (void* clientp, int keytype, const(char)* key, size_t keylen);

enum curl_usessl
{
    CURLUSESSL_NONE = 0,
    CURLUSESSL_TRY = 1,
    CURLUSESSL_CONTROL = 2,
    CURLUSESSL_ALL = 3,
    CURLUSESSL_LAST = 4
}

alias CURLUSESSL_NONE = curl_usessl.CURLUSESSL_NONE;
alias CURLUSESSL_TRY = curl_usessl.CURLUSESSL_TRY;
alias CURLUSESSL_CONTROL = curl_usessl.CURLUSESSL_CONTROL;
alias CURLUSESSL_ALL = curl_usessl.CURLUSESSL_ALL;
alias CURLUSESSL_LAST = curl_usessl.CURLUSESSL_LAST;

enum CURLSSLOPT_ALLOW_BEAST = 1 << 0;
enum CURLSSLOPT_NO_REVOKE = 1 << 1;
enum CURLSSLOPT_NO_PARTIALCHAIN = 1 << 2;
enum CURLSSLOPT_REVOKE_BEST_EFFORT = 1 << 3;
enum CURLSSLOPT_NATIVE_CA = 1 << 4;
enum CURLSSLOPT_AUTO_CLIENT_CERT = 1 << 5;
enum CURLSSLOPT_EARLYDATA = 1 << 6;
enum CURL_HET_DEFAULT = 200L;
enum CURL_UPKEEP_INTERVAL_DEFAULT = 60000L;
enum CURLFTPSSL_NONE = curl_usessl.CURLUSESSL_NONE;
enum CURLFTPSSL_TRY = curl_usessl.CURLUSESSL_TRY;
enum CURLFTPSSL_CONTROL = curl_usessl.CURLUSESSL_CONTROL;
enum CURLFTPSSL_ALL = curl_usessl.CURLUSESSL_ALL;
enum CURLFTPSSL_LAST = curl_usessl.CURLUSESSL_LAST;
alias curl_ftpssl = curl_usessl;

enum curl_ftpccc
{
    CURLFTPSSL_CCC_NONE = 0,
    CURLFTPSSL_CCC_PASSIVE = 1,
    CURLFTPSSL_CCC_ACTIVE = 2,
    CURLFTPSSL_CCC_LAST = 3
}

alias CURLFTPSSL_CCC_NONE = curl_ftpccc.CURLFTPSSL_CCC_NONE;
alias CURLFTPSSL_CCC_PASSIVE = curl_ftpccc.CURLFTPSSL_CCC_PASSIVE;
alias CURLFTPSSL_CCC_ACTIVE = curl_ftpccc.CURLFTPSSL_CCC_ACTIVE;
alias CURLFTPSSL_CCC_LAST = curl_ftpccc.CURLFTPSSL_CCC_LAST;

enum curl_ftpauth
{
    CURLFTPAUTH_DEFAULT = 0,
    CURLFTPAUTH_SSL = 1,
    CURLFTPAUTH_TLS = 2,
    CURLFTPAUTH_LAST = 3
}

alias CURLFTPAUTH_DEFAULT = curl_ftpauth.CURLFTPAUTH_DEFAULT;
alias CURLFTPAUTH_SSL = curl_ftpauth.CURLFTPAUTH_SSL;
alias CURLFTPAUTH_TLS = curl_ftpauth.CURLFTPAUTH_TLS;
alias CURLFTPAUTH_LAST = curl_ftpauth.CURLFTPAUTH_LAST;

enum curl_ftpcreatedir
{
    CURLFTP_CREATE_DIR_NONE = 0,
    CURLFTP_CREATE_DIR = 1,
    CURLFTP_CREATE_DIR_RETRY = 2,
    CURLFTP_CREATE_DIR_LAST = 3
}

alias CURLFTP_CREATE_DIR_NONE = curl_ftpcreatedir.CURLFTP_CREATE_DIR_NONE;
alias CURLFTP_CREATE_DIR = curl_ftpcreatedir.CURLFTP_CREATE_DIR;
alias CURLFTP_CREATE_DIR_RETRY = curl_ftpcreatedir.CURLFTP_CREATE_DIR_RETRY;
alias CURLFTP_CREATE_DIR_LAST = curl_ftpcreatedir.CURLFTP_CREATE_DIR_LAST;

enum curl_ftpmethod
{
    CURLFTPMETHOD_DEFAULT = 0,
    CURLFTPMETHOD_MULTICWD = 1,
    CURLFTPMETHOD_NOCWD = 2,
    CURLFTPMETHOD_SINGLECWD = 3,
    CURLFTPMETHOD_LAST = 4
}

alias CURLFTPMETHOD_DEFAULT = curl_ftpmethod.CURLFTPMETHOD_DEFAULT;
alias CURLFTPMETHOD_MULTICWD = curl_ftpmethod.CURLFTPMETHOD_MULTICWD;
alias CURLFTPMETHOD_NOCWD = curl_ftpmethod.CURLFTPMETHOD_NOCWD;
alias CURLFTPMETHOD_SINGLECWD = curl_ftpmethod.CURLFTPMETHOD_SINGLECWD;
alias CURLFTPMETHOD_LAST = curl_ftpmethod.CURLFTPMETHOD_LAST;

enum CURLHEADER_UNIFIED = 0;
enum CURLHEADER_SEPARATE = 1 << 0;
enum CURLALTSVC_READONLYFILE = 1 << 2;
enum CURLALTSVC_H1 = 1 << 3;
enum CURLALTSVC_H2 = 1 << 4;
enum CURLALTSVC_H3 = 1 << 5;

struct curl_hstsentry
{
    import std.bitmanip : bitfields;
    char* name;
    size_t namelen;

    mixin(bitfields!(
        uint, "includeSubDomains", 1,
        uint, "", 7));

    char[18] expire;
}

struct curl_index
{
    size_t index;
    size_t total;
}

enum CURLSTScode
{
    CURLSTS_OK = 0,
    CURLSTS_DONE = 1,
    CURLSTS_FAIL = 2
}

alias CURLSTS_OK = CURLSTScode.CURLSTS_OK;
alias CURLSTS_DONE = CURLSTScode.CURLSTS_DONE;
alias CURLSTS_FAIL = CURLSTScode.CURLSTS_FAIL;

alias curl_hstsread_callback = CURLSTScode function (CURL* easy, curl_hstsentry* e, void* userp);
alias curl_hstswrite_callback = CURLSTScode function (CURL* easy, curl_hstsentry* e, curl_index* i, void* userp);
enum CURLHSTS_ENABLE = cast(c_long) 1 << 0;
enum CURLHSTS_READONLYFILE = cast(c_long) 1 << 1;
enum CURLPROTO_HTTP = 1 << 0;
enum CURLPROTO_HTTPS = 1 << 1;
enum CURLPROTO_FTP = 1 << 2;
enum CURLPROTO_FTPS = 1 << 3;
enum CURLPROTO_SCP = 1 << 4;
enum CURLPROTO_SFTP = 1 << 5;
enum CURLPROTO_TELNET = 1 << 6;
enum CURLPROTO_LDAP = 1 << 7;
enum CURLPROTO_LDAPS = 1 << 8;
enum CURLPROTO_DICT = 1 << 9;
enum CURLPROTO_FILE = 1 << 10;
enum CURLPROTO_TFTP = 1 << 11;
enum CURLPROTO_IMAP = 1 << 12;
enum CURLPROTO_IMAPS = 1 << 13;
enum CURLPROTO_POP3 = 1 << 14;
enum CURLPROTO_POP3S = 1 << 15;
enum CURLPROTO_SMTP = 1 << 16;
enum CURLPROTO_SMTPS = 1 << 17;
enum CURLPROTO_RTSP = 1 << 18;
enum CURLPROTO_RTMP = 1 << 19;
enum CURLPROTO_RTMPT = 1 << 20;
enum CURLPROTO_RTMPE = 1 << 21;
enum CURLPROTO_RTMPTE = 1 << 22;
enum CURLPROTO_RTMPS = 1 << 23;
enum CURLPROTO_RTMPTS = 1 << 24;
enum CURLPROTO_GOPHER = 1 << 25;
enum CURLPROTO_SMB = 1 << 26;
enum CURLPROTO_SMBS = 1 << 27;
enum CURLPROTO_MQTT = 1 << 28;
enum CURLPROTO_GOPHERS = 1 << 29;
enum CURLPROTO_ALL = ~0;
enum CURLOPTTYPE_LONG = 0;
enum CURLOPTTYPE_OBJECTPOINT = 10000;
enum CURLOPTTYPE_FUNCTIONPOINT = 20000;
enum CURLOPTTYPE_OFF_T = 30000;
enum CURLOPTTYPE_BLOB = 40000;
enum CURLOPTTYPE_STRINGPOINT = CURLOPTTYPE_OBJECTPOINT;
enum CURLOPTTYPE_SLISTPOINT = CURLOPTTYPE_OBJECTPOINT;
enum CURLOPTTYPE_CBPOINT = CURLOPTTYPE_OBJECTPOINT;
enum CURLOPTTYPE_VALUES = CURLOPTTYPE_LONG;

enum CURLoption
{
    CURLOPT_WRITEDATA = 10001,
    CURLOPT_URL = 10002,
    CURLOPT_PORT = 3,
    CURLOPT_PROXY = 10004,
    CURLOPT_USERPWD = 10005,
    CURLOPT_PROXYUSERPWD = 10006,
    CURLOPT_RANGE = 10007,
    CURLOPT_READDATA = 10009,
    CURLOPT_ERRORBUFFER = 10010,
    CURLOPT_WRITEFUNCTION = 20011,
    CURLOPT_READFUNCTION = 20012,
    CURLOPT_TIMEOUT = 13,
    CURLOPT_INFILESIZE = 14,
    CURLOPT_POSTFIELDS = 10015,
    CURLOPT_REFERER = 10016,
    CURLOPT_FTPPORT = 10017,
    CURLOPT_USERAGENT = 10018,
    CURLOPT_LOW_SPEED_LIMIT = 19,
    CURLOPT_LOW_SPEED_TIME = 20,
    CURLOPT_RESUME_FROM = 21,
    CURLOPT_COOKIE = 10022,
    CURLOPT_HTTPHEADER = 10023,
    CURLOPT_HTTPPOST = 10024,
    CURLOPT_SSLCERT = 10025,
    CURLOPT_KEYPASSWD = 10026,
    CURLOPT_CRLF = 27,
    CURLOPT_QUOTE = 10028,
    CURLOPT_HEADERDATA = 10029,
    CURLOPT_COOKIEFILE = 10031,
    CURLOPT_SSLVERSION = 32,
    CURLOPT_TIMECONDITION = 33,
    CURLOPT_TIMEVALUE = 34,
    CURLOPT_CUSTOMREQUEST = 10036,
    CURLOPT_STDERR = 10037,
    CURLOPT_POSTQUOTE = 10039,
    CURLOPT_VERBOSE = 41,
    CURLOPT_HEADER = 42,
    CURLOPT_NOPROGRESS = 43,
    CURLOPT_NOBODY = 44,
    CURLOPT_FAILONERROR = 45,
    CURLOPT_UPLOAD = 46,
    CURLOPT_POST = 47,
    CURLOPT_DIRLISTONLY = 48,
    CURLOPT_APPEND = 50,
    CURLOPT_NETRC = 51,
    CURLOPT_FOLLOWLOCATION = 52,
    CURLOPT_TRANSFERTEXT = 53,
    CURLOPT_PUT = 54,
    CURLOPT_PROGRESSFUNCTION = 20056,
    CURLOPT_XFERINFODATA = 10057,
    CURLOPT_AUTOREFERER = 58,
    CURLOPT_PROXYPORT = 59,
    CURLOPT_POSTFIELDSIZE = 60,
    CURLOPT_HTTPPROXYTUNNEL = 61,
    CURLOPT_INTERFACE = 10062,
    CURLOPT_KRBLEVEL = 10063,
    CURLOPT_SSL_VERIFYPEER = 64,
    CURLOPT_CAINFO = 10065,
    CURLOPT_MAXREDIRS = 68,
    CURLOPT_FILETIME = 69,
    CURLOPT_TELNETOPTIONS = 10070,
    CURLOPT_MAXCONNECTS = 71,
    CURLOPT_FRESH_CONNECT = 74,
    CURLOPT_FORBID_REUSE = 75,
    CURLOPT_RANDOM_FILE = 10076,
    CURLOPT_EGDSOCKET = 10077,
    CURLOPT_CONNECTTIMEOUT = 78,
    CURLOPT_HEADERFUNCTION = 20079,
    CURLOPT_HTTPGET = 80,
    CURLOPT_SSL_VERIFYHOST = 81,
    CURLOPT_COOKIEJAR = 10082,
    CURLOPT_SSL_CIPHER_LIST = 10083,
    CURLOPT_HTTP_VERSION = 84,
    CURLOPT_FTP_USE_EPSV = 85,
    CURLOPT_SSLCERTTYPE = 10086,
    CURLOPT_SSLKEY = 10087,
    CURLOPT_SSLKEYTYPE = 10088,
    CURLOPT_SSLENGINE = 10089,
    CURLOPT_SSLENGINE_DEFAULT = 90,
    CURLOPT_DNS_USE_GLOBAL_CACHE = 91,
    CURLOPT_DNS_CACHE_TIMEOUT = 92,
    CURLOPT_PREQUOTE = 10093,
    CURLOPT_DEBUGFUNCTION = 20094,
    CURLOPT_DEBUGDATA = 10095,
    CURLOPT_COOKIESESSION = 96,
    CURLOPT_CAPATH = 10097,
    CURLOPT_BUFFERSIZE = 98,
    CURLOPT_NOSIGNAL = 99,
    CURLOPT_SHARE = 10100,
    CURLOPT_PROXYTYPE = 101,
    CURLOPT_ACCEPT_ENCODING = 10102,
    CURLOPT_PRIVATE = 10103,
    CURLOPT_HTTP200ALIASES = 10104,
    CURLOPT_UNRESTRICTED_AUTH = 105,
    CURLOPT_FTP_USE_EPRT = 106,
    CURLOPT_HTTPAUTH = 107,
    CURLOPT_SSL_CTX_FUNCTION = 20108,
    CURLOPT_SSL_CTX_DATA = 10109,
    CURLOPT_FTP_CREATE_MISSING_DIRS = 110,
    CURLOPT_PROXYAUTH = 111,
    CURLOPT_SERVER_RESPONSE_TIMEOUT = 112,
    CURLOPT_IPRESOLVE = 113,
    CURLOPT_MAXFILESIZE = 114,
    CURLOPT_INFILESIZE_LARGE = 30115,
    CURLOPT_RESUME_FROM_LARGE = 30116,
    CURLOPT_MAXFILESIZE_LARGE = 30117,
    CURLOPT_NETRC_FILE = 10118,
    CURLOPT_USE_SSL = 119,
    CURLOPT_POSTFIELDSIZE_LARGE = 30120,
    CURLOPT_TCP_NODELAY = 121,
    CURLOPT_FTPSSLAUTH = 129,
    CURLOPT_IOCTLFUNCTION = 20130,
    CURLOPT_IOCTLDATA = 10131,
    CURLOPT_FTP_ACCOUNT = 10134,
    CURLOPT_COOKIELIST = 10135,
    CURLOPT_IGNORE_CONTENT_LENGTH = 136,
    CURLOPT_FTP_SKIP_PASV_IP = 137,
    CURLOPT_FTP_FILEMETHOD = 138,
    CURLOPT_LOCALPORT = 139,
    CURLOPT_LOCALPORTRANGE = 140,
    CURLOPT_CONNECT_ONLY = 141,
    CURLOPT_CONV_FROM_NETWORK_FUNCTION = 20142,
    CURLOPT_CONV_TO_NETWORK_FUNCTION = 20143,
    CURLOPT_CONV_FROM_UTF8_FUNCTION = 20144,
    CURLOPT_MAX_SEND_SPEED_LARGE = 30145,
    CURLOPT_MAX_RECV_SPEED_LARGE = 30146,
    CURLOPT_FTP_ALTERNATIVE_TO_USER = 10147,
    CURLOPT_SOCKOPTFUNCTION = 20148,
    CURLOPT_SOCKOPTDATA = 10149,
    CURLOPT_SSL_SESSIONID_CACHE = 150,
    CURLOPT_SSH_AUTH_TYPES = 151,
    CURLOPT_SSH_PUBLIC_KEYFILE = 10152,
    CURLOPT_SSH_PRIVATE_KEYFILE = 10153,
    CURLOPT_FTP_SSL_CCC = 154,
    CURLOPT_TIMEOUT_MS = 155,
    CURLOPT_CONNECTTIMEOUT_MS = 156,
    CURLOPT_HTTP_TRANSFER_DECODING = 157,
    CURLOPT_HTTP_CONTENT_DECODING = 158,
    CURLOPT_NEW_FILE_PERMS = 159,
    CURLOPT_NEW_DIRECTORY_PERMS = 160,
    CURLOPT_POSTREDIR = 161,
    CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 = 10162,
    CURLOPT_OPENSOCKETFUNCTION = 20163,
    CURLOPT_OPENSOCKETDATA = 10164,
    CURLOPT_COPYPOSTFIELDS = 10165,
    CURLOPT_PROXY_TRANSFER_MODE = 166,
    CURLOPT_SEEKFUNCTION = 20167,
    CURLOPT_SEEKDATA = 10168,
    CURLOPT_CRLFILE = 10169,
    CURLOPT_ISSUERCERT = 10170,
    CURLOPT_ADDRESS_SCOPE = 171,
    CURLOPT_CERTINFO = 172,
    CURLOPT_USERNAME = 10173,
    CURLOPT_PASSWORD = 10174,
    CURLOPT_PROXYUSERNAME = 10175,
    CURLOPT_PROXYPASSWORD = 10176,
    CURLOPT_NOPROXY = 10177,
    CURLOPT_TFTP_BLKSIZE = 178,
    CURLOPT_SOCKS5_GSSAPI_SERVICE = 10179,
    CURLOPT_SOCKS5_GSSAPI_NEC = 180,
    CURLOPT_PROTOCOLS = 181,
    CURLOPT_REDIR_PROTOCOLS = 182,
    CURLOPT_SSH_KNOWNHOSTS = 10183,
    CURLOPT_SSH_KEYFUNCTION = 20184,
    CURLOPT_SSH_KEYDATA = 10185,
    CURLOPT_MAIL_FROM = 10186,
    CURLOPT_MAIL_RCPT = 10187,
    CURLOPT_FTP_USE_PRET = 188,
    CURLOPT_RTSP_REQUEST = 189,
    CURLOPT_RTSP_SESSION_ID = 10190,
    CURLOPT_RTSP_STREAM_URI = 10191,
    CURLOPT_RTSP_TRANSPORT = 10192,
    CURLOPT_RTSP_CLIENT_CSEQ = 193,
    CURLOPT_RTSP_SERVER_CSEQ = 194,
    CURLOPT_INTERLEAVEDATA = 10195,
    CURLOPT_INTERLEAVEFUNCTION = 20196,
    CURLOPT_WILDCARDMATCH = 197,
    CURLOPT_CHUNK_BGN_FUNCTION = 20198,
    CURLOPT_CHUNK_END_FUNCTION = 20199,
    CURLOPT_FNMATCH_FUNCTION = 20200,
    CURLOPT_CHUNK_DATA = 10201,
    CURLOPT_FNMATCH_DATA = 10202,
    CURLOPT_RESOLVE = 10203,
    CURLOPT_TLSAUTH_USERNAME = 10204,
    CURLOPT_TLSAUTH_PASSWORD = 10205,
    CURLOPT_TLSAUTH_TYPE = 10206,
    CURLOPT_TRANSFER_ENCODING = 207,
    CURLOPT_CLOSESOCKETFUNCTION = 20208,
    CURLOPT_CLOSESOCKETDATA = 10209,
    CURLOPT_GSSAPI_DELEGATION = 210,
    CURLOPT_DNS_SERVERS = 10211,
    CURLOPT_ACCEPTTIMEOUT_MS = 212,
    CURLOPT_TCP_KEEPALIVE = 213,
    CURLOPT_TCP_KEEPIDLE = 214,
    CURLOPT_TCP_KEEPINTVL = 215,
    CURLOPT_SSL_OPTIONS = 216,
    CURLOPT_MAIL_AUTH = 10217,
    CURLOPT_SASL_IR = 218,
    CURLOPT_XFERINFOFUNCTION = 20219,
    CURLOPT_XOAUTH2_BEARER = 10220,
    CURLOPT_DNS_INTERFACE = 10221,
    CURLOPT_DNS_LOCAL_IP4 = 10222,
    CURLOPT_DNS_LOCAL_IP6 = 10223,
    CURLOPT_LOGIN_OPTIONS = 10224,
    CURLOPT_SSL_ENABLE_NPN = 225,
    CURLOPT_SSL_ENABLE_ALPN = 226,
    CURLOPT_EXPECT_100_TIMEOUT_MS = 227,
    CURLOPT_PROXYHEADER = 10228,
    CURLOPT_HEADEROPT = 229,
    CURLOPT_PINNEDPUBLICKEY = 10230,
    CURLOPT_UNIX_SOCKET_PATH = 10231,
    CURLOPT_SSL_VERIFYSTATUS = 232,
    CURLOPT_SSL_FALSESTART = 233,
    CURLOPT_PATH_AS_IS = 234,
    CURLOPT_PROXY_SERVICE_NAME = 10235,
    CURLOPT_SERVICE_NAME = 10236,
    CURLOPT_PIPEWAIT = 237,
    CURLOPT_DEFAULT_PROTOCOL = 10238,
    CURLOPT_STREAM_WEIGHT = 239,
    CURLOPT_STREAM_DEPENDS = 10240,
    CURLOPT_STREAM_DEPENDS_E = 10241,
    CURLOPT_TFTP_NO_OPTIONS = 242,
    CURLOPT_CONNECT_TO = 10243,
    CURLOPT_TCP_FASTOPEN = 244,
    CURLOPT_KEEP_SENDING_ON_ERROR = 245,
    CURLOPT_PROXY_CAINFO = 10246,
    CURLOPT_PROXY_CAPATH = 10247,
    CURLOPT_PROXY_SSL_VERIFYPEER = 248,
    CURLOPT_PROXY_SSL_VERIFYHOST = 249,
    CURLOPT_PROXY_SSLVERSION = 250,
    CURLOPT_PROXY_TLSAUTH_USERNAME = 10251,
    CURLOPT_PROXY_TLSAUTH_PASSWORD = 10252,
    CURLOPT_PROXY_TLSAUTH_TYPE = 10253,
    CURLOPT_PROXY_SSLCERT = 10254,
    CURLOPT_PROXY_SSLCERTTYPE = 10255,
    CURLOPT_PROXY_SSLKEY = 10256,
    CURLOPT_PROXY_SSLKEYTYPE = 10257,
    CURLOPT_PROXY_KEYPASSWD = 10258,
    CURLOPT_PROXY_SSL_CIPHER_LIST = 10259,
    CURLOPT_PROXY_CRLFILE = 10260,
    CURLOPT_PROXY_SSL_OPTIONS = 261,
    CURLOPT_PRE_PROXY = 10262,
    CURLOPT_PROXY_PINNEDPUBLICKEY = 10263,
    CURLOPT_ABSTRACT_UNIX_SOCKET = 10264,
    CURLOPT_SUPPRESS_CONNECT_HEADERS = 265,
    CURLOPT_REQUEST_TARGET = 10266,
    CURLOPT_SOCKS5_AUTH = 267,
    CURLOPT_SSH_COMPRESSION = 268,
    CURLOPT_MIMEPOST = 10269,
    CURLOPT_TIMEVALUE_LARGE = 30270,
    CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS = 271,
    CURLOPT_RESOLVER_START_FUNCTION = 20272,
    CURLOPT_RESOLVER_START_DATA = 10273,
    CURLOPT_HAPROXYPROTOCOL = 274,
    CURLOPT_DNS_SHUFFLE_ADDRESSES = 275,
    CURLOPT_TLS13_CIPHERS = 10276,
    CURLOPT_PROXY_TLS13_CIPHERS = 10277,
    CURLOPT_DISALLOW_USERNAME_IN_URL = 278,
    CURLOPT_DOH_URL = 10279,
    CURLOPT_UPLOAD_BUFFERSIZE = 280,
    CURLOPT_UPKEEP_INTERVAL_MS = 281,
    CURLOPT_CURLU = 10282,
    CURLOPT_TRAILERFUNCTION = 20283,
    CURLOPT_TRAILERDATA = 10284,
    CURLOPT_HTTP09_ALLOWED = 285,
    CURLOPT_ALTSVC_CTRL = 286,
    CURLOPT_ALTSVC = 10287,
    CURLOPT_MAXAGE_CONN = 288,
    CURLOPT_SASL_AUTHZID = 10289,
    CURLOPT_MAIL_RCPT_ALLOWFAILS = 290,
    CURLOPT_SSLCERT_BLOB = 40291,
    CURLOPT_SSLKEY_BLOB = 40292,
    CURLOPT_PROXY_SSLCERT_BLOB = 40293,
    CURLOPT_PROXY_SSLKEY_BLOB = 40294,
    CURLOPT_ISSUERCERT_BLOB = 40295,
    CURLOPT_PROXY_ISSUERCERT = 10296,
    CURLOPT_PROXY_ISSUERCERT_BLOB = 40297,
    CURLOPT_SSL_EC_CURVES = 10298,
    CURLOPT_HSTS_CTRL = 299,
    CURLOPT_HSTS = 10300,
    CURLOPT_HSTSREADFUNCTION = 20301,
    CURLOPT_HSTSREADDATA = 10302,
    CURLOPT_HSTSWRITEFUNCTION = 20303,
    CURLOPT_HSTSWRITEDATA = 10304,
    CURLOPT_AWS_SIGV4 = 10305,
    CURLOPT_DOH_SSL_VERIFYPEER = 306,
    CURLOPT_DOH_SSL_VERIFYHOST = 307,
    CURLOPT_DOH_SSL_VERIFYSTATUS = 308,
    CURLOPT_CAINFO_BLOB = 40309,
    CURLOPT_PROXY_CAINFO_BLOB = 40310,
    CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256 = 10311,
    CURLOPT_PREREQFUNCTION = 20312,
    CURLOPT_PREREQDATA = 10313,
    CURLOPT_MAXLIFETIME_CONN = 314,
    CURLOPT_MIME_OPTIONS = 315,
    CURLOPT_SSH_HOSTKEYFUNCTION = 20316,
    CURLOPT_SSH_HOSTKEYDATA = 10317,
    CURLOPT_PROTOCOLS_STR = 10318,
    CURLOPT_REDIR_PROTOCOLS_STR = 10319,
    CURLOPT_WS_OPTIONS = 320,
    CURLOPT_CA_CACHE_TIMEOUT = 321,
    CURLOPT_QUICK_EXIT = 322,
    CURLOPT_HAPROXY_CLIENT_IP = 10323,
    CURLOPT_SERVER_RESPONSE_TIMEOUT_MS = 324,
    CURLOPT_ECH = 10325,
    CURLOPT_TCP_KEEPCNT = 326,
    CURLOPT_LASTENTRY = 327
}

alias CURLOPT_WRITEDATA = CURLoption.CURLOPT_WRITEDATA;
alias CURLOPT_URL = CURLoption.CURLOPT_URL;
alias CURLOPT_PORT = CURLoption.CURLOPT_PORT;
alias CURLOPT_PROXY = CURLoption.CURLOPT_PROXY;
alias CURLOPT_USERPWD = CURLoption.CURLOPT_USERPWD;
alias CURLOPT_PROXYUSERPWD = CURLoption.CURLOPT_PROXYUSERPWD;
alias CURLOPT_RANGE = CURLoption.CURLOPT_RANGE;
alias CURLOPT_READDATA = CURLoption.CURLOPT_READDATA;
alias CURLOPT_ERRORBUFFER = CURLoption.CURLOPT_ERRORBUFFER;
alias CURLOPT_WRITEFUNCTION = CURLoption.CURLOPT_WRITEFUNCTION;
alias CURLOPT_READFUNCTION = CURLoption.CURLOPT_READFUNCTION;
alias CURLOPT_TIMEOUT = CURLoption.CURLOPT_TIMEOUT;
alias CURLOPT_INFILESIZE = CURLoption.CURLOPT_INFILESIZE;
alias CURLOPT_POSTFIELDS = CURLoption.CURLOPT_POSTFIELDS;
alias CURLOPT_REFERER = CURLoption.CURLOPT_REFERER;
alias CURLOPT_FTPPORT = CURLoption.CURLOPT_FTPPORT;
alias CURLOPT_USERAGENT = CURLoption.CURLOPT_USERAGENT;
alias CURLOPT_LOW_SPEED_LIMIT = CURLoption.CURLOPT_LOW_SPEED_LIMIT;
alias CURLOPT_LOW_SPEED_TIME = CURLoption.CURLOPT_LOW_SPEED_TIME;
alias CURLOPT_RESUME_FROM = CURLoption.CURLOPT_RESUME_FROM;
alias CURLOPT_COOKIE = CURLoption.CURLOPT_COOKIE;
alias CURLOPT_HTTPHEADER = CURLoption.CURLOPT_HTTPHEADER;
alias CURLOPT_HTTPPOST = CURLoption.CURLOPT_HTTPPOST;
alias CURLOPT_SSLCERT = CURLoption.CURLOPT_SSLCERT;
alias CURLOPT_KEYPASSWD = CURLoption.CURLOPT_KEYPASSWD;
alias CURLOPT_CRLF = CURLoption.CURLOPT_CRLF;
alias CURLOPT_QUOTE = CURLoption.CURLOPT_QUOTE;
alias CURLOPT_HEADERDATA = CURLoption.CURLOPT_HEADERDATA;
alias CURLOPT_COOKIEFILE = CURLoption.CURLOPT_COOKIEFILE;
alias CURLOPT_SSLVERSION = CURLoption.CURLOPT_SSLVERSION;
alias CURLOPT_TIMECONDITION = CURLoption.CURLOPT_TIMECONDITION;
alias CURLOPT_TIMEVALUE = CURLoption.CURLOPT_TIMEVALUE;
alias CURLOPT_CUSTOMREQUEST = CURLoption.CURLOPT_CUSTOMREQUEST;
alias CURLOPT_STDERR = CURLoption.CURLOPT_STDERR;
alias CURLOPT_POSTQUOTE = CURLoption.CURLOPT_POSTQUOTE;
alias CURLOPT_VERBOSE = CURLoption.CURLOPT_VERBOSE;
alias CURLOPT_HEADER = CURLoption.CURLOPT_HEADER;
alias CURLOPT_NOPROGRESS = CURLoption.CURLOPT_NOPROGRESS;
alias CURLOPT_NOBODY = CURLoption.CURLOPT_NOBODY;
alias CURLOPT_FAILONERROR = CURLoption.CURLOPT_FAILONERROR;
alias CURLOPT_UPLOAD = CURLoption.CURLOPT_UPLOAD;
alias CURLOPT_POST = CURLoption.CURLOPT_POST;
alias CURLOPT_DIRLISTONLY = CURLoption.CURLOPT_DIRLISTONLY;
alias CURLOPT_APPEND = CURLoption.CURLOPT_APPEND;
alias CURLOPT_NETRC = CURLoption.CURLOPT_NETRC;
alias CURLOPT_FOLLOWLOCATION = CURLoption.CURLOPT_FOLLOWLOCATION;
alias CURLOPT_TRANSFERTEXT = CURLoption.CURLOPT_TRANSFERTEXT;
alias CURLOPT_PUT = CURLoption.CURLOPT_PUT;
alias CURLOPT_PROGRESSFUNCTION = CURLoption.CURLOPT_PROGRESSFUNCTION;
alias CURLOPT_XFERINFODATA = CURLoption.CURLOPT_XFERINFODATA;
alias CURLOPT_AUTOREFERER = CURLoption.CURLOPT_AUTOREFERER;
alias CURLOPT_PROXYPORT = CURLoption.CURLOPT_PROXYPORT;
alias CURLOPT_POSTFIELDSIZE = CURLoption.CURLOPT_POSTFIELDSIZE;
alias CURLOPT_HTTPPROXYTUNNEL = CURLoption.CURLOPT_HTTPPROXYTUNNEL;
alias CURLOPT_INTERFACE = CURLoption.CURLOPT_INTERFACE;
alias CURLOPT_KRBLEVEL = CURLoption.CURLOPT_KRBLEVEL;
alias CURLOPT_SSL_VERIFYPEER = CURLoption.CURLOPT_SSL_VERIFYPEER;
alias CURLOPT_CAINFO = CURLoption.CURLOPT_CAINFO;
alias CURLOPT_MAXREDIRS = CURLoption.CURLOPT_MAXREDIRS;
alias CURLOPT_FILETIME = CURLoption.CURLOPT_FILETIME;
alias CURLOPT_TELNETOPTIONS = CURLoption.CURLOPT_TELNETOPTIONS;
alias CURLOPT_MAXCONNECTS = CURLoption.CURLOPT_MAXCONNECTS;
alias CURLOPT_FRESH_CONNECT = CURLoption.CURLOPT_FRESH_CONNECT;
alias CURLOPT_FORBID_REUSE = CURLoption.CURLOPT_FORBID_REUSE;
alias CURLOPT_RANDOM_FILE = CURLoption.CURLOPT_RANDOM_FILE;
alias CURLOPT_EGDSOCKET = CURLoption.CURLOPT_EGDSOCKET;
alias CURLOPT_CONNECTTIMEOUT = CURLoption.CURLOPT_CONNECTTIMEOUT;
alias CURLOPT_HEADERFUNCTION = CURLoption.CURLOPT_HEADERFUNCTION;
alias CURLOPT_HTTPGET = CURLoption.CURLOPT_HTTPGET;
alias CURLOPT_SSL_VERIFYHOST = CURLoption.CURLOPT_SSL_VERIFYHOST;
alias CURLOPT_COOKIEJAR = CURLoption.CURLOPT_COOKIEJAR;
alias CURLOPT_SSL_CIPHER_LIST = CURLoption.CURLOPT_SSL_CIPHER_LIST;
alias CURLOPT_HTTP_VERSION = CURLoption.CURLOPT_HTTP_VERSION;
alias CURLOPT_FTP_USE_EPSV = CURLoption.CURLOPT_FTP_USE_EPSV;
alias CURLOPT_SSLCERTTYPE = CURLoption.CURLOPT_SSLCERTTYPE;
alias CURLOPT_SSLKEY = CURLoption.CURLOPT_SSLKEY;
alias CURLOPT_SSLKEYTYPE = CURLoption.CURLOPT_SSLKEYTYPE;
alias CURLOPT_SSLENGINE = CURLoption.CURLOPT_SSLENGINE;
alias CURLOPT_SSLENGINE_DEFAULT = CURLoption.CURLOPT_SSLENGINE_DEFAULT;
alias CURLOPT_DNS_USE_GLOBAL_CACHE = CURLoption.CURLOPT_DNS_USE_GLOBAL_CACHE;
alias CURLOPT_DNS_CACHE_TIMEOUT = CURLoption.CURLOPT_DNS_CACHE_TIMEOUT;
alias CURLOPT_PREQUOTE = CURLoption.CURLOPT_PREQUOTE;
alias CURLOPT_DEBUGFUNCTION = CURLoption.CURLOPT_DEBUGFUNCTION;
alias CURLOPT_DEBUGDATA = CURLoption.CURLOPT_DEBUGDATA;
alias CURLOPT_COOKIESESSION = CURLoption.CURLOPT_COOKIESESSION;
alias CURLOPT_CAPATH = CURLoption.CURLOPT_CAPATH;
alias CURLOPT_BUFFERSIZE = CURLoption.CURLOPT_BUFFERSIZE;
alias CURLOPT_NOSIGNAL = CURLoption.CURLOPT_NOSIGNAL;
alias CURLOPT_SHARE = CURLoption.CURLOPT_SHARE;
alias CURLOPT_PROXYTYPE = CURLoption.CURLOPT_PROXYTYPE;
alias CURLOPT_ACCEPT_ENCODING = CURLoption.CURLOPT_ACCEPT_ENCODING;
alias CURLOPT_PRIVATE = CURLoption.CURLOPT_PRIVATE;
alias CURLOPT_HTTP200ALIASES = CURLoption.CURLOPT_HTTP200ALIASES;
alias CURLOPT_UNRESTRICTED_AUTH = CURLoption.CURLOPT_UNRESTRICTED_AUTH;
alias CURLOPT_FTP_USE_EPRT = CURLoption.CURLOPT_FTP_USE_EPRT;
alias CURLOPT_HTTPAUTH = CURLoption.CURLOPT_HTTPAUTH;
alias CURLOPT_SSL_CTX_FUNCTION = CURLoption.CURLOPT_SSL_CTX_FUNCTION;
alias CURLOPT_SSL_CTX_DATA = CURLoption.CURLOPT_SSL_CTX_DATA;
alias CURLOPT_FTP_CREATE_MISSING_DIRS = CURLoption.CURLOPT_FTP_CREATE_MISSING_DIRS;
alias CURLOPT_PROXYAUTH = CURLoption.CURLOPT_PROXYAUTH;
alias CURLOPT_SERVER_RESPONSE_TIMEOUT = CURLoption.CURLOPT_SERVER_RESPONSE_TIMEOUT;
alias CURLOPT_IPRESOLVE = CURLoption.CURLOPT_IPRESOLVE;
alias CURLOPT_MAXFILESIZE = CURLoption.CURLOPT_MAXFILESIZE;
alias CURLOPT_INFILESIZE_LARGE = CURLoption.CURLOPT_INFILESIZE_LARGE;
alias CURLOPT_RESUME_FROM_LARGE = CURLoption.CURLOPT_RESUME_FROM_LARGE;
alias CURLOPT_MAXFILESIZE_LARGE = CURLoption.CURLOPT_MAXFILESIZE_LARGE;
alias CURLOPT_NETRC_FILE = CURLoption.CURLOPT_NETRC_FILE;
alias CURLOPT_USE_SSL = CURLoption.CURLOPT_USE_SSL;
alias CURLOPT_POSTFIELDSIZE_LARGE = CURLoption.CURLOPT_POSTFIELDSIZE_LARGE;
alias CURLOPT_TCP_NODELAY = CURLoption.CURLOPT_TCP_NODELAY;
alias CURLOPT_FTPSSLAUTH = CURLoption.CURLOPT_FTPSSLAUTH;
alias CURLOPT_IOCTLFUNCTION = CURLoption.CURLOPT_IOCTLFUNCTION;
alias CURLOPT_IOCTLDATA = CURLoption.CURLOPT_IOCTLDATA;
alias CURLOPT_FTP_ACCOUNT = CURLoption.CURLOPT_FTP_ACCOUNT;
alias CURLOPT_COOKIELIST = CURLoption.CURLOPT_COOKIELIST;
alias CURLOPT_IGNORE_CONTENT_LENGTH = CURLoption.CURLOPT_IGNORE_CONTENT_LENGTH;
alias CURLOPT_FTP_SKIP_PASV_IP = CURLoption.CURLOPT_FTP_SKIP_PASV_IP;
alias CURLOPT_FTP_FILEMETHOD = CURLoption.CURLOPT_FTP_FILEMETHOD;
alias CURLOPT_LOCALPORT = CURLoption.CURLOPT_LOCALPORT;
alias CURLOPT_LOCALPORTRANGE = CURLoption.CURLOPT_LOCALPORTRANGE;
alias CURLOPT_CONNECT_ONLY = CURLoption.CURLOPT_CONNECT_ONLY;
alias CURLOPT_CONV_FROM_NETWORK_FUNCTION = CURLoption.CURLOPT_CONV_FROM_NETWORK_FUNCTION;
alias CURLOPT_CONV_TO_NETWORK_FUNCTION = CURLoption.CURLOPT_CONV_TO_NETWORK_FUNCTION;
alias CURLOPT_CONV_FROM_UTF8_FUNCTION = CURLoption.CURLOPT_CONV_FROM_UTF8_FUNCTION;
alias CURLOPT_MAX_SEND_SPEED_LARGE = CURLoption.CURLOPT_MAX_SEND_SPEED_LARGE;
alias CURLOPT_MAX_RECV_SPEED_LARGE = CURLoption.CURLOPT_MAX_RECV_SPEED_LARGE;
alias CURLOPT_FTP_ALTERNATIVE_TO_USER = CURLoption.CURLOPT_FTP_ALTERNATIVE_TO_USER;
alias CURLOPT_SOCKOPTFUNCTION = CURLoption.CURLOPT_SOCKOPTFUNCTION;
alias CURLOPT_SOCKOPTDATA = CURLoption.CURLOPT_SOCKOPTDATA;
alias CURLOPT_SSL_SESSIONID_CACHE = CURLoption.CURLOPT_SSL_SESSIONID_CACHE;
alias CURLOPT_SSH_AUTH_TYPES = CURLoption.CURLOPT_SSH_AUTH_TYPES;
alias CURLOPT_SSH_PUBLIC_KEYFILE = CURLoption.CURLOPT_SSH_PUBLIC_KEYFILE;
alias CURLOPT_SSH_PRIVATE_KEYFILE = CURLoption.CURLOPT_SSH_PRIVATE_KEYFILE;
alias CURLOPT_FTP_SSL_CCC = CURLoption.CURLOPT_FTP_SSL_CCC;
alias CURLOPT_TIMEOUT_MS = CURLoption.CURLOPT_TIMEOUT_MS;
alias CURLOPT_CONNECTTIMEOUT_MS = CURLoption.CURLOPT_CONNECTTIMEOUT_MS;
alias CURLOPT_HTTP_TRANSFER_DECODING = CURLoption.CURLOPT_HTTP_TRANSFER_DECODING;
alias CURLOPT_HTTP_CONTENT_DECODING = CURLoption.CURLOPT_HTTP_CONTENT_DECODING;
alias CURLOPT_NEW_FILE_PERMS = CURLoption.CURLOPT_NEW_FILE_PERMS;
alias CURLOPT_NEW_DIRECTORY_PERMS = CURLoption.CURLOPT_NEW_DIRECTORY_PERMS;
alias CURLOPT_POSTREDIR = CURLoption.CURLOPT_POSTREDIR;
alias CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 = CURLoption.CURLOPT_SSH_HOST_PUBLIC_KEY_MD5;
alias CURLOPT_OPENSOCKETFUNCTION = CURLoption.CURLOPT_OPENSOCKETFUNCTION;
alias CURLOPT_OPENSOCKETDATA = CURLoption.CURLOPT_OPENSOCKETDATA;
alias CURLOPT_COPYPOSTFIELDS = CURLoption.CURLOPT_COPYPOSTFIELDS;
alias CURLOPT_PROXY_TRANSFER_MODE = CURLoption.CURLOPT_PROXY_TRANSFER_MODE;
alias CURLOPT_SEEKFUNCTION = CURLoption.CURLOPT_SEEKFUNCTION;
alias CURLOPT_SEEKDATA = CURLoption.CURLOPT_SEEKDATA;
alias CURLOPT_CRLFILE = CURLoption.CURLOPT_CRLFILE;
alias CURLOPT_ISSUERCERT = CURLoption.CURLOPT_ISSUERCERT;
alias CURLOPT_ADDRESS_SCOPE = CURLoption.CURLOPT_ADDRESS_SCOPE;
alias CURLOPT_CERTINFO = CURLoption.CURLOPT_CERTINFO;
alias CURLOPT_USERNAME = CURLoption.CURLOPT_USERNAME;
alias CURLOPT_PASSWORD = CURLoption.CURLOPT_PASSWORD;
alias CURLOPT_PROXYUSERNAME = CURLoption.CURLOPT_PROXYUSERNAME;
alias CURLOPT_PROXYPASSWORD = CURLoption.CURLOPT_PROXYPASSWORD;
alias CURLOPT_NOPROXY = CURLoption.CURLOPT_NOPROXY;
alias CURLOPT_TFTP_BLKSIZE = CURLoption.CURLOPT_TFTP_BLKSIZE;
alias CURLOPT_SOCKS5_GSSAPI_SERVICE = CURLoption.CURLOPT_SOCKS5_GSSAPI_SERVICE;
alias CURLOPT_SOCKS5_GSSAPI_NEC = CURLoption.CURLOPT_SOCKS5_GSSAPI_NEC;
alias CURLOPT_PROTOCOLS = CURLoption.CURLOPT_PROTOCOLS;
alias CURLOPT_REDIR_PROTOCOLS = CURLoption.CURLOPT_REDIR_PROTOCOLS;
alias CURLOPT_SSH_KNOWNHOSTS = CURLoption.CURLOPT_SSH_KNOWNHOSTS;
alias CURLOPT_SSH_KEYFUNCTION = CURLoption.CURLOPT_SSH_KEYFUNCTION;
alias CURLOPT_SSH_KEYDATA = CURLoption.CURLOPT_SSH_KEYDATA;
alias CURLOPT_MAIL_FROM = CURLoption.CURLOPT_MAIL_FROM;
alias CURLOPT_MAIL_RCPT = CURLoption.CURLOPT_MAIL_RCPT;
alias CURLOPT_FTP_USE_PRET = CURLoption.CURLOPT_FTP_USE_PRET;
alias CURLOPT_RTSP_REQUEST = CURLoption.CURLOPT_RTSP_REQUEST;
alias CURLOPT_RTSP_SESSION_ID = CURLoption.CURLOPT_RTSP_SESSION_ID;
alias CURLOPT_RTSP_STREAM_URI = CURLoption.CURLOPT_RTSP_STREAM_URI;
alias CURLOPT_RTSP_TRANSPORT = CURLoption.CURLOPT_RTSP_TRANSPORT;
alias CURLOPT_RTSP_CLIENT_CSEQ = CURLoption.CURLOPT_RTSP_CLIENT_CSEQ;
alias CURLOPT_RTSP_SERVER_CSEQ = CURLoption.CURLOPT_RTSP_SERVER_CSEQ;
alias CURLOPT_INTERLEAVEDATA = CURLoption.CURLOPT_INTERLEAVEDATA;
alias CURLOPT_INTERLEAVEFUNCTION = CURLoption.CURLOPT_INTERLEAVEFUNCTION;
alias CURLOPT_WILDCARDMATCH = CURLoption.CURLOPT_WILDCARDMATCH;
alias CURLOPT_CHUNK_BGN_FUNCTION = CURLoption.CURLOPT_CHUNK_BGN_FUNCTION;
alias CURLOPT_CHUNK_END_FUNCTION = CURLoption.CURLOPT_CHUNK_END_FUNCTION;
alias CURLOPT_FNMATCH_FUNCTION = CURLoption.CURLOPT_FNMATCH_FUNCTION;
alias CURLOPT_CHUNK_DATA = CURLoption.CURLOPT_CHUNK_DATA;
alias CURLOPT_FNMATCH_DATA = CURLoption.CURLOPT_FNMATCH_DATA;
alias CURLOPT_RESOLVE = CURLoption.CURLOPT_RESOLVE;
alias CURLOPT_TLSAUTH_USERNAME = CURLoption.CURLOPT_TLSAUTH_USERNAME;
alias CURLOPT_TLSAUTH_PASSWORD = CURLoption.CURLOPT_TLSAUTH_PASSWORD;
alias CURLOPT_TLSAUTH_TYPE = CURLoption.CURLOPT_TLSAUTH_TYPE;
alias CURLOPT_TRANSFER_ENCODING = CURLoption.CURLOPT_TRANSFER_ENCODING;
alias CURLOPT_CLOSESOCKETFUNCTION = CURLoption.CURLOPT_CLOSESOCKETFUNCTION;
alias CURLOPT_CLOSESOCKETDATA = CURLoption.CURLOPT_CLOSESOCKETDATA;
alias CURLOPT_GSSAPI_DELEGATION = CURLoption.CURLOPT_GSSAPI_DELEGATION;
alias CURLOPT_DNS_SERVERS = CURLoption.CURLOPT_DNS_SERVERS;
alias CURLOPT_ACCEPTTIMEOUT_MS = CURLoption.CURLOPT_ACCEPTTIMEOUT_MS;
alias CURLOPT_TCP_KEEPALIVE = CURLoption.CURLOPT_TCP_KEEPALIVE;
alias CURLOPT_TCP_KEEPIDLE = CURLoption.CURLOPT_TCP_KEEPIDLE;
alias CURLOPT_TCP_KEEPINTVL = CURLoption.CURLOPT_TCP_KEEPINTVL;
alias CURLOPT_SSL_OPTIONS = CURLoption.CURLOPT_SSL_OPTIONS;
alias CURLOPT_MAIL_AUTH = CURLoption.CURLOPT_MAIL_AUTH;
alias CURLOPT_SASL_IR = CURLoption.CURLOPT_SASL_IR;
alias CURLOPT_XFERINFOFUNCTION = CURLoption.CURLOPT_XFERINFOFUNCTION;
alias CURLOPT_XOAUTH2_BEARER = CURLoption.CURLOPT_XOAUTH2_BEARER;
alias CURLOPT_DNS_INTERFACE = CURLoption.CURLOPT_DNS_INTERFACE;
alias CURLOPT_DNS_LOCAL_IP4 = CURLoption.CURLOPT_DNS_LOCAL_IP4;
alias CURLOPT_DNS_LOCAL_IP6 = CURLoption.CURLOPT_DNS_LOCAL_IP6;
alias CURLOPT_LOGIN_OPTIONS = CURLoption.CURLOPT_LOGIN_OPTIONS;
alias CURLOPT_SSL_ENABLE_NPN = CURLoption.CURLOPT_SSL_ENABLE_NPN;
alias CURLOPT_SSL_ENABLE_ALPN = CURLoption.CURLOPT_SSL_ENABLE_ALPN;
alias CURLOPT_EXPECT_100_TIMEOUT_MS = CURLoption.CURLOPT_EXPECT_100_TIMEOUT_MS;
alias CURLOPT_PROXYHEADER = CURLoption.CURLOPT_PROXYHEADER;
alias CURLOPT_HEADEROPT = CURLoption.CURLOPT_HEADEROPT;
alias CURLOPT_PINNEDPUBLICKEY = CURLoption.CURLOPT_PINNEDPUBLICKEY;
alias CURLOPT_UNIX_SOCKET_PATH = CURLoption.CURLOPT_UNIX_SOCKET_PATH;
alias CURLOPT_SSL_VERIFYSTATUS = CURLoption.CURLOPT_SSL_VERIFYSTATUS;
alias CURLOPT_SSL_FALSESTART = CURLoption.CURLOPT_SSL_FALSESTART;
alias CURLOPT_PATH_AS_IS = CURLoption.CURLOPT_PATH_AS_IS;
alias CURLOPT_PROXY_SERVICE_NAME = CURLoption.CURLOPT_PROXY_SERVICE_NAME;
alias CURLOPT_SERVICE_NAME = CURLoption.CURLOPT_SERVICE_NAME;
alias CURLOPT_PIPEWAIT = CURLoption.CURLOPT_PIPEWAIT;
alias CURLOPT_DEFAULT_PROTOCOL = CURLoption.CURLOPT_DEFAULT_PROTOCOL;
alias CURLOPT_STREAM_WEIGHT = CURLoption.CURLOPT_STREAM_WEIGHT;
alias CURLOPT_STREAM_DEPENDS = CURLoption.CURLOPT_STREAM_DEPENDS;
alias CURLOPT_STREAM_DEPENDS_E = CURLoption.CURLOPT_STREAM_DEPENDS_E;
alias CURLOPT_TFTP_NO_OPTIONS = CURLoption.CURLOPT_TFTP_NO_OPTIONS;
alias CURLOPT_CONNECT_TO = CURLoption.CURLOPT_CONNECT_TO;
alias CURLOPT_TCP_FASTOPEN = CURLoption.CURLOPT_TCP_FASTOPEN;
alias CURLOPT_KEEP_SENDING_ON_ERROR = CURLoption.CURLOPT_KEEP_SENDING_ON_ERROR;
alias CURLOPT_PROXY_CAINFO = CURLoption.CURLOPT_PROXY_CAINFO;
alias CURLOPT_PROXY_CAPATH = CURLoption.CURLOPT_PROXY_CAPATH;
alias CURLOPT_PROXY_SSL_VERIFYPEER = CURLoption.CURLOPT_PROXY_SSL_VERIFYPEER;
alias CURLOPT_PROXY_SSL_VERIFYHOST = CURLoption.CURLOPT_PROXY_SSL_VERIFYHOST;
alias CURLOPT_PROXY_SSLVERSION = CURLoption.CURLOPT_PROXY_SSLVERSION;
alias CURLOPT_PROXY_TLSAUTH_USERNAME = CURLoption.CURLOPT_PROXY_TLSAUTH_USERNAME;
alias CURLOPT_PROXY_TLSAUTH_PASSWORD = CURLoption.CURLOPT_PROXY_TLSAUTH_PASSWORD;
alias CURLOPT_PROXY_TLSAUTH_TYPE = CURLoption.CURLOPT_PROXY_TLSAUTH_TYPE;
alias CURLOPT_PROXY_SSLCERT = CURLoption.CURLOPT_PROXY_SSLCERT;
alias CURLOPT_PROXY_SSLCERTTYPE = CURLoption.CURLOPT_PROXY_SSLCERTTYPE;
alias CURLOPT_PROXY_SSLKEY = CURLoption.CURLOPT_PROXY_SSLKEY;
alias CURLOPT_PROXY_SSLKEYTYPE = CURLoption.CURLOPT_PROXY_SSLKEYTYPE;
alias CURLOPT_PROXY_KEYPASSWD = CURLoption.CURLOPT_PROXY_KEYPASSWD;
alias CURLOPT_PROXY_SSL_CIPHER_LIST = CURLoption.CURLOPT_PROXY_SSL_CIPHER_LIST;
alias CURLOPT_PROXY_CRLFILE = CURLoption.CURLOPT_PROXY_CRLFILE;
alias CURLOPT_PROXY_SSL_OPTIONS = CURLoption.CURLOPT_PROXY_SSL_OPTIONS;
alias CURLOPT_PRE_PROXY = CURLoption.CURLOPT_PRE_PROXY;
alias CURLOPT_PROXY_PINNEDPUBLICKEY = CURLoption.CURLOPT_PROXY_PINNEDPUBLICKEY;
alias CURLOPT_ABSTRACT_UNIX_SOCKET = CURLoption.CURLOPT_ABSTRACT_UNIX_SOCKET;
alias CURLOPT_SUPPRESS_CONNECT_HEADERS = CURLoption.CURLOPT_SUPPRESS_CONNECT_HEADERS;
alias CURLOPT_REQUEST_TARGET = CURLoption.CURLOPT_REQUEST_TARGET;
alias CURLOPT_SOCKS5_AUTH = CURLoption.CURLOPT_SOCKS5_AUTH;
alias CURLOPT_SSH_COMPRESSION = CURLoption.CURLOPT_SSH_COMPRESSION;
alias CURLOPT_MIMEPOST = CURLoption.CURLOPT_MIMEPOST;
alias CURLOPT_TIMEVALUE_LARGE = CURLoption.CURLOPT_TIMEVALUE_LARGE;
alias CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS = CURLoption.CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS;
alias CURLOPT_RESOLVER_START_FUNCTION = CURLoption.CURLOPT_RESOLVER_START_FUNCTION;
alias CURLOPT_RESOLVER_START_DATA = CURLoption.CURLOPT_RESOLVER_START_DATA;
alias CURLOPT_HAPROXYPROTOCOL = CURLoption.CURLOPT_HAPROXYPROTOCOL;
alias CURLOPT_DNS_SHUFFLE_ADDRESSES = CURLoption.CURLOPT_DNS_SHUFFLE_ADDRESSES;
alias CURLOPT_TLS13_CIPHERS = CURLoption.CURLOPT_TLS13_CIPHERS;
alias CURLOPT_PROXY_TLS13_CIPHERS = CURLoption.CURLOPT_PROXY_TLS13_CIPHERS;
alias CURLOPT_DISALLOW_USERNAME_IN_URL = CURLoption.CURLOPT_DISALLOW_USERNAME_IN_URL;
alias CURLOPT_DOH_URL = CURLoption.CURLOPT_DOH_URL;
alias CURLOPT_UPLOAD_BUFFERSIZE = CURLoption.CURLOPT_UPLOAD_BUFFERSIZE;
alias CURLOPT_UPKEEP_INTERVAL_MS = CURLoption.CURLOPT_UPKEEP_INTERVAL_MS;
alias CURLOPT_CURLU = CURLoption.CURLOPT_CURLU;
alias CURLOPT_TRAILERFUNCTION = CURLoption.CURLOPT_TRAILERFUNCTION;
alias CURLOPT_TRAILERDATA = CURLoption.CURLOPT_TRAILERDATA;
alias CURLOPT_HTTP09_ALLOWED = CURLoption.CURLOPT_HTTP09_ALLOWED;
alias CURLOPT_ALTSVC_CTRL = CURLoption.CURLOPT_ALTSVC_CTRL;
alias CURLOPT_ALTSVC = CURLoption.CURLOPT_ALTSVC;
alias CURLOPT_MAXAGE_CONN = CURLoption.CURLOPT_MAXAGE_CONN;
alias CURLOPT_SASL_AUTHZID = CURLoption.CURLOPT_SASL_AUTHZID;
alias CURLOPT_MAIL_RCPT_ALLOWFAILS = CURLoption.CURLOPT_MAIL_RCPT_ALLOWFAILS;
alias CURLOPT_SSLCERT_BLOB = CURLoption.CURLOPT_SSLCERT_BLOB;
alias CURLOPT_SSLKEY_BLOB = CURLoption.CURLOPT_SSLKEY_BLOB;
alias CURLOPT_PROXY_SSLCERT_BLOB = CURLoption.CURLOPT_PROXY_SSLCERT_BLOB;
alias CURLOPT_PROXY_SSLKEY_BLOB = CURLoption.CURLOPT_PROXY_SSLKEY_BLOB;
alias CURLOPT_ISSUERCERT_BLOB = CURLoption.CURLOPT_ISSUERCERT_BLOB;
alias CURLOPT_PROXY_ISSUERCERT = CURLoption.CURLOPT_PROXY_ISSUERCERT;
alias CURLOPT_PROXY_ISSUERCERT_BLOB = CURLoption.CURLOPT_PROXY_ISSUERCERT_BLOB;
alias CURLOPT_SSL_EC_CURVES = CURLoption.CURLOPT_SSL_EC_CURVES;
alias CURLOPT_HSTS_CTRL = CURLoption.CURLOPT_HSTS_CTRL;
alias CURLOPT_HSTS = CURLoption.CURLOPT_HSTS;
alias CURLOPT_HSTSREADFUNCTION = CURLoption.CURLOPT_HSTSREADFUNCTION;
alias CURLOPT_HSTSREADDATA = CURLoption.CURLOPT_HSTSREADDATA;
alias CURLOPT_HSTSWRITEFUNCTION = CURLoption.CURLOPT_HSTSWRITEFUNCTION;
alias CURLOPT_HSTSWRITEDATA = CURLoption.CURLOPT_HSTSWRITEDATA;
alias CURLOPT_AWS_SIGV4 = CURLoption.CURLOPT_AWS_SIGV4;
alias CURLOPT_DOH_SSL_VERIFYPEER = CURLoption.CURLOPT_DOH_SSL_VERIFYPEER;
alias CURLOPT_DOH_SSL_VERIFYHOST = CURLoption.CURLOPT_DOH_SSL_VERIFYHOST;
alias CURLOPT_DOH_SSL_VERIFYSTATUS = CURLoption.CURLOPT_DOH_SSL_VERIFYSTATUS;
alias CURLOPT_CAINFO_BLOB = CURLoption.CURLOPT_CAINFO_BLOB;
alias CURLOPT_PROXY_CAINFO_BLOB = CURLoption.CURLOPT_PROXY_CAINFO_BLOB;
alias CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256 = CURLoption.CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256;
alias CURLOPT_PREREQFUNCTION = CURLoption.CURLOPT_PREREQFUNCTION;
alias CURLOPT_PREREQDATA = CURLoption.CURLOPT_PREREQDATA;
alias CURLOPT_MAXLIFETIME_CONN = CURLoption.CURLOPT_MAXLIFETIME_CONN;
alias CURLOPT_MIME_OPTIONS = CURLoption.CURLOPT_MIME_OPTIONS;
alias CURLOPT_SSH_HOSTKEYFUNCTION = CURLoption.CURLOPT_SSH_HOSTKEYFUNCTION;
alias CURLOPT_SSH_HOSTKEYDATA = CURLoption.CURLOPT_SSH_HOSTKEYDATA;
alias CURLOPT_PROTOCOLS_STR = CURLoption.CURLOPT_PROTOCOLS_STR;
alias CURLOPT_REDIR_PROTOCOLS_STR = CURLoption.CURLOPT_REDIR_PROTOCOLS_STR;
alias CURLOPT_WS_OPTIONS = CURLoption.CURLOPT_WS_OPTIONS;
alias CURLOPT_CA_CACHE_TIMEOUT = CURLoption.CURLOPT_CA_CACHE_TIMEOUT;
alias CURLOPT_QUICK_EXIT = CURLoption.CURLOPT_QUICK_EXIT;
alias CURLOPT_HAPROXY_CLIENT_IP = CURLoption.CURLOPT_HAPROXY_CLIENT_IP;
alias CURLOPT_SERVER_RESPONSE_TIMEOUT_MS = CURLoption.CURLOPT_SERVER_RESPONSE_TIMEOUT_MS;
alias CURLOPT_ECH = CURLoption.CURLOPT_ECH;
alias CURLOPT_TCP_KEEPCNT = CURLoption.CURLOPT_TCP_KEEPCNT;
alias CURLOPT_LASTENTRY = CURLoption.CURLOPT_LASTENTRY;

enum CURLOPT_PROGRESSDATA = CURLoption.CURLOPT_XFERINFODATA;
enum CURLOPT_POST301 = CURLoption.CURLOPT_POSTREDIR;
enum CURLOPT_SSLKEYPASSWD = CURLoption.CURLOPT_KEYPASSWD;
enum CURLOPT_FTPAPPEND = CURLoption.CURLOPT_APPEND;
enum CURLOPT_FTPLISTONLY = CURLoption.CURLOPT_DIRLISTONLY;
enum CURLOPT_FTP_SSL = CURLoption.CURLOPT_USE_SSL;
enum CURLOPT_SSLCERTPASSWD = CURLoption.CURLOPT_KEYPASSWD;
enum CURLOPT_KRB4LEVEL = CURLoption.CURLOPT_KRBLEVEL;
enum CURLOPT_FTP_RESPONSE_TIMEOUT = CURLoption.CURLOPT_SERVER_RESPONSE_TIMEOUT;
enum CURLOPT_MAIL_RCPT_ALLLOWFAILS = CURLoption.CURLOPT_MAIL_RCPT_ALLOWFAILS;
enum CURL_IPRESOLVE_WHATEVER = 0;
enum CURL_IPRESOLVE_V4 = 1;
enum CURL_IPRESOLVE_V6 = 2;
enum CURLOPT_RTSPHEADER = CURLoption.CURLOPT_HTTPHEADER;

enum httpver
{
    CURL_HTTP_VERSION_NONE = 0,
    CURL_HTTP_VERSION_1_0 = 1,
    CURL_HTTP_VERSION_1_1 = 2,
    CURL_HTTP_VERSION_2_0 = 3,
    CURL_HTTP_VERSION_2TLS = 4,
    CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE = 5,
    CURL_HTTP_VERSION_3 = 30,
    CURL_HTTP_VERSION_3ONLY = 31,
    CURL_HTTP_VERSION_LAST = 32
}

alias CURL_HTTP_VERSION_NONE = httpver.CURL_HTTP_VERSION_NONE;
alias CURL_HTTP_VERSION_1_0 = httpver.CURL_HTTP_VERSION_1_0;
alias CURL_HTTP_VERSION_1_1 = httpver.CURL_HTTP_VERSION_1_1;
alias CURL_HTTP_VERSION_2_0 = httpver.CURL_HTTP_VERSION_2_0;
alias CURL_HTTP_VERSION_2TLS = httpver.CURL_HTTP_VERSION_2TLS;
alias CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE = httpver.CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE;
alias CURL_HTTP_VERSION_3 = httpver.CURL_HTTP_VERSION_3;
alias CURL_HTTP_VERSION_3ONLY = httpver.CURL_HTTP_VERSION_3ONLY;
alias CURL_HTTP_VERSION_LAST = httpver.CURL_HTTP_VERSION_LAST;

enum CURL_HTTP_VERSION_2 = httpver.CURL_HTTP_VERSION_2_0;

enum hz
{
    CURL_RTSPREQ_NONE = 0,
    CURL_RTSPREQ_OPTIONS = 1,
    CURL_RTSPREQ_DESCRIBE = 2,
    CURL_RTSPREQ_ANNOUNCE = 3,
    CURL_RTSPREQ_SETUP = 4,
    CURL_RTSPREQ_PLAY = 5,
    CURL_RTSPREQ_PAUSE = 6,
    CURL_RTSPREQ_TEARDOWN = 7,
    CURL_RTSPREQ_GET_PARAMETER = 8,
    CURL_RTSPREQ_SET_PARAMETER = 9,
    CURL_RTSPREQ_RECORD = 10,
    CURL_RTSPREQ_RECEIVE = 11,
    CURL_RTSPREQ_LAST = 12
}

alias CURL_RTSPREQ_NONE = hz.CURL_RTSPREQ_NONE;
alias CURL_RTSPREQ_OPTIONS = hz.CURL_RTSPREQ_OPTIONS;
alias CURL_RTSPREQ_DESCRIBE = hz.CURL_RTSPREQ_DESCRIBE;
alias CURL_RTSPREQ_ANNOUNCE = hz.CURL_RTSPREQ_ANNOUNCE;
alias CURL_RTSPREQ_SETUP = hz.CURL_RTSPREQ_SETUP;
alias CURL_RTSPREQ_PLAY = hz.CURL_RTSPREQ_PLAY;
alias CURL_RTSPREQ_PAUSE = hz.CURL_RTSPREQ_PAUSE;
alias CURL_RTSPREQ_TEARDOWN = hz.CURL_RTSPREQ_TEARDOWN;
alias CURL_RTSPREQ_GET_PARAMETER = hz.CURL_RTSPREQ_GET_PARAMETER;
alias CURL_RTSPREQ_SET_PARAMETER = hz.CURL_RTSPREQ_SET_PARAMETER;
alias CURL_RTSPREQ_RECORD = hz.CURL_RTSPREQ_RECORD;
alias CURL_RTSPREQ_RECEIVE = hz.CURL_RTSPREQ_RECEIVE;
alias CURL_RTSPREQ_LAST = hz.CURL_RTSPREQ_LAST;

enum CURL_NETRC_OPTION
{
    CURL_NETRC_IGNORED = 0,
    CURL_NETRC_OPTIONAL = 1,
    CURL_NETRC_REQUIRED = 2,
    CURL_NETRC_LAST = 3
}

alias CURL_NETRC_IGNORED = CURL_NETRC_OPTION.CURL_NETRC_IGNORED;
alias CURL_NETRC_OPTIONAL = CURL_NETRC_OPTION.CURL_NETRC_OPTIONAL;
alias CURL_NETRC_REQUIRED = CURL_NETRC_OPTION.CURL_NETRC_REQUIRED;
alias CURL_NETRC_LAST = CURL_NETRC_OPTION.CURL_NETRC_LAST;

enum CURL_SSLVERSION_DEFAULT = 0;
enum CURL_SSLVERSION_TLSv1 = 1;
enum CURL_SSLVERSION_SSLv2 = 2;
enum CURL_SSLVERSION_SSLv3 = 3;
enum CURL_SSLVERSION_TLSv1_0 = 4;
enum CURL_SSLVERSION_TLSv1_1 = 5;
enum CURL_SSLVERSION_TLSv1_2 = 6;
enum CURL_SSLVERSION_TLSv1_3 = 7;
enum CURL_SSLVERSION_LAST = 8;
enum CURL_SSLVERSION_MAX_NONE = 0;
enum CURL_SSLVERSION_MAX_DEFAULT = CURL_SSLVERSION_TLSv1 << 16;
enum CURL_SSLVERSION_MAX_TLSv1_0 = CURL_SSLVERSION_TLSv1_0 << 16;
enum CURL_SSLVERSION_MAX_TLSv1_1 = CURL_SSLVERSION_TLSv1_1 << 16;
enum CURL_SSLVERSION_MAX_TLSv1_2 = CURL_SSLVERSION_TLSv1_2 << 16;
enum CURL_SSLVERSION_MAX_TLSv1_3 = CURL_SSLVERSION_TLSv1_3 << 16;
enum CURL_SSLVERSION_MAX_LAST = CURL_SSLVERSION_LAST << 16;

enum CURL_TLSAUTH
{
    CURL_TLSAUTH_NONE = 0,
    CURL_TLSAUTH_SRP = 1,
    CURL_TLSAUTH_LAST = 2
}

alias CURL_TLSAUTH_NONE = CURL_TLSAUTH.CURL_TLSAUTH_NONE;
alias CURL_TLSAUTH_SRP = CURL_TLSAUTH.CURL_TLSAUTH_SRP;
alias CURL_TLSAUTH_LAST = CURL_TLSAUTH.CURL_TLSAUTH_LAST;

enum CURL_REDIR_GET_ALL = 0;
enum CURL_REDIR_POST_301 = 1;
enum CURL_REDIR_POST_302 = 2;
enum CURL_REDIR_POST_303 = 4;
enum CURL_REDIR_POST_ALL = CURL_REDIR_POST_301 | CURL_REDIR_POST_302 | CURL_REDIR_POST_303;

enum curl_TimeCond
{
    CURL_TIMECOND_NONE = 0,
    CURL_TIMECOND_IFMODSINCE = 1,
    CURL_TIMECOND_IFUNMODSINCE = 2,
    CURL_TIMECOND_LASTMOD = 3,
    CURL_TIMECOND_LAST = 4
}

alias CURL_TIMECOND_NONE = curl_TimeCond.CURL_TIMECOND_NONE;
alias CURL_TIMECOND_IFMODSINCE = curl_TimeCond.CURL_TIMECOND_IFMODSINCE;
alias CURL_TIMECOND_IFUNMODSINCE = curl_TimeCond.CURL_TIMECOND_IFUNMODSINCE;
alias CURL_TIMECOND_LASTMOD = curl_TimeCond.CURL_TIMECOND_LASTMOD;
alias CURL_TIMECOND_LAST = curl_TimeCond.CURL_TIMECOND_LAST;

enum CURL_ZERO_TERMINATED = cast(size_t) -1;
int curl_strequal (const(char)* s1, const(char)* s2);
int curl_strnequal (const(char)* s1, const(char)* s2, size_t n);
struct curl_mime;
struct curl_mimepart;
enum CURLMIMEOPT_FORMESCAPE = 1 << 0;
curl_mime* curl_mime_init (CURL* easy);
void curl_mime_free (curl_mime* mime);
curl_mimepart* curl_mime_addpart (curl_mime* mime);
CURLcode curl_mime_name (curl_mimepart* part, const(char)* name);
CURLcode curl_mime_filename (curl_mimepart* part, const(char)* filename);
CURLcode curl_mime_type (curl_mimepart* part, const(char)* mimetype);
CURLcode curl_mime_encoder (curl_mimepart* part, const(char)* encoding);
CURLcode curl_mime_data (curl_mimepart* part, const(char)* data, size_t datasize);
CURLcode curl_mime_filedata (curl_mimepart* part, const(char)* filename);
CURLcode curl_mime_data_cb (curl_mimepart* part, curl_off_t datasize, curl_read_callback readfunc, curl_seek_callback seekfunc, curl_free_callback freefunc, void* arg);
CURLcode curl_mime_subparts (curl_mimepart* part, curl_mime* subparts);
CURLcode curl_mime_headers (curl_mimepart* part, curl_slist* headers, int take_ownership);

enum CURLformoption
{
    CURLFORM_NOTHING = 0,
    CURLFORM_COPYNAME = 1,
    CURLFORM_PTRNAME = 2,
    CURLFORM_NAMELENGTH = 3,
    CURLFORM_COPYCONTENTS = 4,
    CURLFORM_PTRCONTENTS = 5,
    CURLFORM_CONTENTSLENGTH = 6,
    CURLFORM_FILECONTENT = 7,
    CURLFORM_ARRAY = 8,
    CURLFORM_OBSOLETE = 9,
    CURLFORM_FILE = 10,
    CURLFORM_BUFFER = 11,
    CURLFORM_BUFFERPTR = 12,
    CURLFORM_BUFFERLENGTH = 13,
    CURLFORM_CONTENTTYPE = 14,
    CURLFORM_CONTENTHEADER = 15,
    CURLFORM_FILENAME = 16,
    CURLFORM_END = 17,
    CURLFORM_OBSOLETE2 = 18,
    CURLFORM_STREAM = 19,
    CURLFORM_CONTENTLEN = 20,
    CURLFORM_LASTENTRY = 21
}

alias CURLFORM_NOTHING = CURLformoption.CURLFORM_NOTHING;
alias CURLFORM_COPYNAME = CURLformoption.CURLFORM_COPYNAME;
alias CURLFORM_PTRNAME = CURLformoption.CURLFORM_PTRNAME;
alias CURLFORM_NAMELENGTH = CURLformoption.CURLFORM_NAMELENGTH;
alias CURLFORM_COPYCONTENTS = CURLformoption.CURLFORM_COPYCONTENTS;
alias CURLFORM_PTRCONTENTS = CURLformoption.CURLFORM_PTRCONTENTS;
alias CURLFORM_CONTENTSLENGTH = CURLformoption.CURLFORM_CONTENTSLENGTH;
alias CURLFORM_FILECONTENT = CURLformoption.CURLFORM_FILECONTENT;
alias CURLFORM_ARRAY = CURLformoption.CURLFORM_ARRAY;
alias CURLFORM_OBSOLETE = CURLformoption.CURLFORM_OBSOLETE;
alias CURLFORM_FILE = CURLformoption.CURLFORM_FILE;
alias CURLFORM_BUFFER = CURLformoption.CURLFORM_BUFFER;
alias CURLFORM_BUFFERPTR = CURLformoption.CURLFORM_BUFFERPTR;
alias CURLFORM_BUFFERLENGTH = CURLformoption.CURLFORM_BUFFERLENGTH;
alias CURLFORM_CONTENTTYPE = CURLformoption.CURLFORM_CONTENTTYPE;
alias CURLFORM_CONTENTHEADER = CURLformoption.CURLFORM_CONTENTHEADER;
alias CURLFORM_FILENAME = CURLformoption.CURLFORM_FILENAME;
alias CURLFORM_END = CURLformoption.CURLFORM_END;
alias CURLFORM_OBSOLETE2 = CURLformoption.CURLFORM_OBSOLETE2;
alias CURLFORM_STREAM = CURLformoption.CURLFORM_STREAM;
alias CURLFORM_CONTENTLEN = CURLformoption.CURLFORM_CONTENTLEN;
alias CURLFORM_LASTENTRY = CURLformoption.CURLFORM_LASTENTRY;

struct curl_forms
{
    CURLformoption option;
    const(char)* value;
}

enum CURLFORMcode
{
    CURL_FORMADD_OK = 0,
    CURL_FORMADD_MEMORY = 1,
    CURL_FORMADD_OPTION_TWICE = 2,
    CURL_FORMADD_NULL = 3,
    CURL_FORMADD_UNKNOWN_OPTION = 4,
    CURL_FORMADD_INCOMPLETE = 5,
    CURL_FORMADD_ILLEGAL_ARRAY = 6,
    CURL_FORMADD_DISABLED = 7,
    CURL_FORMADD_LAST = 8
}

alias CURL_FORMADD_OK = CURLFORMcode.CURL_FORMADD_OK;
alias CURL_FORMADD_MEMORY = CURLFORMcode.CURL_FORMADD_MEMORY;
alias CURL_FORMADD_OPTION_TWICE = CURLFORMcode.CURL_FORMADD_OPTION_TWICE;
alias CURL_FORMADD_NULL = CURLFORMcode.CURL_FORMADD_NULL;
alias CURL_FORMADD_UNKNOWN_OPTION = CURLFORMcode.CURL_FORMADD_UNKNOWN_OPTION;
alias CURL_FORMADD_INCOMPLETE = CURLFORMcode.CURL_FORMADD_INCOMPLETE;
alias CURL_FORMADD_ILLEGAL_ARRAY = CURLFORMcode.CURL_FORMADD_ILLEGAL_ARRAY;
alias CURL_FORMADD_DISABLED = CURLFORMcode.CURL_FORMADD_DISABLED;
alias CURL_FORMADD_LAST = CURLFORMcode.CURL_FORMADD_LAST;

CURLFORMcode curl_formadd (curl_httppost** httppost, curl_httppost** last_post, ...);
alias curl_formget_callback = c_ulong function (void* arg, const(char)* buf, size_t len);
int curl_formget (curl_httppost* form, void* arg, curl_formget_callback append);
void curl_formfree (curl_httppost* form);
char* curl_getenv (const(char)* variable);
char* curl_version ();
char* curl_easy_escape (CURL* handle, const(char)* string, int length);
char* curl_escape (const(char)* string, int length);
char* curl_easy_unescape (CURL* handle, const(char)* string, int length, int* outlength);
char* curl_unescape (const(char)* string, int length);
void curl_free (void* p);
CURLcode curl_global_init (c_long flags);
CURLcode curl_global_init_mem (c_long flags, curl_malloc_callback m, curl_free_callback f, curl_realloc_callback r, curl_strdup_callback s, curl_calloc_callback c);
void curl_global_cleanup ();
CURLcode curl_global_trace (const(char)* config);

struct curl_slist
{
}

struct curl_ssl_backend
{
    curl_sslbackend id;
    const(char)* name;
}

enum CURLsslset
{
    CURLSSLSET_OK = 0,
    CURLSSLSET_UNKNOWN_BACKEND = 1,
    CURLSSLSET_TOO_LATE = 2,
    CURLSSLSET_NO_BACKENDS = 3
}

alias CURLSSLSET_OK = CURLsslset.CURLSSLSET_OK;
alias CURLSSLSET_UNKNOWN_BACKEND = CURLsslset.CURLSSLSET_UNKNOWN_BACKEND;
alias CURLSSLSET_TOO_LATE = CURLsslset.CURLSSLSET_TOO_LATE;
alias CURLSSLSET_NO_BACKENDS = CURLsslset.CURLSSLSET_NO_BACKENDS;

CURLsslset curl_global_sslset (curl_sslbackend id, const(char)* name, const(curl_ssl_backend**)* avail);

curl_slist* curl_slist_append (curl_slist* list, const(char)* data);

void curl_slist_free_all (curl_slist* list);

time_t curl_getdate (const(char)* p, const(time_t)* unused);

struct curl_certinfo
{
    int num_of_certs;
    curl_slist** certinfo;
}

struct curl_tlssessioninfo
{
    curl_sslbackend backend;
    void* internals;
}

enum CURLINFO_STRING = 0x100000;
enum CURLINFO_LONG = 0x200000;
enum CURLINFO_DOUBLE = 0x300000;
enum CURLINFO_SLIST = 0x400000;
enum CURLINFO_PTR = 0x400000;
enum CURLINFO_SOCKET = 0x500000;
enum CURLINFO_OFF_T = 0x600000;
enum CURLINFO_MASK = 0x0fffff;
enum CURLINFO_TYPEMASK = 0xf00000;

enum CURLINFO
{
    CURLINFO_NONE = 0,
    CURLINFO_EFFECTIVE_URL = CURLINFO_STRING + 1,
    CURLINFO_RESPONSE_CODE = CURLINFO_LONG + 2,
    CURLINFO_TOTAL_TIME = CURLINFO_DOUBLE + 3,
    CURLINFO_NAMELOOKUP_TIME = CURLINFO_DOUBLE + 4,
    CURLINFO_CONNECT_TIME = CURLINFO_DOUBLE + 5,
    CURLINFO_PRETRANSFER_TIME = CURLINFO_DOUBLE + 6,
    CURLINFO_SIZE_UPLOAD = 3145735,
    CURLINFO_SIZE_UPLOAD_T = CURLINFO_OFF_T + 7,
    CURLINFO_SIZE_DOWNLOAD = 3145736,
    CURLINFO_SIZE_DOWNLOAD_T = CURLINFO_OFF_T + 8,
    CURLINFO_SPEED_DOWNLOAD = 3145737,
    CURLINFO_SPEED_DOWNLOAD_T = CURLINFO_OFF_T + 9,
    CURLINFO_SPEED_UPLOAD = 3145738,
    CURLINFO_SPEED_UPLOAD_T = CURLINFO_OFF_T + 10,
    CURLINFO_HEADER_SIZE = CURLINFO_LONG + 11,
    CURLINFO_REQUEST_SIZE = CURLINFO_LONG + 12,
    CURLINFO_SSL_VERIFYRESULT = CURLINFO_LONG + 13,
    CURLINFO_FILETIME = CURLINFO_LONG + 14,
    CURLINFO_FILETIME_T = CURLINFO_OFF_T + 14,
    CURLINFO_CONTENT_LENGTH_DOWNLOAD = 3145743,
    CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = CURLINFO_OFF_T + 15,
    CURLINFO_CONTENT_LENGTH_UPLOAD = 3145744,
    CURLINFO_CONTENT_LENGTH_UPLOAD_T = CURLINFO_OFF_T + 16,
    CURLINFO_STARTTRANSFER_TIME = CURLINFO_DOUBLE + 17,
    CURLINFO_CONTENT_TYPE = CURLINFO_STRING + 18,
    CURLINFO_REDIRECT_TIME = CURLINFO_DOUBLE + 19,
    CURLINFO_REDIRECT_COUNT = CURLINFO_LONG + 20,
    CURLINFO_PRIVATE = CURLINFO_STRING + 21,
    CURLINFO_HTTP_CONNECTCODE = CURLINFO_LONG + 22,
    CURLINFO_HTTPAUTH_AVAIL = CURLINFO_LONG + 23,
    CURLINFO_PROXYAUTH_AVAIL = CURLINFO_LONG + 24,
    CURLINFO_OS_ERRNO = CURLINFO_LONG + 25,
    CURLINFO_NUM_CONNECTS = CURLINFO_LONG + 26,
    CURLINFO_SSL_ENGINES = CURLINFO_SLIST + 27,
    CURLINFO_COOKIELIST = CURLINFO_SLIST + 28,
    CURLINFO_LASTSOCKET = 2097181,
    CURLINFO_FTP_ENTRY_PATH = CURLINFO_STRING + 30,
    CURLINFO_REDIRECT_URL = CURLINFO_STRING + 31,
    CURLINFO_PRIMARY_IP = CURLINFO_STRING + 32,
    CURLINFO_APPCONNECT_TIME = CURLINFO_DOUBLE + 33,
    CURLINFO_CERTINFO = CURLINFO_PTR + 34,
    CURLINFO_CONDITION_UNMET = CURLINFO_LONG + 35,
    CURLINFO_RTSP_SESSION_ID = CURLINFO_STRING + 36,
    CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO_LONG + 37,
    CURLINFO_RTSP_SERVER_CSEQ = CURLINFO_LONG + 38,
    CURLINFO_RTSP_CSEQ_RECV = CURLINFO_LONG + 39,
    CURLINFO_PRIMARY_PORT = CURLINFO_LONG + 40,
    CURLINFO_LOCAL_IP = CURLINFO_STRING + 41,
    CURLINFO_LOCAL_PORT = CURLINFO_LONG + 42,
    CURLINFO_TLS_SESSION = 4194347,
    CURLINFO_ACTIVESOCKET = CURLINFO_SOCKET + 44,
    CURLINFO_TLS_SSL_PTR = CURLINFO_PTR + 45,
    CURLINFO_HTTP_VERSION = CURLINFO_LONG + 46,
    CURLINFO_PROXY_SSL_VERIFYRESULT = CURLINFO_LONG + 47,
    CURLINFO_PROTOCOL = 2097200,
    CURLINFO_SCHEME = CURLINFO_STRING + 49,
    CURLINFO_TOTAL_TIME_T = CURLINFO_OFF_T + 50,
    CURLINFO_NAMELOOKUP_TIME_T = CURLINFO_OFF_T + 51,
    CURLINFO_CONNECT_TIME_T = CURLINFO_OFF_T + 52,
    CURLINFO_PRETRANSFER_TIME_T = CURLINFO_OFF_T + 53,
    CURLINFO_STARTTRANSFER_TIME_T = CURLINFO_OFF_T + 54,
    CURLINFO_REDIRECT_TIME_T = CURLINFO_OFF_T + 55,
    CURLINFO_APPCONNECT_TIME_T = CURLINFO_OFF_T + 56,
    CURLINFO_RETRY_AFTER = CURLINFO_OFF_T + 57,
    CURLINFO_EFFECTIVE_METHOD = CURLINFO_STRING + 58,
    CURLINFO_PROXY_ERROR = CURLINFO_LONG + 59,
    CURLINFO_REFERER = CURLINFO_STRING + 60,
    CURLINFO_CAINFO = CURLINFO_STRING + 61,
    CURLINFO_CAPATH = CURLINFO_STRING + 62,
    CURLINFO_XFER_ID = CURLINFO_OFF_T + 63,
    CURLINFO_CONN_ID = CURLINFO_OFF_T + 64,
    CURLINFO_QUEUE_TIME_T = CURLINFO_OFF_T + 65,
    CURLINFO_USED_PROXY = CURLINFO_LONG + 66,
    CURLINFO_POSTTRANSFER_TIME_T = CURLINFO_OFF_T + 67,
    CURLINFO_EARLYDATA_SENT_T = CURLINFO_OFF_T + 68,
    CURLINFO_LASTONE = 68
}

alias CURLINFO_NONE = CURLINFO.CURLINFO_NONE;
alias CURLINFO_EFFECTIVE_URL = CURLINFO.CURLINFO_EFFECTIVE_URL;
alias CURLINFO_RESPONSE_CODE = CURLINFO.CURLINFO_RESPONSE_CODE;
alias CURLINFO_TOTAL_TIME = CURLINFO.CURLINFO_TOTAL_TIME;
alias CURLINFO_NAMELOOKUP_TIME = CURLINFO.CURLINFO_NAMELOOKUP_TIME;
alias CURLINFO_CONNECT_TIME = CURLINFO.CURLINFO_CONNECT_TIME;
alias CURLINFO_PRETRANSFER_TIME = CURLINFO.CURLINFO_PRETRANSFER_TIME;
alias CURLINFO_SIZE_UPLOAD = CURLINFO.CURLINFO_SIZE_UPLOAD;
alias CURLINFO_SIZE_UPLOAD_T = CURLINFO.CURLINFO_SIZE_UPLOAD_T;
alias CURLINFO_SIZE_DOWNLOAD = CURLINFO.CURLINFO_SIZE_DOWNLOAD;
alias CURLINFO_SIZE_DOWNLOAD_T = CURLINFO.CURLINFO_SIZE_DOWNLOAD_T;
alias CURLINFO_SPEED_DOWNLOAD = CURLINFO.CURLINFO_SPEED_DOWNLOAD;
alias CURLINFO_SPEED_DOWNLOAD_T = CURLINFO.CURLINFO_SPEED_DOWNLOAD_T;
alias CURLINFO_SPEED_UPLOAD = CURLINFO.CURLINFO_SPEED_UPLOAD;
alias CURLINFO_SPEED_UPLOAD_T = CURLINFO.CURLINFO_SPEED_UPLOAD_T;
alias CURLINFO_HEADER_SIZE = CURLINFO.CURLINFO_HEADER_SIZE;
alias CURLINFO_REQUEST_SIZE = CURLINFO.CURLINFO_REQUEST_SIZE;
alias CURLINFO_SSL_VERIFYRESULT = CURLINFO.CURLINFO_SSL_VERIFYRESULT;
alias CURLINFO_FILETIME = CURLINFO.CURLINFO_FILETIME;
alias CURLINFO_FILETIME_T = CURLINFO.CURLINFO_FILETIME_T;
alias CURLINFO_CONTENT_LENGTH_DOWNLOAD = CURLINFO.CURLINFO_CONTENT_LENGTH_DOWNLOAD;
alias CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = CURLINFO.CURLINFO_CONTENT_LENGTH_DOWNLOAD_T;
alias CURLINFO_CONTENT_LENGTH_UPLOAD = CURLINFO.CURLINFO_CONTENT_LENGTH_UPLOAD;
alias CURLINFO_CONTENT_LENGTH_UPLOAD_T = CURLINFO.CURLINFO_CONTENT_LENGTH_UPLOAD_T;
alias CURLINFO_STARTTRANSFER_TIME = CURLINFO.CURLINFO_STARTTRANSFER_TIME;
alias CURLINFO_CONTENT_TYPE = CURLINFO.CURLINFO_CONTENT_TYPE;
alias CURLINFO_REDIRECT_TIME = CURLINFO.CURLINFO_REDIRECT_TIME;
alias CURLINFO_REDIRECT_COUNT = CURLINFO.CURLINFO_REDIRECT_COUNT;
alias CURLINFO_PRIVATE = CURLINFO.CURLINFO_PRIVATE;
alias CURLINFO_HTTP_CONNECTCODE = CURLINFO.CURLINFO_HTTP_CONNECTCODE;
alias CURLINFO_HTTPAUTH_AVAIL = CURLINFO.CURLINFO_HTTPAUTH_AVAIL;
alias CURLINFO_PROXYAUTH_AVAIL = CURLINFO.CURLINFO_PROXYAUTH_AVAIL;
alias CURLINFO_OS_ERRNO = CURLINFO.CURLINFO_OS_ERRNO;
alias CURLINFO_NUM_CONNECTS = CURLINFO.CURLINFO_NUM_CONNECTS;
alias CURLINFO_SSL_ENGINES = CURLINFO.CURLINFO_SSL_ENGINES;
alias CURLINFO_COOKIELIST = CURLINFO.CURLINFO_COOKIELIST;
alias CURLINFO_LASTSOCKET = CURLINFO.CURLINFO_LASTSOCKET;
alias CURLINFO_FTP_ENTRY_PATH = CURLINFO.CURLINFO_FTP_ENTRY_PATH;
alias CURLINFO_REDIRECT_URL = CURLINFO.CURLINFO_REDIRECT_URL;
alias CURLINFO_PRIMARY_IP = CURLINFO.CURLINFO_PRIMARY_IP;
alias CURLINFO_APPCONNECT_TIME = CURLINFO.CURLINFO_APPCONNECT_TIME;
alias CURLINFO_CERTINFO = CURLINFO.CURLINFO_CERTINFO;
alias CURLINFO_CONDITION_UNMET = CURLINFO.CURLINFO_CONDITION_UNMET;
alias CURLINFO_RTSP_SESSION_ID = CURLINFO.CURLINFO_RTSP_SESSION_ID;
alias CURLINFO_RTSP_CLIENT_CSEQ = CURLINFO.CURLINFO_RTSP_CLIENT_CSEQ;
alias CURLINFO_RTSP_SERVER_CSEQ = CURLINFO.CURLINFO_RTSP_SERVER_CSEQ;
alias CURLINFO_RTSP_CSEQ_RECV = CURLINFO.CURLINFO_RTSP_CSEQ_RECV;
alias CURLINFO_PRIMARY_PORT = CURLINFO.CURLINFO_PRIMARY_PORT;
alias CURLINFO_LOCAL_IP = CURLINFO.CURLINFO_LOCAL_IP;
alias CURLINFO_LOCAL_PORT = CURLINFO.CURLINFO_LOCAL_PORT;
alias CURLINFO_TLS_SESSION = CURLINFO.CURLINFO_TLS_SESSION;
alias CURLINFO_ACTIVESOCKET = CURLINFO.CURLINFO_ACTIVESOCKET;
alias CURLINFO_TLS_SSL_PTR = CURLINFO.CURLINFO_TLS_SSL_PTR;
alias CURLINFO_HTTP_VERSION = CURLINFO.CURLINFO_HTTP_VERSION;
alias CURLINFO_PROXY_SSL_VERIFYRESULT = CURLINFO.CURLINFO_PROXY_SSL_VERIFYRESULT;
alias CURLINFO_PROTOCOL = CURLINFO.CURLINFO_PROTOCOL;
alias CURLINFO_SCHEME = CURLINFO.CURLINFO_SCHEME;
alias CURLINFO_TOTAL_TIME_T = CURLINFO.CURLINFO_TOTAL_TIME_T;
alias CURLINFO_NAMELOOKUP_TIME_T = CURLINFO.CURLINFO_NAMELOOKUP_TIME_T;
alias CURLINFO_CONNECT_TIME_T = CURLINFO.CURLINFO_CONNECT_TIME_T;
alias CURLINFO_PRETRANSFER_TIME_T = CURLINFO.CURLINFO_PRETRANSFER_TIME_T;
alias CURLINFO_STARTTRANSFER_TIME_T = CURLINFO.CURLINFO_STARTTRANSFER_TIME_T;
alias CURLINFO_REDIRECT_TIME_T = CURLINFO.CURLINFO_REDIRECT_TIME_T;
alias CURLINFO_APPCONNECT_TIME_T = CURLINFO.CURLINFO_APPCONNECT_TIME_T;
alias CURLINFO_RETRY_AFTER = CURLINFO.CURLINFO_RETRY_AFTER;
alias CURLINFO_EFFECTIVE_METHOD = CURLINFO.CURLINFO_EFFECTIVE_METHOD;
alias CURLINFO_PROXY_ERROR = CURLINFO.CURLINFO_PROXY_ERROR;
alias CURLINFO_REFERER = CURLINFO.CURLINFO_REFERER;
alias CURLINFO_CAINFO = CURLINFO.CURLINFO_CAINFO;
alias CURLINFO_CAPATH = CURLINFO.CURLINFO_CAPATH;
alias CURLINFO_XFER_ID = CURLINFO.CURLINFO_XFER_ID;
alias CURLINFO_CONN_ID = CURLINFO.CURLINFO_CONN_ID;
alias CURLINFO_QUEUE_TIME_T = CURLINFO.CURLINFO_QUEUE_TIME_T;
alias CURLINFO_USED_PROXY = CURLINFO.CURLINFO_USED_PROXY;
alias CURLINFO_POSTTRANSFER_TIME_T = CURLINFO.CURLINFO_POSTTRANSFER_TIME_T;
alias CURLINFO_EARLYDATA_SENT_T = CURLINFO.CURLINFO_EARLYDATA_SENT_T;
alias CURLINFO_LASTONE = CURLINFO.CURLINFO_LASTONE;

enum CURLINFO_HTTP_CODE = CURLINFO.CURLINFO_RESPONSE_CODE;

enum curl_closepolicy
{
    CURLCLOSEPOLICY_NONE = 0,

    CURLCLOSEPOLICY_OLDEST = 1,
    CURLCLOSEPOLICY_LEAST_RECENTLY_USED = 2,
    CURLCLOSEPOLICY_LEAST_TRAFFIC = 3,
    CURLCLOSEPOLICY_SLOWEST = 4,
    CURLCLOSEPOLICY_CALLBACK = 5,

    CURLCLOSEPOLICY_LAST = 6
}

alias CURLCLOSEPOLICY_NONE = curl_closepolicy.CURLCLOSEPOLICY_NONE;
alias CURLCLOSEPOLICY_OLDEST = curl_closepolicy.CURLCLOSEPOLICY_OLDEST;
alias CURLCLOSEPOLICY_LEAST_RECENTLY_USED = curl_closepolicy.CURLCLOSEPOLICY_LEAST_RECENTLY_USED;
alias CURLCLOSEPOLICY_LEAST_TRAFFIC = curl_closepolicy.CURLCLOSEPOLICY_LEAST_TRAFFIC;
alias CURLCLOSEPOLICY_SLOWEST = curl_closepolicy.CURLCLOSEPOLICY_SLOWEST;
alias CURLCLOSEPOLICY_CALLBACK = curl_closepolicy.CURLCLOSEPOLICY_CALLBACK;
alias CURLCLOSEPOLICY_LAST = curl_closepolicy.CURLCLOSEPOLICY_LAST;

enum CURL_GLOBAL_SSL = 1 << 0;
enum CURL_GLOBAL_WIN32 = 1 << 1;
enum CURL_GLOBAL_ALL = CURL_GLOBAL_SSL | CURL_GLOBAL_WIN32;
enum CURL_GLOBAL_NOTHING = 0;
enum CURL_GLOBAL_DEFAULT = CURL_GLOBAL_ALL;
enum CURL_GLOBAL_ACK_EINTR = 1 << 2;

enum curl_lock_data
{
    CURL_LOCK_DATA_NONE = 0,

    CURL_LOCK_DATA_SHARE = 1,
    CURL_LOCK_DATA_COOKIE = 2,
    CURL_LOCK_DATA_DNS = 3,
    CURL_LOCK_DATA_SSL_SESSION = 4,
    CURL_LOCK_DATA_CONNECT = 5,
    CURL_LOCK_DATA_PSL = 6,
    CURL_LOCK_DATA_HSTS = 7,
    CURL_LOCK_DATA_LAST = 8
}

alias CURL_LOCK_DATA_NONE = curl_lock_data.CURL_LOCK_DATA_NONE;
alias CURL_LOCK_DATA_SHARE = curl_lock_data.CURL_LOCK_DATA_SHARE;
alias CURL_LOCK_DATA_COOKIE = curl_lock_data.CURL_LOCK_DATA_COOKIE;
alias CURL_LOCK_DATA_DNS = curl_lock_data.CURL_LOCK_DATA_DNS;
alias CURL_LOCK_DATA_SSL_SESSION = curl_lock_data.CURL_LOCK_DATA_SSL_SESSION;
alias CURL_LOCK_DATA_CONNECT = curl_lock_data.CURL_LOCK_DATA_CONNECT;
alias CURL_LOCK_DATA_PSL = curl_lock_data.CURL_LOCK_DATA_PSL;
alias CURL_LOCK_DATA_HSTS = curl_lock_data.CURL_LOCK_DATA_HSTS;
alias CURL_LOCK_DATA_LAST = curl_lock_data.CURL_LOCK_DATA_LAST;

enum curl_lock_access
{
    CURL_LOCK_ACCESS_NONE = 0,
    CURL_LOCK_ACCESS_SHARED = 1,
    CURL_LOCK_ACCESS_SINGLE = 2,
    CURL_LOCK_ACCESS_LAST = 3
}

alias CURL_LOCK_ACCESS_NONE = curl_lock_access.CURL_LOCK_ACCESS_NONE;
alias CURL_LOCK_ACCESS_SHARED = curl_lock_access.CURL_LOCK_ACCESS_SHARED;
alias CURL_LOCK_ACCESS_SINGLE = curl_lock_access.CURL_LOCK_ACCESS_SINGLE;
alias CURL_LOCK_ACCESS_LAST = curl_lock_access.CURL_LOCK_ACCESS_LAST;

alias curl_lock_function = void function (CURL* handle, curl_lock_data data, curl_lock_access locktype, void* userptr);
alias curl_unlock_function = void function (CURL* handle, curl_lock_data data, void* userptr);

enum CURLSHcode
{
    CURLSHE_OK = 0,
    CURLSHE_BAD_OPTION = 1,
    CURLSHE_IN_USE = 2,
    CURLSHE_INVALID = 3,
    CURLSHE_NOMEM = 4,
    CURLSHE_NOT_BUILT_IN = 5,
    CURLSHE_LAST = 6
}

alias CURLSHE_OK = CURLSHcode.CURLSHE_OK;
alias CURLSHE_BAD_OPTION = CURLSHcode.CURLSHE_BAD_OPTION;
alias CURLSHE_IN_USE = CURLSHcode.CURLSHE_IN_USE;
alias CURLSHE_INVALID = CURLSHcode.CURLSHE_INVALID;
alias CURLSHE_NOMEM = CURLSHcode.CURLSHE_NOMEM;
alias CURLSHE_NOT_BUILT_IN = CURLSHcode.CURLSHE_NOT_BUILT_IN;
alias CURLSHE_LAST = CURLSHcode.CURLSHE_LAST;

enum CURLSHoption
{
    CURLSHOPT_NONE = 0,
    CURLSHOPT_SHARE = 1,
    CURLSHOPT_UNSHARE = 2,
    CURLSHOPT_LOCKFUNC = 3,
    CURLSHOPT_UNLOCKFUNC = 4,
    CURLSHOPT_USERDATA = 5,

    CURLSHOPT_LAST = 6
}

alias CURLSHOPT_NONE = CURLSHoption.CURLSHOPT_NONE;
alias CURLSHOPT_SHARE = CURLSHoption.CURLSHOPT_SHARE;
alias CURLSHOPT_UNSHARE = CURLSHoption.CURLSHOPT_UNSHARE;
alias CURLSHOPT_LOCKFUNC = CURLSHoption.CURLSHOPT_LOCKFUNC;
alias CURLSHOPT_UNLOCKFUNC = CURLSHoption.CURLSHOPT_UNLOCKFUNC;
alias CURLSHOPT_USERDATA = CURLSHoption.CURLSHOPT_USERDATA;
alias CURLSHOPT_LAST = CURLSHoption.CURLSHOPT_LAST;

CURLSH* curl_share_init ();
CURLSHcode curl_share_setopt (CURLSH* share, CURLSHoption option, ...);
CURLSHcode curl_share_cleanup (CURLSH* share);

enum CURLversion
{
    CURLVERSION_FIRST = 0,
    CURLVERSION_SECOND = 1,
    CURLVERSION_THIRD = 2,
    CURLVERSION_FOURTH = 3,
    CURLVERSION_FIFTH = 4,
    CURLVERSION_SIXTH = 5,
    CURLVERSION_SEVENTH = 6,
    CURLVERSION_EIGHTH = 7,
    CURLVERSION_NINTH = 8,
    CURLVERSION_TENTH = 9,
    CURLVERSION_ELEVENTH = 10,
    CURLVERSION_TWELFTH = 11,
    CURLVERSION_LAST = 12
}

alias CURLVERSION_FIRST = CURLversion.CURLVERSION_FIRST;
alias CURLVERSION_SECOND = CURLversion.CURLVERSION_SECOND;
alias CURLVERSION_THIRD = CURLversion.CURLVERSION_THIRD;
alias CURLVERSION_FOURTH = CURLversion.CURLVERSION_FOURTH;
alias CURLVERSION_FIFTH = CURLversion.CURLVERSION_FIFTH;
alias CURLVERSION_SIXTH = CURLversion.CURLVERSION_SIXTH;
alias CURLVERSION_SEVENTH = CURLversion.CURLVERSION_SEVENTH;
alias CURLVERSION_EIGHTH = CURLversion.CURLVERSION_EIGHTH;
alias CURLVERSION_NINTH = CURLversion.CURLVERSION_NINTH;
alias CURLVERSION_TENTH = CURLversion.CURLVERSION_TENTH;
alias CURLVERSION_ELEVENTH = CURLversion.CURLVERSION_ELEVENTH;
alias CURLVERSION_TWELFTH = CURLversion.CURLVERSION_TWELFTH;
alias CURLVERSION_LAST = CURLversion.CURLVERSION_LAST;

enum CURLVERSION_NOW = CURLversion.CURLVERSION_TWELFTH;

struct curl_version_info_data
{
    CURLversion age;
    const(char)* version_;
    uint version_num;
    const(char)* host;
    int features;
    const(char)* ssl_version;
    c_long ssl_version_num;
    const(char)* libz_version;

    const(char*)* protocols;

    const(char)* ares;
    int ares_num;

    const(char)* libidn;

    int iconv_ver_num;

    const(char)* libssh_version;

    uint brotli_ver_num;

    const(char)* brotli_version;

    uint nghttp2_ver_num;

    const(char)* nghttp2_version;
    const(char)* quic_version;

    const(char)* cainfo;

    const(char)* capath;

    uint zstd_ver_num;

    const(char)* zstd_version;

    const(char)* hyper_version;

    const(char)* gsasl_version;

    const(char*)* feature_names;

    const(char)* rtmp_version;
}

enum CURL_VERSION_IPV6 = 1 << 0;
enum CURL_VERSION_KERBEROS4 = 1 << 1;

enum CURL_VERSION_SSL = 1 << 2;
enum CURL_VERSION_LIBZ = 1 << 3;
enum CURL_VERSION_NTLM = 1 << 4;
enum CURL_VERSION_GSSNEGOTIATE = 1 << 5;

enum CURL_VERSION_DEBUG = 1 << 6;
enum CURL_VERSION_ASYNCHDNS = 1 << 7;
enum CURL_VERSION_SPNEGO = 1 << 8;
enum CURL_VERSION_LARGEFILE = 1 << 9;
enum CURL_VERSION_IDN = 1 << 10;

enum CURL_VERSION_SSPI = 1 << 11;
enum CURL_VERSION_CONV = 1 << 12;
enum CURL_VERSION_CURLDEBUG = 1 << 13;
enum CURL_VERSION_TLSAUTH_SRP = 1 << 14;
enum CURL_VERSION_NTLM_WB = 1 << 15;

enum CURL_VERSION_HTTP2 = 1 << 16;
enum CURL_VERSION_GSSAPI = 1 << 17;
enum CURL_VERSION_KERBEROS5 = 1 << 18;
enum CURL_VERSION_UNIX_SOCKETS = 1 << 19;
enum CURL_VERSION_PSL = 1 << 20;

enum CURL_VERSION_HTTPS_PROXY = 1 << 21;
enum CURL_VERSION_MULTI_SSL = 1 << 22;
enum CURL_VERSION_BROTLI = 1 << 23;
enum CURL_VERSION_ALTSVC = 1 << 24;
enum CURL_VERSION_HTTP3 = 1 << 25;
enum CURL_VERSION_ZSTD = 1 << 26;
enum CURL_VERSION_UNICODE = 1 << 27;
enum CURL_VERSION_HSTS = 1 << 28;
enum CURL_VERSION_GSASL = 1 << 29;
enum CURL_VERSION_THREADSAFE = 1 << 30;

curl_version_info_data* curl_version_info (CURLversion);

const(char)* curl_easy_strerror (CURLcode);

const(char)* curl_share_strerror (CURLSHcode);

CURLcode curl_easy_pause (CURL* handle, int bitmask);

enum CURLPAUSE_RECV = 1 << 0;
enum CURLPAUSE_RECV_CONT = 0;

enum CURLPAUSE_SEND = 1 << 2;
enum CURLPAUSE_SEND_CONT = 0;

enum CURLPAUSE_ALL = CURLPAUSE_RECV | CURLPAUSE_SEND;
enum CURLPAUSE_CONT = CURLPAUSE_RECV_CONT | CURLPAUSE_SEND_CONT;

CURL* curl_easy_init(); 
CURLcode curl_easy_perform(CURL* curl);
void curl_easy_cleanup(CURL* curl); 

CURLcode curl_easy_setopt(CURL* curl, CURLoption option, ...);
CURLcode curl_easy_getinfo(CURL* curl, CURLINFO info, ...); 
// CURLSHcode curl_share_setopt(CURLSH*, CURLSHoption option, ...); 
// CURLMcode curl_multi_setopt(CURLM* multi_handle, CURLMoption option, ...);