package vendor:curl

Source

CURL :: struct {}

CURLM :: struct {}

CURLSH :: struct {}

CURLU :: struct {}

Hcode :: enum i32 {
	E_OK, 
	E_BADINDEX,      // header exists but not with this index
	E_MISSING,       // no such header exists
	E_NOHEADERS,     // no headers at all exist (yet)
	E_NOREQUEST,     // no request with this number was used
	E_OUT_OF_MEMORY, // out of memory while processing
	E_BAD_ARGUMENT,  // a function argument was not okay
	E_NOT_BUILT_IN,  // if API was disabled in the build
}

INFO :: enum i32 {
	NONE,                                // first, never use this
	EFFECTIVE_URL             = 1048577, 
	RESPONSE_CODE             = 2097154, 
	TOTAL_TIME                = 3145731, 
	NAMELOOKUP_TIME           = 3145732, 
	CONNECT_TIME              = 3145733, 
	PRETRANSFER_TIME          = 3145734, 
	SIZE_UPLOAD_T             = 6291463, 
	SIZE_DOWNLOAD_T           = 6291464, 
	SPEED_DOWNLOAD_T          = 6291465, 
	SPEED_UPLOAD_T            = 6291466, 
	HEADER_SIZE               = 2097163, 
	REQUEST_SIZE              = 2097164, 
	SSL_VERIFYRESULT          = 2097165, 
	FILETIME                  = 2097166, 
	FILETIME_T                = 6291470, 
	CONTENT_LENGTH_DOWNLOAD_T = 6291471, 
	CONTENT_LENGTH_UPLOAD_T   = 6291472, 
	STARTTRANSFER_TIME        = 3145745, 
	CONTENT_TYPE              = 1048594, 
	REDIRECT_TIME             = 3145747, 
	REDIRECT_COUNT            = 2097172, 
	PRIVATE                   = 1048597, 
	HTTP_CONNECTCODE          = 2097174, 
	HTTPAUTH_AVAIL            = 2097175, 
	PROXYAUTH_AVAIL           = 2097176, 
	OS_ERRNO                  = 2097177, 
	NUM_CONNECTS              = 2097178, 
	SSL_ENGINES               = 4194331, 
	COOKIELIST                = 4194332, 
	FTP_ENTRY_PATH            = 1048606, 
	REDIRECT_URL              = 1048607, 
	PRIMARY_IP                = 1048608, 
	APPCONNECT_TIME           = 3145761, 
	CERTINFO                  = 4194338, 
	CONDITION_UNMET           = 2097187, 
	RTSP_SESSION_ID           = 1048612, 
	RTSP_CLIENT_CSEQ          = 2097189, 
	RTSP_SERVER_CSEQ          = 2097190, 
	RTSP_CSEQ_RECV            = 2097191, 
	PRIMARY_PORT              = 2097192, 
	LOCAL_IP                  = 1048617, 
	LOCAL_PORT                = 2097194, 
	ACTIVESOCKET              = 5242924, 
	TLS_SSL_PTR               = 4194349, 
	HTTP_VERSION              = 2097198, 
	PROXY_SSL_VERIFYRESULT    = 2097199, 
	SCHEME                    = 1048625, 
	TOTAL_TIME_T              = 6291506, 
	NAMELOOKUP_TIME_T         = 6291507, 
	CONNECT_TIME_T            = 6291508, 
	PRETRANSFER_TIME_T        = 6291509, 
	STARTTRANSFER_TIME_T      = 6291510, 
	REDIRECT_TIME_T           = 6291511, 
	APPCONNECT_TIME_T         = 6291512, 
	RETRY_AFTER               = 6291513, 
	EFFECTIVE_METHOD          = 1048634, 
	PROXY_ERROR               = 2097211, 
	REFERER                   = 1048636, 
	CAINFO                    = 1048637, 
	CAPATH                    = 1048638, 
	XFER_ID                   = 6291519, 
	CONN_ID                   = 6291520, 
	QUEUE_TIME_T              = 6291521, 
	USED_PROXY                = 2097218, 
	POSTTRANSFER_TIME_T       = 6291523, 
	EARLYDATA_SENT_T          = 6291524, 
	HTTPAUTH_USED             = 2097221, 
	PROXYAUTH_USED            = 2097222, 
	// CURLINFO_RESPONSE_CODE is the new name for the option previously known as
	// 	   CURLINFO_HTTP_CODE 
	HTTP_CODE                 = 2097154, 
}

MSG :: enum i32 {
	NONE, // first, not used
	DONE, // This easy handle has completed. 'result' contains
	          the CURLcode of the transfer
}

MULTI_NOTIFY :: enum u32 {
	INFO_READ = 0, 
	EASY_DONE = 1, 
}

Mcode :: enum i32 {
	CALL_MULTI_PERFORM    = -1, // please call curl_multi_perform() or
                                    curl_multi_socket*() soon
	OK, 
	BAD_HANDLE,                 // the passed-in handle is not a valid CURLM handle
	BAD_EASY_HANDLE,            // an easy handle was not good/valid
	OUT_OF_MEMORY,              // if you ever get this, you are in deep sh*t
	INTERNAL_ERROR,             // this is a libcurl bug
	BAD_SOCKET,                 // the passed in socket argument did not match
	UNKNOWN_OPTION,             // curl_multi_setopt() with unsupported option
	ADDED_ALREADY,              // an easy handle already added to a multi handle was
                            attempted to get added - again
	RECURSIVE_API_CALL,         // an api function was called from inside a
                               callback
	WAKEUP_FAILURE,             // wakeup is unavailable or failed
	BAD_FUNCTION_ARGUMENT,      // function called with a bad parameter
	ABORTED_BY_CALLBACK, 
	UNRECOVERABLE_POLL, 
	CALL_MULTI_SOCKET     = -1, 
}

Minfo :: enum i32 {
	// first, never use this 
	NONE               = 0, 
	// The number of easy handles currently managed by the multi handle,
	// 	 * e.g. have been added but not yet removed. 
	XFERS_CURRENT      = 1, 
	// The number of easy handles running, e.g. not done and not queueing. 
	XFERS_RUNNING      = 2, 
	// The number of easy handles waiting to start, e.g. for a connection
	// 	 * to become available due to limits on parallelism, max connections
	// 	 * or other factors. 
	INFO_XFERS_PENDING = 3, 
	// The number of easy handles finished, waiting for their results to
	// 	 * be read via `curl_multi_info_read()`. 
	XFERS_DONE         = 4, 
	// The total number of easy handles added to the multi handle, ever. 
	XFERS_ADDED        = 5, 
	// the last unused 
	LASTENTRY, 
}

Moption :: enum i32 {
	// This is the socket callback function pointer 
	SOCKETFUNCTION              = 20001, 
	// This is the argument passed to the socket callback 
	SOCKETDATA                  = 10002, 
	// set to 1 to enable pipelining for this multi handle 
	PIPELINING                  = 3, 
	// This is the timer callback function pointer 
	TIMERFUNCTION               = 20004, 
	// This is the argument passed to the timer callback 
	TIMERDATA                   = 10005, 
	// maximum number of entries in the connection cache 
	MAXCONNECTS                 = 6, 
	// maximum number of (pipelining) connections to one host 
	MAX_HOST_CONNECTIONS        = 7, 
	// maximum number of requests in a pipeline 
	MAX_PIPELINE_LENGTH         = 8, 
	// a connection with a content-length longer than this
	// 	will not be considered for pipelining 
	CONTENT_LENGTH_PENALTY_SIZE = 30009, 
	// a connection with a chunk length longer than this
	// 	will not be considered for pipelining 
	CHUNK_LENGTH_PENALTY_SIZE   = 30010, 
	// a list of site names(+port) that are blocked from pipelining 
	PIPELINING_SITE_BL          = 10011, 
	// a list of server types that are blocked from pipelining 
	PIPELINING_SERVER_BL        = 10012, 
	// maximum number of open connections in total 
	MAX_TOTAL_CONNECTIONS       = 13, 
	// This is the server push callback function pointer 
	PUSHFUNCTION                = 20014, 
	// This is the argument passed to the server push callback 
	PUSHDATA                    = 10015, 
	// maximum number of concurrent streams to support on a connection 
	MAX_CONCURRENT_STREAMS      = 16, 
	// network has changed, adjust caches/connection reuse 
	NETWORK_CHANGED             = 17, 
	// This is the notify callback function pointer 
	NOTIFYFUNCTION              = 20018, 
	// This is the argument passed to the notify callback 
	NOTIFYDATA                  = 10019, 
}

Msg :: struct {
	msg:         MSG,
	// what this message means 
	easy_handle: ^CURL,
	// the handle it concerns 
	data:        struct #raw_union {
		whatever: rawptr,
		// message-specific data 
		result:   code,
	},
}

NETRC_OPTION :: enum i32 {
	// we set a single member here, just to make sure we still provide the enum,
	// 	   but the values to use are defined above with L suffixes 
	LAST = 3, 
}

SHcode :: enum i32 {
	OK,           // all is fine
	BAD_OPTION,   // 1
	IN_USE,       // 2
	INVALID,      // 3
	NOMEM,        // 4 out of memory
	NOT_BUILT_IN, // 5 feature not present in lib
}

SHoption :: enum i32 {
	NONE,                 // do not use
	CURLSHOPT_SHARE,      // specify a data type to share
	CURLSHOPT_UNSHARE,    // specify which data type to stop sharing
	CURLSHOPT_LOCKFUNC,   // pass in a 'curl_lock_function' pointer
	CURLSHOPT_UNLOCKFUNC, // pass in a 'curl_unlock_function' pointer
	CURLSHOPT_USERDATA,   // pass in a user data pointer used in the lock/unlock
	                         callback functions
}

STScode :: enum i32 {
	OK, 
	DONE, 
	FAIL, 
}

TLSAUTH :: enum i32 {
	// 		we set a single member here, just to make sure we still provide the enum,
	// 		but the values to use are defined above with L suffixes
	LAST = 2, 
}

TimeCond :: enum i32 {
	// 		we set a single member here, just to make sure we still provide
	// 		the enum typedef, but the values to use are defined above with L
	// 		suffixes
	LAST = 4, 
}

UFlag :: enum u32 {
	DEFAULT_PORT       = 0,  // return default port number
	NO_DEFAULT_PORT    = 1,  // act as if no port number was set,
	                             if the port number matches the
	                             default for the scheme
	DEFAULT_SCHEME     = 2,  // return default scheme if
	                             missing
	NON_SUPPORT_SCHEME = 3,  // allow non-supported scheme
	PATH_AS_IS         = 4,  // leave dot sequences
	DISALLOW_USER      = 5,  // no user+password allowed
	URLDECODE          = 6,  // URL decode on get
	URLENCODE          = 7,  // URL encode on set
	APPENDQUERY        = 8,  // append a form style part
	GUESS_SCHEME       = 9,  // legacy curl-style guessing
	NO_AUTHORITY       = 10, // Allow empty authority when the
	                             scheme is unknown.
	ALLOW_SPACE        = 11, // Allow spaces in the URL
	PUNYCODE           = 12, // get the hostname in punycode
	PUNY2IDN           = 13, // punycode => IDN conversion
	GET_EMPTY          = 14, // allow empty queries and fragments
	                             when extracting the URL or the
	                             components
	NO_GUESS_SCHEME    = 15, // for get, do not accept a guess
}

UFlags :: distinct bit_set[UFlag; u32]

UPart :: enum i32 {
	URL, 
	SCHEME, 
	USER, 
	PASSWORD, 
	OPTIONS, 
	HOST, 
	PORT, 
	PATH, 
	QUERY, 
	FRAGMENT, 
	ZONEID,   // added in 7.65.0
}

Ucode :: enum i32 {
	E_OK, 
	E_BAD_HANDLE,         // 1
	E_BAD_PARTPOINTER,    // 2
	E_MALFORMED_INPUT,    // 3
	E_BAD_PORT_NUMBER,    // 4
	E_UNSUPPORTED_SCHEME, // 5
	E_URLDECODE,          // 6
	E_OUT_OF_MEMORY,      // 7
	E_USER_NOT_ALLOWED,   // 8
	E_UNKNOWN_PART,       // 9
	E_NO_SCHEME,          // 10
	E_NO_USER,            // 11
	E_NO_PASSWORD,        // 12
	E_NO_OPTIONS,         // 13
	E_NO_HOST,            // 14
	E_NO_PORT,            // 15
	E_NO_QUERY,           // 16
	E_NO_FRAGMENT,        // 17
	E_NO_ZONEID,          // 18
	E_BAD_FILE_URL,       // 19
	E_BAD_FRAGMENT,       // 20
	E_BAD_HOSTNAME,       // 21
	E_BAD_IPV6,           // 22
	E_BAD_LOGIN,          // 23
	E_BAD_PASSWORD,       // 24
	E_BAD_PATH,           // 25
	E_BAD_QUERY,          // 26
	E_BAD_SCHEME,         // 27
	E_BAD_SLASHES,        // 28
	E_BAD_USER,           // 29
	E_LACKS_IDN,          // 30
	E_TOO_LARGE,          // 31
}

blob :: struct {
	data:  rawptr,
	len:   uint,
	flags: blob_flags,
}

blob_flag :: enum u32 {
	COPY = 0, 
}

blob_flags :: distinct bit_set[blob_flag; u32]

calloc_callback :: proc "c" (nmemb, size: uint) -> rawptr

certinfo :: struct {
	num_of_certs: i32,
	// number of certificates with information 
	certinfo:     ^^slist,
}

chunk_bgn_callback :: proc "c" (transfer_info: rawptr, ptr: rawptr, remains: i32) -> i32

chunk_end_callback :: proc "c" (ptr: rawptr) -> i32

closepolicy :: enum i32 {
	NONE,                                // first, never use this
	CURLCLOSEPOLICY_OLDEST, 
	CURLCLOSEPOLICY_LEAST_RECENTLY_USED, 
	CURLCLOSEPOLICY_LEAST_TRAFFIC, 
	CURLCLOSEPOLICY_SLOWEST, 
	CURLCLOSEPOLICY_CALLBACK, 
}

closesocket_callback :: proc "c" (clientp: rawptr, item: socket_t) -> i32

code :: enum i32 {
	E_OK                       = 0, 
	E_UNSUPPORTED_PROTOCOL,         // 1
	E_FAILED_INIT,                  // 2
	E_URL_MALFORMAT,                // 3
	E_NOT_BUILT_IN,                 // 4 - [was obsoleted in August 2007 for
                                    7.17.0, reused in April 2011 for 7.21.5]
	E_COULDNT_RESOLVE_PROXY,        // 5
	E_COULDNT_RESOLVE_HOST,         // 6
	E_COULDNT_CONNECT,              // 7
	E_WEIRD_SERVER_REPLY,           // 8
	E_REMOTE_ACCESS_DENIED,         // 9 a service was denied by the server
                                    due to lack of access - when login fails
                                    this is not returned.
	E_FTP_ACCEPT_FAILED,            // 10 - [was obsoleted in April 2006 for
                                    7.15.4, reused in Dec 2011 for 7.24.0]
	E_FTP_WEIRD_PASS_REPLY,         // 11
	E_FTP_ACCEPT_TIMEOUT,           // 12 - timeout occurred accepting server
                                    [was obsoleted in August 2007 for 7.17.0,
                                    reused in Dec 2011 for 7.24.0]
	E_FTP_WEIRD_PASV_REPLY,         // 13
	E_FTP_WEIRD_227_FORMAT,         // 14
	E_FTP_CANT_GET_HOST,            // 15
	E_HTTP2,                        // 16 - A problem in the http2 framing layer.
                                    [was obsoleted in August 2007 for 7.17.0,
                                    reused in July 2014 for 7.38.0]
	E_FTP_COULDNT_SET_TYPE,         // 17
	E_PARTIAL_FILE,                 // 18
	E_FTP_COULDNT_RETR_FILE,        // 19
	E_OBSOLETE20,                   // 20 - NOT USED
	E_QUOTE_ERROR,                  // 21 - quote command failure
	E_HTTP_RETURNED_ERROR,          // 22
	E_WRITE_ERROR,                  // 23
	E_OBSOLETE24,                   // 24 - NOT USED
	E_UPLOAD_FAILED,                // 25 - failed upload "command"
	E_READ_ERROR,                   // 26 - could not open/read from file
	E_OUT_OF_MEMORY,                // 27
	E_OPERATION_TIMEDOUT,           // 28 - the timeout time was reached
	E_OBSOLETE29,                   // 29 - NOT USED
	E_FTP_PORT_FAILED,              // 30 - FTP PORT operation failed
	E_FTP_COULDNT_USE_REST,         // 31 - the REST command failed
	E_OBSOLETE32,                   // 32 - NOT USED
	E_RANGE_ERROR,                  // 33 - RANGE "command" did not work
	E_OBSOLETE34,                   // 34
	E_SSL_CONNECT_ERROR,            // 35 - wrong when connecting with SSL
	E_BAD_DOWNLOAD_RESUME,          // 36 - could not resume download
	E_FILE_COULDNT_READ_FILE,       // 37
	E_LDAP_CANNOT_BIND,             // 38
	E_LDAP_SEARCH_FAILED,           // 39
	E_OBSOLETE40,                   // 40 - NOT USED
	E_OBSOLETE41,                   // 41 - NOT USED starting with 7.53.0
	E_ABORTED_BY_CALLBACK,          // 42
	E_BAD_FUNCTION_ARGUMENT,        // 43
	E_OBSOLETE44,                   // 44 - NOT USED
	E_INTERFACE_FAILED,             // 45 - CURLOPT_INTERFACE failed
	E_OBSOLETE46,                   // 46 - NOT USED
	E_TOO_MANY_REDIRECTS,           // 47 - catch endless re-direct loops
	E_UNKNOWN_OPTION,               // 48 - User specified an unknown option
	E_SETOPT_OPTION_SYNTAX,         // 49 - Malformed setopt option
	E_OBSOLETE50,                   // 50 - NOT USED
	E_OBSOLETE51,                   // 51 - NOT USED
	E_GOT_NOTHING,                  // 52 - when this is a specific error
	E_SSL_ENGINE_NOTFOUND,          // 53 - SSL crypto engine not found
	E_SSL_ENGINE_SETFAILED,         // 54 - can not set SSL crypto engine as
                                    default
	E_SEND_ERROR,                   // 55 - failed sending network data
	E_RECV_ERROR,                   // 56 - failure in receiving network data
	E_OBSOLETE57,                   // 57 - NOT IN USE
	E_SSL_CERTPROBLEM,              // 58 - problem with the local certificate
	E_SSL_CIPHER,                   // 59 - could not use specified cipher
	E_PEER_FAILED_VERIFICATION,     // 60 - peer's certificate or fingerprint
                                     was not verified fine
	E_BAD_CONTENT_ENCODING,         // 61 - Unrecognized/bad encoding
	E_OBSOLETE62,                   // 62 - NOT IN USE since 7.82.0
	E_FILESIZE_EXCEEDED,            // 63 - Maximum file size exceeded
	E_USE_SSL_FAILED,               // 64 - Requested FTP SSL level failed
	E_SEND_FAIL_REWIND,             // 65 - Sending the data requires a rewind
                                    that failed
	E_SSL_ENGINE_INITFAILED,        // 66 - failed to initialise ENGINE
	E_LOGIN_DENIED,                 // 67 - user, password or similar was not
                                    accepted and we failed to login
	E_TFTP_NOTFOUND,                // 68 - file not found on server
	E_TFTP_PERM,                    // 69 - permission problem on server
	E_REMOTE_DISK_FULL,             // 70 - out of disk space on server
	E_TFTP_ILLEGAL,                 // 71 - Illegal TFTP operation
	E_TFTP_UNKNOWNID,               // 72 - Unknown transfer ID
	E_REMOTE_FILE_EXISTS,           // 73 - File already exists
	E_TFTP_NOSUCHUSER,              // 74 - No such user
	E_OBSOLETE75,                   // 75 - NOT IN USE since 7.82.0
	E_OBSOLETE76,                   // 76 - NOT IN USE since 7.82.0
	E_SSL_CACERT_BADFILE,           // 77 - could not load CACERT file, missing
                                    or wrong format
	E_REMOTE_FILE_NOT_FOUND,        // 78 - remote file not found
	E_SSH,                          // 79 - error from the SSH layer, somewhat
                                    generic so the error message will be of
                                    interest when this has happened
	E_SSL_SHUTDOWN_FAILED,          // 80 - Failed to shut down the SSL
                                    connection
	E_AGAIN,                        // 81 - socket is not ready for send/recv,
                                    wait till it is ready and try again (Added
                                    in 7.18.2)
	E_SSL_CRL_BADFILE,              // 82 - could not load CRL file, missing or
                                    wrong format (Added in 7.19.0)
	E_SSL_ISSUER_ERROR,             // 83 - Issuer check failed.  (Added in
                                    7.19.0)
	E_FTP_PRET_FAILED,              // 84 - a PRET command failed
	E_RTSP_CSEQ_ERROR,              // 85 - mismatch of RTSP CSeq numbers
	E_RTSP_SESSION_ERROR,           // 86 - mismatch of RTSP Session Ids
	E_FTP_BAD_FILE_LIST,            // 87 - unable to parse FTP file list
	E_CHUNK_FAILED,                 // 88 - chunk callback reported error
	E_NO_CONNECTION_AVAILABLE,      // 89 - No connection available, the
                                    session will be queued
	E_SSL_PINNEDPUBKEYNOTMATCH,     // 90 - specified pinned public key did not
                                     match
	E_SSL_INVALIDCERTSTATUS,        // 91 - invalid certificate status
	E_HTTP2_STREAM,                 // 92 - stream error in HTTP/2 framing layer
	E_RECURSIVE_API_CALL,           // 93 - an api function was called from
                                    inside a callback
	E_AUTH_ERROR,                   // 94 - an authentication function returned an
                                    error
	E_HTTP3,                        // 95 - An HTTP/3 layer problem
	E_QUIC_CONNECT_ERROR,           // 96 - QUIC connection error
	E_PROXY,                        // 97 - proxy handshake error
	E_SSL_CLIENTCERT,               // 98 - client-side certificate required
	E_UNRECOVERABLE_POLL,           // 99 - poll/select returned fatal error
	E_TOO_LARGE,                    // 100 - a value/data met its maximum
	E_ECH_REQUIRED,                 // 101 - ECH tried but failed
}

conv_callback :: proc "c" (buffer: [^]u8, length: uint) -> code

curl_notify_function :: proc "c" (multi_handle: ^CURLM, notification: MULTI_NOTIFY, easy: ^CURL, user_data: rawptr)

debug_callback :: proc "c" (handle: ^CURL, type: infotype, data: [^]u8, size: uint, userptr: rawptr) -> i32

easyoption :: struct {
	name:  cstring,
	id:    option,
	type:  easytype,
	flags: easyoptionflags,
}

easyoptionflag :: enum u32 {
	// "alias" means it is provided for old programs to remain functional, we prefer another name 
	ALIAS = 0, 
}

easyoptionflags :: distinct bit_set[easyoptionflag; u32]

easytype :: enum i32 {
	OT_LONG,     // long (a range of values)
	OT_VALUES,   //      (a defined set or bitmask)
	OT_OFF_T,    // curl_off_t (a range of values)
	OT_OBJECT,   // pointer (void *)
	OT_STRING,   //         (char * to null-terminated buffer)
	OT_SLIST,    //         (struct curl_slist *)
	OT_CBPTR,    //         (void * passed as-is to a callback)
	OT_BLOB,     // blob (struct curl_blob *)
	OT_FUNCTION, // function pointer
}

fileinfo :: struct {
	filename:  cstring,
	filetype:  filetype,
	time:      libc.time_t,
	// always zero! 
	perm:      u32,
	uid:       i32,
	gid:       i32,
	size:      i64,
	hardlinks: i32,
	strings:   struct {
		// If some of these fields is not NULL, it is a pointer to b_data. 
		time:   cstring,
		perm:   cstring,
		user:   cstring,
		group:  cstring,
		target: cstring,
	},
	flags:     finfoflags,
	// These are libcurl private struct fields. Previously used by libcurl, so
	// 	they must never be interfered with. 
	b_data:    [^]u8,
	b_size:    uint,
	b_used:    uint,
}

filetype :: enum i32 {
	FILE         = 0, 
	DIRECTORY, 
	SYMLINK, 
	DEVICE_BLOCK, 
	DEVICE_CHAR, 
	NAMEDPIPE, 
	SOCKET, 
	DOOR,             // is possible only on Sun Solaris now
	UNKNOWN,          // should never occur
}

finfoflag :: enum u32 {
	KNOWN_FILENAME   = 0, 
	KNOWN_FILETYPE   = 1, 
	KNOWN_TIME       = 2, 
	KNOWN_PERM       = 3, 
	KNOWN_UID        = 4, 
	KNOWN_GID        = 5, 
	KNOWN_SIZE       = 6, 
	KNOWN_HLINKCOUNT = 7, 
}

finfoflags :: distinct bit_set[finfoflag; u32]

fnmatch_callback :: proc "c" (ptr: rawptr, pattern: cstring, string: cstring) -> i32

formget_callback :: proc "c" (arg: rawptr, buf: [^]u8, len: uint) -> uint

free_callback :: proc "c" (ptr: rawptr)

ftpauth :: enum i32 {
	DEFAULT, // let libcurl decide
	SSL,     // use "AUTH SSL"
	TLS,     // use "AUTH TLS"
}

ftpccc :: enum i32 {
	NONE,    // do not send CCC
	PASSIVE, // Let the server initiate the shutdown
	ACTIVE,  // Initiate the shutdown
}

ftpcreatedir :: enum i32 {
	DIR_NONE, // do NOT create missing dirs!
	DIR,      // (FTP/SFTP) if CWD fails, try MKD and then CWD
                again if MKD succeeded, for SFTP this does
                similar magic
	_RETRY,   // (FTP only) if CWD fails, try MKD and then CWD
                   again even if MKD failed!
}

ftpmethod :: enum i32 {
	DEFAULT,   // let libcurl pick
	MULTICWD,  // single CWD operation for each path part
	NOCWD,     // no CWD at all
	SINGLECWD, // one CWD to full dir, then work on file
}

header :: struct {
	name:   cstring,
	// this might not use the same case 
	value:  cstring,
	amount: uint,
	// number of headers using this name  
	index:  uint,
	// ... of this instance, 0 or higher 
	origin: header_origin_bits,
	// see bits below 
	anchor: rawptr,
}

header_origin_bit :: enum u32 {
	H_HEADER  = 0, // plain server header
	H_TRAILER = 1, // trailers
	H_CONNECT = 2, // CONNECT headers
	H_1XX     = 3, // 1xx headers
	H_PSEUDO  = 4, // pseudo headers
}

header_origin_bits :: distinct bit_set[header_origin_bit; u32]

hstsentry :: struct {
	name:    cstring,
	namelen: uint,
	using _: bit_field u32 {
		includeSubDomains: bool | 1,
	},
	expire:  [18]u8,
}

hstsread_callback :: proc "c" (easy: ^CURL, e: ^hstsentry, userp: rawptr) -> STScode

hstswrite_callback :: proc "c" (easy: ^CURL, e: ^hstsentry, i: ^index, userp: rawptr) -> STScode

httppost :: struct {
	next:           ^httppost,
	// next entry in the list 
	name:           cstring `fmt:"v,name"`,
	// pointer to allocated name 
	namelength:     i32,
	// length of name length 
	contents:       cstring,
	// pointer to allocated data contents 
	contentslength: i32,
	// length of contents field, see also
	// 	                                                CURL_HTTPPOST_LARGE 
	buffer:         [^]u8,
	// pointer to allocated buffer contents 
	bufferlength:   i32,
	// length of buffer field 
	contenttype:    cstring,
	// Content-Type 
	contentheader:  ^slist,
	// list of extra headers for this form 
	more:           ^httppost,
	// if one field name has more than one
	// 	                                                file, this link should link to following
	// 	                                                files 
	flags:          httppost_flags,
	// as defined below 
	showfilename:   cstring,
	// The filename to show. If not set, the
	// 	                           actual filename will be used (if this
	// 	                           is a file part) 
	userp:          rawptr,
	// custom pointer used for
	//                                    HTTPPOST_CALLBACK posts 
	contentlen:     i64,
}

httppost_flag :: enum i32 {
	// specified content is a filename 
	FILENAME    = 0, 
	// specified content is a filename 
	READFILE    = 1, 
	// name is only stored pointer do not free in formfree 
	PTRNAME     = 2, 
	// contents is only stored pointer do not free in formfree 
	PTRCONTENTS = 3, 
	// upload file from buffer 
	BUFFER      = 4, 
	// upload file from pointer contents 
	PTRBUFFER   = 5, 
	// upload file contents by using the regular read callback to get the data and
	// 	   pass the given pointer as custom pointer 
	CALLBACK    = 6, 
	// use size in 'contentlen', added in 7.46.0 
	LARGE       = 7, 
}

httppost_flags :: distinct bit_set[httppost_flag; i32]

index :: struct {
	index: uint,
	// the provided entry's "index" or count 
	total: uint,
}

infotype :: enum i32 {
	TEXT         = 0, 
	HEADER_IN,        // 1
	HEADER_OUT,       // 2
	DATA_IN,          // 3
	DATA_OUT,         // 4
	SSL_DATA_IN,      // 5
	SSL_DATA_OUT,     // 6
	END, 
}

iocmd :: enum i32 {
	NOP,         // no operation
	RESTARTREAD, // restart the read stream from start
}

ioctl_callback :: proc "c" (handle: ^CURL, cmd: i32, clientp: rawptr) -> ioerr

ioerr :: enum i32 {
	E_OK,          // I/O operation successful
	E_UNKNOWNCMD,  // command was unknown to callback
	E_FAILRESTART, // failed to restart the read
}

khkey :: struct {
	key:     cstring,
	// points to a null-terminated string encoded with base64
	// 	                 if len is zero, otherwise to the "raw" data 
	len:     uint,
	keytype: khtype,
}

khmatch :: enum i32 {
	OK,       // match
	MISMATCH, // host found, key mismatch!
	MISSING,  // no matching host/key found
}

khstat :: enum i32 {
	FINE_ADD_TO_FILE, 
	FINE, 
	REJECT,           // reject the connection, return an error
	DEFER,            // do not accept it, but we cannot answer right now.
	           Causes a CURLE_PEER_FAILED_VERIFICATION error but the
	           connection will be left intact etc
	FINE_REPLACE,     // accept and replace the wrong key
}

khtype :: enum i32 {
	UNKNOWN, 
	RSA1, 
	RSA, 
	DSS, 
	ECDSA, 
	ED25519, 
}

lock_access :: enum i32 {
	NONE   = 0, // unspecified action
	SHARED = 1, // for read perhaps
	SINGLE = 2, // for write perhaps
}

lock_data :: enum i32 {
	NONE        = 0, 
	//  CURL_LOCK_DATA_SHARE is used internally to say that
	// 	*  the locking is just made to change the internal state of the share
	// 	*  itself.
	SHARE, 
	COOKIE, 
	DNS, 
	SSL_SESSION, 
	CONNECT, 
	PSL, 
	HSTS, 
}

lock_function :: proc "c" (handle: ^CURL, data: lock_data, locktype: lock_access, userptr: rawptr)

malloc_callback :: proc "c" (size: uint) -> rawptr

mime :: struct {}

mimepart :: struct {}

multi_timer_callback :: proc "c" (multi: ^CURLM, timeout_ms: i32, userp: rawptr) -> i32

off_t :: i64

opensocket_callback :: proc "c" (clientp: rawptr, purpose: socktype, address: ^sockaddr) -> socket_t

option :: enum i32 {
	// This is the FILE * or void * the regular output should be written to. 
	WRITEDATA                  = 10001, 
	// The full URL to get/put 
	URL                        = 10002, 
	// Port number to connect to, if other than default. 
	PORT                       = 3, 
	// Name of proxy to use. 
	PROXY                      = 10004, 
	// "user:password;options" to use when fetching. 
	USERPWD                    = 10005, 
	// "user:password" to use with proxy. 
	PROXYUSERPWD               = 10006, 
	// Range to get, specified as an ASCII string. 
	RANGE                      = 10007, 
	// Specified file stream to upload from (use as input): 
	READDATA                   = 10009, 
	// Buffer to receive error messages in, must be at least CURL_ERROR_SIZE
	// 	* bytes big. 
	ERRORBUFFER                = 10010, 
	// Function that will be called to store the output (instead of fwrite). The
	// 	* parameters will use fwrite() syntax, make sure to follow them. 
	WRITEFUNCTION              = 20011, 
	// Function that will be called to read the input (instead of fread). The
	// 	* parameters will use fread() syntax, make sure to follow them. 
	READFUNCTION               = 20012, 
	// Time-out the read operation after this amount of seconds 
	TIMEOUT                    = 13, 
	// If CURLOPT_READDATA is used, this can be used to inform libcurl about
	// 	* how large the file being sent really is. That allows better error
	// 	* checking and better verifies that the upload was successful. -1 means
	// 	* unknown size.
	// 	*
	// 	* For large file support, there is also a _LARGE version of the key
	// 	* which takes an off_t type, allowing platforms with larger off_t
	// 	* sizes to handle larger files. See below for INFILESIZE_LARGE.
	INFILESIZE                 = 14, 
	// POST static input fields. 
	POSTFIELDS                 = 10015, 
	// Set the referrer page (needed by some CGIs) 
	REFERER                    = 10016, 
	// Set the FTP PORT string (interface name, named or numerical IP address)
	// 	Use i.e '-' to use default address. 
	FTPPORT                    = 10017, 
	// Set the User-Agent string (examined by some CGIs) 
	USERAGENT                  = 10018, 
	// Set the "low speed limit" 
	LOW_SPEED_LIMIT            = 19, 
	// Set the "low speed time" 
	LOW_SPEED_TIME             = 20, 
	// Set the continuation offset.
	// 	*
	// 	* Note there is also a _LARGE version of this key which uses
	// 	* off_t types, allowing for large file offsets on platforms which
	// 	* use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE.
	RESUME_FROM                = 21, 
	// Set cookie in request: 
	COOKIE                     = 10022, 
	// This points to a linked list of headers, struct curl_slist kind. This
	// 	list is also used for RTSP (in spite of its name) 
	HTTPHEADER                 = 10023, 
	// name of the file keeping your private SSL-certificate 
	SSLCERT                    = 10025, 
	// password for the SSL or SSH private key 
	KEYPASSWD                  = 10026, 
	// send TYPE parameter? 
	CRLF                       = 27, 
	// send linked-list of QUOTE commands 
	QUOTE                      = 10028, 
	// send FILE * or void * to store headers to, if you use a callback it
	// 	is simply passed to the callback unmodified 
	HEADERDATA                 = 10029, 
	// point to a file to read the initial cookies from, also enables
	// 	"cookie awareness" 
	COOKIEFILE                 = 10031, 
	// What version to specifically try to use.
	// 	See CURL_SSLVERSION defines below. 
	SSLVERSION                 = 32, 
	// What kind of HTTP time condition to use, see defines 
	TIMECONDITION              = 33, 
	// Time to use with the above condition. Specified in number of seconds
	// 	since 1 Jan 1970 
	TIMEVALUE                  = 34, 
	// Custom request, for customizing the get command like
	// 	HTTP: DELETE, TRACE and others
	// 	FTP: to use a different list command
	CUSTOMREQUEST              = 10036, 
	// FILE handle to use instead of stderr 
	STDERR                     = 10037, 
	// send linked-list of post-transfer QUOTE commands 
	POSTQUOTE                  = 10039, 
	// talk a lot 
	VERBOSE                    = 41, 
	// throw the header out too 
	HEADER                     = 42, 
	// shut off the progress meter 
	NOPROGRESS                 = 43, 
	// use HEAD to get http document 
	NOBODY                     = 44, 
	// no output on http error codes >= 400 
	FAILONERROR                = 45, 
	// this is an upload 
	UPLOAD                     = 46, 
	// HTTP POST method 
	POST                       = 47, 
	// bare names when listing directories 
	DIRLISTONLY                = 48, 
	// Append instead of overwrite on upload! 
	APPEND                     = 50, 
	// Specify whether to read the user+password from the .netrc or the URL.
	// 	* This must be one of the CURL_NETRC_* enums below. 
	NETRC                      = 51, 
	// use Location: Luke! 
	FOLLOWLOCATION             = 52, 
	// transfer data in text/ASCII format 
	TRANSFERTEXT               = 53, 
	// Data passed to the CURLOPT_PROGRESSFUNCTION and CURLOPT_XFERINFOFUNCTION
	// 	callbacks 
	XFERINFODATA               = 10057, 
	PROGRESSDATA               = 10057, 
	// We want the referrer field set automatically when following locations 
	AUTOREFERER                = 58, 
	// Port of the proxy, can be set in the proxy string as well with:
	// 	"[host]:[port]" 
	PROXYPORT                  = 59, 
	// size of the POST input data, if strlen() is not good to use 
	POSTFIELDSIZE              = 60, 
	// tunnel non-http operations through an HTTP proxy 
	HTTPPROXYTUNNEL            = 61, 
	// Set the interface string to use as outgoing network interface 
	INTERFACE                  = 10062, 
	// Set the krb4/5 security level, this also enables krb4/5 awareness. This
	// 	* is a string, 'clear', 'safe', 'confidential' or 'private'. If the string
	// 	* is set but does not match one of these, 'private' will be used.  
	KRBLEVEL                   = 10063, 
	// Set if we should verify the peer in ssl handshake, set 1 to verify. 
	SSL_VERIFYPEER             = 64, 
	// The CApath or CAfile used to validate the peer certificate
	// 	this option is used only if SSL_VERIFYPEER is true 
	CAINFO                     = 10065, 
	// Maximum number of http redirects to follow 
	MAXREDIRS                  = 68, 
	// Pass a long set to 1 to get the date of the requested document (if
	// 	possible)! Pass a zero to shut it off. 
	FILETIME                   = 69, 
	// This points to a linked list of telnet options 
	TELNETOPTIONS              = 10070, 
	// Max amount of cached alive connections 
	MAXCONNECTS                = 71, 
	// Set to explicitly use a new connection for the upcoming transfer.
	// 	Do not use this unless you are absolutely sure of this, as it makes the
	// 	operation slower and is less friendly for the network. 
	FRESH_CONNECT              = 74, 
	// Set to explicitly forbid the upcoming transfer's connection to be reused
	// 	when done. Do not use this unless you are absolutely sure of this, as it
	// 	makes the operation slower and is less friendly for the network. 
	FORBID_REUSE               = 75, 
	// Time-out connect operations after this amount of seconds, if connects are
	// 	OK within this time, then fine... This only aborts the connect phase. 
	CONNECTTIMEOUT             = 78, 
	// Function that will be called to store headers (instead of fwrite). The
	// 	* parameters will use fwrite() syntax, make sure to follow them. 
	HEADERFUNCTION             = 20079, 
	// Set this to force the HTTP request to get back to GET. Only really usable
	// 	if POST, PUT or a custom request have been used first.
	HTTPGET                    = 80, 
	// Set if we should verify the Common name from the peer certificate in ssl
	// 	* handshake, set 1 to check existence, 2 to ensure that it matches the
	// 	* provided hostname. 
	SSL_VERIFYHOST             = 81, 
	// Specify which filename to write all known cookies in after completed
	// 	operation. Set filename to "-" (dash) to make it go to stdout. 
	COOKIEJAR                  = 10082, 
	// Specify which TLS 1.2 (1.1, 1.0) ciphers to use 
	SSL_CIPHER_LIST            = 10083, 
	// Specify which HTTP version to use! This must be set to one of the
	// 	CURL_HTTP_VERSION* enums set below. 
	HTTP_VERSION               = 84, 
	// Specifically switch on or off the FTP engine's use of the EPSV command. By
	// 	default, that one will always be attempted before the more traditional
	// 	PASV command. 
	FTP_USE_EPSV               = 85, 
	// type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") 
	SSLCERTTYPE                = 10086, 
	// name of the file keeping your private SSL-key 
	SSLKEY                     = 10087, 
	// type of the file keeping your private SSL-key ("DER", "PEM", "ENG") 
	SSLKEYTYPE                 = 10088, 
	// crypto engine for the SSL-sub system 
	SSLENGINE                  = 10089, 
	// set the crypto engine for the SSL-sub system as default
	// 	the param has no meaning...
	SSLENGINE_DEFAULT          = 90, 
	// DNS cache timeout 
	DNS_CACHE_TIMEOUT          = 92, 
	// send linked-list of pre-transfer QUOTE commands 
	PREQUOTE                   = 10093, 
	// set the debug function 
	DEBUGFUNCTION              = 20094, 
	// set the data for the debug function 
	DEBUGDATA                  = 10095, 
	// mark this as start of a cookie session 
	COOKIESESSION              = 96, 
	// The CApath directory used to validate the peer certificate
	// 	this option is used only if SSL_VERIFYPEER is true 
	CAPATH                     = 10097, 
	// Instruct libcurl to use a smaller receive buffer 
	BUFFERSIZE                 = 98, 
	// Instruct libcurl to not use any signal/alarm handlers, even when using
	// 	timeouts. This option is useful for multi-threaded applications.
	// 	See libcurl-the-guide for more background information. 
	NOSIGNAL                   = 99, 
	// Provide a CURLShare for mutexing non-ts data 
	SHARE                      = 10100, 
	// indicates type of proxy. accepted values are CURLPROXY_HTTP (default),
	// 	CURLPROXY_HTTPS, CURLPROXY_SOCKS4, CURLPROXY_SOCKS4A and
	// 	CURLPROXY_SOCKS5. 
	PROXYTYPE                  = 101, 
	// Set the Accept-Encoding string. Use this to tell a server you would like
	// 	the response to be compressed. Before 7.21.6, this was known as
	// 	CURLOPT_ENCODING 
	ACCEPT_ENCODING            = 10102, 
	// Set pointer to private data 
	PRIVATE                    = 10103, 
	// Set aliases for HTTP 200 in the HTTP Response header 
	HTTP200ALIASES             = 10104, 
	// Continue to send authentication (user+password) when following locations,
	// 	even when hostname changed. This can potentially send off the name
	// 	and password to whatever host the server decides. 
	UNRESTRICTED_AUTH          = 105, 
	// Specifically switch on or off the FTP engine's use of the EPRT command (
	// 	it also disables the LPRT attempt). By default, those ones will always be
	// 	attempted before the good old traditional PORT command. 
	FTP_USE_EPRT               = 106, 
	// Set this to a bitmask value to enable the particular authentications
	// 	methods you like. Use this in combination with CURLOPT_USERPWD.
	// 	Note that setting multiple bits may cause extra network round-trips. 
	HTTPAUTH                   = 107, 
	// Set the ssl context callback function, currently only for OpenSSL or
	// 	wolfSSL ssl_ctx, or mbedTLS mbedtls_ssl_config in the second argument.
	// 	The function must match the curl_ssl_ctx_callback prototype. 
	SSL_CTX_FUNCTION           = 20108, 
	// Set the userdata for the ssl context callback function's third
	// 	argument 
	SSL_CTX_DATA               = 10109, 
	// FTP Option that causes missing dirs to be created on the remote server.
	// 	In 7.19.4 we introduced the convenience enums for this option using the
	// 	CURLFTP_CREATE_DIR prefix.
	FTP_CREATE_MISSING_DIRS    = 110, 
	// Set this to a bitmask value to enable the particular authentications
	// 	methods you like. Use this in combination with CURLOPT_PROXYUSERPWD.
	// 	Note that setting multiple bits may cause extra network round-trips. 
	PROXYAUTH                  = 111, 
	// Option that changes the timeout, in seconds, associated with getting a
	// 	response. This is different from transfer timeout time and essentially
	// 	places a demand on the server to acknowledge commands in a timely
	// 	manner. For FTP, SMTP, IMAP and POP3. 
	SERVER_RESPONSE_TIMEOUT    = 112, 
	// Set this option to one of the CURL_IPRESOLVE_* defines (see below) to
	// 	tell libcurl to use those IP versions only. This only has effect on
	// 	systems with support for more than one, i.e IPv4 _and_ IPv6. 
	IPRESOLVE                  = 113, 
	// Set this option to limit the size of a file that will be downloaded from
	// 	an HTTP or FTP server.
	// 
	// 	Note there is also _LARGE version which adds large file support for
	// 	platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. 
	MAXFILESIZE                = 114, 
	// See the comment for INFILESIZE above, but in short, specifies
	// 	* the size of the file being uploaded.  -1 means unknown.
	INFILESIZE_LARGE           = 30115, 
	// Sets the continuation offset. There is also a CURLOPTTYPE_LONG version
	// 	* of this; look above for RESUME_FROM.
	RESUME_FROM_LARGE          = 30116, 
	// Sets the maximum size of data that will be downloaded from
	// 	* an HTTP or FTP server. See MAXFILESIZE above for the LONG version.
	MAXFILESIZE_LARGE          = 30117, 
	// Set this option to the filename of your .netrc file you want libcurl
	// 	to parse (using the CURLOPT_NETRC option). If not set, libcurl will do
	// 	a poor attempt to find the user's home directory and check for a .netrc
	// 	file in there. 
	NETRC_FILE                 = 10118, 
	// Enable SSL/TLS for FTP, pick one of:
	// 	CURLUSESSL_TRY     - try using SSL, proceed anyway otherwise
	// 	CURLUSESSL_CONTROL - SSL for the control connection or fail
	// 	CURLUSESSL_ALL     - SSL for all communication or fail
	USE_SSL                    = 119, 
	// The _LARGE version of the standard POSTFIELDSIZE option 
	POSTFIELDSIZE_LARGE        = 30120, 
	// Enable/disable the TCP Nagle algorithm 
	TCP_NODELAY                = 121, 
	// When FTP over SSL/TLS is selected (with CURLOPT_USE_SSL), this option
	// 	can be used to change libcurl's default action which is to first try
	// 	"AUTH SSL" and then "AUTH TLS" in this order, and proceed when a OK
	// 	response has been received.
	// 
	// 	Available parameters are:
	// 	CURLFTPAUTH_DEFAULT - let libcurl decide
	// 	CURLFTPAUTH_SSL     - try "AUTH SSL" first, then TLS
	// 	CURLFTPAUTH_TLS     - try "AUTH TLS" first, then SSL
	FTPSSLAUTH                 = 129, 
	// null-terminated string for pass on to the FTP server when asked for
	// 	"account" info 
	FTP_ACCOUNT                = 10134, 
	// feed cookie into cookie engine 
	COOKIELIST                 = 10135, 
	// ignore Content-Length 
	IGNORE_CONTENT_LENGTH      = 136, 
	// Set to non-zero to skip the IP address received in a 227 PASV FTP server
	// 	response. Typically used for FTP-SSL purposes but is not restricted to
	// 	that. libcurl will then instead use the same IP address it used for the
	// 	control connection. 
	FTP_SKIP_PASV_IP           = 137, 
	// Select "file method" to use when doing FTP, see the curl_ftpmethod
	// 	above. 
	FTP_FILEMETHOD             = 138, 
	// Local port number to bind the socket to 
	LOCALPORT                  = 139, 
	// Number of ports to try, including the first one set with LOCALPORT.
	// 	Thus, setting it to 1 will make no additional attempts but the first.
	LOCALPORTRANGE             = 140, 
	// no transfer, set up connection and let application use the socket by
	// 	extracting it with CURLINFO_LASTSOCKET 
	CONNECT_ONLY               = 141, 
	// if the connection proceeds too quickly then need to slow it down 
	// limit-rate: maximum number of bytes per second to send or receive 
	MAX_SEND_SPEED_LARGE       = 30145, 
	MAX_RECV_SPEED_LARGE       = 30146, 
	// Pointer to command string to send if USER/PASS fails. 
	FTP_ALTERNATIVE_TO_USER    = 10147, 
	// callback function for setting socket options 
	SOCKOPTFUNCTION            = 20148, 
	SOCKOPTDATA                = 10149, 
	// set to 0 to disable session ID reuse for this transfer, default is
	// 	enabled (== 1) 
	SSL_SESSIONID_CACHE        = 150, 
	// allowed SSH authentication methods 
	SSH_AUTH_TYPES             = 151, 
	// Used by scp/sftp to do public/private key authentication 
	SSH_PUBLIC_KEYFILE         = 10152, 
	SSH_PRIVATE_KEYFILE        = 10153, 
	// Send CCC (Clear Command Channel) after authentication 
	FTP_SSL_CCC                = 154, 
	// Same as TIMEOUT and CONNECTTIMEOUT, but with ms resolution 
	TIMEOUT_MS                 = 155, 
	CONNECTTIMEOUT_MS          = 156, 
	// set to zero to disable the libcurl's decoding and thus pass the raw body
	// 	data to the application even when it is encoded/compressed 
	HTTP_TRANSFER_DECODING     = 157, 
	HTTP_CONTENT_DECODING      = 158, 
	// Permission used when creating new files and directories on the remote
	// 	server for protocols that support it, SFTP/SCP/FILE 
	NEW_FILE_PERMS             = 159, 
	NEW_DIRECTORY_PERMS        = 160, 
	// Set the behavior of POST when redirecting. Values must be set to one
	// 	of CURL_REDIR* defines below. This used to be called CURLOPT_POST301 
	POSTREDIR                  = 161, 
	// used by scp/sftp to verify the host's public key 
	SSH_HOST_PUBLIC_KEY_MD5    = 10162, 
	// Callback function for opening socket (instead of socket(2)). Optionally,
	// 	callback is able change the address or refuse to connect returning
	// 	CURL_SOCKET_BAD. The callback should have type
	// 	curl_opensocket_callback 
	OPENSOCKETFUNCTION         = 20163, 
	OPENSOCKETDATA             = 10164, 
	// POST volatile input fields. 
	COPYPOSTFIELDS             = 10165, 
	// set transfer mode (;type=<a|i>) when doing FTP via an HTTP proxy 
	PROXY_TRANSFER_MODE        = 166, 
	// Callback function for seeking in the input stream 
	SEEKFUNCTION               = 20167, 
	SEEKDATA                   = 10168, 
	// CRL file 
	CRLFILE                    = 10169, 
	// Issuer certificate 
	ISSUERCERT                 = 10170, 
	// (IPv6) Address scope 
	ADDRESS_SCOPE              = 171, 
	// Collect certificate chain info and allow it to get retrievable with
	// 	CURLINFO_CERTINFO after the transfer is complete. 
	CERTINFO                   = 172, 
	// "name" and "pwd" to use when fetching. 
	USERNAME                   = 10173, 
	PASSWORD                   = 10174, 
	// "name" and "pwd" to use with Proxy when fetching. 
	PROXYUSERNAME              = 10175, 
	PROXYPASSWORD              = 10176, 
	// Comma separated list of hostnames defining no-proxy zones. These should
	// 	match both hostnames directly, and hostnames within a domain. For
	// 	example, local.com will match local.com and www.local.com, but NOT
	// 	notlocal.com or www.notlocal.com. For compatibility with other
	// 	implementations of this, .local.com will be considered to be the same as
	// 	local.com. A single * is the only valid wildcard, and effectively
	// 	disables the use of proxy. 
	NOPROXY                    = 10177, 
	// block size for TFTP transfers 
	TFTP_BLKSIZE               = 178, 
	// Socks Service 
	SOCKS5_GSSAPI_NEC          = 180, 
	// set the SSH knownhost filename to use 
	SSH_KNOWNHOSTS             = 10183, 
	// set the SSH host key callback, must point to a curl_sshkeycallback
	// 	function 
	SSH_KEYFUNCTION            = 20184, 
	// set the SSH host key callback custom pointer 
	SSH_KEYDATA                = 10185, 
	// set the SMTP mail originator 
	MAIL_FROM                  = 10186, 
	// set the list of SMTP mail receiver(s) 
	MAIL_RCPT                  = 10187, 
	// FTP: send PRET before PASV 
	FTP_USE_PRET               = 188, 
	// RTSP request method (OPTIONS, SETUP, PLAY, etc...) 
	RTSP_REQUEST               = 189, 
	// The RTSP session identifier 
	RTSP_SESSION_ID            = 10190, 
	// The RTSP stream URI 
	RTSP_STREAM_URI            = 10191, 
	// The Transport: header to use in RTSP requests 
	RTSP_TRANSPORT             = 10192, 
	// Manually initialize the client RTSP CSeq for this handle 
	RTSP_CLIENT_CSEQ           = 193, 
	// Manually initialize the server RTSP CSeq for this handle 
	RTSP_SERVER_CSEQ           = 194, 
	// The stream to pass to INTERLEAVEFUNCTION. 
	INTERLEAVEDATA             = 10195, 
	// Let the application define a custom write method for RTP data 
	INTERLEAVEFUNCTION         = 20196, 
	// Turn on wildcard matching 
	WILDCARDMATCH              = 197, 
	// Directory matching callback called before downloading of an
	// 	individual file (chunk) started 
	CHUNK_BGN_FUNCTION         = 20198, 
	// Directory matching callback called after the file (chunk)
	// 	was downloaded, or skipped 
	CHUNK_END_FUNCTION         = 20199, 
	// Change match (fnmatch-like) callback for wildcard matching 
	FNMATCH_FUNCTION           = 20200, 
	// Let the application define custom chunk data pointer 
	CHUNK_DATA                 = 10201, 
	// FNMATCH_FUNCTION user pointer 
	FNMATCH_DATA               = 10202, 
	// send linked-list of name:port:address sets 
	RESOLVE                    = 10203, 
	// Set a username for authenticated TLS 
	TLSAUTH_USERNAME           = 10204, 
	// Set a password for authenticated TLS 
	TLSAUTH_PASSWORD           = 10205, 
	// Set authentication type for authenticated TLS 
	TLSAUTH_TYPE               = 10206, 
	// Set to 1 to enable the "TE:" header in HTTP requests to ask for
	// 	compressed transfer-encoded responses. Set to 0 to disable the use of TE:
	// 	in outgoing requests. The current default is 0, but it might change in a
	// 	future libcurl release.
	// 
	// 	libcurl will ask for the compressed methods it knows of, and if that
	// 	is not any, it will not ask for transfer-encoding at all even if this
	// 	option is set to 1.
	TRANSFER_ENCODING          = 207, 
	// Callback function for closing socket (instead of close(2)). The callback
	// 	should have type curl_closesocket_callback 
	CLOSESOCKETFUNCTION        = 20208, 
	CLOSESOCKETDATA            = 10209, 
	// allow GSSAPI credential delegation 
	GSSAPI_DELEGATION          = 210, 
	// Set the name servers to use for DNS resolution.
	// 	* Only supported by the c-ares DNS backend 
	DNS_SERVERS                = 10211, 
	// Time-out accept operations (currently for FTP only) after this amount
	// 	of milliseconds. 
	ACCEPTTIMEOUT_MS           = 212, 
	// Set TCP keepalive 
	TCP_KEEPALIVE              = 213, 
	// non-universal keepalive knobs (Linux, AIX, HP-UX, more) 
	TCP_KEEPIDLE               = 214, 
	TCP_KEEPINTVL              = 215, 
	// Enable/disable specific SSL features with a bitmask, see CURLSSLOPT_* 
	SSL_OPTIONS                = 216, 
	// Set the SMTP auth originator 
	MAIL_AUTH                  = 10217, 
	// Enable/disable SASL initial response 
	SASL_IR                    = 218, 
	// Function that will be called instead of the internal progress display
	// 	* function. This function should be defined as the curl_xferinfo_callback
	// 	* prototype defines. (Deprecates CURLOPT_PROGRESSFUNCTION) 
	XFERINFOFUNCTION           = 20219, 
	// The XOAUTH2 bearer token 
	XOAUTH2_BEARER             = 10220, 
	// Set the interface string to use as outgoing network
	// 	* interface for DNS requests.
	// 	* Only supported by the c-ares DNS backend 
	DNS_INTERFACE              = 10221, 
	// Set the local IPv4 address to use for outgoing DNS requests.
	// 	* Only supported by the c-ares DNS backend 
	DNS_LOCAL_IP4              = 10222, 
	// Set the local IPv6 address to use for outgoing DNS requests.
	// 	* Only supported by the c-ares DNS backend 
	DNS_LOCAL_IP6              = 10223, 
	// Set authentication options directly 
	LOGIN_OPTIONS              = 10224, 
	// Enable/disable TLS ALPN extension (http2 over ssl might fail without) 
	SSL_ENABLE_ALPN            = 226, 
	// Time to wait for a response to an HTTP request containing an
	// 	* Expect: 100-continue header before sending the data anyway. 
	EXPECT_100_TIMEOUT_MS      = 227, 
	// This points to a linked list of headers used for proxy requests only,
	// 	struct curl_slist kind 
	PROXYHEADER                = 10228, 
	// Pass in a bitmask of "header options" 
	HEADEROPT                  = 229, 
	// The public key in DER form used to validate the peer public key
	// 	this option is used only if SSL_VERIFYPEER is true 
	PINNEDPUBLICKEY            = 10230, 
	// Path to Unix domain socket 
	UNIX_SOCKET_PATH           = 10231, 
	// Set if we should verify the certificate status. 
	SSL_VERIFYSTATUS           = 232, 
	// Do not squash dot-dot sequences 
	PATH_AS_IS                 = 234, 
	// Proxy Service Name 
	PROXY_SERVICE_NAME         = 10235, 
	// Service Name 
	SERVICE_NAME               = 10236, 
	// Wait/do not wait for pipe/mutex to clarify 
	PIPEWAIT                   = 237, 
	// Set the protocol used when curl is given a URL without a protocol 
	DEFAULT_PROTOCOL           = 10238, 
	// Set stream weight, 1 - 256 (default is 16) 
	STREAM_WEIGHT              = 239, 
	// Set stream dependency on another curl handle 
	STREAM_DEPENDS             = 10240, 
	// Set E-xclusive stream dependency on another curl handle 
	STREAM_DEPENDS_E           = 10241, 
	// Do not send any tftp option requests to the server 
	TFTP_NO_OPTIONS            = 242, 
	// Linked-list of host:port:connect-to-host:connect-to-port,
	// 	overrides the URL's host:port (only for the network layer) 
	CONNECT_TO                 = 10243, 
	// Set TCP Fast Open 
	TCP_FASTOPEN               = 244, 
	// Continue to send data if the server responds early with an
	// 	* HTTP status code >= 300 
	KEEP_SENDING_ON_ERROR      = 245, 
	// The CApath or CAfile used to validate the proxy certificate
	// 	this option is used only if PROXY_SSL_VERIFYPEER is true 
	PROXY_CAINFO               = 10246, 
	// The CApath directory used to validate the proxy certificate
	// 	this option is used only if PROXY_SSL_VERIFYPEER is true 
	PROXY_CAPATH               = 10247, 
	// Set if we should verify the proxy in ssl handshake,
	// 	set 1 to verify. 
	PROXY_SSL_VERIFYPEER       = 248, 
	// Set if we should verify the Common name from the proxy certificate in ssl
	// 	* handshake, set 1 to check existence, 2 to ensure that it matches
	// 	* the provided hostname. 
	PROXY_SSL_VERIFYHOST       = 249, 
	// What version to specifically try to use for proxy.
	// 	See CURL_SSLVERSION defines below. 
	PROXY_SSLVERSION           = 250, 
	// Set a username for authenticated TLS for proxy 
	PROXY_TLSAUTH_USERNAME     = 10251, 
	// Set a password for authenticated TLS for proxy 
	PROXY_TLSAUTH_PASSWORD     = 10252, 
	// Set authentication type for authenticated TLS for proxy 
	PROXY_TLSAUTH_TYPE         = 10253, 
	// name of the file keeping your private SSL-certificate for proxy 
	PROXY_SSLCERT              = 10254, 
	// type of the file keeping your SSL-certificate ("DER", "PEM", "ENG") for
	// 	proxy 
	PROXY_SSLCERTTYPE          = 10255, 
	// name of the file keeping your private SSL-key for proxy 
	PROXY_SSLKEY               = 10256, 
	// type of the file keeping your private SSL-key ("DER", "PEM", "ENG") for
	// 	proxy 
	PROXY_SSLKEYTYPE           = 10257, 
	// password for the SSL private key for proxy 
	PROXY_KEYPASSWD            = 10258, 
	// Specify which TLS 1.2 (1.1, 1.0) ciphers to use for proxy 
	PROXY_SSL_CIPHER_LIST      = 10259, 
	// CRL file for proxy 
	PROXY_CRLFILE              = 10260, 
	// Enable/disable specific SSL features with a bitmask for proxy, see
	// 	CURLSSLOPT_* 
	PROXY_SSL_OPTIONS          = 261, 
	// Name of pre proxy to use. 
	PRE_PROXY                  = 10262, 
	// The public key in DER form used to validate the proxy public key
	// 	this option is used only if PROXY_SSL_VERIFYPEER is true 
	PROXY_PINNEDPUBLICKEY      = 10263, 
	// Path to an abstract Unix domain socket 
	ABSTRACT_UNIX_SOCKET       = 10264, 
	// Suppress proxy CONNECT response headers from user callbacks 
	SUPPRESS_CONNECT_HEADERS   = 265, 
	// The request target, instead of extracted from the URL 
	REQUEST_TARGET             = 10266, 
	// bitmask of allowed auth methods for connections to SOCKS5 proxies 
	SOCKS5_AUTH                = 267, 
	// Enable/disable SSH compression 
	SSH_COMPRESSION            = 268, 
	// Post MIME data. 
	MIMEPOST                   = 10269, 
	// Time to use with the CURLOPT_TIMECONDITION. Specified in number of
	// 	seconds since 1 Jan 1970. 
	TIMEVALUE_LARGE            = 30270, 
	// Head start in milliseconds to give happy eyeballs. 
	HAPPY_EYEBALLS_TIMEOUT_MS  = 271, 
	// Function that will be called before a resolver request is made 
	RESOLVER_START_FUNCTION    = 20272, 
	// User data to pass to the resolver start callback. 
	RESOLVER_START_DATA        = 10273, 
	// send HAProxy PROXY protocol header? 
	HAPROXYPROTOCOL            = 274, 
	// shuffle addresses before use when DNS returns multiple 
	DNS_SHUFFLE_ADDRESSES      = 275, 
	// Specify which TLS 1.3 ciphers suites to use 
	TLS13_CIPHERS              = 10276, 
	PROXY_TLS13_CIPHERS        = 10277, 
	// Disallow specifying username/login in URL. 
	DISALLOW_USERNAME_IN_URL   = 278, 
	// DNS-over-HTTPS URL 
	DOH_URL                    = 10279, 
	// Preferred buffer size to use for uploads 
	UPLOAD_BUFFERSIZE          = 280, 
	// Time in ms between connection upkeep calls for long-lived connections. 
	UPKEEP_INTERVAL_MS         = 281, 
	// Specify URL using CURL URL API. 
	CURLU                      = 10282, 
	// add trailing data just after no more data is available 
	TRAILERFUNCTION            = 20283, 
	// pointer to be passed to HTTP_TRAILER_FUNCTION 
	TRAILERDATA                = 10284, 
	// set this to 1L to allow HTTP/0.9 responses or 0L to disallow 
	HTTP09_ALLOWED             = 285, 
	// alt-svc control bitmask 
	ALTSVC_CTRL                = 286, 
	// alt-svc cache filename to possibly read from/write to 
	ALTSVC                     = 10287, 
	// maximum age (idle time) of a connection to consider it for reuse
	// 	* (in seconds) 
	MAXAGE_CONN                = 288, 
	// SASL authorization identity 
	SASL_AUTHZID               = 10289, 
	// allow RCPT TO command to fail for some recipients 
	MAIL_RCPT_ALLOWFAILS       = 290, 
	// the private SSL-certificate as a "blob" 
	SSLCERT_BLOB               = 40291, 
	SSLKEY_BLOB                = 40292, 
	PROXY_SSLCERT_BLOB         = 40293, 
	PROXY_SSLKEY_BLOB          = 40294, 
	ISSUERCERT_BLOB            = 40295, 
	// Issuer certificate for proxy 
	PROXY_ISSUERCERT           = 10296, 
	PROXY_ISSUERCERT_BLOB      = 40297, 
	// the EC curves requested by the TLS client (RFC 8422, 5.1);
	// 	* OpenSSL support via 'set_groups'/'set_curves':
	// 	* https://docs.openssl.org/master/man3/SSL_CTX_set1_curves/
	SSL_EC_CURVES              = 10298, 
	// HSTS bitmask 
	HSTS_CTRL                  = 299, 
	// HSTS filename 
	HSTS                       = 10300, 
	// HSTS read callback 
	HSTSREADFUNCTION           = 20301, 
	HSTSREADDATA               = 10302, 
	// HSTS write callback 
	HSTSWRITEFUNCTION          = 20303, 
	HSTSWRITEDATA              = 10304, 
	// Parameters for V4 signature 
	AWS_SIGV4                  = 10305, 
	// Same as CURLOPT_SSL_VERIFYPEER but for DoH (DNS-over-HTTPS) servers. 
	DOH_SSL_VERIFYPEER         = 306, 
	// Same as CURLOPT_SSL_VERIFYHOST but for DoH (DNS-over-HTTPS) servers. 
	DOH_SSL_VERIFYHOST         = 307, 
	// Same as CURLOPT_SSL_VERIFYSTATUS but for DoH (DNS-over-HTTPS) servers. 
	DOH_SSL_VERIFYSTATUS       = 308, 
	// The CA certificates as "blob" used to validate the peer certificate
	// 	this option is used only if SSL_VERIFYPEER is true 
	CAINFO_BLOB                = 40309, 
	// The CA certificates as "blob" used to validate the proxy certificate
	// 	this option is used only if PROXY_SSL_VERIFYPEER is true 
	PROXY_CAINFO_BLOB          = 40310, 
	// used by scp/sftp to verify the host's public key 
	SSH_HOST_PUBLIC_KEY_SHA256 = 10311, 
	// Function that will be called immediately before the initial request
	// 	is made on a connection (after any protocol negotiation step).  
	PREREQFUNCTION             = 20312, 
	// Data passed to the CURLOPT_PREREQFUNCTION callback 
	PREREQDATA                 = 10313, 
	// maximum age (since creation) of a connection to consider it for reuse
	// 	* (in seconds) 
	MAXLIFETIME_CONN           = 314, 
	// Set MIME option flags. 
	MIME_OPTIONS               = 315, 
	// set the SSH host key callback, must point to a curl_sshkeycallback
	// 	function 
	SSH_HOSTKEYFUNCTION        = 20316, 
	// set the SSH host key callback custom pointer 
	SSH_HOSTKEYDATA            = 10317, 
	// specify which protocols that are allowed to be used for the transfer,
	// 	which thus helps the app which takes URLs from users or other external
	// 	inputs and want to restrict what protocol(s) to deal with. Defaults to
	// 	all built-in protocols. 
	PROTOCOLS_STR              = 10318, 
	// specify which protocols that libcurl is allowed to follow directs to 
	REDIR_PROTOCOLS_STR        = 10319, 
	// WebSockets options 
	WS_OPTIONS                 = 320, 
	// CA cache timeout 
	CA_CACHE_TIMEOUT           = 321, 
	// Can leak things, gonna exit() soon 
	QUICK_EXIT                 = 322, 
	// set a specific client IP for HAProxy PROXY protocol header? 
	HAPROXY_CLIENT_IP          = 10323, 
	// millisecond version 
	SERVER_RESPONSE_TIMEOUT_MS = 324, 
	// set ECH configuration 
	ECH                        = 10325, 
	// maximum number of keepalive probes (Linux, *BSD, macOS, etc.) 
	TCP_KEEPCNT                = 326, 
	UPLOAD_FLAGS               = 327, 
	// set TLS supported signature algorithms 
	SSL_SIGNATURE_ALGORITHMS   = 10328, 
}

platform_fd_set :: sys_windows.fd_set

platform_sockaddr :: sys_windows.sockaddr

prereq_callback :: proc "c" (clientp: rawptr, conn_primary_ip: cstring, conn_local_ip: cstring, conn_primary_port: i32, conn_local_port: i32) -> i32

progress_callback :: proc "c" (clientp: rawptr, dltotal: f64, dlnow: f64, ultotal: f64, ulnow: f64) -> i32

proxycode :: enum i32 {
	OK, 
	BAD_ADDRESS_TYPE, 
	BAD_VERSION, 
	CLOSED, 
	GSSAPI, 
	GSSAPI_PERMSG, 
	GSSAPI_PROTECTION, 
	IDENTD, 
	IDENTD_DIFFER, 
	LONG_HOSTNAME, 
	LONG_PASSWD, 
	LONG_USER, 
	NO_AUTH, 
	RECV_ADDRESS, 
	RECV_AUTH, 
	RECV_CONNECT, 
	RECV_REQACK, 
	REPLY_ADDRESS_TYPE_NOT_SUPPORTED, 
	REPLY_COMMAND_NOT_SUPPORTED, 
	REPLY_CONNECTION_REFUSED, 
	REPLY_GENERAL_SERVER_FAILURE, 
	REPLY_HOST_UNREACHABLE, 
	REPLY_NETWORK_UNREACHABLE, 
	REPLY_NOT_ALLOWED, 
	REPLY_TTL_EXPIRED, 
	REPLY_UNASSIGNED, 
	REQUEST_FAILED, 
	RESOLVE_HOST, 
	SEND_AUTH, 
	SEND_CONNECT, 
	SEND_REQUEST, 
	UNKNOWN_FAIL, 
	UNKNOWN_MODE, 
	USER_REJECTED, 
}

proxytype :: enum i32 {
	HTTP            = 0, // added in 7.10, new in 7.19.4 default is to use
	                        CONNECT HTTP/1.1
	HTTP_1_0        = 1, // added in 7.19.4, force to use CONNECT
                               HTTP/1.0
	HTTPS           = 2, // HTTPS but stick to HTTP/1 added in 7.52.0
	HTTPS2          = 3, // HTTPS and attempt HTTP/2 added in 8.2.0
	SOCKS4          = 4, // support added in 7.15.2, enum existed already
	                        in 7.10
	SOCKS5          = 5, // added in 7.10
	SOCKS4A         = 6, // added in 7.18.0
	SOCKS5_HOSTNAME = 7, // Use the SOCKS5 protocol but pass along the
	                        hostname rather than the IP address. added
	                        in 7.18.0
}

push_callback :: proc "c" (parent: ^CURL, easy: ^CURL, num_headers: uint, headers: [^]pushheaders, userp: rawptr) -> i32

pushheaders :: struct {}

read_callback :: proc "c" (buffer: [^]u8, size: uint, nitems: uint, instream: rawptr) -> uint

realloc_callback :: proc "c" (ptr: rawptr, size: uint) -> rawptr

resolver_start_callback :: proc "c" (resolver_state: rawptr, reserved: rawptr, userdata: rawptr) -> i32

seek_callback :: proc "c" (instream: rawptr, offset: i64, origin: i32) -> i32

slist :: struct {
	data: [^]u8,
	next: ^slist,
}

sockaddr :: struct {
	family:   i32,
	socktype: i32,
	protocol: i32,
	addrlen:  u32,
	// addrlen was a socklen_t type before 7.18.0 but it
	//                            turned really ugly and painful on the systems that
	//                            lack this type 
	addr:     sys_windows.sockaddr,
}

socket_callback :: proc "c" (easy: ^CURL, s: socket_t, what: i32, userp: rawptr, socketp: rawptr) -> i32

socket_t :: distinct i32

socklen_t :: i32

sockopt_callback :: proc "c" (clientp: rawptr, curlfd: socket_t, purpose: socktype) -> i32

socktype :: enum i32 {
	IPCXN,  // socket created for a specific IP connection
	ACCEPT, // socket created by accept() call
	LAST,   // never use
}

sshhostkeycallback :: proc "c" (clientp: rawptr, keytype: i32, key: cstring, keylen: uint) -> code

sshkeycallback :: proc "c" (easy: ^CURL, knownkey: ^khkey, foundkey: ^khkey, _: khmatch, clientp: rawptr) -> i32

ssl_backend :: struct {
	id:   sslbackend,
	name: cstring,
}

ssl_ctx_callback :: proc "c" (curl: ^CURL, ssl_ctx: rawptr, userptr: rawptr) -> code

sslbackend :: enum i32 {
	NONE            = 0, 
	OPENSSL         = 1, 
	GNUTLS          = 2, 
	NSS             = 3,  // CURL_DEPRECATED(8.3.0, "")
	OBSOLETE4       = 4,  // Was QSOSSL.
	GSKIT           = 5,  // CURL_DEPRECATED(8.3.0, "")
	POLARSSL        = 6,  // CURL_DEPRECATED(7.69.0, "")
	WOLFSSL         = 7, 
	SCHANNEL        = 8, 
	SECURETRANSPORT = 9,  // CURL_DEPRECATED(8.15.0, "")
	AXTLS           = 10, // CURL_DEPRECATED(7.61.0, "")
	MBEDTLS         = 11, 
	MESALINK        = 12, // CURL_DEPRECATED(7.82.0, "")
	BEARSSL         = 13, // CURL_DEPRECATED(8.15.0, "")
	RUSTLS          = 14, 
	AWSLC           = 1, 
	BORINGSSL       = 1, 
	LIBRESSL        = 1, 
}

ssls_export_cb :: proc "c" (handle: ^CURL, userptr: rawptr, session_key: cstring, shmac: [^]u8, shmac_len: uint, sdata: [^]u8, sdata_len: uint, valid_until: i64, ietf_tls_id: i32, alpn: cstring, earlydata_max: uint) -> code

sslset :: enum i32 {
	OK              = 0, 
	UNKNOWN_BACKEND, 
	TOO_LATE, 
	NO_BACKENDS,         // libcurl was built without any SSL support
}

strdup_callback :: proc "c" (str: cstring) -> cstring

tlssessioninfo :: struct {
	backend:   sslbackend,
	internals: rawptr,
}

trailer_callback :: proc "c" (list: ^^slist, userdata: rawptr) -> i32

unlock_function :: proc "c" (handle: ^CURL, data: lock_data, userptr: rawptr)

usessl :: enum i32 {
}

version_enum :: enum i32 {
	FIRST,    // 7.10
	SECOND,   // 7.11.1
	THIRD,    // 7.12.0
	FOURTH,   // 7.16.1
	FIFTH,    // 7.57.0
	SIXTH,    // 7.66.0
	SEVENTH,  // 7.70.0
	EIGHTH,   // 7.72.0
	NINTH,    // 7.75.0
	TENTH,    // 7.77.0
	ELEVENTH, // 7.87.0
	TWELFTH,  // 8.8.0
}

version_info_data :: struct {
	age:             version_enum,
	// age of the returned struct 
	version:         cstring,
	// LIBCURL_VERSION 
	version_num:     u32,
	// LIBCURL_VERSION_NUM 
	host:            cstring,
	// OS/host/cpu/machine when configured 
	features:        i32,
	// bitmask, see defines below 
	ssl_version:     cstring,
	// human readable string 
	ssl_version_num: i32,
	// not used anymore, always 0 
	libz_version:    cstring,
	// protocols is terminated by an entry with a NULL protoname 
	protocols:       [^]cstring,
	// The fields below this were added in CURLVERSION_SECOND 
	ares:            cstring,
	ares_num:        i32,
	// This field was added in CURLVERSION_THIRD 
	libidn:          cstring,
	// Same as '_libiconv_version' if built with HAVE_ICONV 
	iconv_ver_num:   i32,
	libssh_version:  cstring,
	// These fields were added in CURLVERSION_FIFTH 
	brotli_ver_num:  u32,
	// Numeric Brotli version
	// 	                          (MAJOR << 24) | (MINOR << 12) | PATCH 
	brotli_version:  cstring,
	// These fields were added in CURLVERSION_SIXTH 
	nghttp2_ver_num: u32,
	// Numeric nghttp2 version
	// 	                           (MAJOR << 16) | (MINOR << 8) | PATCH 
	nghttp2_version: cstring,
	// human readable string. 
	quic_version:    cstring,
	// These fields were added in CURLVERSION_SEVENTH 
	cainfo:          cstring,
	// the built-in default CURLOPT_CAINFO, might
	// 	                             be NULL 
	capath:          cstring,
	// These fields were added in CURLVERSION_EIGHTH 
	zstd_ver_num:    u32,
	// Numeric Zstd version
	// 	                          (MAJOR << 24) | (MINOR << 12) | PATCH 
	zstd_version:    cstring,
	// These fields were added in CURLVERSION_NINTH 
	hyper_version:   cstring,
	// These fields were added in CURLVERSION_TENTH 
	gsasl_version:   cstring,
	// These fields were added in CURLVERSION_ELEVENTH 
	// feature_names is terminated by an entry with a NULL feature name 
	feature_names:   [^]cstring,
	// These fields were added in CURLVERSION_TWELFTH 
	rtmp_version:    cstring,
}

waitfd :: struct {
	fd:      socket_t,
	events:  i16,
	revents: i16,
}

write_callback :: proc "c" (buffer: [^]u8, size: uint, nitems: uint, outstream: rawptr) -> uint

ws_flag :: enum u32 {
	// flag bits 
	TEXT   = 0, 
	BINARY = 1, 
	CONT   = 2, 
	CLOSE  = 3, 
	PING   = 4, 
	OFFSET = 5, 
	// flags for curl_ws_send() 
	PONG   = 6, 
}

ws_flags :: distinct bit_set[ws_flag; u32]

ws_frame :: struct {
	age:       i32,
	// zero 
	flags:     ws_flags,
	// See the CURLWS_* defines 
	offset:    i64,
	// the offset of this data into the frame 
	bytesleft: i64,
	// number of pending bytes left of the payload 
	len:       uint,
}

xferinfo_callback :: proc "c" (clientp: rawptr, dltotal: i64, dlnow: i64, ultotal: i64, ulnow: i64) -> i32

ALTSVC_H1: int : 1 << 3

ALTSVC_H2: int : 1 << 4

ALTSVC_H3: int : 1 << 5

ALTSVC_READONLYFILE: int : 1 << 2

AUTH_ANY: u32 : ~AUTH_DIGEST_IE

AUTH_ANYSAFE: u32 : ~(AUTH_BASIC | AUTH_DIGEST_IE)

AUTH_AWS_SIGV4: u32 : ((c.ulong)(1)) << 7

AUTH_BASIC: u32 : ((c.ulong)(1)) << 0

AUTH_BEARER: u32 : ((c.ulong)(1)) << 6

AUTH_DIGEST: u32 : ((c.ulong)(1)) << 1

AUTH_DIGEST_IE: u32 : ((c.ulong)(1)) << 4

AUTH_GSSAPI: u32 : AUTH_NEGOTIATE

AUTH_GSSNEGOTIATE: u32 : AUTH_NEGOTIATE

AUTH_NEGOTIATE: u32 : ((c.ulong)(1)) << 2

AUTH_NONE: u32 : (c.ulong)(0)

AUTH_NTLM: u32 : ((c.ulong)(1)) << 3

AUTH_ONLY: u32 : ((c.ulong)(1)) << 31

BLOB_COPY :: blob_flags{.COPY}

BLOB_NOCOPY :: blob_flags{}

CHUNK_BGN_FUNC_FAIL: int : 1

CHUNK_BGN_FUNC_OK: int : 0

CHUNK_BGN_FUNC_SKIP: int : 2

CHUNK_END_FUNC_FAIL: int : 1

CHUNK_END_FUNC_OK: int : 0

COPYRIGHT: string : "Daniel Stenberg, <daniel@haxx.se>."

CSELECT_ERR: int : 0x04

CSELECT_IN: int : 0x01

CSELECT_OUT: int : 0x02

ERROR_SIZE: int : 256

FINFOFLAG_KNOWN_FILENAME :: finfoflags{.KNOWN_FILENAME}

FINFOFLAG_KNOWN_FILETYPE :: finfoflags{.KNOWN_FILETYPE}

FINFOFLAG_KNOWN_GID :: finfoflags{.KNOWN_GID}

FINFOFLAG_KNOWN_HLINKCOUNT :: finfoflags{.KNOWN_HLINKCOUNT}

FINFOFLAG_KNOWN_PERM :: finfoflags{.KNOWN_PERM}

FINFOFLAG_KNOWN_SIZE :: finfoflags{.KNOWN_SIZE}

FINFOFLAG_KNOWN_TIME :: finfoflags{.KNOWN_TIME}

FINFOFLAG_KNOWN_UID :: finfoflags{.KNOWN_UID}

FNMATCHFUNC_FAIL: int : 2

FNMATCHFUNC_MATCH: int : 0

FNMATCHFUNC_NOMATCH: int : 1

FOLLOW_ALL: int : 1

FOLLOW_FIRSTONLY: int : 3

FOLLOW_OBEYCODE: int : 2

GLOBAL_ACK_EINTR: int : 1 << 2

GLOBAL_ALL: int : GLOBAL_SSL | GLOBAL_WIN32

GLOBAL_DEFAULT: int : GLOBAL_ALL

GLOBAL_NOTHING: int : 0

GLOBAL_SSL: int : 1 << 0

GLOBAL_WIN32: int : 1 << 1

GSSAPI_DELEGATION_FLAG: int : 1 << 1

GSSAPI_DELEGATION_NONE: int : 0

GSSAPI_DELEGATION_POLICY_FLAG: int : 1 << 0

HEADER_SEPARATE: int : 1 << 0

HEADER_UNIFIED: int : 0

HET_DEFAULT: int : 200

HSTS_ENABLE: i32 : (c.long)(1 << 0)

HSTS_READONLYFILE: i32 : (c.long)(1 << 1)

HTTPPOST_BUFFER :: httppost_flags{.BUFFER}

HTTPPOST_CALLBACK :: httppost_flags{.CALLBACK}

HTTPPOST_FILENAME :: httppost_flags{.FILENAME}

HTTPPOST_LARGE :: httppost_flags{.LARGE}

HTTPPOST_PTRBUFFER :: httppost_flags{.PTRBUFFER}

HTTPPOST_PTRCONTENTS :: httppost_flags{.PTRCONTENTS}

HTTPPOST_PTRNAME :: httppost_flags{.PTRNAME}

HTTPPOST_READFILE :: httppost_flags{.READFILE}

HTTP_VERSION_1_0: int : 1

HTTP_VERSION_1_1: int : 2

HTTP_VERSION_2: int : HTTP_VERSION_2_0

HTTP_VERSION_2TLS: int : 4

HTTP_VERSION_2_0: int : 3

HTTP_VERSION_2_PRIOR_KNOWLEDGE: int : 5

HTTP_VERSION_3: int : 30

HTTP_VERSION_3ONLY: int : 31

HTTP_VERSION_LAST: int : 32

HTTP_VERSION_NONE: int : 0

H_1XX :: header_origin_bits{.H_1XX}

H_CONNECT :: header_origin_bits{.H_CONNECT}

H_HEADER :: header_origin_bits{.H_HEADER}

H_PSEUDO :: header_origin_bits{.H_PSEUDO}

H_TRAILER :: header_origin_bits{.H_TRAILER}

INFO_DOUBLE: int : 0x300000

INFO_LONG: int : 0x200000

INFO_MASK: int : 0x0fffff

INFO_OFF_T: int : 0x600000

INFO_PTR: int : 0x400000

INFO_SLIST: int : 0x400000

INFO_SOCKET: int : 0x500000

INFO_STRING: int : 0x100000

INFO_TYPEMASK: int : 0xf00000

IPRESOLVE_V4: int : 1

IPRESOLVE_V6: int : 2

IPRESOLVE_WHATEVER: int : 0

MAX_HTTP_HEADER: int : 100 * 1024

MAX_READ_SIZE: int : 10 * 1024 * 1024

MAX_WRITE_SIZE: int : 16384

MIMEOPT_FORMESCAPE: int : 1 << 0

MNWC_CLEAR_CONNS: int : 1 << 0

MNWC_CLEAR_DNS: int : 1 << 0

NETRC_IGNORED: int : 0

NETRC_OPTIONAL: int : 1

NETRC_REQUIRED: int : 2

OPTTYPE_BLOB: int : 40000

OPTTYPE_CBPOINT: int : OPTTYPE_OBJECTPOINT

OPTTYPE_FUNCTIONPOINT: int : 20000

OPTTYPE_LONG: int : 0

OPTTYPE_OBJECTPOINT: int : 10000

OPTTYPE_OFF_T: int : 30000

OPTTYPE_SLISTPOINT: int : OPTTYPE_OBJECTPOINT

OPTTYPE_STRINGPOINT: int : OPTTYPE_OBJECTPOINT

OPTTYPE_VALUES: int : OPTTYPE_LONG

PAUSE_ALL: int : PAUSE_RECV | PAUSE_SEND

PAUSE_CONT: int : PAUSE_RECV_CONT | PAUSE_SEND_CONT

PAUSE_RECV: int : 1 << 0

PAUSE_RECV_CONT: int : 0

PAUSE_SEND: int : 1 << 2

PAUSE_SEND_CONT: int : 0

PIPE_HTTP1: int : 1

PIPE_MULTIPLEX: int : 2

PIPE_NOTHING: int : 0

POLL_IN: int : 1

POLL_INOUT: int : 3

POLL_NONE: int : 0

POLL_OUT: int : 2

POLL_REMOVE: int : 4

PREREQFUNC_ABORT: int : 1

PREREQFUNC_OK: int : 0

PROGRESSFUNC_CONTINUE: int : 0x10000001

PROTO_ALL: i32 : ~c.int(0)

PROTO_DICT: int : 1 << 9

PROTO_FILE: int : 1 << 10

PROTO_FTP: int : 1 << 2

PROTO_FTPS: int : 1 << 3

PROTO_GOPHER: int : 1 << 25

PROTO_GOPHERS: int : 1 << 29

PROTO_HTTP: int : 1 << 0

PROTO_HTTPS: int : 1 << 1

PROTO_IMAP: int : 1 << 12

PROTO_IMAPS: int : 1 << 13

PROTO_LDAP: int : 1 << 7

PROTO_LDAPS: int : 1 << 8

PROTO_MQTT: int : 1 << 28

PROTO_POP3: int : 1 << 14

PROTO_POP3S: int : 1 << 15

PROTO_RTMP: int : 1 << 19

PROTO_RTMPE: int : 1 << 21

PROTO_RTMPS: int : 1 << 23

PROTO_RTMPT: int : 1 << 20

PROTO_RTMPTE: int : 1 << 22

PROTO_RTMPTS: int : 1 << 24

PROTO_RTSP: int : 1 << 18

PROTO_SCP: int : 1 << 4

PROTO_SFTP: int : 1 << 5

PROTO_SMB: int : 1 << 26

PROTO_SMBS: int : 1 << 27

PROTO_SMTP: int : 1 << 16

PROTO_SMTPS: int : 1 << 17

PROTO_TELNET: int : 1 << 6

PROTO_TFTP: int : 1 << 11

PT_RTSPHEADER :: option.HTTPHEADER

PUSH_DENY: int : 1

PUSH_ERROROUT: int : 2

PUSH_OK: int : 0

READFUNC_ABORT: int : 0x10000000

READFUNC_PAUSE: int : 0x10000001

REDIR_GET_ALL: int : 0

REDIR_POST_301: int : 1

REDIR_POST_302: int : 2

REDIR_POST_303: int : 4

REDIR_POST_ALL: int : REDIR_POST_301 | REDIR_POST_302 | REDIR_POST_303

RTSPREQ_ANNOUNCE: int : 3

RTSPREQ_DESCRIBE: int : 2

RTSPREQ_GET_PARAMETER: int : 8

RTSPREQ_LAST: int : 12

RTSPREQ_NONE: int : 0

RTSPREQ_OPTIONS: int : 1

RTSPREQ_PAUSE: int : 6

RTSPREQ_PLAY: int : 5

RTSPREQ_RECEIVE: int : 11

RTSPREQ_RECORD: int : 10

RTSPREQ_SETUP: int : 4

RTSPREQ_SET_PARAMETER: int : 9

RTSPREQ_TEARDOWN: int : 7

SEEKFUNC_CANTSEEK: int : 2

SEEKFUNC_FAIL: int : 1

SEEKFUNC_OK: int : 0

SOCKET_BAD :: socket_t(-1)

SOCKET_TIMEOUT: socket_t : SOCKET_BAD

SOCKOPT_ALREADY_CONNECTED: int : 2

SOCKOPT_ERROR: int : 1

SOCKOPT_OK: int : 0

SSH_AUTH_AGENT: int : 1 << 4

SSH_AUTH_ANY: i32 : ~c.int(0)

SSH_AUTH_DEFAULT: i32 : SSH_AUTH_ANY

SSH_AUTH_GSSAPI: int : 1 << 5

SSH_AUTH_HOST: int : 1 << 2

SSH_AUTH_KEYBOARD: int : 1 << 3

SSH_AUTH_NONE: int : 0

SSH_AUTH_PASSWORD: int : 1 << 1

SSH_AUTH_PUBLICKEY: int : 1 << 0

SSLOPT_ALLOW_BEAST: int : 1 << 0

SSLOPT_AUTO_CLIENT_CERT: int : 1 << 5

SSLOPT_EARLYDATA: int : 1 << 6

SSLOPT_NATIVE_CA: int : 1 << 4

SSLOPT_NO_PARTIALCHAIN: int : 1 << 2

SSLOPT_NO_REVOKE: int : 1 << 1

SSLOPT_REVOKE_BEST_EFFORT: int : 1 << 3

SSLVERSION_DEFAULT: int : 0

SSLVERSION_LAST: int : 8

SSLVERSION_MAX_DEFAULT: int : SSLVERSION_TLSv1 << 16

SSLVERSION_MAX_LAST: int : SSLVERSION_LAST << 16

SSLVERSION_MAX_NONE: int : 0

SSLVERSION_MAX_TLSv1_0: int : SSLVERSION_TLSv1_0 << 16

SSLVERSION_MAX_TLSv1_1: int : SSLVERSION_TLSv1_1 << 16

SSLVERSION_MAX_TLSv1_2: int : SSLVERSION_TLSv1_2 << 16

SSLVERSION_MAX_TLSv1_3: int : SSLVERSION_TLSv1_3 << 16

SSLVERSION_SSLv2: int : 2

SSLVERSION_SSLv3: int : 3

SSLVERSION_TLSv1: int : 1

SSLVERSION_TLSv1_0: int : 4

SSLVERSION_TLSv1_1: int : 5

SSLVERSION_TLSv1_2: int : 6

SSLVERSION_TLSv1_3: int : 7

TIMECOND_IFMODSINCE: int : 1

TIMECOND_IFUNMODSINCE: int : 2

TIMECOND_LASTMOD: int : 3

TIMECOND_NONE: int : 0

TIMESTAMP: string : "2025-11-05"

TLSAUTH_NONE: int : 0

TLSAUTH_SRP: int : 1

TRAILERFUNC_ABORT: int : 1

TRAILERFUNC_OK: int : 0

ULFLAG_ANSWERED: int : 1 << 0

ULFLAG_DELETED: int : 1 << 1

ULFLAG_DRAFT: int : 1 << 2

ULFLAG_FLAGGED: int : 1 << 3

ULFLAG_SEEN: int : 1 << 4

UPKEEP_INTERVAL_DEFAULT: int : 60000

USESSL_ALL: int : 3

USESSL_CONTROL: int : 2

USESSL_NONE: int : 0

USESSL_TRY: int : 1

U_ALLOW_SPACE :: UFlags{.ALLOW_SPACE}

U_APPENDQUERY :: UFlags{.APPENDQUERY}

U_DEFAULT_PORT :: UFlags{.DEFAULT_PORT}

U_DEFAULT_SCHEME :: UFlags{.DEFAULT_SCHEME}

U_DISALLOW_USER :: UFlags{.DISALLOW_USER}

U_GET_EMPTY :: UFlags{.GET_EMPTY}

U_GUESS_SCHEME :: UFlags{.GUESS_SCHEME}

U_NON_SUPPORT_SCHEME :: UFlags{.NON_SUPPORT_SCHEME}