diff --git a/README.md b/README.md
index 31cf839..10a1381 100644
--- a/README.md
+++ b/README.md
@@ -37,12 +37,17 @@ the current directory where it be used with `--libdir <folder>` and `--lib <libn
 Because of the hard naming rules in C3, names sometimes need to be
 rewritten to work in C3, and one also have to consider the namespacing C3 will add. Here follows a short guide on current best practices:
 
+### Two types of bindings
+
+There are two options when creating bindings:
+
+1. Create a direct binding, this tries to be as faithful as possible to the original API. This can be valuable if the user wants to follow the code written in other languages.
+2. Bindings leveraging C3 and conforming to C3 standards. This often creates a more integrated and overall better experience, but at the cost of making it harder to easily explore.
+
 ### Names in general
 
 1. Keep names predicable so that a user who knows the name in C can easily find the name in C3.
-2. Avoid changing the names to conform to some other style, even if it's the C3 standard. By keeping the original name it's much
- easier to drop in code examples and to see exactly what is the library code. Users can write 'C3-like' wrappers later, 
- but that can be added when the "raw" functions are already there.
+2. If using a direct binding: avoid changing the names to conform to some other style, even if it's the C3 standard.
 
 ### Module name
 
@@ -69,6 +74,7 @@ options:
 
 1. Use a lowercase prefix and use `@builtin`: `win32_OpenWindow(...)`.
 2. Use a module and lowercase the first letter in the function `win32::openWindow(...)`.
+3. If a C3-like binding is desired, rename it `open_window`.
 
 *Note* never combine things, `win32::win32_OpenWindow(...)` is *bad*.
 
@@ -89,7 +95,7 @@ name collision.
 
 #### Type names that are not valid C3 type names
 
-The recommended solution is to prefix them with a minimal name prefix which
+In direct bindings the recommended solution is to prefix them with a minimal name prefix which
 that ensures the rule is followed:
 
 `HANDLE` -> `Win32_HANDLE`
@@ -104,6 +110,8 @@ size_t -> usz
 UINT32 -> uint
 ```
 
+For C3-like bindings, the best option is usually to always prefix with the name of the library, e.g. `FooVersionInfo` for `versioninfo` in a library "Foo".
+
 #### Type names that collide with existing C3 type names
 
 In these cases, consider retaining the type name as is and require the user
@@ -190,86 +198,10 @@ enum Button
 
 #### C enums with gaps
 
-C enums that have gaps need to be modelled as constants. This can be done
-from simple to more complex.
-
-1. Declare them as regular constants (do this sparingly)
-2. Declare as constants with a distinct type.
-3. Declare in a sub-module with a distinct type.
-
-##### Declaring a regular constant
-
-This is simply 
-
-```c
-const GL_TEXTURE_2D = ...`
-```
-
-However, if this is plainly added as such, the
-module prefix will be required. So if a prefix
-already exists, then add `@builtin`:
-
-```c
-const GL_TEXTURE_2D @builtin = ...`
-```
-
-This allows it to be used without prefix. The
-enum is then replaced in types and functions with
-CInt / int.
-
-##### Using a distinct type
-
-In this case we first define a distinct type, 
-matching the enum name, then use constant but with
-the distinct type. This is a better experience for 
-the user and is recommended.
-
-The same recommendation regarding `@builtin`
-should be followed as in the normal const case.
-
-```
-distinct GlEnum = CInt;
-
-const GlEnum GL_TEXTURE_2D @builtin = ...;
-const GlEnum GL_LINE_LOOP @builtin = ...;
-```
-
-##### Declare in a sub-module with a distinct type.
-
-This method can be used when the enum doesn't have any good namespacing,
-so we want to introduce one.
-
-An example, with the following C definition:
-```c
-// C enum:
-typedef enum
-{
-   ANY = 0x1,
-   CANCEL = 0xAA,
-} Button;
-```
-
-We can model this as:
-```c
-// Define the distinct type
-distinct Button = CInt;
-
-// Create a specific sub module based on the enum name  
-module mylib::ui::button;
-
-// Place the constants inside
-const Button ANY = 0x1;
-const Button CANCEL = 0xAA;
-```
-
-The advantage that we can now do:
-```c
-ui::newButton(button::ANY);
-```
+C enums that have gaps should be modeled as `constdef`.
 
 ### Global and constant names
 
-Global and constant names can usually be just converted to conform in a minimal manner (e.g
-lower case the first character or convert all to upper case).
+Global and constant names can usually be just converted to conform in a minimal manner (e.g lower case the first character or convert all to upper case).
 
 If this is not desired, use the same strategies as functions.
diff --git a/libraries/curl.c3l/curl.c3i b/libraries/curl.c3l/curl.c3i
index d4a2979..351a19c 100644
--- a/libraries/curl.c3l/curl.c3i
+++ b/libraries/curl.c3l/curl.c3i
@@ -1,719 +1,947 @@
 // curl.c3i
 // Created 16/07/2023
-// Updated 17/07/2023
+// Last updated 25/02/2026
 // Wrapper originally created Kenta @ https://github.com/Its-Kenta
 
 module curl;
-import libc;
-import std::io;
+import libc, std::io;
 
-alias Curl = void;
-alias CurlSH = void;
+enum CurlSslBackendType : int
+{
+	NONE,
+	OPENSSL,
+	GNUTLS,
+	NSS,
+	OBSOLETE4,
+	GSKIT,
+	POLARSSL,
+	WOLFSSL,
+	SCHANNEL,
+	SECURETRANSPORT,
+	AXTLS,
+	MBEDTLS,
+	MESALINK,
+	BEARSSL,
+	RUSTLS
+}
 
-struct Fd_set
+enum CurlStsResult : int
 {
-	long[16] __fds_bits;
+	OK,
+	DONE,
+	FAIL
 }
 
-struct _Sockaddr
+enum CurlSockType : int
 {
-	ushort sa_family;
-	char[14] sa_data;
+	IPCXN,
+	ACCEPT,
+	LAST
 }
 
-alias Socklen = uint;
-alias Off_t = long;
-alias Socket_t = int;
+enum CurlIoResult : int
+{
+	OK,
+	UNKNOWNCMD,
+	FAILRESTART,
+	LAST
+}
 
-enum Sslbackend : int
+enum CurlDebugInfoType : int
 {
-	CURLSSLBACKEND_NONE,
-	CURLSSLBACKEND_OPENSSL,
-	CURLSSLBACKEND_GNUTLS,
-	CURLSSLBACKEND_NSS,
-	CURLSSLBACKEND_OBSOLETE4,
-	CURLSSLBACKEND_GSKIT,
-	CURLSSLBACKEND_POLARSSL,
-	CURLSSLBACKEND_WOLFSSL,
-	CURLSSLBACKEND_SCHANNEL,
-	CURLSSLBACKEND_SECURETRANSPORT,
-	CURLSSLBACKEND_AXTLS,
-	CURLSSLBACKEND_MBEDTLS,
-	CURLSSLBACKEND_MESALINK,
-	CURLSSLBACKEND_BEARSSL,
-	CURLSSLBACKEND_RUSTLS
+	TEXT,
+	HEADER_IN,
+	HEADER_OUT,
+	DATA_IN,
+	DATA_OUT,
+	SSL_DATA_IN,
+	SSL_DATA_OUT,
+	END
 }
 
-struct Slist
+constdef CurlHttpPostFlag : CLong
 {
-	char* data;
-	Slist* next;
+	FILENAME    = 1,
+	READFILE    = 2,
+	PTRNAME     = 4,
+	PTRCONTENTS = 8,
+	BUFFER      = 16,
+	PTRBUFFER   = 32,
+	CALLBACK    = 64,
+	LARGE       = 128,
 }
 
-struct Httppost
+enum CurlFileType : int
 {
-	Httppost* next;
-	char* name;
-	long namelength;
-	char* contents;
-	long contentslength;
+	FILE,
+	DIRECTORY,
+	SYMLINK,
+	DEVICE_BLOCK,
+	DEVICE_CHAR,
+	NAMEDPIPE,
+	SOCKET,
+	DOOR,
+	UNKNOWN
+}
 
-	char* buffer;
-	long bufferlength;
-	char* contenttype;
-	Slist* contentheader;
-	Httppost* more;
-	long flags;
-	char* showfilename;
-	void* userp;
-	Off_t contentlen;
+enum CurlResult : int
+{
+	OK,
+	UNSUPPORTED_PROTOCOL,
+	FAILED_INIT,
+	URL_MALFORMAT,
+	NOT_BUILT_IN,
+	COULDNT_RESOLVE_PROXY,
+	COULDNT_RESOLVE_HOST,
+	COULDNT_CONNECT,
+	WEIRD_SERVER_REPLY,
+	REMOTE_ACCESS_DENIED,
+	FTP_ACCEPT_FAILED,
+	FTP_WEIRD_PASS_REPLY,
+	FTP_ACCEPT_TIMEOUT,
+	FTP_WEIRD_PASV_REPLY,
+	FTP_WEIRD_227_FORMAT,
+	FTP_CANT_GET_HOST,
+	HTTP2,
+	FTP_COULDNT_SET_TYPE,
+	PARTIAL_FILE,
+	FTP_COULDNT_RETR_FILE,
+	OBSOLETE20,
+	QUOTE_ERROR,
+	HTTP_RETURNED_ERROR,
+	WRITE_ERROR,
+	OBSOLETE24,
+	UPLOAD_FAILED,
+	READ_ERROR,
+	OUT_OF_MEMORY,
+	OPERATION_TIMEDOUT,
+	OBSOLETE29,
+	FTP_PORT_FAILED,
+	FTP_COULDNT_USE_REST,
+	OBSOLETE32,
+	RANGE_ERROR,
+	HTTP_POST_ERROR,
+	SSL_CONNECT_ERROR,
+	BAD_DOWNLOAD_RESUME,
+	FILE_COULDNT_READ_FILE,
+	LDAP_CANNOT_BIND,
+	LDAP_SEARCH_FAILED,
+	OBSOLETE40,
+	NOT_FOUND,
+	ABORTED_BY_CALLBACK,
+	ARGUMENT,
+	OBSOLETE44,
+	INTERFACE_FAILED,
+	OBSOLETE46,
+	TOO_MANY_REDIRECTS,
+	UNKNOWN_OPTION,
+	SETOPT_OPTION_SYNTAX,
+	OBSOLETE50,
+	OBSOLETE51,
+	GOT_NOTHING,
+	SSL_ENGINE_NOTFOUND,
+	SSL_ENGINE_SETFAILED,
+	SEND_ERROR,
+	RECV_ERROR,
+	OBSOLETE57,
+	SSL_CERTPROBLEM,
+	SSL_CIPHER,
+	PEER_FAILED_VERIFICATION,
+	BAD_CONTENT_ENCODING,
+	OBSOLETE62,
+	FILESIZE_EXCEEDED,
+	USE_SSL_FAILED,
+	SEND_FAIL_REWIND,
+	SSL_ENGINE_INITFAILED,
+	LOGIN_DENIED,
+	TFTP_NOTFOUND,
+	TFTP_PERM,
+	REMOTE_DISK_FULL,
+	TFTP_ILLEGAL,
+	TFTP_UNKNOWNID,
+	REMOTE_FILE_EXISTS,
+	TFTP_NOSUCHUSER,
+	OBSOLETE75,
+	OBSOLETE76,
+	SSL_CACERT_BADFILE,
+	REMOTE_FILE_NOT_FOUND,
+	SSH,
+	SSL_SHUTDOWN_FAILED,
+	AGAIN,
+	SSL_CRL_BADFILE,
+	SSL_ISSUER_ERROR,
+	FTP_PRET_FAILED,
+	RTSP_CSEQ_ERROR,
+	RTSP_SESSION_ERROR,
+	FTP_BAD_FILE_LIST,
+	CHUNK_FAILED,
+	NO_CONNECTION_AVAILABLE,
+	SSL_PINNEDPUBKEYNOTMATCH,
+	SSL_INVALIDCERTSTATUS,
+	HTTP2_STREAM,
+	RECURSIVE_API_CALL,
+	AUTH_ERROR,
+	HTTP3,
+	QUIC_CONNECT_ERROR,
+	PROXY,
+	SSL_CLIENTCERT,
+	UNRECOVERABLE_POLL,
+	LAST
 }
 
-const int CURL_HTTPPOST_FILENAME    = 1;
-const int CURL_HTTPPOST_READFILE    = 2;
-const int CURL_HTTPPOST_PTRNAME     = 4;
-const int CURL_HTTPPOST_PTRCONTENTS = 8;
-const int CURL_HTTPPOST_BUFFER      = 16;
-const int CURL_HTTPPOST_PTRBUFFER   = 32;
-const int CURL_HTTPPOST_CALLBACK    = 64;
-const int CURL_HTTPPOST_LARGE       = 128;
+enum CurlKhType : int
+{
+	UNKNOWN,
+	RSA1,
+	RSA,
+	DSS,
+	ECDSA,
+	ED25519
+}
 
-alias Curl_progress_callback = fn int(void* clientp, double dltotal, double dlnow, double ultotal, double ulnow);
-alias Curl_xferinfo_callback = fn int(void* clientp, Off_t dltotal, Off_t dlnow, Off_t ultotal, Off_t ulnow);
-alias Curl_write_callback = fn usz(char* buffer, usz size, usz nitems, void* outstream);
-alias Curl_resolver_start_callback = fn int(void* resolver_state, void* reserved, void* userdata);
+enum CurlProxyType : int
+{
+	HTTP,
+	HTTP_1_0,
+	HTTPS,
+	HTTPS2,
+	SOCKS4,
+	SOCKS5,
+	SOCKS4A,
+	SOCKS5_HOSTNAME
+}
 
-enum Filetype : int
+enum CurlUseSslType : int
 {
-	CURLFILETYPE_FILE,
-	CURLFILETYPE_DIRECTORY,
-	CURLFILETYPE_SYMLINK,
-	CURLFILETYPE_DEVICE_BLOCK,
-	CURLFILETYPE_DEVICE_CHAR,
-	CURLFILETYPE_NAMEDPIPE,
-	CURLFILETYPE_SOCKET,
-	CURLFILETYPE_DOOR,
-	CURLFILETYPE_UNKNOWN
+	NONE,
+	TRY,
+	CONTROL,
+	ALL,
+	LAST
 }
 
-struct Fileinfo
+enum CurlKhStatType : int
 {
-	char* filename;
-	Filetype filetype;
-	libc::Time_t time;
-	uint perm;
-	int uid;
-	int gid;
-	Off_t size;
-	long hardlinks;
+	FINE_ADD_TO_FILE,
+	FINE,
+	REJECT,
+	DEFER,
+	FINE_REPLACE,
+	LAST
+}
 
-	struct strings
-	{
-		char *time;
-		char *perm;
-		char *user;
-		char *group;
-		char *target;
-	}
+enum CurlFtpAuthType : int
+{
+	DEFAULT,
+	SSL,
+	TLS,
+	LAST
+}
 
-	uint flags;
+enum CurlFtpCreateDirType : int
+{
+	DIR_NONE,
+	DIR,
+	DIR_RETRY,
+	DIR_LAST
+}
 
-	char* b_data;
-	usz b_size;
-	usz b_used;
+enum CurlKhMatchType : int
+{
+	OK,
+	MISMATCH,
+	MISSING,
+	LAST
 }
 
-alias Curl_chunk_bgn_callback = fn long(void* transfer_info,void* ptr, int remains);
-alias Curl_chunk_end_callback = fn long(void* ptr);
-alias Curl_fnmatch_callback = fn int(void* ptr, char* pattern, char* string);
-alias Curl_seek_callback = fn int(void* instream, Off_t offset, int origin);
-alias Curl_read_callback = fn usz(char* buffer, usz size, usz nitems, void* instream);
-alias Curl_trailer_callback = fn int(Slist** list, void* userdata);
+enum CurlFtpMethodType : int
+{
+	DEFAULT,
+	MULTICWD,
+	NOCWD,
+	SINGLECWD,
+	LAST
+}
 
-enum Socktype : int
+enum CurlFtpSslCccType : int
 {
-	CURLSOCKTYPE_IPCXN,
-	CURLSOCKTYPE_ACCEPT,
-	CURLSOCKTYPE_LAST
+	NONE,
+	PASSIVE,
+	ACTIVE,
+	LAST
 }
 
-alias Curl_sockopt_callback = fn int(void* clientp, Socket_t curlfd, Socktype purpose);
+constdef CurlOption : int
+{
+	WRITEDATA = 10001,
+	URL = 10002,
+	PORT = 3,
+	PROXY = 10004,
+	USERPWD = 10005,
+	PROXYUSERPWD = 10006,
+	RANGE = 10007,
+	READDATA = 10009,
+	ERRORBUFFER = 10010,
+	WRITEFUNCTION = 20011,
+	READFUNCTION = 20012,
+	TIMEOUT = 13,
+	INFILESIZE = 14,
+	POSTFIELDS = 10015,
+	REFERER = 10016,
+	FTPPORT = 10017,
+	USERAGENT = 10018,
+	LOW_SPEED_LIMIT = 19,
+	LOW_SPEED_TIME = 20,
+	RESUME_FROM = 21,
+	COOKIE = 10022,
+	HTTPHEADER = 10023,
+	HTTPPOST = 10024,
+	SSLCERT = 10025,
+	KEYPASSWD = 10026,
+	CRLF = 27,
+	QUOTE = 10028,
+	HEADERDATA = 10029,
+	COOKIEFILE = 10031,
+	SSLVERSION = 32,
+	TIMECONDITION = 33,
+	TIMEVALUE = 34,
+	CUSTOMREQUEST = 10036,
+	STDERR = 10037,
+	POSTQUOTE = 10039,
+	OBSOLETE40 = 10040,
+	VERBOSE = 41,
+	HEADER = 42,
+	NOPROGRESS = 43,
+	NOBODY = 44,
+	FAILONERROR = 45,
+	UPLOAD = 46,
+	POST = 47,
+	DIRLISTONLY = 48,
+	APPEND = 50,
+	NETRC = 51,
+	FOLLOWLOCATION = 52,
+	TRANSFERTEXT = 53,
+	PUT = 54,
+	PROGRESSFUNCTION = 20056,
+	XFERINFODATA = 10057,
+	AUTOREFERER = 58,
+	PROXYPORT = 59,
+	POSTFIELDSIZE = 60,
+	HTTPPROXYTUNNEL = 61,
+	INTERFACE = 10062,
+	KRBLEVEL = 10063,
+	SSL_VERIFYPEER = 64,
+	CAINFO = 10065,
+	MAXREDIRS = 68,
+	FILETIME = 69,
+	TELNETOPTIONS = 10070,
+	MAXCONNECTS = 71,
+	OBSOLETE72 = 72,
+	FRESH_CONNECT = 74,
+	FORBID_REUSE = 75,
+	RANDOM_FILE = 10076,
+	EGDSOCKET = 10077,
+	CONNECTTIMEOUT = 78,
+	HEADERFUNCTION = 20079,
+	HTTPGET = 80,
+	SSL_VERIFYHOST = 81,
+	COOKIEJAR = 10082,
+	SSL_CIPHER_LIST = 10083,
+	HTTP_VERSION = 84,
+	FTP_USE_EPSV = 85,
+	SSLCERTTYPE = 10086,
+	SSLKEY = 10087,
+	SSLKEYTYPE = 10088,
+	SSLENGINE = 10089,
+	SSLENGINE_DEFAULT = 90,
+	DNS_USE_GLOBAL_CACHE = 91,
+	DNS_CACHE_TIMEOUT = 92,
+	PREQUOTE = 10093,
+	DEBUGFUNCTION = 20094,
+	DEBUGDATA = 10095,
+	COOKIESESSION = 96,
+	CAPATH = 10097,
+	BUFFERSIZE = 98,
+	NOSIGNAL = 99,
+	SHARE = 10100,
+	PROXYTYPE = 101,
+	ACCEPT_ENCODING = 10102,
+	PRIVATE = 10103,
+	HTTP200ALIASES = 10104,
+	UNRESTRICTED_AUTH = 105,
+	FTP_USE_EPRT = 106,
+	HTTPAUTH = 107,
+	SSL_CTX_FUNCTION = 20108,
+	SSL_CTX_DATA = 10109,
+	FTP_CREATE_MISSING_DIRS = 110,
+	PROXYAUTH = 111,
+	SERVER_RESPONSE_TIMEOUT = 112,
+	IPRESOLVE = 113,
+	MAXFILESIZE = 114,
+	INFILESIZE_LARGE = 30115,
+	RESUME_FROM_LARGE = 30116,
+	MAXFILESIZE_LARGE = 30117,
+	NETRC_FILE = 10118,
+	USE_SSL = 119,
+	POSTFIELDSIZE_LARGE = 30120,
+	TCP_NODELAY = 121,
+	FTPSSLAUTH = 129,
+	IOCTLFUNCTION = 20130,
+	IOCTLDATA = 10131,
+	FTP_ACCOUNT = 10134,
+	COOKIELIST = 10135,
+	IGNORE_CONTENT_LENGTH = 136,
+	FTP_SKIP_PASV_IP = 137,
+	FTP_FILEMETHOD = 138,
+	LOCALPORT = 139,
+	LOCALPORTRANGE = 140,
+	CONNECT_ONLY = 141,
+	CONV_FROM_NETWORK_FUNCTION = 20142,
+	CONV_TO_NETWORK_FUNCTION = 20143,
+	CONV_FROM_UTF8_FUNCTION = 20144,
+	MAX_SEND_SPEED_LARGE = 30145,
+	MAX_RECV_SPEED_LARGE = 30146,
+	FTP_ALTERNATIVE_TO_USER = 10147,
+	SOCKOPTFUNCTION = 20148,
+	SOCKOPTDATA = 10149,
+	SSL_SESSIONID_CACHE = 150,
+	SSH_AUTH_TYPES = 151,
+	SSH_PUBLIC_KEYFILE = 10152,
+	SSH_PRIVATE_KEYFILE = 10153,
+	FTP_SSL_CCC = 154,
+	TIMEOUT_MS = 155,
+	CONNECTTIMEOUT_MS = 156,
+	HTTP_TRANSFER_DECODING = 157,
+	HTTP_CONTENT_DECODING = 158,
+	NEW_FILE_PERMS = 159,
+	NEW_DIRECTORY_PERMS = 160,
+	POSTREDIR = 161,
+	SSH_HOST_PUBLIC_KEY_MD5 = 10162,
+	OPENSOCKETFUNCTION = 20163,
+	OPENSOCKETDATA = 10164,
+	COPYPOSTFIELDS = 10165,
+	PROXY_TRANSFER_MODE = 166,
+	SEEKFUNCTION = 20167,
+	SEEKDATA = 10168,
+	CRLFILE = 10169,
+	ISSUERCERT = 10170,
+	ADDRESS_SCOPE = 171,
+	CERTINFO = 172,
+	USERNAME = 10173,
+	PASSWORD = 10174,
+	PROXYUSERNAME = 10175,
+	PROXYPASSWORD = 10176,
+	NOPROXY = 10177,
+	TFTP_BLKSIZE = 178,
+	SOCKS5_GSSAPI_SERVICE = 10179,
+	SOCKS5_GSSAPI_NEC = 180,
+	PROTOCOLS = 181,
+	REDIR_PROTOCOLS = 182,
+	SSH_KNOWNHOSTS = 10183,
+	SSH_KEYFUNCTION = 20184,
+	SSH_KEYDATA = 10185,
+	MAIL_FROM = 10186,
+	MAIL_RCPT = 10187,
+	FTP_USE_PRET = 188,
+	RTSP_REQUEST = 189,
+	RTSP_SESSION_ID = 10190,
+	RTSP_STREAM_URI = 10191,
+	RTSP_TRANSPORT = 10192,
+	RTSP_CLIENT_CSEQ = 193,
+	RTSP_SERVER_CSEQ = 194,
+	INTERLEAVEDATA = 10195,
+	INTERLEAVEFUNCTION = 20196,
+	WILDCARDMATCH = 197,
+	CHUNK_BGN_FUNCTION = 20198,
+	CHUNK_END_FUNCTION = 20199,
+	FNMATCH_FUNCTION = 20200,
+	CHUNK_DATA = 10201,
+	FNMATCH_DATA = 10202,
+	RESOLVE = 10203,
+	TLSAUTH_USERNAME = 10204,
+	TLSAUTH_PASSWORD = 10205,
+	TLSAUTH_TYPE = 10206,
+	TRANSFER_ENCODING = 207,
+	CLOSESOCKETFUNCTION = 20208,
+	CLOSESOCKETDATA = 10209,
+	GSSAPI_DELEGATION = 210,
+	DNS_SERVERS = 10211,
+	ACCEPTTIMEOUT_MS = 212,
+	TCP_KEEPALIVE = 213,
+	TCP_KEEPIDLE = 214,
+	TCP_KEEPINTVL = 215,
+	SSL_OPTIONS = 216,
+	MAIL_AUTH = 10217,
+	SASL_IR = 218,
+	XFERINFOFUNCTION = 20219,
+	XOAUTH2_BEARER = 10220,
+	DNS_INTERFACE = 10221,
+	DNS_LOCAL_IP4 = 10222,
+	DNS_LOCAL_IP6 = 10223,
+	LOGIN_OPTIONS = 10224,
+	SSL_ENABLE_NPN = 225,
+	SSL_ENABLE_ALPN = 226,
+	EXPECT_100_TIMEOUT_MS = 227,
+	PROXYHEADER = 10228,
+	HEADEROPT = 229,
+	PINNEDPUBLICKEY = 10230,
+	UNIX_SOCKET_PATH = 10231,
+	SSL_VERIFYSTATUS = 232,
+	SSL_FALSESTART = 233,
+	PATH_AS_IS = 234,
+	PROXY_SERVICE_NAME = 10235,
+	SERVICE_NAME = 10236,
+	PIPEWAIT = 237,
+	DEFAULT_PROTOCOL = 10238,
+	STREAM_WEIGHT = 239,
+	STREAM_DEPENDS = 10240,
+	STREAM_DEPENDS_E = 10241,
+	TFTP_NO_OPTIONS = 242,
+	CONNECT_TO = 10243,
+	TCP_FASTOPEN = 244,
+	KEEP_SENDING_ON_ERROR = 245,
+	PROXY_CAINFO = 10246,
+	PROXY_CAPATH = 10247,
+	PROXY_SSL_VERIFYPEER = 248,
+	PROXY_SSL_VERIFYHOST = 249,
+	PROXY_SSLVERSION = 250,
+	PROXY_TLSAUTH_USERNAME = 10251,
+	PROXY_TLSAUTH_PASSWORD = 10252,
+	PROXY_TLSAUTH_TYPE = 10253,
+	PROXY_SSLCERT = 10254,
+	PROXY_SSLCERTTYPE = 10255,
+	PROXY_SSLKEY = 10256,
+	PROXY_SSLKEYTYPE = 10257,
+	PROXY_KEYPASSWD = 10258,
+	PROXY_SSL_CIPHER_LIST = 10259,
+	PROXY_CRLFILE = 10260,
+	PROXY_SSL_OPTIONS = 261,
+	PRE_PROXY = 10262,
+	PROXY_PINNEDPUBLICKEY = 10263,
+	ABSTRACT_UNIX_SOCKET = 10264,
+	SUPPRESS_CONNECT_HEADERS = 265,
+	REQUEST_TARGET = 10266,
+	SOCKS5_AUTH = 267,
+	SSH_COMPRESSION = 268,
+	MIMEPOST = 10269,
+	TIMEVALUE_LARGE = 30270,
+	HAPPY_EYEBALLS_TIMEOUT_MS = 271,
+	RESOLVER_START_FUNCTION = 20272,
+	RESOLVER_START_DATA = 10273,
+	HAPROXYPROTOCOL = 274,
+	DNS_SHUFFLE_ADDRESSES = 275,
+	TLS13_CIPHERS = 10276,
+	PROXY_TLS13_CIPHERS = 10277,
+	DISALLOW_USERNAME_IN_URL = 278,
+	DOH_URL = 10279,
+	UPLOAD_BUFFERSIZE = 280,
+	UPKEEP_INTERVAL_MS = 281,
+	CURLU = 10282,
+	TRAILERFUNCTION = 20283,
+	TRAILERDATA = 10284,
+	HTTP09_ALLOWED = 285,
+	ALTSVC_CTRL = 286,
+	ALTSVC = 10287,
+	MAXAGE_CONN = 288,
+	SASL_AUTHZID = 10289,
+	MAIL_RCPT_ALLLOWFAILS = 290,
+	SSLCERT_BLOB = 40291,
+	SSLKEY_BLOB = 40292,
+	PROXY_SSLCERT_BLOB = 40293,
+	PROXY_SSLKEY_BLOB = 40294,
+	ISSUERCERT_BLOB = 40295,
+	PROXY_ISSUERCERT = 10296,
+	PROXY_ISSUERCERT_BLOB = 40297,
+	SSL_EC_CURVES = 10298,
+	HSTS_CTRL = 299,
+	HSTS = 10300,
+	HSTSREADFUNCTION = 20301,
+	HSTSREADDATA = 10302,
+	HSTSWRITEFUNCTION = 20303,
+	HSTSWRITEDATA = 10304,
+	AWS_SIGV4 = 10305,
+	DOH_SSL_VERIFYPEER = 306,
+	DOH_SSL_VERIFYHOST = 307,
+	DOH_SSL_VERIFYSTATUS = 308,
+	CAINFO_BLOB = 40309,
+	PROXY_CAINFO_BLOB = 40310,
+	SSH_HOST_PUBLIC_KEY_SHA256 = 10311,
+	PREREQFUNCTION = 20312,
+	PREREQDATA = 10313,
+	MAXLIFETIME_CONN = 314,
+	MIME_OPTIONS = 315,
+	SSH_HOSTKEYFUNCTION = 20316,
+	SSH_HOSTKEYDATA = 10317,
+	PROTOCOLS_STR = 10318,
+	REDIR_PROTOCOLS_STR = 10319,
+	WS_OPTIONS = 320,
+	CA_CACHE_TIMEOUT = 321,
+	QUICK_EXIT = 322,
+	LASTENTRY = 323,
+}
 
-struct Sockaddr
+enum CurlTimeCondType : int
 {
-	int family;
-	int socktype;
-	int protocol;
-	uint addrlen;
+	NONE,
+	IFMODSINCE,
+	IFUNMODSINCE,
+	LASTMOD,
+	LAST
+}
 
-	_Sockaddr addr;
-}
-
-alias Curl_opensocket_callback = fn Socket_t(void* clientp, Socktype purpose, Sockaddr* address);
-alias Curl_closesocket_callback = fn int(void* clientp, Socket_t item);
-
-enum Curlioerr : int
-{
-	CURLIOE_OK,
-	CURLIOE_UNKNOWNCMD,
-	CURLIOE_FAILRESTART,
-	CURLIOE_LAST
-}
-
-alias Curl_malloc_callback = fn void*(usz size);
-alias Curl_free_callback = fn void(void* ptr);
-alias Curl_realloc_callback = fn void*(void* ptr, usz size);
-alias Curl_strdup_callback = fn char*(char* str);
-alias Curl_calloc_callback = fn void*(usz nmemb, usz size);
-alias Curl_ioctl_callback = fn Curlioerr(Curl* handle, int cmd, void* clientp);
-
-enum Infotype : int
-{
-	CURLINFO_TEXT,
-	CURLINFO_HEADER_IN,
-	CURLINFO_HEADER_OUT,
-	CURLINFO_DATA_IN,
-	CURLINFO_DATA_OUT,
-	CURLINFO_SSL_DATA_IN,
-	CURLINFO_SSL_DATA_OUT,
-	CURLINFO_END
-}
-
-alias Curl_debug_callback = fn int(Curl* handle, Infotype type, char* data, usz size, void* userptr);
-alias Curl_prereq_callback = fn int(void* clientp, char* conn_primary_ip, char* conn_local_ip, int conn_primary_port, int conn_local_port);
-
-enum CURLcode : int
-{
-	CURLE_OK,
-	CURLE_UNSUPPORTED_PROTOCOL,
-	CURLE_FAILED_INIT,
-	CURLE_URL_MALFORMAT,
-	CURLE_NOT_BUILT_IN,
-	CURLE_COULDNT_RESOLVE_PROXY,
-	CURLE_COULDNT_RESOLVE_HOST,
-	CURLE_COULDNT_CONNECT,
-	CURLE_WEIRD_SERVER_REPLY,
-	CURLE_REMOTE_ACCESS_DENIED,
-	CURLE_FTP_ACCEPT_FAILED,
-	CURLE_FTP_WEIRD_PASS_REPLY,
-	CURLE_FTP_ACCEPT_TIMEOUT,
-	CURLE_FTP_WEIRD_PASV_REPLY,
-	CURLE_FTP_WEIRD_227_FORMAT,
-	CURLE_FTP_CANT_GET_HOST,
-	CURLE_HTTP2,
-	CURLE_FTP_COULDNT_SET_TYPE,
-	CURLE_PARTIAL_FILE,
-	CURLE_FTP_COULDNT_RETR_FILE,
-	CURLE_OBSOLETE20,
-	CURLE_QUOTE_ERROR,
-	CURLE_HTTP_RETURNED_ERROR,
-	CURLE_WRITE_ERROR,
-	CURLE_OBSOLETE24,
-	CURLE_UPLOAD_FAILED,
-	CURLE_READ_ERROR,
-	CURLE_OUT_OF_MEMORY,
-	CURLE_OPERATION_TIMEDOUT,
-	CURLE_OBSOLETE29,
-	CURLE_FTP_PORT_FAILED,
-	CURLE_FTP_COULDNT_USE_REST,
-	CURLE_OBSOLETE32,
-	CURLE_RANGE_ERROR,
-	CURLE_HTTP_POST_ERROR,
-	CURLE_SSL_CONNECT_ERROR,
-	CURLE_BAD_DOWNLOAD_RESUME,
-	CURLE_FILE_COULDNT_READ_FILE,
-	CURLE_LDAP_CANNOT_BIND,
-	CURLE_LDAP_SEARCH_FAILED,
-	CURLE_OBSOLETE40,
-	CURLE_NOT_FOUND,
-	CURLE_ABORTED_BY_CALLBACK,
-	CURLE_ARGUMENT,
-	CURLE_OBSOLETE44,
-	CURLE_INTERFACE_FAILED,
-	CURLE_OBSOLETE46,
-	CURLE_TOO_MANY_REDIRECTS,
-	CURLE_UNKNOWN_OPTION,
-	CURLE_SETOPT_OPTION_SYNTAX,
-	CURLE_OBSOLETE50,
-	CURLE_OBSOLETE51,
-	CURLE_GOT_NOTHING,
-	CURLE_SSL_ENGINE_NOTFOUND,
-	CURLE_SSL_ENGINE_SETFAILED,
-	CURLE_SEND_ERROR,
-	CURLE_RECV_ERROR,
-	CURLE_OBSOLETE57,
-	CURLE_SSL_CERTPROBLEM,
-	CURLE_SSL_CIPHER,
-	CURLE_PEER_FAILED_VERIFICATION,
-	CURLE_BAD_CONTENT_ENCODING,
-	CURLE_OBSOLETE62,
-	CURLE_FILESIZE_EXCEEDED,
-	CURLE_USE_SSL_FAILED,
-	CURLE_SEND_FAIL_REWIND,
-	CURLE_SSL_ENGINE_INITFAILED,
-	CURLE_LOGIN_DENIED,
-	CURLE_TFTP_NOTFOUND,
-	CURLE_TFTP_PERM,
-	CURLE_REMOTE_DISK_FULL,
-	CURLE_TFTP_ILLEGAL,
-	CURLE_TFTP_UNKNOWNID,
-	CURLE_REMOTE_FILE_EXISTS,
-	CURLE_TFTP_NOSUCHUSER,
-	CURLE_OBSOLETE75,
-	CURLE_OBSOLETE76,
-	CURLE_SSL_CACERT_BADFILE,
-	CURLE_REMOTE_FILE_NOT_FOUND,
-	CURLE_SSH,
-	CURLE_SSL_SHUTDOWN_FAILED,
-	CURLE_AGAIN,
-	CURLE_SSL_CRL_BADFILE,
-	CURLE_SSL_ISSUER_ERROR,
-	CURLE_FTP_PRET_FAILED,
-	CURLE_RTSP_CSEQ_ERROR,
-	CURLE_RTSP_SESSION_ERROR,
-	CURLE_FTP_BAD_FILE_LIST,
-	CURLE_CHUNK_FAILED,
-	CURLE_NO_CONNECTION_AVAILABLE,
-	CURLE_SSL_PINNEDPUBKEYNOTMATCH,
-	CURLE_SSL_INVALIDCERTSTATUS,
-	CURLE_HTTP2_STREAM,
-	CURLE_RECURSIVE_API_CALL,
-	CURLE_AUTH_ERROR,
-	CURLE_HTTP3,
-	CURLE_QUIC_CONNECT_ERROR,
-	CURLE_PROXY,
-	CURLE_SSL_CLIENTCERT,
-	CURLE_UNRECOVERABLE_POLL,
-	CURL_LAST
-}
-
-alias Curl_conv_callback = fn CURLcode(char* buffer, usz length);
-alias Curl_ssl_ctx_callback = fn CURLcode(Curl* curl, void* ssl_ctx, void* userptr);
-
-enum Proxytype : int
-{
-	CURLPROXY_HTTP,
-	CURLPROXY_HTTP_1_0,
-	CURLPROXY_HTTPS,
-	CURLPROXY_HTTPS2,
-	CURLPROXY_SOCKS4,
-	CURLPROXY_SOCKS5,
-	CURLPROXY_SOCKS4A,
-	CURLPROXY_SOCKS5_HOSTNAME
-}
-
-enum Khtype : int
-{
-	CURLKHTYPE_UNKNOWN,
-	CURLKHTYPE_RSA1,
-	CURLKHTYPE_RSA,
-	CURLKHTYPE_DSS,
-	CURLKHTYPE_ECDSA,
-	CURLKHTYPE_ED25519
-}
-
-struct Khkey
+enum CurlTlsAuthType : int
 {
-	char* key;
+	NONE,
+	SRP,
+	LAST
+}
 
-	usz len;
-	Khtype keytype;
+enum CurlNetrcOption : int
+{
+	IGNORED,
+	OPTIONAL,
+	REQUIRED,
+	LAST
 }
 
-enum Khstat : int
+enum CurlFormAddResult : int
 {
-	CURLKHSTAT_FINE_ADD_TO_FILE,
-	CURLKHSTAT_FINE,
-	CURLKHSTAT_REJECT,
-	CURLKHSTAT_DEFER,
-	CURLKHSTAT_FINE_REPLACE,
-	CURLKHSTAT_LAST
+	OK,
+	MEMORY,
+	OPTION_TWICE,
+	NULL,
+	UNKNOWN_OPTION,
+	INCOMPLETE,
+	ILLEGAL_ARRAY,
+	DISABLED,
+	LAST
 }
 
-enum Khmatch : int
+enum CurlSslSetResult : int
 {
-	CURLKHMATCH_OK,
-	CURLKHMATCH_MISMATCH,
-	CURLKHMATCH_MISSING,
-	CURLKHMATCH_LAST
+	OK,
+	UNKNOWN_BACKEND,
+	TOO_LATE,
+	NO_BACKENDS
 }
 
-alias Curl_sshkeycallback = fn int(Curl* easy, Khkey* knownkey, Khkey* foundkey, Khmatch, void* clientp);
-alias Curl_sshhostkeycallback = fn int(void* clientp, int keytype, char* key, usz keylen);
+enum CurlFormOption : int
+{
+	NOTHING,
+	COPYNAME,
+	PTRNAME,
+	NAMELENGTH,
+	COPYCONTENTS,
+	PTRCONTENTS,
+	CONTENTSLENGTH,
+	FILECONTENT,
+	ARRAY,
+	OBSOLETE,
+	FILE,
+	BUFFER,
+	BUFFERPTR,
+	BUFFERLENGTH,
+	CONTENTTYPE,
+	CONTENTHEADER,
+	FILENAME,
+	END,
+	OBSOLETE2,
+	STREAM,
+	CONTENTLEN,
+	LASTENTRY
+}
 
-enum Usessl : int
+
+constdef CurlInfoType : int
 {
-	CURLUSESSL_NONE,
-	CURLUSESSL_TRY,
-	CURLUSESSL_CONTROL,
-	CURLUSESSL_ALL,
-	CURLUSESSL_LAST
+	NONE = 0,
+	EFFECTIVE_URL = 1048577,
+	RESPONSE_CODE = 2097154,
+	TOTAL_TIME = 3145731,
+	NAMELOOKUP_TIME = 3145732,
+	CONNECT_TIME = 3145733,
+	PRETRANSFER_TIME = 3145734,
+	SIZE_UPLOAD = 3145735,
+	SIZE_UPLOAD_T = 6291463,
+	SIZE_DOWNLOAD = 3145736,
+	SIZE_DOWNLOAD_T = 6291464,
+	SPEED_DOWNLOAD = 3145737,
+	SPEED_DOWNLOAD_T = 6291465,
+	SPEED_UPLOAD = 3145738,
+	SPEED_UPLOAD_T = 6291466,
+	HEADER_SIZE = 2097163,
+	REQUEST_SIZE = 2097164,
+	SSL_VERIFYRESULT = 2097165,
+	FILETIME = 2097166,
+	FILETIME_T = 6291470,
+	CONTENT_LENGTH_DOWNLOAD = 3145743,
+	CONTENT_LENGTH_DOWNLOAD_T = 6291471,
+	CONTENT_LENGTH_UPLOAD = 3145744,
+	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,
+	LASTSOCKET = 2097181,
+	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,
+	TLS_SESSION = 4194347,
+	ACTIVESOCKET = 5242924,
+	TLS_SSL_PTR = 4194349,
+	HTTP_VERSION = 2097198,
+	PROXY_SSL_VERIFYRESULT = 2097199,
+	PROTOCOL = 2097200,
+	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,
+	LASTONE = 62,
 }
 
-enum Ftpccc : int
+enum CurlClosePolicyType : int
 {
-	CURLFTPSSL_CCC_NONE,
-	CURLFTPSSL_CCC_PASSIVE,
-	CURLFTPSSL_CCC_ACTIVE,
-	CURLFTPSSL_CCC_LAST
+	NONE,
+	OLDEST,
+	LEAST_RECENTLY_USED,
+	LEAST_TRAFFIC,
+	SLOWEST,
+	CALLBACK,
+	LAST
 }
 
-enum Ftpauth : int
+enum CurlShResult : int
 {
-	CURLFTPAUTH_DEFAULT,
-	CURLFTPAUTH_SSL,
-	CURLFTPAUTH_TLS,
-	CURLFTPAUTH_LAST
+	OK,
+	BAD_OPTION,
+	IN_USE,
+	INVALID,
+	NOMEM,
+	NOT_BUILT_IN,
+	LAST
 }
 
-enum Ftpcreatedir : int
+enum CurlShOption : int
 {
-	CURLFTP_CREATE_DIR_NONE,
-	CURLFTP_CREATE_DIR,
-	CURLFTP_CREATE_DIR_RETRY,
-	CURLFTP_CREATE_DIR_LAST
+	NONE,
+	SHARE,
+	UNSHARE,
+	LOCKFUNC,
+	UNLOCKFUNC,
+	USERDATA,
+	LAST
 }
 
-enum Ftpmethod : int
+enum CurlLockDataType : int
 {
-	CURLFTPMETHOD_DEFAULT,
-	CURLFTPMETHOD_MULTICWD,
-	CURLFTPMETHOD_NOCWD,
-	CURLFTPMETHOD_SINGLECWD,
-	CURLFTPMETHOD_LAST
+	NONE,
+	SHARE,
+	COOKIE,
+	DNS,
+	SSL_SESSION,
+	CONNECT,
+	PSL,
+	HSTS,
+	LAST
 }
 
-struct Hstsentry
+enum CurlLockAccessType : int
 {
-	char* name;
-	usz namelen;
-	uint includeSubDomains;
-	char[18] expire;
+	NONE,
+	SHARED,
+	SINGLE,
+	LAST
 }
 
-struct Index
+enum CurlVersionType : int
 {
-	usz index;
-	usz total;
+	FIRST,
+	SECOND,
+	THIRD,
+	FOURTH,
+	FIFTH,
+	SIXTH,
+	SEVENTH,
+	EIGHTH,
+	NINTH,
+	TENTH,
+	ELEVENTH,
+	LAST
 }
 
-enum CurlStScode : int
-{
-	CURLSTS_OK,
-	CURLSTS_DONE,
-	CURLSTS_FAIL
-}
-
-alias Curl_hstsread_callback = fn CurlStScode(Curl* easy, Hstsentry* e, void* userp);
-alias Curl_hstswrite_callback = fn CurlStScode(Curl* easy, Hstsentry* e, Index* i, void* userp);
-
-typedef CURLoption = int;
-
-const CURLoption CURLOPT_WRITEDATA = 10001;
-const CURLoption CURLOPT_URL = 10002;
-const CURLoption CURLOPT_PORT = 3;
-const CURLoption CURLOPT_PROXY = 10004;
-const CURLoption CURLOPT_USERPWD = 10005;
-const CURLoption CURLOPT_PROXYUSERPWD = 10006;
-const CURLoption CURLOPT_RANGE = 10007;
-const CURLoption CURLOPT_READDATA = 10009;
-const CURLoption CURLOPT_ERRORBUFFER = 10010;
-const CURLoption CURLOPT_WRITEFUNCTION = 20011;
-const CURLoption CURLOPT_READFUNCTION = 20012;
-const CURLoption CURLOPT_TIMEOUT = 13;
-const CURLoption CURLOPT_INFILESIZE = 14;
-const CURLoption CURLOPT_POSTFIELDS = 10015;
-const CURLoption CURLOPT_REFERER = 10016;
-const CURLoption CURLOPT_FTPPORT = 10017;
-const CURLoption CURLOPT_USERAGENT = 10018;
-const CURLoption CURLOPT_LOW_SPEED_LIMIT = 19;
-const CURLoption CURLOPT_LOW_SPEED_TIME = 20;
-const CURLoption CURLOPT_RESUME_FROM = 21;
-const CURLoption CURLOPT_COOKIE = 10022;
-const CURLoption CURLOPT_HTTPHEADER = 10023;
-const CURLoption CURLOPT_HTTPPOST = 10024;
-const CURLoption CURLOPT_SSLCERT = 10025;
-const CURLoption CURLOPT_KEYPASSWD = 10026;
-const CURLoption CURLOPT_CRLF = 27;
-const CURLoption CURLOPT_QUOTE = 10028;
-const CURLoption CURLOPT_HEADERDATA = 10029;
-const CURLoption CURLOPT_COOKIEFILE = 10031;
-const CURLoption CURLOPT_SSLVERSION = 32;
-const CURLoption CURLOPT_TIMECONDITION = 33;
-const CURLoption CURLOPT_TIMEVALUE = 34;
-const CURLoption CURLOPT_CUSTOMREQUEST = 10036;
-const CURLoption CURLOPT_STDERR = 10037;
-const CURLoption CURLOPT_POSTQUOTE = 10039;
-const CURLoption CURLOPT_OBSOLETE40 = 10040;
-const CURLoption CURLOPT_VERBOSE = 41;
-const CURLoption CURLOPT_HEADER = 42;
-const CURLoption CURLOPT_NOPROGRESS = 43;
-const CURLoption CURLOPT_NOBODY = 44;
-const CURLoption CURLOPT_FAILONERROR = 45;
-const CURLoption CURLOPT_UPLOAD = 46;
-const CURLoption CURLOPT_POST = 47;
-const CURLoption CURLOPT_DIRLISTONLY = 48;
-const CURLoption CURLOPT_APPEND = 50;
-const CURLoption CURLOPT_NETRC = 51;
-const CURLoption CURLOPT_FOLLOWLOCATION = 52;
-const CURLoption CURLOPT_TRANSFERTEXT = 53;
-const CURLoption CURLOPT_PUT = 54;
-const CURLoption CURLOPT_PROGRESSFUNCTION = 20056;
-const CURLoption CURLOPT_XFERINFODATA = 10057;
-const CURLoption CURLOPT_AUTOREFERER = 58;
-const CURLoption CURLOPT_PROXYPORT = 59;
-const CURLoption CURLOPT_POSTFIELDSIZE = 60;
-const CURLoption CURLOPT_HTTPPROXYTUNNEL = 61;
-const CURLoption CURLOPT_INTERFACE = 10062;
-const CURLoption CURLOPT_KRBLEVEL = 10063;
-const CURLoption CURLOPT_SSL_VERIFYPEER = 64;
-const CURLoption CURLOPT_CAINFO = 10065;
-const CURLoption CURLOPT_MAXREDIRS = 68;
-const CURLoption CURLOPT_FILETIME = 69;
-const CURLoption CURLOPT_TELNETOPTIONS = 10070;
-const CURLoption CURLOPT_MAXCONNECTS = 71;
-const CURLoption CURLOPT_OBSOLETE72 = 72;
-const CURLoption CURLOPT_FRESH_CONNECT = 74;
-const CURLoption CURLOPT_FORBID_REUSE = 75;
-const CURLoption CURLOPT_RANDOM_FILE = 10076;
-const CURLoption CURLOPT_EGDSOCKET = 10077;
-const CURLoption CURLOPT_CONNECTTIMEOUT = 78;
-const CURLoption CURLOPT_HEADERFUNCTION = 20079;
-const CURLoption CURLOPT_HTTPGET = 80;
-const CURLoption CURLOPT_SSL_VERIFYHOST = 81;
-const CURLoption CURLOPT_COOKIEJAR = 10082;
-const CURLoption CURLOPT_SSL_CIPHER_LIST = 10083;
-const CURLoption CURLOPT_HTTP_VERSION = 84;
-const CURLoption CURLOPT_FTP_USE_EPSV = 85;
-const CURLoption CURLOPT_SSLCERTTYPE = 10086;
-const CURLoption CURLOPT_SSLKEY = 10087;
-const CURLoption CURLOPT_SSLKEYTYPE = 10088;
-const CURLoption CURLOPT_SSLENGINE = 10089;
-const CURLoption CURLOPT_SSLENGINE_DEFAULT = 90;
-const CURLoption CURLOPT_DNS_USE_GLOBAL_CACHE = 91;
-const CURLoption CURLOPT_DNS_CACHE_TIMEOUT = 92;
-const CURLoption CURLOPT_PREQUOTE = 10093;
-const CURLoption CURLOPT_DEBUGFUNCTION = 20094;
-const CURLoption CURLOPT_DEBUGDATA = 10095;
-const CURLoption CURLOPT_COOKIESESSION = 96;
-const CURLoption CURLOPT_CAPATH = 10097;
-const CURLoption CURLOPT_BUFFERSIZE = 98;
-const CURLoption CURLOPT_NOSIGNAL = 99;
-const CURLoption CURLOPT_SHARE = 10100;
-const CURLoption CURLOPT_PROXYTYPE = 101;
-const CURLoption CURLOPT_ACCEPT_ENCODING = 10102;
-const CURLoption CURLOPT_PRIVATE = 10103;
-const CURLoption CURLOPT_HTTP200ALIASES = 10104;
-const CURLoption CURLOPT_UNRESTRICTED_AUTH = 105;
-const CURLoption CURLOPT_FTP_USE_EPRT = 106;
-const CURLoption CURLOPT_HTTPAUTH = 107;
-const CURLoption CURLOPT_SSL_CTX_FUNCTION = 20108;
-const CURLoption CURLOPT_SSL_CTX_DATA = 10109;
-const CURLoption CURLOPT_FTP_CREATE_MISSING_DIRS = 110;
-const CURLoption CURLOPT_PROXYAUTH = 111;
-const CURLoption CURLOPT_SERVER_RESPONSE_TIMEOUT = 112;
-const CURLoption CURLOPT_IPRESOLVE = 113;
-const CURLoption CURLOPT_MAXFILESIZE = 114;
-const CURLoption CURLOPT_INFILESIZE_LARGE = 30115;
-const CURLoption CURLOPT_RESUME_FROM_LARGE = 30116;
-const CURLoption CURLOPT_MAXFILESIZE_LARGE = 30117;
-const CURLoption CURLOPT_NETRC_FILE = 10118;
-const CURLoption CURLOPT_USE_SSL = 119;
-const CURLoption CURLOPT_POSTFIELDSIZE_LARGE = 30120;
-const CURLoption CURLOPT_TCP_NODELAY = 121;
-const CURLoption CURLOPT_FTPSSLAUTH = 129;
-const CURLoption CURLOPT_IOCTLFUNCTION = 20130;
-const CURLoption CURLOPT_IOCTLDATA = 10131;
-const CURLoption CURLOPT_FTP_ACCOUNT = 10134;
-const CURLoption CURLOPT_COOKIELIST = 10135;
-const CURLoption CURLOPT_IGNORE_CONTENT_LENGTH = 136;
-const CURLoption CURLOPT_FTP_SKIP_PASV_IP = 137;
-const CURLoption CURLOPT_FTP_FILEMETHOD = 138;
-const CURLoption CURLOPT_LOCALPORT = 139;
-const CURLoption CURLOPT_LOCALPORTRANGE = 140;
-const CURLoption CURLOPT_CONNECT_ONLY = 141;
-const CURLoption CURLOPT_CONV_FROM_NETWORK_FUNCTION = 20142;
-const CURLoption CURLOPT_CONV_TO_NETWORK_FUNCTION = 20143;
-const CURLoption CURLOPT_CONV_FROM_UTF8_FUNCTION = 20144;
-const CURLoption CURLOPT_MAX_SEND_SPEED_LARGE = 30145;
-const CURLoption CURLOPT_MAX_RECV_SPEED_LARGE = 30146;
-const CURLoption CURLOPT_FTP_ALTERNATIVE_TO_USER = 10147;
-const CURLoption CURLOPT_SOCKOPTFUNCTION = 20148;
-const CURLoption CURLOPT_SOCKOPTDATA = 10149;
-const CURLoption CURLOPT_SSL_SESSIONID_CACHE = 150;
-const CURLoption CURLOPT_SSH_AUTH_TYPES = 151;
-const CURLoption CURLOPT_SSH_PUBLIC_KEYFILE = 10152;
-const CURLoption CURLOPT_SSH_PRIVATE_KEYFILE = 10153;
-const CURLoption CURLOPT_FTP_SSL_CCC = 154;
-const CURLoption CURLOPT_TIMEOUT_MS = 155;
-const CURLoption CURLOPT_CONNECTTIMEOUT_MS = 156;
-const CURLoption CURLOPT_HTTP_TRANSFER_DECODING = 157;
-const CURLoption CURLOPT_HTTP_CONTENT_DECODING = 158;
-const CURLoption CURLOPT_NEW_FILE_PERMS = 159;
-const CURLoption CURLOPT_NEW_DIRECTORY_PERMS = 160;
-const CURLoption CURLOPT_POSTREDIR = 161;
-const CURLoption CURLOPT_SSH_HOST_PUBLIC_KEY_MD5 = 10162;
-const CURLoption CURLOPT_OPENSOCKETFUNCTION = 20163;
-const CURLoption CURLOPT_OPENSOCKETDATA = 10164;
-const CURLoption CURLOPT_COPYPOSTFIELDS = 10165;
-const CURLoption CURLOPT_PROXY_TRANSFER_MODE = 166;
-const CURLoption CURLOPT_SEEKFUNCTION = 20167;
-const CURLoption CURLOPT_SEEKDATA = 10168;
-const CURLoption CURLOPT_CRLFILE = 10169;
-const CURLoption CURLOPT_ISSUERCERT = 10170;
-const CURLoption CURLOPT_ADDRESS_SCOPE = 171;
-const CURLoption CURLOPT_CERTINFO = 172;
-const CURLoption CURLOPT_USERNAME = 10173;
-const CURLoption CURLOPT_PASSWORD = 10174;
-const CURLoption CURLOPT_PROXYUSERNAME = 10175;
-const CURLoption CURLOPT_PROXYPASSWORD = 10176;
-const CURLoption CURLOPT_NOPROXY = 10177;
-const CURLoption CURLOPT_TFTP_BLKSIZE = 178;
-const CURLoption CURLOPT_SOCKS5_GSSAPI_SERVICE = 10179;
-const CURLoption CURLOPT_SOCKS5_GSSAPI_NEC = 180;
-const CURLoption CURLOPT_PROTOCOLS = 181;
-const CURLoption CURLOPT_REDIR_PROTOCOLS = 182;
-const CURLoption CURLOPT_SSH_KNOWNHOSTS = 10183;
-const CURLoption CURLOPT_SSH_KEYFUNCTION = 20184;
-const CURLoption CURLOPT_SSH_KEYDATA = 10185;
-const CURLoption CURLOPT_MAIL_FROM = 10186;
-const CURLoption CURLOPT_MAIL_RCPT = 10187;
-const CURLoption CURLOPT_FTP_USE_PRET = 188;
-const CURLoption CURLOPT_RTSP_REQUEST = 189;
-const CURLoption CURLOPT_RTSP_SESSION_ID = 10190;
-const CURLoption CURLOPT_RTSP_STREAM_URI = 10191;
-const CURLoption CURLOPT_RTSP_TRANSPORT = 10192;
-const CURLoption CURLOPT_RTSP_CLIENT_CSEQ = 193;
-const CURLoption CURLOPT_RTSP_SERVER_CSEQ = 194;
-const CURLoption CURLOPT_INTERLEAVEDATA = 10195;
-const CURLoption CURLOPT_INTERLEAVEFUNCTION = 20196;
-const CURLoption CURLOPT_WILDCARDMATCH = 197;
-const CURLoption CURLOPT_CHUNK_BGN_FUNCTION = 20198;
-const CURLoption CURLOPT_CHUNK_END_FUNCTION = 20199;
-const CURLoption CURLOPT_FNMATCH_FUNCTION = 20200;
-const CURLoption CURLOPT_CHUNK_DATA = 10201;
-const CURLoption CURLOPT_FNMATCH_DATA = 10202;
-const CURLoption CURLOPT_RESOLVE = 10203;
-const CURLoption CURLOPT_TLSAUTH_USERNAME = 10204;
-const CURLoption CURLOPT_TLSAUTH_PASSWORD = 10205;
-const CURLoption CURLOPT_TLSAUTH_TYPE = 10206;
-const CURLoption CURLOPT_TRANSFER_ENCODING = 207;
-const CURLoption CURLOPT_CLOSESOCKETFUNCTION = 20208;
-const CURLoption CURLOPT_CLOSESOCKETDATA = 10209;
-const CURLoption CURLOPT_GSSAPI_DELEGATION = 210;
-const CURLoption CURLOPT_DNS_SERVERS = 10211;
-const CURLoption CURLOPT_ACCEPTTIMEOUT_MS = 212;
-const CURLoption CURLOPT_TCP_KEEPALIVE = 213;
-const CURLoption CURLOPT_TCP_KEEPIDLE = 214;
-const CURLoption CURLOPT_TCP_KEEPINTVL = 215;
-const CURLoption CURLOPT_SSL_OPTIONS = 216;
-const CURLoption CURLOPT_MAIL_AUTH = 10217;
-const CURLoption CURLOPT_SASL_IR = 218;
-const CURLoption CURLOPT_XFERINFOFUNCTION = 20219;
-const CURLoption CURLOPT_XOAUTH2_BEARER = 10220;
-const CURLoption CURLOPT_DNS_INTERFACE = 10221;
-const CURLoption CURLOPT_DNS_LOCAL_IP4 = 10222;
-const CURLoption CURLOPT_DNS_LOCAL_IP6 = 10223;
-const CURLoption CURLOPT_LOGIN_OPTIONS = 10224;
-const CURLoption CURLOPT_SSL_ENABLE_NPN = 225;
-const CURLoption CURLOPT_SSL_ENABLE_ALPN = 226;
-const CURLoption CURLOPT_EXPECT_100_TIMEOUT_MS = 227;
-const CURLoption CURLOPT_PROXYHEADER = 10228;
-const CURLoption CURLOPT_HEADEROPT = 229;
-const CURLoption CURLOPT_PINNEDPUBLICKEY = 10230;
-const CURLoption CURLOPT_UNIX_SOCKET_PATH = 10231;
-const CURLoption CURLOPT_SSL_VERIFYSTATUS = 232;
-const CURLoption CURLOPT_SSL_FALSESTART = 233;
-const CURLoption CURLOPT_PATH_AS_IS = 234;
-const CURLoption CURLOPT_PROXY_SERVICE_NAME = 10235;
-const CURLoption CURLOPT_SERVICE_NAME = 10236;
-const CURLoption CURLOPT_PIPEWAIT = 237;
-const CURLoption CURLOPT_DEFAULT_PROTOCOL = 10238;
-const CURLoption CURLOPT_STREAM_WEIGHT = 239;
-const CURLoption CURLOPT_STREAM_DEPENDS = 10240;
-const CURLoption CURLOPT_STREAM_DEPENDS_E = 10241;
-const CURLoption CURLOPT_TFTP_NO_OPTIONS = 242;
-const CURLoption CURLOPT_CONNECT_TO = 10243;
-const CURLoption CURLOPT_TCP_FASTOPEN = 244;
-const CURLoption CURLOPT_KEEP_SENDING_ON_ERROR = 245;
-const CURLoption CURLOPT_PROXY_CAINFO = 10246;
-const CURLoption CURLOPT_PROXY_CAPATH = 10247;
-const CURLoption CURLOPT_PROXY_SSL_VERIFYPEER = 248;
-const CURLoption CURLOPT_PROXY_SSL_VERIFYHOST = 249;
-const CURLoption CURLOPT_PROXY_SSLVERSION = 250;
-const CURLoption CURLOPT_PROXY_TLSAUTH_USERNAME = 10251;
-const CURLoption CURLOPT_PROXY_TLSAUTH_PASSWORD = 10252;
-const CURLoption CURLOPT_PROXY_TLSAUTH_TYPE = 10253;
-const CURLoption CURLOPT_PROXY_SSLCERT = 10254;
-const CURLoption CURLOPT_PROXY_SSLCERTTYPE = 10255;
-const CURLoption CURLOPT_PROXY_SSLKEY = 10256;
-const CURLoption CURLOPT_PROXY_SSLKEYTYPE = 10257;
-const CURLoption CURLOPT_PROXY_KEYPASSWD = 10258;
-const CURLoption CURLOPT_PROXY_SSL_CIPHER_LIST = 10259;
-const CURLoption CURLOPT_PROXY_CRLFILE = 10260;
-const CURLoption CURLOPT_PROXY_SSL_OPTIONS = 261;
-const CURLoption CURLOPT_PRE_PROXY = 10262;
-const CURLoption CURLOPT_PROXY_PINNEDPUBLICKEY = 10263;
-const CURLoption CURLOPT_ABSTRACT_UNIX_SOCKET = 10264;
-const CURLoption CURLOPT_SUPPRESS_CONNECT_HEADERS = 265;
-const CURLoption CURLOPT_REQUEST_TARGET = 10266;
-const CURLoption CURLOPT_SOCKS5_AUTH = 267;
-const CURLoption CURLOPT_SSH_COMPRESSION = 268;
-const CURLoption CURLOPT_MIMEPOST = 10269;
-const CURLoption CURLOPT_TIMEVALUE_LARGE = 30270;
-const CURLoption CURLOPT_HAPPY_EYEBALLS_TIMEOUT_MS = 271;
-const CURLoption CURLOPT_RESOLVER_START_FUNCTION = 20272;
-const CURLoption CURLOPT_RESOLVER_START_DATA = 10273;
-const CURLoption CURLOPT_HAPROXYPROTOCOL = 274;
-const CURLoption CURLOPT_DNS_SHUFFLE_ADDRESSES = 275;
-const CURLoption CURLOPT_TLS13_CIPHERS = 10276;
-const CURLoption CURLOPT_PROXY_TLS13_CIPHERS = 10277;
-const CURLoption CURLOPT_DISALLOW_USERNAME_IN_URL = 278;
-const CURLoption CURLOPT_DOH_URL = 10279;
-const CURLoption CURLOPT_UPLOAD_BUFFERSIZE = 280;
-const CURLoption CURLOPT_UPKEEP_INTERVAL_MS = 281;
-const CURLoption CURLOPT_CURLU = 10282;
-const CURLoption CURLOPT_TRAILERFUNCTION = 20283;
-const CURLoption CURLOPT_TRAILERDATA = 10284;
-const CURLoption CURLOPT_HTTP09_ALLOWED = 285;
-const CURLoption CURLOPT_ALTSVC_CTRL = 286;
-const CURLoption CURLOPT_ALTSVC = 10287;
-const CURLoption CURLOPT_MAXAGE_CONN = 288;
-const CURLoption CURLOPT_SASL_AUTHZID = 10289;
-const CURLoption CURLOPT_MAIL_RCPT_ALLLOWFAILS = 290;
-const CURLoption CURLOPT_SSLCERT_BLOB = 40291;
-const CURLoption CURLOPT_SSLKEY_BLOB = 40292;
-const CURLoption CURLOPT_PROXY_SSLCERT_BLOB = 40293;
-const CURLoption CURLOPT_PROXY_SSLKEY_BLOB = 40294;
-const CURLoption CURLOPT_ISSUERCERT_BLOB = 40295;
-const CURLoption CURLOPT_PROXY_ISSUERCERT = 10296;
-const CURLoption CURLOPT_PROXY_ISSUERCERT_BLOB = 40297;
-const CURLoption CURLOPT_SSL_EC_CURVES = 10298;
-const CURLoption CURLOPT_HSTS_CTRL = 299;
-const CURLoption CURLOPT_HSTS = 10300;
-const CURLoption CURLOPT_HSTSREADFUNCTION = 20301;
-const CURLoption CURLOPT_HSTSREADDATA = 10302;
-const CURLoption CURLOPT_HSTSWRITEFUNCTION = 20303;
-const CURLoption CURLOPT_HSTSWRITEDATA = 10304;
-const CURLoption CURLOPT_AWS_SIGV4 = 10305;
-const CURLoption CURLOPT_DOH_SSL_VERIFYPEER = 306;
-const CURLoption CURLOPT_DOH_SSL_VERIFYHOST = 307;
-const CURLoption CURLOPT_DOH_SSL_VERIFYSTATUS = 308;
-const CURLoption CURLOPT_CAINFO_BLOB = 40309;
-const CURLoption CURLOPT_PROXY_CAINFO_BLOB = 40310;
-const CURLoption CURLOPT_SSH_HOST_PUBLIC_KEY_SHA256 = 10311;
-const CURLoption CURLOPT_PREREQFUNCTION = 20312;
-const CURLoption CURLOPT_PREREQDATA = 10313;
-const CURLoption CURLOPT_MAXLIFETIME_CONN = 314;
-const CURLoption CURLOPT_MIME_OPTIONS = 315;
-const CURLoption CURLOPT_SSH_HOSTKEYFUNCTION = 20316;
-const CURLoption CURLOPT_SSH_HOSTKEYDATA = 10317;
-const CURLoption CURLOPT_PROTOCOLS_STR = 10318;
-const CURLoption CURLOPT_REDIR_PROTOCOLS_STR = 10319;
-const CURLoption CURLOPT_WS_OPTIONS = 320;
-const CURLoption CURLOPT_CA_CACHE_TIMEOUT = 321;
-const CURLoption CURLOPT_QUICK_EXIT = 322;
-const CURLoption CURLOPT_LASTENTRY = 323;
+enum CurlMResult : int
+{
+	CALL_MULTI_PERFORM,
+	OK,
+	BAD_HANDLE,
+	BAD_EASY_HANDLE,
+	OUT_OF_MEMORY,
+	INTERNAL_ERROR,
+	BAD_SOCKET,
+	UNKNOWN_OPTION,
+	ADDED_ALREADY,
+	RECURSIVE_API_CALL,
+	WAKEUP_FAILURE,
+	ARGUMENT,
+	ABORTED_BY_CALLBACK,
+	UNRECOVERABLE_POLL,
+	LAST
+}
+enum CurlMsgType : int
+{
+	NONE,
+	DONE,
+	LAST
+}
+
+constdef CurlMOption : int
+{
+	SOCKETFUNCTION = 20001,
+	SOCKETDATA = 10002,
+	PIPELINING = 3,
+	TIMERFUNCTION = 20004,
+	TIMERDATA = 10005,
+	MAXCONNECTS = 6,
+	MAX_HOST_CONNECTIONS = 7,
+	MAX_PIPELINE_LENGTH = 8,
+	CONTENT_LENGTH_PENALTY_SIZE = 30009,
+	CHUNK_LENGTH_PENALTY_SIZE = 30010,
+	PIPELINING_SITE_BL = 10011,
+	PIPELINING_SERVER_BL = 10012,
+	MAX_TOTAL_CONNECTIONS = 13,
+	PUSHFUNCTION = 2001,
+	PUSHDATA = 10015,
+	MAX_CONCURRENT_STREAMS = 16,
+	LASTENTRY = 17,
+}
+
+enum CurlUResult : int
+{
+	OK,
+	BAD_HANDLE,
+	BAD_PARTPOINTER,
+	MALFORMED_INPUT,
+	BAD_PORT_NUMBER,
+	UNSUPPORTED_SCHEME,
+	URLDECODE,
+	OUT_OF_MEMORY,
+	USER_NOT_ALLOWED,
+	UNKNOWN_PART,
+	NO_SCHEME,
+	NO_USER,
+	NO_PASSWORD,
+	NO_OPTIONS,
+	NO_HOST,
+	NO_PORT,
+	NO_QUERY,
+	NO_FRAGMENT,
+	NO_ZONEID,
+	BAD_FILE_URL,
+	BAD_FRAGMENT,
+	BAD_HOSTNAME,
+	BAD_IPV6,
+	BAD_LOGIN,
+	BAD_PASSWORD,
+	BAD_PATH,
+	BAD_QUERY,
+	BAD_SCHEME,
+	BAD_SLASHES,
+	BAD_USER,
+	LACKS_IDN,
+	LAST
+}
+
+enum CurlEasyType : int
+{
+	LONG,
+	VALUES,
+	OFF_T,
+	OBJECT,
+	STRING,
+	SLIST,
+	CBPTR,
+	BLOB,
+	FUNCTION
+}
+
+enum CurlUPartType : int
+{
+	URL,
+	SCHEME,
+	USER,
+	PASSWORD,
+	OPTIONS,
+	HOST,
+	PORT,
+	PATH,
+	QUERY,
+	FRAGMENT,
+	ZONEID
+}
+
+enum CurlHResult : int
+{
+	OK,
+	BADINDEX,
+	MISSING,
+	NOHEADERS,
+	NOREQUEST,
+	OUT_OF_MEMORY,
+	BAD_ARGUMENT,
+	NOT_BUILT_IN
+}
+
+enum CurlMimeKind : int
+{
+	NONE,
+	DATA,
+	FILE,
+	CALLBACK,
+	MULTIPART,
+	LAST
+}
+
+enum CurlMimeStateType : int
+{
+	BEGIN,
+	CURLHEADERS,
+	USERHEADERS,
+	EOH,
+	BODY,
+	BOUNDARY1,
+	BOUNDARY2,
+	CONTENT,
+	END,
+	LAST
+}
 
 const int CURL_HTTP_VERSION_NONE = 0;
 const int CURL_HTTP_VERSION_1_0 = 1;
@@ -738,14 +966,6 @@ const int CURL_RTSPREQ_RECORD = 10;
 const int CURL_RTSPREQ_RECEIVE = 11;
 const int CURL_RTSPREQ_LAST = 12;
 
-enum Curl_Netrc_Option : int
-{
-	CURL_NETRC_IGNORED,
-	CURL_NETRC_OPTIONAL,
-	CURL_NETRC_REQUIRED,
-	CURL_NETRC_LAST
-}
-
 const int CURL_SSLVERSION_DEFAULT = 0;
 const int CURL_SSLVERSION_TLSV1 = 1;
 const int CURL_SSLVERSION_SSLV2 = 2;
@@ -763,248 +983,178 @@ const int CURL_SSLVERSION_MAX_TLSV1_2 = 393216;
 const int CURL_SSLVERSION_MAX_TLSV1_3 = 458752;
 const int CURL_SSLVERSION_MAX_LAST = 524288;
 
-enum TLSAuth : int
+const MIME_BOUNDARY_DASHES = 24;
+const MIME_RAND_BOUNDARY_CHARS = 16;
+const MIME_BOUNDARY_LEN = (MIME_BOUNDARY_DASHES + MIME_RAND_BOUNDARY_CHARS);
+const ENCODING_BUFFER_SIZE = 256;
+
+alias Curl_formget_callback = fn usz(void* arg, char* buf, usz len);
+alias CurlProgressCallback = fn int(void* clientp, double dltotal, double dlnow, double ultotal, double ulnow);
+alias CurlXferinfoCallback = fn int(void* clientp, CurlOff dltotal, CurlOff dlnow, CurlOff ultotal, CurlOff ulnow);
+alias CurlWriteCallback = fn usz(char* buffer, usz size, usz nitems, void* outstream);
+alias CurlResolverStartCallback = fn int(void* resolver_state, void* reserved, void* userdata);
+alias CurlChunkBgnCallback = fn long(void* transfer_info,void* ptr, int remains);
+alias CurlChunkEndCallback = fn long(void* ptr);
+alias CurlFnMatchCallback = fn int(void* ptr, char* pattern, char* string);
+alias CurlSeekCallback = fn int(void* instream, CurlOff offset, int origin);
+alias CurlReadCallback = fn usz(char* buffer, usz size, usz nitems, void* instream);
+alias CurlTrailerCallback = fn int(CurlSlist** list, void* userdata);
+alias CurlSockoptCallback = fn int(void* clientp, CurlSocket curlfd, CurlSockType purpose);
+alias CurlOpenSocketCallback = fn CurlSocket(void* clientp, CurlSockType purpose, CurlSockaddr* address);
+alias CurlCloseSocketCallback = fn int(void* clientp, CurlSocket item);
+alias CurlMallocCallback = fn void*(usz size);
+alias CurlFreeCallback = fn void(void* ptr);
+alias CurlReallocCallback = fn void*(void* ptr, usz size);
+alias CurlStrdupCallback = fn char*(char* str);
+alias CurlCallocCallback = fn void*(usz nmemb, usz size);
+alias CurlIoctlCallback = fn CurlIoResult(Curl* handle, int cmd, void* clientp);
+alias CurlDebugCallback = fn int(Curl* handle, CurlDebugInfoType type, char* data, usz size, void* userptr);
+alias CurlPrereqCallback = fn int(void* clientp, char* conn_primary_ip, char* conn_local_ip, int conn_primary_port, int conn_local_port);
+alias CurlConvCallback = fn CurlResult(char* buffer, usz length);
+alias CurlSslCtxCallback = fn CurlResult(Curl* curl, void* ssl_ctx, void* userptr);
+alias CurlSshKeyCallback = fn int(Curl* easy, CurlKhKey* knownkey, CurlKhKey* foundkey, CurlKhMatchType, void* clientp);
+alias CurlSshHostKeyCallback = fn int(void* clientp, int keytype, char* key, usz keylen);
+alias CurlHstsReadCallback = fn CurlStsResult(Curl* easy, CurlHstsEntry* e, void* userp);
+alias CurlHstsWriteCallback = fn CurlStsResult(Curl* easy, CurlHstsEntry* e, CurlIndex* i, void* userp);
+alias CurlLockFunction = fn void(Curl* handle, CurlLockDataType data, CurlLockAccessType locktype, void* userptr);
+alias CurlUnlockFunction = fn void(Curl* handle, CurlLockDataType data, void* userptr);
+alias CurlSocketCallback = fn int(Curl* easy, CurlSocket s, int what, void* userp, void* socketp);
+alias CurlMultiTimerCallback = fn int(CurlM* multi, long timeout_ms, void* userp);
+alias CurlEncodeFunc = fn usz(char* buffer, usz size, bool ateof, CurlMimePart* part);
+alias CurlSizeFunc = fn CurlOff(CurlMimePart* part);
+
+alias Curl = void;
+alias CurlSH = void;
+
+struct CurlFdSet
 {
-	CURL_TLSAUTH_NONE,
-	CURL_TLSAUTH_SRP,
-	CURL_TLSAUTH_LAST
+	long[16] __fds_bits;
 }
 
-enum TimeCond : int
+struct _CurlSockaddr
 {
-	CURL_TIMECOND_NONE,
-	CURL_TIMECOND_IFMODSINCE,
-	CURL_TIMECOND_IFUNMODSINCE,
-	CURL_TIMECOND_LASTMOD,
-	CURL_TIMECOND_LAST
+	ushort sa_family;
+	char[14] sa_data;
 }
 
-// alias Mime = struct Mime;
-// alias Mimepart = struct Mimepart;
+alias CurlSocklen = uint;
+alias CurlOff = long;
+alias CurlSocket = int;
 
-enum Formoption : int
+struct CurlSlist
 {
-	CURLFORM_NOTHING,
-	CURLFORM_COPYNAME,
-	CURLFORM_PTRNAME,
-	CURLFORM_NAMELENGTH,
-	CURLFORM_COPYCONTENTS,
-	CURLFORM_PTRCONTENTS,
-	CURLFORM_CONTENTSLENGTH,
-	CURLFORM_FILECONTENT,
-	CURLFORM_ARRAY,
-	CURLFORM_OBSOLETE,
-	CURLFORM_FILE,
-	CURLFORM_BUFFER,
-	CURLFORM_BUFFERPTR,
-	CURLFORM_BUFFERLENGTH,
-	CURLFORM_CONTENTTYPE,
-	CURLFORM_CONTENTHEADER,
-	CURLFORM_FILENAME,
-	CURLFORM_END,
-	CURLFORM_OBSOLETE2,
-	CURLFORM_STREAM,
-	CURLFORM_CONTENTLEN,
-	CURLFORM_LASTENTRY
+	char* data;
+	CurlSlist* next;
 }
 
-struct Forms
+struct CurlHttpPost
 {
-	Formoption option;
-	char* value;
+	CurlHttpPost* next;
+	char* name;
+	long namelength;
+	char* contents;
+	long contentslength;
+
+	char* buffer;
+	long bufferlength;
+	char* contenttype;
+	CurlSlist* contentheader;
+	CurlHttpPost* more;
+	CurlHttpPostFlag flags;
+	char* showfilename;
+	void* userp;
+	CurlOff contentlen;
 }
 
-enum CurlFormCode : int
+struct CurlFileInfo
 {
-	CURL_FORMADD_OK,
-	CURL_FORMADD_MEMORY,
-	CURL_FORMADD_OPTION_TWICE,
-	CURL_FORMADD_NULL,
-	CURL_FORMADD_UNKNOWN_OPTION,
-	CURL_FORMADD_INCOMPLETE,
-	CURL_FORMADD_ILLEGAL_ARRAY,
-	CURL_FORMADD_DISABLED,
-	CURL_FORMADD_LAST
+	ZString filename;
+	CurlFileType filetype;
+	Time_t time;
+	uint perm;
+	int uid;
+	int gid;
+	CurlOff size;
+	long hardlinks;
+
+	struct strings
+	{
+		ZString time;
+		ZString perm;
+		ZString user;
+		ZString group;
+		ZString target;
+	}
+
+	uint flags;
+
+	char* b_data;
+	usz b_size;
+	usz b_used;
 }
 
-alias Curl_formget_callback = fn usz(void* arg, char* buf, usz len);
+struct CurlSockaddr
+{
+	int family;
+	int socktype;
+	int protocol;
+	uint addrlen;
 
-struct Ssl_backend
+	_CurlSockaddr addr;
+}
+
+struct CurlKhKey
+{
+	char* key;
+	usz len;
+	CurlKhType keytype;
+}
+
+struct CurlHstsEntry
 {
-	Sslbackend id;
 	char* name;
+	usz namelen;
+	uint include_sub_domains;
+	char[18] expire;
 }
 
-enum CurlSslset : int
+struct CurlIndex
 {
-	CURLSSLSET_OK,
-	CURLSSLSET_UNKNOWN_BACKEND,
-	CURLSSLSET_TOO_LATE,
-	CURLSSLSET_NO_BACKENDS
+	usz index;
+	usz total;
 }
 
-struct Certinfo
+// alias CurlMime = struct CurlMime;
+// alias CurlMimePart = struct CurlMimePart;
+
+struct CurlForms
+{
+	CurlFormOption option;
+	ZString value;
+}
+
+struct CurlSslBackend
+{
+	CurlSslBackendType id;
+	ZString name;
+}
+
+
+struct CurlCertinfo
 {
 	int num_of_certs;
-	Slist* *certinfo;
+	CurlSlist* *certinfo;
 }
 
-struct Tlssessioninfo
+struct CurlTlsSessionInfo
 {
-	Sslbackend backend;
+	CurlSslBackendType backend;
 	void* internals;
 }
 
-typedef CURLInfo = int;
-
-const CURLInfo CURLINFO_NONE = 0;
-const CURLInfo CURLINFO_EFFECTIVE_URL = 1048577;
-const CURLInfo CURLINFO_RESPONSE_CODE = 2097154;
-const CURLInfo CURLINFO_TOTAL_TIME = 3145731;
-const CURLInfo CURLINFO_NAMELOOKUP_TIME = 3145732;
-const CURLInfo CURLINFO_CONNECT_TIME = 3145733;
-const CURLInfo CURLINFO_PRETRANSFER_TIME = 3145734;
-const CURLInfo CURLINFO_SIZE_UPLOAD = 3145735;
-const CURLInfo CURLINFO_SIZE_UPLOAD_T = 6291463;
-const CURLInfo CURLINFO_SIZE_DOWNLOAD = 3145736;
-const CURLInfo CURLINFO_SIZE_DOWNLOAD_T = 6291464;
-const CURLInfo CURLINFO_SPEED_DOWNLOAD = 3145737;
-const CURLInfo CURLINFO_SPEED_DOWNLOAD_T = 6291465;
-const CURLInfo CURLINFO_SPEED_UPLOAD = 3145738;
-const CURLInfo CURLINFO_SPEED_UPLOAD_T = 6291466;
-const CURLInfo CURLINFO_HEADER_SIZE = 2097163;
-const CURLInfo CURLINFO_REQUEST_SIZE = 2097164;
-const CURLInfo CURLINFO_SSL_VERIFYRESULT = 2097165;
-const CURLInfo CURLINFO_FILETIME = 2097166;
-const CURLInfo CURLINFO_FILETIME_T = 6291470;
-const CURLInfo CURLINFO_CONTENT_LENGTH_DOWNLOAD = 3145743;
-const CURLInfo CURLINFO_CONTENT_LENGTH_DOWNLOAD_T = 6291471;
-const CURLInfo CURLINFO_CONTENT_LENGTH_UPLOAD = 3145744;
-const CURLInfo CURLINFO_CONTENT_LENGTH_UPLOAD_T = 6291472;
-const CURLInfo CURLINFO_STARTTRANSFER_TIME = 3145745;
-const CURLInfo CURLINFO_CONTENT_TYPE = 1048594;
-const CURLInfo CURLINFO_REDIRECT_TIME = 3145747;
-const CURLInfo CURLINFO_REDIRECT_COUNT = 2097172;
-const CURLInfo CURLINFO_PRIVATE = 1048597;
-const CURLInfo CURLINFO_HTTP_CONNECTCODE = 2097174;
-const CURLInfo CURLINFO_HTTPAUTH_AVAIL = 2097175;
-const CURLInfo CURLINFO_PROXYAUTH_AVAIL = 2097176;
-const CURLInfo CURLINFO_OS_ERRNO = 2097177;
-const CURLInfo CURLINFO_NUM_CONNECTS = 2097178;
-const CURLInfo CURLINFO_SSL_ENGINES = 4194331;
-const CURLInfo CURLINFO_COOKIELIST = 4194332;
-const CURLInfo CURLINFO_LASTSOCKET = 2097181;
-const CURLInfo CURLINFO_FTP_ENTRY_PATH = 1048606;
-const CURLInfo CURLINFO_REDIRECT_URL = 1048607;
-const CURLInfo CURLINFO_PRIMARY_IP = 1048608;
-const CURLInfo CURLINFO_APPCONNECT_TIME = 3145761;
-const CURLInfo CURLINFO_CERTINFO = 4194338;
-const CURLInfo CURLINFO_CONDITION_UNMET = 2097187;
-const CURLInfo CURLINFO_RTSP_SESSION_ID = 1048612;
-const CURLInfo CURLINFO_RTSP_CLIENT_CSEQ = 2097189;
-const CURLInfo CURLINFO_RTSP_SERVER_CSEQ = 2097190;
-const CURLInfo CURLINFO_RTSP_CSEQ_RECV = 2097191;
-const CURLInfo CURLINFO_PRIMARY_PORT = 2097192;
-const CURLInfo CURLINFO_LOCAL_IP = 1048617;
-const CURLInfo CURLINFO_LOCAL_PORT = 2097194;
-const CURLInfo CURLINFO_TLS_SESSION = 4194347;
-const CURLInfo CURLINFO_ACTIVESOCKET = 5242924;
-const CURLInfo CURLINFO_TLS_SSL_PTR = 4194349;
-const CURLInfo CURLINFO_HTTP_VERSION = 2097198;
-const CURLInfo CURLINFO_PROXY_SSL_VERIFYRESULT = 2097199;
-const CURLInfo CURLINFO_PROTOCOL = 2097200;
-const CURLInfo CURLINFO_SCHEME = 1048625;
-const CURLInfo CURLINFO_TOTAL_TIME_T = 6291506;
-const CURLInfo CURLINFO_NAMELOOKUP_TIME_T = 6291507;
-const CURLInfo CURLINFO_CONNECT_TIME_T = 6291508;
-const CURLInfo CURLINFO_PRETRANSFER_TIME_T = 6291509;
-const CURLInfo CURLINFO_STARTTRANSFER_TIME_T = 6291510;
-const CURLInfo CURLINFO_REDIRECT_TIME_T = 6291511;
-const CURLInfo CURLINFO_APPCONNECT_TIME_T = 6291512;
-const CURLInfo CURLINFO_RETRY_AFTER = 6291513;
-const CURLInfo CURLINFO_EFFECTIVE_METHOD = 1048634;
-const CURLInfo CURLINFO_PROXY_ERROR = 2097211;
-const CURLInfo CURLINFO_REFERER = 1048636;
-const CURLInfo CURLINFO_CAINFO = 1048637;
-const CURLInfo CURLINFO_CAPATH = 1048638;
-const CURLInfo CURLINFO_LASTONE = 62;
-
-enum Closepolicy : int
-{
-	CURLCLOSEPOLICY_NONE,
-	CURLCLOSEPOLICY_OLDEST,
-	CURLCLOSEPOLICY_LEAST_RECENTLY_USED,
-	CURLCLOSEPOLICY_LEAST_TRAFFIC,
-	CURLCLOSEPOLICY_SLOWEST,
-	CURLCLOSEPOLICY_CALLBACK,
-	CURLCLOSEPOLICY_LAST
-}
-
-enum Lock_data : int
-{
-	CURL_LOCK_DATA_NONE,
-	CURL_LOCK_DATA_SHARE,
-	CURL_LOCK_DATA_COOKIE,
-	CURL_LOCK_DATA_DNS,
-	CURL_LOCK_DATA_SSL_SESSION,
-	CURL_LOCK_DATA_CONNECT,
-	CURL_LOCK_DATA_PSL,
-	CURL_LOCK_DATA_HSTS,
-	CURL_LOCK_DATA_LAST
-}
-
-enum Lock_access : int
-{
-	CURL_LOCK_ACCESS_NONE,
-	CURL_LOCK_ACCESS_SHARED,
-	CURL_LOCK_ACCESS_SINGLE,
-	CURL_LOCK_ACCESS_LAST
-}
-
-alias Curl_lock_function = fn void(Curl* handle, Lock_data data, Lock_access locktype, void* userptr);
-alias Curl_unlock_function = fn void(Curl* handle, Lock_data data, void* userptr);
-
-enum CURLSHcode : int
-{
-	CURLSHE_OK,
-	CURLSHE_BAD_OPTION,
-	CURLSHE_IN_USE,
-	CURLSHE_INVALID,
-	CURLSHE_NOMEM,
-	CURLSHE_NOT_BUILT_IN,
-	CURLSHE_LAST
-}
-
-enum CURLSHoption : int
-{
-	CURLSHOPT_NONE,
-	CURLSHOPT_SHARE,
-	CURLSHOPT_UNSHARE,
-	CURLSHOPT_LOCKFUNC,
-	CURLSHOPT_UNLOCKFUNC,
-	CURLSHOPT_USERDATA,
-	CURLSHOPT_LAST
-}
-
-enum CURLversion : int
-{
-	CURLVERSION_FIRST,
-	CURLVERSION_SECOND,
-	CURLVERSION_THIRD,
-	CURLVERSION_FOURTH,
-	CURLVERSION_FIFTH,
-	CURLVERSION_SIXTH,
-	CURLVERSION_SEVENTH,
-	CURLVERSION_EIGHTH,
-	CURLVERSION_NINTH,
-	CURLVERSION_TENTH,
-	CURLVERSION_ELEVENTH,
-	CURLVERSION_LAST
-}
-
-struct Version_info_data
-{
-	CURLversion age;
+struct CurlVersionInfoData
+{
+	CurlVersionType age;
 	char* version;
 	uint version_num;
 	char* host;
@@ -1032,247 +1182,95 @@ struct Version_info_data
 	char* feature_names;
 }
 
-struct Blob
+struct CurlBlob
 {
 	void* data;
 	usz len;
 	int flags;
 }
 
-
-enum CURLMcode : int
+struct CurlMsg
 {
-	CURLM_CALL_MULTI_PERFORM,
-	CURLM_OK,
-	CURLM_BAD_HANDLE,
-	CURLM_BAD_EASY_HANDLE,
-	CURLM_OUT_OF_MEMORY,
-	CURLM_INTERNAL_ERROR,
-	CURLM_BAD_SOCKET,
-	CURLM_UNKNOWN_OPTION,
-	CURLM_ADDED_ALREADY,
-	CURLM_RECURSIVE_API_CALL,
-	CURLM_WAKEUP_FAILURE,
-	CURLM_ARGUMENT,
-	CURLM_ABORTED_BY_CALLBACK,
-	CURLM_UNRECOVERABLE_POLL,
-	CURLM_LAST
-}
-enum CURLMsgEnum : int
-{
-	CURLMSG_NONE,
-	CURLMSG_DONE,
-	CURLMSG_LAST
-}
-
-struct CURLMsg
-{
-	CURLMsgEnum msg;
+	CurlMsgType msg;
 	void* easy_handle;
 	union data
 	{
 		void* whatever;
-		CURLcode result;
+		CurlResult result;
 	}
 }
 
-struct Waitfd
+struct CurlWaitFd
 {
-	Socket_t fd;
+	CurlSocket fd;
 	short events;
 	short revents;
 }
 
 alias CurlM = void;
 
-alias Curl_socket_callback = fn int(Curl* easy, Socket_t s, int what, void* userp, void* socketp);
-alias Curl_multi_timer_callback = fn int(CurlM* multi, long timeout_ms, void* userp);
-
-typedef CURLMoption = int;
-
-const CURLMoption CURLMOPT_SOCKETFUNCTION = 20001;
-const CURLMoption CURLMOPT_SOCKETDATA = 10002;
-const CURLMoption CURLMOPT_PIPELINING = 3;
-const CURLMoption CURLMOPT_TIMERFUNCTION = 20004;
-const CURLMoption CURLMOPT_TIMERDATA = 10005;
-const CURLMoption CURLMOPT_MAXCONNECTS = 6;
-const CURLMoption CURLMOPT_MAX_HOST_CONNECTIONS = 7;
-const CURLMoption CURLMOPT_MAX_PIPELINE_LENGTH = 8;
-const CURLMoption CURLMOPT_CONTENT_LENGTH_PENALTY_SIZE = 30009;
-const CURLMoption CURLMOPT_CHUNK_LENGTH_PENALTY_SIZE = 30010;
-const CURLMoption CURLMOPT_PIPELINING_SITE_BL = 10011;
-const CURLMoption CURLMOPT_PIPELINING_SERVER_BL = 10012;
-const CURLMoption CURLMOPT_MAX_TOTAL_CONNECTIONS = 13;
-const CURLMoption CURLMOPT_PUSHFUNCTION = 2001;
-const CURLMoption CURLMOPT_PUSHDATA = 10015;
-const CURLMoption CURLMOPT_MAX_CONCURRENT_STREAMS = 16;
-const CURLMoption CURLMOPT_LASTENTRY = 17;
-
-enum CURLUcode : int
-{
-	CURLUE_OK,
-	CURLUE_BAD_HANDLE,
-	CURLUE_BAD_PARTPOINTER,
-	CURLUE_MALFORMED_INPUT,
-	CURLUE_BAD_PORT_NUMBER,
-	CURLUE_UNSUPPORTED_SCHEME,
-	CURLUE_URLDECODE,
-	CURLUE_OUT_OF_MEMORY,
-	CURLUE_USER_NOT_ALLOWED,
-	CURLUE_UNKNOWN_PART,
-	CURLUE_NO_SCHEME,
-	CURLUE_NO_USER,
-	CURLUE_NO_PASSWORD,
-	CURLUE_NO_OPTIONS,
-	CURLUE_NO_HOST,
-	CURLUE_NO_PORT,
-	CURLUE_NO_QUERY,
-	CURLUE_NO_FRAGMENT,
-	CURLUE_NO_ZONEID,
-	CURLUE_BAD_FILE_URL,
-	CURLUE_BAD_FRAGMENT,
-	CURLUE_BAD_HOSTNAME,
-	CURLUE_BAD_IPV6,
-	CURLUE_BAD_LOGIN,
-	CURLUE_BAD_PASSWORD,
-	CURLUE_BAD_PATH,
-	CURLUE_BAD_QUERY,
-	CURLUE_BAD_SCHEME,
-	CURLUE_BAD_SLASHES,
-	CURLUE_BAD_USER,
-	CURLUE_LACKS_IDN,
-	CURLUE_LAST
-}
-enum CURLUPart : int
-{
-	CURLUPART_URL,
-	CURLUPART_SCHEME,
-	CURLUPART_USER,
-	CURLUPART_PASSWORD,
-	CURLUPART_OPTIONS,
-	CURLUPART_HOST,
-	CURLUPART_PORT,
-	CURLUPART_PATH,
-	CURLUPART_QUERY,
-	CURLUPART_FRAGMENT,
-	CURLUPART_ZONEID
-}
-
-struct Curl_URL
-{
-	char* scheme;
-	char* user;
-	char* password;
-	char* options;
-	char* host;
-	char* zoneid;
-	char* port;
-	char* path;
-	char* query;
-	char* fragment;
+struct CurlUrl
+{
+	ZString scheme;
+	ZString user;
+	ZString password;
+	ZString options;
+	ZString host;
+	ZString zoneid;
+	ZString port;
+	ZString path;
+	ZString query;
+	ZString fragment;
 	long portnum;
 }
 
-alias CurlU = Curl_URL;
+alias CurlU = CurlUrl;
 
-enum Easytype : int
-{
-	CURLOT_LONG,
-	CURLOT_VALUES,
-	CURLOT_OFF_T,
-	CURLOT_OBJECT,
-	CURLOT_STRING,
-	CURLOT_SLIST,
-	CURLOT_CBPTR,
-	CURLOT_BLOB,
-	CURLOT_FUNCTION
-}
-
-struct Easyoption
+struct CurlEasyOption
 {
 	char* name;
-	CURLoption id;
-	Easytype type;
+	CurlOption id;
+	CurlEasyType type;
 	uint flags;
 }
 
-struct Header
+struct CurlHeader
 {
-	char* name;
-	char* value;
+	ZString name;
+	ZString value;
 	usz amount;
 	usz index;
 	uint origin;
 	void* anchor;
 }
 
-enum CURLHcode : int
-{
-	CURLHE_OK,
-	CURLHE_BADINDEX,
-	CURLHE_MISSING,
-	CURLHE_NOHEADERS,
-	CURLHE_NOREQUEST,
-	CURLHE_OUT_OF_MEMORY,
-	CURLHE_BAD_ARGUMENT,
-	CURLHE_NOT_BUILT_IN
-}
 
-struct Ws_frame
+struct CurlWsFrame
 {
 	int age;
 	int flags;
-	Off_t offset;
-	Off_t bytesleft;
+	CurlOff offset;
+	CurlOff bytesleft;
 	usz len;
 }
 
-const MIME_BOUNDARY_DASHES = 24;
-const MIME_RAND_BOUNDARY_CHARS = 16;
-const MIME_BOUNDARY_LEN = (MIME_BOUNDARY_DASHES + MIME_RAND_BOUNDARY_CHARS);
-const ENCODING_BUFFER_SIZE = 256;
-
-enum Mimekind : int
-{
-	MIMEKIND_NONE,
-	MIMEKIND_DATA,
-	MIMEKIND_FILE,
-	MIMEKIND_CALLBACK,
-	MIMEKIND_MULTIPART,
-	MIMEKIND_LAST
-}
-
-enum Mimestate : int
+struct CurlMimeState
 {
-	MIMESTATE_BEGIN,
-	MIMESTATE_CURLHEADERS,
-	MIMESTATE_USERHEADERS,
-	MIMESTATE_EOH,
-	MIMESTATE_BODY,
-	MIMESTATE_BOUNDARY1,
-	MIMESTATE_BOUNDARY2,
-	MIMESTATE_CONTENT,
-	MIMESTATE_END,
-	MIMESTATE_LAST
-}
-
-struct Mime_state
-{
-	Mimestate state;
+	CurlMimeStateType state;
 	void* ptr;
-	Off_t offset;
+	CurlOff offset;
 }
 
-struct Mime
+struct CurlMime
 {
-	Mimepart* parent;
-	Mimepart* firstpart;
-	Mimepart* lastpart;
+	CurlMimePart* parent;
+	CurlMimePart* firstpart;
+	CurlMimePart* lastpart;
 	char[MIME_BOUNDARY_LEN + 1] boundary;
-	Mime_state state;
+	CurlMimeState state;
 }
 
-struct Mime_encoder_state
+struct CurlMimeEncoderState
 {
 	usz pos;
 	usz bufbeg;
@@ -1280,137 +1278,117 @@ struct Mime_encoder_state
 	char[ENCODING_BUFFER_SIZE] buf;
 }
 
-alias Encodefunc = fn usz(char* buffer, usz size, bool ateof, Mimepart* part);
-alias Sizefunc = fn Off_t(Mimepart* part);
-
-struct Mime_encoder
+struct CurlMimeEncoder
 {
 	char* name;
-	Encodefunc encodefunc;
-	Sizefunc sizefunc;
+	CurlEncodeFunc encodefunc;
+	CurlSizeFunc sizefunc;
 }
 
-struct Mimepart
+struct CurlMimePart
 {
-	Mime* parent;
-	Mimepart* nextpart;
-	Mimekind kind;
+	CurlMime* parent;
+	CurlMimePart* nextpart;
+	CurlMimeKind kind;
 	uint flags;
 	char* data;
-	Curl_read_callback readfunc;
-	Curl_seek_callback seekfunc;
-	Curl_free_callback freefunc;
+	CurlReadCallback readfunc;
+	CurlSeekCallback seekfunc;
+	CurlFreeCallback freefunc;
 	void* arg;
 	File *fp;
-	Slist* curlheader;
-	Slist* userheader;
+	CurlSlist* curlheader;
+	CurlSlist* userheader;
 	char* mimetype;
 	char* filename;
 	char* name;
-	Off_t datasize;
-	Mime_state state;
-	Mime_encoder *encoder;
-	Mime_encoder_state encstate;
+	CurlOff datasize;
+	CurlMimeState state;
+	CurlMimeEncoder *encoder;
+	CurlMimeEncoderState encstate;
 	usz lastreadstatus;
 }
 
-enum CurlUPart : int
-{
-	CURLUPART_URL,
-	CURLUPART_SCHEME,
-	CURLUPART_USER,
-	CURLUPART_PASSWORD,
-	CURLUPART_OPTIONS,
-	CURLUPART_HOST,
-	CURLUPART_PORT,
-	CURLUPART_PATH,
-	CURLUPART_QUERY,
-	CURLUPART_FRAGMENT,
-	CURLUPART_ZONEID
-}
-
-typedef Easy_ptr = void*;
-typedef Nghttp2_push_promise_ref = void*;
-typedef Pushheaders_ref = void*;
-
-fn int strequal(char* s1, char* s2) @cname("curl_strequal");
-fn int strnequal(char* s1, char* s2, usz n) @cname("curl_strnequal");
-fn Mime* mime_init(Curl* easy) @cname("curl_mime_init");
-fn void mime_free(Mime* mime) @cname("curl_mime_free");
-fn Mimepart* mime_addpart(Mime* mime) @cname("curl_mime_addpart");
-fn CURLcode mime_name(Mimepart* part, char* name) @cname("curl_mime_name");
-fn CURLcode mime_filename(Mimepart* part, char* filename) @cname("curl_mime_filename");
-fn CURLcode mime_type(Mimepart* part, char* mimetype) @cname("curl_mime_type");
-fn CURLcode mime_encoder(Mimepart* part, char* encoding) @cname("curl_mime_encoder");
-fn CURLcode mime_data(Mimepart* part, char* data, usz datasize) @cname("curl_mime_data");
-fn CURLcode mime_filedata(Mimepart* part, char* filename) @cname("curl_mime_filedata");
-fn CURLcode mime_data_cb(Mimepart* part, Off_t datasize, Curl_read_callback readfunc, Curl_seek_callback seekfunc, Curl_free_callback freefunc, void* arg) @cname("curl_mime_data_cb");
-fn CURLcode mime_subparts(Mimepart* part, Mime* subparts) @cname("curl_mime_subparts");
-fn CURLcode mime_headers(Mimepart* part, Slist* headers, int take_ownership) @cname("curl_mime_headers");
-fn CurlFormCode formadd(Httppost **httppost, Httppost **last_post, ...) @cname("curl_formadd");
-fn usz formget(Httppost *form, void* arg, Curl_formget_callback append) @cname("curl_formget");
-fn void formfree(Httppost* form) @cname("curl_formfree");
-fn char* getenv(char* variable) @cname("curl_getenv");
-fn char* version() @cname("curl_version");
-fn char* easy_escape(Curl* handle, char* string, int length) @cname("curl_easy_escape");
-fn char* escape(char* string, int length) @cname("curl_escape");
-fn char* easy_unescape(Curl* handle, char* string, int length, int* outlength) @cname("curl_easy_unescape");
-fn char *unescape(char* string, int length) @cname("curl_unescape");
-fn void free(void* p) @cname("curl_free");
-fn CURLcode global_init(long flags) @cname("curl_global_init");
-fn CURLcode global_init_mem(long flags, Curl_malloc_callback m, Curl_free_callback f, Curl_realloc_callback r, Curl_strdup_callback s, Curl_calloc_callback c) @cname("curl_global_init_mem");
-fn void global_cleanup() @cname("curl_global_cleanup");
-fn CurlSslset global_sslset(Sslbackend id, char* name, Ssl_backend ***avail) @cname("curl_global_sslset");
-fn Slist* slist_append(Slist* list, char* data) @cname("curl_slist_append");
-fn void slist_free_all(Slist* list) @cname("curl_slist_free_all");
-fn libc::Time_t getdate(char* p, libc::Time_t *unused) @cname("curl_getdate");
-fn void* share_init() @cname("curl_share_init");
-fn CURLSHcode share_setopt(void* share, CURLSHoption option, ...) @cname("curl_share_setopt");
-fn CURLSHcode share_cleanup(void* share) @cname("curl_share_cleanup");
-fn Version_info_data* version_info(CURLversion) @cname("curl_version_info");
-fn char* easy_strerror(CURLcode) @cname("curl_easy_strerror");
-fn char* share_strerror(CURLSHcode) @cname("curl_share_strerror");
-fn CURLcode easy_pause(Curl* handle, int bitmask) @cname("curl_easy_pause");
-fn Curl* easy_init() @cname("curl_easy_init");
-fn CURLcode easy_setopt(Curl* curl, CURLoption option, ...) @cname("curl_easy_setopt");
-fn CURLcode easy_perform(Curl* curl) @cname("curl_easy_perform");
-fn void easy_cleanup(Curl* curl) @cname("curl_easy_cleanup");
-fn CURLcode easy_getinfo(Curl* curl, CURLInfo info, ...) @cname("curl_easy_getinfo");
-fn Curl* easy_duphandle(Curl* curl) @cname("curl_easy_duphandle");
-fn void easy_reset(Curl* curl) @cname("curl_easy_reset");
-fn CURLcode easy_recv(Curl* curl, void* buffer, usz buflen, usz* n) @cname("curl_easy_recv");
-fn CURLcode easy_send(Curl* curl, void* buffer, usz buflen, usz* n) @cname("curl_easy_send");
-fn CURLcode easy_upkeep(Curl* curl) @cname("curl_easy_upkeep");
-fn CurlM* multi_init() @cname("curl_multi_init");
-fn CURLMcode multi_add_handle(CurlM* multi_handle, Curl* curl_handle) @cname("curl_multi_add_handle");
-fn CURLMcode multi_remove_handle(CurlM* multi_handle, Curl* curl_handle) @cname("curl_multi_remove_handle");
-fn CURLMcode multi_fdset(CurlM* multi_handle,Fd_set *read_fd_set, Fd_set *write_fd_set, Fd_set *exc_fd_set, int* max_fd) @cname("curl_multi_fdset");
-fn CURLMcode multi_wait(CurlM* multi_handle, Waitfd* extra_fds, uint extra_nfds, int timeout_ms, int* ret) @cname("curl_multi_wait");
-fn CURLMcode multi_poll(CurlM* multi_handle, Waitfd* extra_fds, uint extra_nfds, int timeout_ms, int* ret) @cname("curl_multi_poll");
-fn CURLMcode multi_wakeup(CurlM* multi_handle) @cname("curl_multi_wakeup");
-fn CURLMcode multi_perform(CurlM* multi_handle, int* running_handles) @cname("curl_multi_perform");
-fn CURLMcode multi_cleanup(CurlM* multi_handle) @cname("curl_multi_cleanup");
-fn CURLMsg *multi_info_read(CurlM* multi_handle, int* msgs_in_queue) @cname("curl_multi_info_read");
-fn char* multi_strerror(CURLMcode) @cname("curl_multi_strerror");
-fn CURLMcode multi_socket(CurlM* multi_handle, Socket_t s, int* running_handles) @cname("curl_multi_socket");
-fn CURLMcode multi_socket_action(CurlM* multi_handle, Socket_t s, int ev_bitmask, int* running_handles) @cname("curl_multi_socket_action");
-fn CURLMcode multi_socket_all(CurlM* multi_handle, int* running_handles) @cname("curl_multi_socket_all");
-fn CURLMcode multi_timeout(CurlM* multi_handle, CLong* milliseconds) @cname("curl_multi_timeout");
-fn CURLMcode multi_setopt(CurlM* multi_handle, CURLMoption option, ...) @cname("curl_multi_setopt");
-fn CURLMcode multi_assign(CurlM* multi_handle, Socket_t sockfd, void* sockp) @cname("curl_multi_assign");
-fn char* pushheader_bynum(Pushheaders_ref h, usz num) @cname("curl_pushheader_bynum");
-fn char* pushheader_byname(Pushheaders_ref h, char *name) @cname("curl_pushheader_byname");
-fn CurlU* url() @cname("curl_url");
-fn void url_cleanup(CurlU* handle) @cname("curl_url_cleanup");
-fn CurlU* url_dup(CurlU* in) @cname("curl_url_dup");
-fn CURLUcode url_get(CurlU* handle, CurlUPart what, char** part, uint flags) @cname("curl_url_get");
-fn CURLUcode url_set(CurlU* handle, CurlUPart what, char* part, uint flags) @cname("curl_url_set");
-fn char* url_strerror(CURLUcode a1) @cname("curl_url_strerror");
-fn Easyoption* easy_option_by_name(char *name) @cname("curl_easy_option_by_name");
-fn Easyoption* easy_option_by_id(CURLoption id) @cname("curl_easy_option_by_id");
-fn Easyoption* easy_option_next(Easyoption* prev) @cname("curl_easy_option_next");
-fn CURLHcode easy_header(Curl* easy, char* name, usz index, uint origin, int request, Header **hout) @cname("curl_easy_header");
-fn Header *easy_nextheader(Curl* easy, uint origin, int request, Header *prev) @cname("curl_easy_nextheader");
-fn CURLcode ws_recv(Curl* curl, void* buffer, usz buflen, usz* recv, Ws_frame **metap) @cname("curl_ws_recv");
-fn CURLcode ws_send(Curl* curl, void* buffer, usz buflen, usz* sent, Off_t framesize, uint sendflags) @cname("curl_ws_send");
-fn Ws_frame *ws_meta(Curl* curl) @cname("curl_ws_meta");
+typedef PushHeaders = void;
+
+extern fn int strequal(ZString s1, ZString s2) @cname("curl_strequal");
+extern fn int strnequal(ZString s1, ZString s2, usz n) @cname("curl_strnequal");
+extern fn CurlMime* mime_init(Curl* easy) @cname("curl_mime_init");
+extern fn void mime_free(CurlMime* mime) @cname("curl_mime_free");
+extern fn CurlMimePart* mime_addpart(CurlMime* mime) @cname("curl_mime_addpart");
+extern fn CurlResult mime_name(CurlMimePart* part, ZString name) @cname("curl_mime_name");
+extern fn CurlResult mime_filename(CurlMimePart* part, ZString filename) @cname("curl_mime_filename");
+extern fn CurlResult mime_type(CurlMimePart* part, ZString mimetype) @cname("curl_mime_type");
+extern fn CurlResult mime_encoder(CurlMimePart* part, ZString encoding) @cname("curl_mime_encoder");
+extern fn CurlResult mime_data(CurlMimePart* part, char* data, usz datasize) @cname("curl_mime_data");
+extern fn CurlResult mime_filedata(CurlMimePart* part, ZString filename) @cname("curl_mime_filedata");
+extern fn CurlResult mime_data_cb(CurlMimePart* part, CurlOff datasize, CurlReadCallback readfunc, CurlSeekCallback seekfunc, CurlFreeCallback freefunc, void* arg) @cname("curl_mime_data_cb");
+extern fn CurlResult mime_subparts(CurlMimePart* part, CurlMime* subparts) @cname("curl_mime_subparts");
+extern fn CurlResult mime_headers(CurlMimePart* part, CurlSlist* headers, int take_ownership) @cname("curl_mime_headers");
+extern fn CurlFormAddResult formadd(CurlHttpPost **httppost, CurlHttpPost **last_post, ...) @cname("curl_formadd");
+extern fn usz formget(CurlHttpPost *form, void* arg, Curl_formget_callback append) @cname("curl_formget");
+extern fn void formfree(CurlHttpPost* form) @cname("curl_formfree");
+extern fn ZString getenv(char* variable) @cname("curl_getenv");
+extern fn ZString version() @cname("curl_version");
+extern fn ZString easy_escape(Curl* handle, char* string, int length) @cname("curl_easy_escape");
+extern fn ZString escape(char* string, int length) @cname("curl_escape");
+extern fn char* easy_unescape(Curl* handle, char* string, int length, int* outlength) @cname("curl_easy_unescape");
+extern fn ZString unescape(char* string, int length) @cname("curl_unescape");
+extern fn void free(void* p) @cname("curl_free");
+extern fn CurlResult global_init(long flags) @cname("curl_global_init");
+extern fn CurlResult global_init_mem(long flags, CurlMallocCallback m, CurlFreeCallback f, CurlReallocCallback r, CurlStrdupCallback s, CurlCallocCallback c) @cname("curl_global_init_mem");
+extern fn void global_cleanup() @cname("curl_global_cleanup");
+extern fn CurlSslSetResult global_sslset(CurlSslBackendType id, char* name, CurlSslBackend ***avail) @cname("curl_global_sslset");
+extern fn CurlSlist* slist_append(CurlSlist* list, char* data) @cname("curl_slist_append");
+extern fn void slist_free_all(CurlSlist* list) @cname("curl_slist_free_all");
+extern fn Time_t getdate(char* p, libc::Time_t *unused) @cname("curl_getdate");
+extern fn void* share_init() @cname("curl_share_init");
+extern fn CurlShResult share_setopt(void* share, CurlShOption option, ...) @cname("curl_share_setopt");
+extern fn CurlShResult share_cleanup(void* share) @cname("curl_share_cleanup");
+extern fn CurlVersionInfoData* version_info(CurlVersionType) @cname("curl_version_info");
+extern fn char* easy_strerror(CurlResult) @cname("curl_easy_strerror");
+extern fn char* share_strerror(CurlShResult) @cname("curl_share_strerror");
+extern fn CurlResult easy_pause(Curl* handle, int bitmask) @cname("curl_easy_pause");
+extern fn Curl* easy_init() @cname("curl_easy_init");
+extern fn CurlResult easy_setopt(Curl* curl, CurlOption option, ...) @cname("curl_easy_setopt");
+extern fn CurlResult easy_perform(Curl* curl) @cname("curl_easy_perform");
+extern fn void easy_cleanup(Curl* curl) @cname("curl_easy_cleanup");
+extern fn CurlResult easy_getinfo(Curl* curl, CurlInfoType info, ...) @cname("curl_easy_getinfo");
+extern fn Curl* easy_duphandle(Curl* curl) @cname("curl_easy_duphandle");
+extern fn void easy_reset(Curl* curl) @cname("curl_easy_reset");
+extern fn CurlResult easy_recv(Curl* curl, void* buffer, usz buflen, usz* n) @cname("curl_easy_recv");
+extern fn CurlResult easy_send(Curl* curl, void* buffer, usz buflen, usz* n) @cname("curl_easy_send");
+extern fn CurlResult easy_upkeep(Curl* curl) @cname("curl_easy_upkeep");
+extern fn CurlM* multi_init() @cname("curl_multi_init");
+extern fn CurlMResult multi_add_handle(CurlM* multi_handle, Curl* curl_handle) @cname("curl_multi_add_handle");
+extern fn CurlMResult multi_remove_handle(CurlM* multi_handle, Curl* curl_handle) @cname("curl_multi_remove_handle");
+extern fn CurlMResult multi_fdset(CurlM* multi_handle,CurlFdSet *read_fd_set, CurlFdSet *write_fd_set, CurlFdSet *exc_fd_set, int* max_fd) @cname("curl_multi_fdset");
+extern fn CurlMResult multi_wait(CurlM* multi_handle, CurlWaitFd* extra_fds, uint extra_nfds, int timeout_ms, int* ret) @cname("curl_multi_wait");
+extern fn CurlMResult multi_poll(CurlM* multi_handle, CurlWaitFd* extra_fds, uint extra_nfds, int timeout_ms, int* ret) @cname("curl_multi_poll");
+extern fn CurlMResult multi_wakeup(CurlM* multi_handle) @cname("curl_multi_wakeup");
+extern fn CurlMResult multi_perform(CurlM* multi_handle, int* running_handles) @cname("curl_multi_perform");
+extern fn CurlMResult multi_cleanup(CurlM* multi_handle) @cname("curl_multi_cleanup");
+extern fn CurlMsg *multi_info_read(CurlM* multi_handle, int* msgs_in_queue) @cname("curl_multi_info_read");
+extern fn char* multi_strerror(CurlMResult) @cname("curl_multi_strerror");
+extern fn CurlMResult multi_socket(CurlM* multi_handle, CurlSocket s, int* running_handles) @cname("curl_multi_socket");
+extern fn CurlMResult multi_socket_action(CurlM* multi_handle, CurlSocket s, int ev_bitmask, int* running_handles) @cname("curl_multi_socket_action");
+extern fn CurlMResult multi_socket_all(CurlM* multi_handle, int* running_handles) @cname("curl_multi_socket_all");
+extern fn CurlMResult multi_timeout(CurlM* multi_handle, CLong* milliseconds) @cname("curl_multi_timeout");
+extern fn CurlMResult multi_setopt(CurlM* multi_handle, CurlMOption option, ...) @cname("curl_multi_setopt");
+extern fn CurlMResult multi_assign(CurlM* multi_handle, CurlSocket sockfd, void* sockp) @cname("curl_multi_assign");
+extern fn char* pushheader_bynum(PushHeaders* h, usz num) @cname("curl_pushheader_bynum");
+extern fn char* pushheader_byname(PushHeaders* h, char *name) @cname("curl_pushheader_byname");
+extern fn CurlU* url() @cname("curl_url");
+extern fn void url_cleanup(CurlU* handle) @cname("curl_url_cleanup");
+extern fn CurlU* url_dup(CurlU* in) @cname("curl_url_dup");
+extern fn CurlUResult url_get(CurlU* handle, CurlUPartType what, char** part, uint flags) @cname("curl_url_get");
+extern fn CurlUResult url_set(CurlU* handle, CurlUPartType what, char* part, uint flags) @cname("curl_url_set");
+extern fn char* url_strerror(CurlUResult a1) @cname("curl_url_strerror");
+extern fn CurlEasyOption* easy_option_by_name(char *name) @cname("curl_easy_option_by_name");
+extern fn CurlEasyOption* easy_option_by_id(CurlOption id) @cname("curl_easy_option_by_id");
+extern fn CurlEasyOption* easy_option_next(CurlEasyOption* prev) @cname("curl_easy_option_next");
+extern fn CurlHResult easy_header(Curl* easy, char* name, usz index, uint origin, int request, CurlHeader **hout) @cname("curl_easy_header");
+extern fn CurlHeader *easy_nextheader(Curl* easy, uint origin, int request, CurlHeader *prev) @cname("curl_easy_nextheader");
+extern fn CurlResult ws_recv(Curl* curl, void* buffer, usz buflen, usz* recv, CurlWsFrame **metap) @cname("curl_ws_recv");
+extern fn CurlResult ws_send(Curl* curl, void* buffer, usz buflen, usz* sent, CurlOff framesize, uint sendflags) @cname("curl_ws_send");
+extern fn CurlWsFrame *ws_meta(Curl* curl) @cname("curl_ws_meta");
diff --git a/libraries/ktx.c3l/khr_df.c3i b/libraries/ktx.c3l/khr_df.c3i
index 0fb406c..92a8842 100644
--- a/libraries/ktx.c3l/khr_df.c3i
+++ b/libraries/ktx.c3l/khr_df.c3i
@@ -1,6 +1,6 @@
 module khr::df;
 
-enum KhrDfWord : const CInt
+constdef KhrDfWord : int
 {
 	VENDORID = 0U,
 	DESCRIPTORTYPE = 0U,
@@ -25,7 +25,7 @@ enum KhrDfWord : const CInt
 	SAMPLESTART = 6U,
 	SAMPLEWORDS = 4U,
 }
-enum KhrDfShift : const CInt
+constdef KhrDfShift : int
 {
 	VENDORID = 0U,
 	DESCRIPTORTYPE = 17U,
@@ -48,7 +48,7 @@ enum KhrDfShift : const CInt
 	BYTESPLANE6 = 16U,
 	BYTESPLANE7 = 24U,
 }
-enum KhrDfMask : const CInt
+constdef KhrDfMask : int
 {
 	VENDORID = 0x1FFFFU,
 	DESCRIPTORTYPE = 0x7FFFU,
@@ -71,7 +71,7 @@ enum KhrDfMask : const CInt
 	BYTESPLANE6 = 0xFFU,
 	BYTESPLANE7 = 0xFFU,
 }
-enum KhrDfSampleWord : const CInt
+constdef KhrDfSampleWord : int
 {
 	BITOFFSET = 0U,
 	BITLENGTH = 0U,
@@ -86,7 +86,7 @@ enum KhrDfSampleWord : const CInt
 	SAMPLEUPPER = 3U,
 }
 
-enum KhrDfSampleShift : const CInt
+constdef KhrDfSampleShift : int
 {
 	BITOFFSET = 0U,
 	BITLENGTH = 16U,
@@ -101,7 +101,7 @@ enum KhrDfSampleShift : const CInt
 	SAMPLEUPPER = 0U,
 }
 
-enum KhrDfSampleMask : const CInt
+constdef KhrDfSampleMask : int
 {
 	BITOFFSET = 0xFFFFU,
 	BITLENGTH = 0xFF,
@@ -115,12 +115,12 @@ enum KhrDfSampleMask : const CInt
 	SAMPLELOWER = (int) 0xFFFFFFFFU,
 	SAMPLEUPPER = (int) 0xFFFFFFFFU,
 }
-enum KhrDfVendorId : const CInt
+constdef KhrDfVendorId : int
 {
 	KHRONOS = 0U,
 	MAX = 0x1FFFFU,
 }
-enum KhrDfKhrDescriptorType : const CInt
+constdef KhrDfKhrDescriptorType : int
 {
 	KHR_DESCRIPTORTYPE_BASICFORMAT = 0U,
 	KHR_DESCRIPTORTYPE_ADDITIONAL_PLANES = 0x6001U,
@@ -130,7 +130,7 @@ enum KhrDfKhrDescriptorType : const CInt
 	KHR_DESCRIPTORTYPE_MAX = 0x7FFFU,
 }
 
-enum KhrDfVersionNumber : const CInt
+constdef KhrDfVersionNumber : int
 {
 	VERSIONNUMBER_1_0 = 0U,
 	VERSIONNUMBER_1_1 = 0U,
@@ -139,7 +139,7 @@ enum KhrDfVersionNumber : const CInt
 	VERSIONNUMBER_LATEST = VERSIONNUMBER_1_3,
 	VERSIONNUMBER_MAX = 0xFFFFU
 }
-enum KhrDfModel : const CInt
+constdef KhrDfModel : int
 {
 	MODEL_UNSPECIFIED = 0U,
 	MODEL_RGBSDA = 1U,
@@ -178,7 +178,7 @@ enum KhrDfModel : const CInt
 	MODEL_UASTC = 166U,
 	MODEL_MAX = 0xFFU,
 }
-enum KhrDfModelChannels : const CInt
+constdef KhrDfModelChannels : int
 {
 	CHANNEL_UNSPECIFIED_0 = 0U,
 	CHANNEL_UNSPECIFIED_1 = 1U,
@@ -355,7 +355,7 @@ enum KhrDfModelChannels : const CInt
 	CHANNEL_COMMON_ALPHA = 15U,
 	CHANNEL_COMMON_A = 15U
 }
-enum KhrDfPrimaries : const CInt
+constdef KhrDfPrimaries : int
 {
 	PRIMARIES_UNSPECIFIED = 0U,
 	PRIMARIES_BT709 = 1U,
@@ -372,7 +372,7 @@ enum KhrDfPrimaries : const CInt
 	PRIMARIES_ADOBERGB = 11U,
 	PRIMARIES_MAX = 0xFFU
 }
-enum KhrDfTransfer : const CInt
+constdef KhrDfTransfer : int
 {
 	TRANSFER_UNSPECIFIED = 0U,
 	TRANSFER_LINEAR = 1U,
@@ -397,13 +397,13 @@ enum KhrDfTransfer : const CInt
 	TRANSFER_MAX = 0xFFU
 }
 
-enum KhrDfFlags : const CInt
+constdef KhrDfFlags : int
 {
 	FLAG_ALPHA_STRAIGHT = 0U,
 	FLAG_ALPHA_PREMULTIPLIED = 1U
 }
 
-enum KhrDfSampleDatatype : const CInt
+constdef KhrDfSampleDatatype : int
 {
 	SAMPLE_DATATYPE_LINEAR = 1U << 4U,
 	SAMPLE_DATATYPE_EXPONENT = 1U << 5U,
diff --git a/libraries/ktx.c3l/ktx.c3i b/libraries/ktx.c3l/ktx.c3i
index 3009a93..cfedc83 100644
--- a/libraries/ktx.c3l/ktx.c3i
+++ b/libraries/ktx.c3l/ktx.c3i
@@ -9,7 +9,7 @@ const ORIENTATION1_FMT = "S=%c";
 const ORIENTATION2_FMT = "S=%c,T=%c";
 const ORIENTATION3_FMT = "S=%c,T=%c,R=%c";
 const GL_UNPACK_ALIGNMENT = 4;
-enum KtxErrorCode : const CInt
+constdef KtxErrorCode : CInt
 {
 	SUCCESS = 0,
 	FILE_DATA_ERROR,
@@ -40,19 +40,19 @@ alias KtxResult = KtxErrorCode;
 alias KtxKVListEntry = void;
 alias KtxHashList = KtxKVListEntry*;
 alias KtxHashListEntry = KtxKVListEntry;
-enum KtxOrientationX : const CInt
+constdef KtxOrientationX : CInt
 {
 	LEFT = 'l', RIGHT = 'r',
 }
-enum KtxOrientationY : const CInt
+constdef KtxOrientationY : CInt
 {
 	UP = 'u', DOWN = 'd',
 }
-enum KtxOrientationZ : const CInt
+constdef KtxOrientationZ : CInt
 {
 	IN = 'i', OUT = 'o',
 }
-enum KtxClassId : const CInt
+constdef KtxClassId : CInt
 {
 	TEXTURE1_C = 1,
 	TEXTURE2_C = 2,
@@ -240,7 +240,7 @@ macro KtxErrorCode KtxTexture1.write_to_memory(&self,
 	char** bytes, usz* size) => self.vtbl.writeToMemory(self, bytes, size);
 macro KtxErrorCode KtxTexture1.write_to_stream(&self,
 	KtxStream* dststr) => self.vtbl.writeToStream(self, dststr);
-enum KtxSuperCmpScheme : const CInt
+constdef KtxSuperCmpScheme : CInt
 {
 	NONE = 0,
 	BASIS_LZ = 1,
@@ -332,12 +332,12 @@ struct KtxTextureCreateInfo
 	bool isArray;
 	bool generateMipmaps;
 }
-enum KtxTextureCreateStorageEnum : const CInt
+constdef KtxTextureCreateStorageEnum : CInt
 {
 	NO_STORAGE = 0,
 	ALLOC_STORAGE = 1,
 }
-enum KtxTextureCreateFlags : const CInt
+constdef KtxTextureCreateFlags : CInt
 {
 	NO_FLAGS = 0x00,
 	LOAD_IMAGE_DATA_BIT = 0x01,
@@ -345,7 +345,7 @@ enum KtxTextureCreateFlags : const CInt
 	SKIP_KVDATA_BIT = 0x04,
 }
 alias KtxOff = ulong;
-enum KtxStreamType : const CInt
+constdef KtxStreamType : CInt
 {
 	FILE = 1,
 	MEMORY = 2,
@@ -453,7 +453,7 @@ fn uint KtxTexture2.get_oetf(&self) @cname("ktxTexture2_GetOETF");
 fn KhrDfModel KtxTexture2.get_color_model_enum(&self) @cname("ktxTexture2_GetColorModel_e");
 fn bool KtxTexture2.get_premultiplied_alpha(&self) @cname("ktxTexture2_GetPremultipliedAlpha");
 fn bool KtxTexture2.needs_transcoding(&self) @cname("ktxTexture2_NeedsTranscoding");
-enum KtxPackUastcFlags : const CInt
+constdef KtxPackUastcFlags : CInt
 {
 	LEVEL_FASTEST = 0,
 	LEVEL_FASTER = 1,
@@ -468,7 +468,7 @@ enum KtxPackUastcFlags : const CInt
 	ETC1_FASTEST_HINTS = 128,
 	_ETC1_DISABLE_FLIP_AND_INDIVIDUAL = 256,
 }
-enum KtxPackAstcQualityLevel : const CInt
+constdef KtxPackAstcQualityLevel : CInt
 {
 	FASTEST = 0,
 	FAST = 10,
@@ -477,7 +477,7 @@ enum KtxPackAstcQualityLevel : const CInt
 	EXHAUSTIVE = 100,
 	MAX = EXHAUSTIVE,
 }
-enum KtxPackAstcBlockDimension : const CInt
+constdef KtxPackAstcBlockDimension : CInt
 {
 	DIMENSION_4X4,
 	DIMENSION_5X4,
@@ -505,7 +505,7 @@ enum KtxPackAstcBlockDimension : const CInt
 	DIMENSION_6X6X6,
 	DIMENSION_MAX = KtxPackAstcBlockDimension.DIMENSION_6X6X6,
 }
-enum KtxPackAstcEncoder : const CInt
+constdef KtxPackAstcEncoder : CInt
 {
 	DEFAULT,
 	LDR,
@@ -556,7 +556,7 @@ struct KtxBasisParams
 	bool uastcRDONoMultithreading;
 }
 fn KtxErrorCode KtxTexture2.compress_basis_ex(&self, KtxBasisParams* params) @cname("ktxTexture2_CompressBasisEx");
-enum KtxTranscodeFmt : const CInt
+constdef KtxTranscodeFmt : CInt
 {
 	ETC1_RGB = 0,
 	ETC2_RGBA = 1,
@@ -580,7 +580,7 @@ enum KtxTranscodeFmt : const CInt
 	BC1_OR_3 = 23,
 	NOSELECTION = 0X7FFFFFFF,
 }
-enum KtxTranscodeFlags : const CInt
+constdef KtxTranscodeFlags : CInt
 {
 	PVRTC_DECODE_TO_NEXT_POW2 = 2,
 	TRANSCODE_ALPHA_DATA_TO_OPAQUE_FORMATS = 4,
diff --git a/libraries/raylib.c3l/raylib.c3i b/libraries/raylib.c3l/raylib.c3i
index 68634c6..5a46102 100644
--- a/libraries/raylib.c3l/raylib.c3i
+++ b/libraries/raylib.c3l/raylib.c3i
@@ -371,7 +371,7 @@ struct RLAutomationEventList
 
 // Trace log level
 // NOTE: Organized by priority level
-enum RLTraceLogLevel : const CInt
+constdef RLTraceLogLevel : CInt
 {
 	ALL = 0, // Display all logs
 	TRACE,   // Trace logging, intended for internal use only
@@ -445,7 +445,7 @@ enum RLGamepadAxis : CInt
 }
 
 // RLMaterial map index
-enum RLMaterialMapIndex : const inline CInt
+constdef RLMaterialMapIndex : inline CInt
 {
 	ALBEDO = 0, // Albedo material (same as: MATERIAL_MAP_DIFFUSE)
 	METALNESS,  // Metalness material (same as: MATERIAL_MAP_SPECULAR)
@@ -465,7 +465,7 @@ enum RLMaterialMapIndex : const inline CInt
 }
 
 // Shader location index
-enum RLShaderLocationIndex : const CInt
+constdef RLShaderLocationIndex : CInt
 {
 	VERTEX_POSITION = 0, // Shader location: vertex attribute: position
 	VERTEX_TEXCOORD01,   // Shader location: vertex attribute: texcoord01
@@ -527,7 +527,7 @@ enum RLShaderAttributeDataType : CInt
 
 // Pixel formats
 // NOTE: Support depends on OpenGL version and platform
-enum RLPixelFormat : const CInt
+constdef RLPixelFormat : CInt
 {
 	UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
 	UNCOMPRESSED_GRAY_ALPHA,    // 8*2 bpp (2 channels)
@@ -1495,7 +1495,7 @@ macro void @rl_mode(CInt mode ;@body)
 // System/Window config flags
 // NOTE: Every bit registers one state (use it with bit masks)
 // By default all flags are set to 0
-enum RLConfigFlag : const uint
+constdef RLConfigFlag : uint
 {
 	VSYNC_HINT         = 0x00000040, // Set to try enabling V-Sync on GPU
 	FULLSCREEN_MODE    = 0x00000002, // Set to run program in fullscreen
@@ -1516,7 +1516,7 @@ enum RLConfigFlag : const uint
 // Keyboard keys (US keyboard layout)
 // NOTE: Use GetKeyPressed() to allow redefining
 // required keys for alternative layouts
-enum RLKeyboardKey : const int
+constdef RLKeyboardKey : int
 {
 	NONE            = 0,   // Key: NONE; used for no key pressed
 	// Alphanumeric keys
@@ -1636,7 +1636,7 @@ enum RLKeyboardKey : const int
 
 // Gesture
 // NOTE: It could be used as flags to enable only some gestures
-enum RLGesture : const int
+constdef RLGesture : int
 {
 	NONE        = 0,   // No gesture
 	TAP         = 1,   // Tap gesture
@@ -1653,7 +1653,7 @@ enum RLGesture : const int
 
 // rlgl.h
 
-enum RLFramebufferAttachType : const int
+constdef RLFramebufferAttachType : int
 {
 	COLOR_CHANNEL0 = 0, // Framebuffer attachment type: color 0
 	COLOR_CHANNEL1 = 1, // Framebuffer attachment type: color 1
@@ -1668,7 +1668,7 @@ enum RLFramebufferAttachType : const int
 }
 
 
-enum RLFramebufferAttachTextureType : const int
+constdef RLFramebufferAttachTextureType : int
 {
 	CUBEMAP_POSITIVE_X = 0, // Framebuffer texture attachment type: cubemap, +X side
 	CUBEMAP_NEGATIVE_X = 1, // Framebuffer texture attachment type: cubemap, -X side
diff --git a/libraries/raylib55.c3l/freebsd-x64/libraylib.a b/libraries/raylib55.c3l/freebsd-x64/libraylib.a
deleted file mode 100644
index c887fd4..0000000
Binary files a/libraries/raylib55.c3l/freebsd-x64/libraylib.a and /dev/null differ
diff --git a/libraries/raylib55.c3l/linux-x64/libraylib.a b/libraries/raylib55.c3l/linux-x64/libraylib.a
deleted file mode 100644
index 6e2d85c..0000000
Binary files a/libraries/raylib55.c3l/linux-x64/libraylib.a and /dev/null differ
diff --git a/libraries/raylib55.c3l/macos-aarch64/libraylib.a b/libraries/raylib55.c3l/macos-aarch64/libraylib.a
deleted file mode 100644
index 350ff3c..0000000
Binary files a/libraries/raylib55.c3l/macos-aarch64/libraylib.a and /dev/null differ
diff --git a/libraries/raylib55.c3l/macos-x64/libraylib.a b/libraries/raylib55.c3l/macos-x64/libraylib.a
deleted file mode 100644
index c75576d..0000000
Binary files a/libraries/raylib55.c3l/macos-x64/libraylib.a and /dev/null differ
diff --git a/libraries/raylib55.c3l/manifest.json b/libraries/raylib55.c3l/manifest.json
deleted file mode 100644
index eff5162..0000000
--- a/libraries/raylib55.c3l/manifest.json
+++ /dev/null
@@ -1,32 +0,0 @@
-{ 
-	"provides" : "raylib55",
-	"targets" : {
-		"macos-x64" : {
-			"link-args" : [],
-			"dependencies" : [],
-			"linked-libraries" : ["raylib", "Cocoa.framework", "OpenGL.framework", "CoreVideo.framework", "GLUT.framework", "IOKit.framework"]
-		},
-		"macos-aarch64" : {
-			"link-args" : [],
-			"dependencies" : [],
-			"linked-libraries" : ["raylib", "Cocoa.framework", "OpenGL.framework", "CoreVideo.framework", "GLUT.framework", "IOKit.framework"]
-		},
-		"linux-x64" : {
-			"link-args" : [],
-			"dependencies" : [],
-			"linked-libraries" : ["raylib", "m"]
-		},
-		"freebsd-x64" : {
-			"link-args" : [],
-			"dependencies" : [],
-			"linked-libraries" : ["raylib", "m"]
-		},
-		"windows-x64" : {
-			"linked-libraries" : ["raylib", "gdi32", "winmm"],
-			"wincrt": "none"
-		},
-		"wasm32" : {
-			"linked-libraries" : ["raylib"]
-		}
-	}
-}
diff --git a/libraries/raylib55.c3l/raylib.c3i b/libraries/raylib55.c3l/raylib.c3i
deleted file mode 100644
index 466a670..0000000
--- a/libraries/raylib55.c3l/raylib.c3i
+++ /dev/null
@@ -1,2142 +0,0 @@
-// This file requires 0.7.7 or later.
-module raylib5::rl;
-
-const float PI = 3.14159265358979323846f;
-const float DEG2RAD = PI / 180.0f;
-const float RAD2DEG = 180.0f / PI;
-
-// Some Basic Colors
-// NOTE: Custom raylib color palette for amazing visuals on WHITE background
-const Color LIGHTGRAY   = { 200, 200, 200, 255 };   // Light Gray
-const Color GRAY        = { 130, 130, 130, 255 };   // Gray
-const Color DARKGRAY    = { 80, 80, 80, 255 };      // Dark Gray
-const Color YELLOW      = { 253, 249, 0, 255 };     // Yellow
-const Color GOLD        = { 255, 203, 0, 255 };     // Gold
-const Color ORANGE      = { 255, 161, 0, 255 };     // Orange
-const Color PINK        = { 255, 109, 194, 255 };   // Pink
-const Color RED         = { 230, 41, 55, 255 };     // Red
-const Color MAROON      = { 190, 33, 55, 255 };     // Maroon
-const Color GREEN       = { 0, 228, 48, 255 };      // Green
-const Color LIME        = { 0, 158, 47, 255 };      // Lime
-const Color DARKGREEN   = { 0, 117, 44, 255 };      // Dark Green
-const Color SKYBLUE     = { 102, 191, 255, 255 };   // Sky Blue
-const Color BLUE        = { 0, 121, 241, 255 };     // Blue
-const Color DARKBLUE    = { 0, 82, 172, 255 };      // Dark Blue
-const Color PURPLE      = { 200, 122, 255, 255 };   // Purple
-const Color VIOLET      = { 135, 60, 190, 255 };    // Violet
-const Color DARKPURPLE  = { 112, 31, 126, 255 };    // Dark Purple
-const Color BEIGE       = { 211, 176, 131, 255 };   // Beige
-const Color BROWN       = { 127, 106, 79, 255 };    // Brown
-const Color DARKBROWN   = { 76, 63, 47, 255 };      // Dark Brown
-
-const Color WHITE       = { 255, 255, 255, 255 };   // White
-const Color BLACK       = { 0, 0, 0, 255 };         // Black
-const Color BLANK       = { 0, 0, 0, 0 };           // Blank (Transparent)
-const Color MAGENTA     = { 255, 0, 255, 255 };     // Magenta
-const Color RAYWHITE    = { 245, 245, 245, 255 };   // My own White (raylib logo)
-
-alias Vector2 = float[<2>];
-alias Vector3 = float[<3>];
-alias Vector4 = float[<4>];
-
-// Quaternion, 4 components (Vector4 alias)
-alias Quaternion = Vector4;
-
-// Matrix, 4x4 components, column major, OpenGL style, right handed
-struct Matrix
-{
-	float m0, m4, m8, m12;  // Matrix first row (4 components)
-	float m1, m5, m9, m13;  // Matrix second row (4 components)
-	float m2, m6, m10, m14; // Matrix third row (4 components)
-	float m3, m7, m11, m15; // Matrix fourth row (4 components)
-}
-
-// Color, 4 components, R8G8B8A8 (32bit)
-alias Color = char[<4>];
-
-// Rectangle, 4 components
-union Rectangle
-{
-	struct
-	{
-		float x;                // Rectangle top-left corner position x
-		float y;                // Rectangle top-left corner position y
-		float width;            // Rectangle width
-		float height;           // Rectangle height
-	}
-	struct
-	{
-		Vector2 pos;
-		Vector2 size;
-	}
-}
-
-// Image, pixel data stored in CPU memory (RAM)
-struct Image
-{
-	void* data;             // Image raw data
-	CInt width;             // Image base width
-	CInt height;            // Image base height
-	CInt mipmaps;           // Mipmap levels, 1 by default
-	PixelFormat format;     // Data format (PixelFormat type)
-}
-
-// Texture, tex data stored in GPU memory (VRAM)
-struct Texture
-{
-	CUInt id;               // OpenGL texture id
-	CInt width;             // Texture base width
-	CInt height;            // Texture base height
-	CInt mipmaps;           // Mipmap levels, 1 by default
-	PixelFormat format;     // Data format (PixelFormat type)
-}
-
-// Texture2D, same as Texture
-alias Texture2D = Texture;
-
-// TextureCubemap, same as Texture
-alias TextureCubemap = Texture;
-
-// RenderTexture, fbo for texture rendering
-struct RenderTexture
-{
-	CUInt id;               // OpenGL framebuffer object id
-	Texture texture;        // Color buffer attachment texture
-	Texture depth;          // Depth buffer attachment texture
-}
-
-// RenderTexture2D, same as RenderTexture
-alias RenderTexture2D = RenderTexture;
-
-// NPatchInfo, n-patch layout info
-struct NPatchInfo
-{
-	Rectangle source;       // Texture source rectangle
-	CInt left;              // Left border offset
-	CInt top;               // Top border offset
-	CInt right;             // Right border offset
-	CInt bottom;            // Bottom border offset
-	NPatchLayout layout;    // Layout of the n-patch: 3x3, 1x3 or 3x1
-}
-
-// GlyphInfo, font characters glyphs info
-struct GlyphInfo
-{
-	CInt value;             // Character value (Unicode)
-	CInt[<2>] offsetX;      // Character offset when drawing
-	CInt advanceX;          // Character advance position X
-	Image image;            // Character image data
-}
-
-// Font, font texture and GlyphInfo array data
-struct Font
-{
-	CInt baseSize;          // Base size (default chars height)
-	CInt glyphCount;        // Number of glyph characters
-	CInt glyphPadding;      // Padding around the glyph characters
-	Texture2D texture;      // Texture atlas containing the glyphs
-	Rectangle* recs;        // Rectangles in texture for the glyphs
-	GlyphInfo* glyphs;      // Glyphs info data
-}
-
-// Camera, defines position/orientation in 3d space
-struct Camera3D
-{
-	Vector3 position;               // Camera position
-	Vector3 target;                 // Camera target it looks-at
-	Vector3 up;                     // Camera up vector (rotation over its axis)
-	float fovy;                     // Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic
-	CameraProjection projection;    // Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
-}
-
-alias Camera = Camera3D;    // Camera type fallback, defaults to Camera3D
-
-// Camera2D, defines position/orientation in 2d space
-struct Camera2D
-{
-	Vector2 offset;         // Camera offset (displacement from target)
-	Vector2 target;         // Camera target (rotation and zoom origin)
-	float rotation;         // Camera rotation in degrees
-	float zoom;             // Camera zoom (scaling), should be 1.0f by default
-}
-
-// Mesh, vertex data and vao/vbo
-struct Mesh
-{
-	CInt vertexCount;       // Number of vertices stored in arrays
-	CInt triangleCount;     // Number of triangles stored (indexed or not)
-
-	// Vertex attributes data
-	float* vertices;        // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
-	float* texcoords;       // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
-	float* texcoords2;      // Vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
-	float* normals;         // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
-	float* tangents;        // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
-	CChar* colors;          // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
-	CUShort *indices;       // Vertex indices (in case vertex data comes indexed)
-
-	// Animation vertex data
-	float* animVertices;    // Animated vertex positions (after bones transformations)
-	float* animNormals;     // Animated normals (after bones transformations)
-	CChar* boneIds;         // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning)
-	float* boneWeights;     // Vertex bone weight, up to 4 bones influence by vertex (skinning)
-	Matrix *boneMatrices;   // Bones animated transformation matrices
-	CInt boneCount;         // Number of bones
-
-	// OpenGL identifiers
-	CUInt vaoId;            // OpenGL Vertex Array Object id
-	CUInt* vboId;           // OpenGL Vertex Buffer Objects id (default vertex data)
-}
-
-// Shader
-struct Shader
-{
-	CUInt id;               // Shader program id
-	CInt* locs;             // Shader locations array (RL_MAX_SHADER_LOCATIONS)
-}
-
-// MaterialMap
-struct MaterialMap
-{
-	Texture2D texture;      // Material map texture
-	Color color;            // Material map color
-	float value;            // Material map value
-}
-
-// Material, includes shader and maps
-struct Material
-{
-	Shader shader;          // Material shader
-	MaterialMap* maps;      // Material maps array (MAX_MATERIAL_MAPS)
-	float[4] params;        // Material generic parameters (if required)
-}
-
-// Transform, vectex transformation data
-struct Transform
-{
-	Vector3 translation;    // Translation
-	Quaternion rotation;    // Rotation
-	Vector3 scale;          // Scale
-}
-
-// Bone, skeletal animation bone
-struct BoneInfo
-{
-	CChar[32] name;         // Bone name
-	CInt parent;            // Bone parent
-}
-
-// Model, meshes, materials and animation data
-struct Model
-{
-	Matrix transform;       // Local transform matrix
-	CInt meshCount;         // Number of meshes
-	CInt materialCount;     // Number of materials
-	Mesh* meshes;           // Meshes array
-	Material* materials;    // Materials array
-	CInt* meshMaterial;     // Mesh material number
-
-	// Animation data
-	CInt boneCount;         // Number of bones
-	BoneInfo* bones;        // Bones information (skeleton)
-	Transform* bindPose;    // Bones base transformation (pose)
-}
-
-// ModelAnimation
-struct ModelAnimation
-{
-	CInt boneCount;         // Number of bones
-	CInt frameCount;        // Number of animation frames
-	BoneInfo* bones;        // Bones information (skeleton)
-	Transform** framePoses; // Poses array by frame
-	CChar[32] name;         // Animation name
-}
-
-// Ray, ray for raycasting
-struct Ray
-{
-	Vector3 position;       // Ray position (origin)
-	Vector3 direction;      // Ray direction (normalized)
-}
-
-// RayCollision, ray hit information
-struct RayCollision
-{
-	bool hit;               // Did the ray hit something?
-	float distance;         // Distance to nearest hit
-	Vector3 point;          // Point of nearest hit
-	Vector3 normal;         // Surface normal of hit
-}
-
-// BoundingBox
-struct BoundingBox @compact
-{
-	Vector3 min;            // Minimum vertex box-corner
-	Vector3 max;            // Maximum vertex box-corner
-}
-
-// Wave, audio wave data
-struct Wave
-{
-	CUInt frameCount;           // Total number of frames (considering channels)
-	CUInt sampleRate;           // Frequency (samples per second)
-	CUInt sampleSize;           // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
-	CUInt channels;             // Number of channels (1-mono, 2-stereo, ...)
-	void* data;                 // Buffer data pointer
-}
-
-alias AudioBufferRef = void*;
-alias AudioProcessorRef = void*;
-
-// AudioStream, custom audio stream
-struct AudioStream
-{
-	AudioBufferRef buffer;       // Pointer to internal data used by the audio system
-	AudioProcessorRef processor; // Pointer to internal data processor, useful for audio effects
-
-	CUInt sampleRate;            // Frequency (samples per second)
-	CUInt sampleSize;            // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
-	CUInt channels;              // Number of channels (1-mono, 2-stereo, ...)
-}
-
-
-// Sound
-struct Sound
-{
-	AudioStream stream;         // Audio stream
-	CUInt frameCount;           // Total number of frames (considering channels)
-}
-
-// Music, audio stream, anything longer than ~10 seconds should be streamed
-struct Music
-{
-	AudioStream stream;         // Audio stream
-	CUInt frameCount;           // Total number of frames (considering channels)
-	bool looping;               // Music looping enable
-
-	CInt ctxType;               // Type of music context (audio filetype)
-	void* ctxData;              // Audio context data, depends on type
-}
-
-// VrDeviceInfo, Head-Mounted-Display device parameters
-struct VrDeviceInfo
-{
-	CInt hResolution;               // Horizontal resolution in pixels
-	CInt vResolution;               // Vertical resolution in pixels
-	float hScreenSize;              // Horizontal size in meters
-	float vScreenSize;              // Vertical size in meters
-	float vScreenCenter;            // Screen center in meters
-	float eyeToScreenDistance;      // Distance between eye and display in meters
-	float lensSeparationDistance;   // Lens separation distance in meters
-	float interpupillaryDistance;   // IPD (distance between pupils) in meters
-	float[4] lensDistortionValues;  // Lens distortion constant parameters
-	float[4] chromaAbCorrection;    // Chromatic aberration correction parameters
-}
-
-// VrStereoConfig, VR stereo rendering configuration for simulator
-struct VrStereoConfig
-{
-	Matrix[2] projection;           // VR projection matrices (per eye)
-	Matrix[2] viewOffset;           // VR view offset matrices (per eye)
-	float[2] leftLensCenter;        // VR left lens center
-	float[2] rightLensCenter;       // VR right lens center
-	float[2] leftScreenCenter;      // VR left screen center
-	float[2] rightScreenCenter;     // VR right screen center
-	float[2] scale;                 // VR distortion scale
-	float[2] scaleIn;               // VR distortion scale in
-}
-
-struct FilePathList
-{
-	CUInt capacity;                 // Filepaths max entries
-	CUInt count;                    // Filepaths entries count
-	ZString* paths;                 // Filepaths entries
-}
-
-// Automation event
-struct AutomationEvent
-{
-	CUInt frame;                     // Event frame
-	CUInt type;                      // Event type (AutomationEventType)
-	CInt[4] params;                  // Event parameters (if required)
-}
-
-// Automation event list
-struct AutomationEventList
-{
-	CUInt capacity;                 // Events max entries (MAX_AUTOMATION_EVENTS)
-	CUInt count;                    // Events entries count
-	AutomationEvent* events;        // Events entries
-}
-
-// Trace log level
-// NOTE: Organized by priority level
-enum TraceLogLevel : const CInt
-{
-	ALL = 0,        // Display all logs
-	TRACE,          // Trace logging, intended for internal use only
-	DEBUG,          // Debug logging, used for internal debugging, it should be disabled on release builds
-	INFO,           // Info logging, used for program execution info
-	WARNING,        // Warning logging, used on recoverable failures
-	ERROR,          // Error logging, used on unrecoverable failures
-	FATAL,          // Fatal logging, used to abort program: exit(EXIT_FAILURE)
-	NONE            // Disable logging
-}
-
-// Mouse buttons
-enum MouseButton : CInt
-{
-	LEFT,           // Mouse button left
-	RIGHT,          // Mouse button right
-	MIDDLE,         // Mouse button middle (pressed wheel)
-	SIDE,           // Mouse button side (advanced mouse device)
-	EXTRA,          // Mouse button extra (advanced mouse device)
-	FORWARD,        // Mouse button forward (advanced mouse device)
-	BACK,           // Mouse button back (advanced mouse device)
-}
-
-// Mouse cursor
-enum MouseCursor : CInt
-{
-	DEFAULT,            // Default pointer shape
-	ARROW,              // Arrow shape
-	IBEAM,              // Text writing cursor shape
-	CROSSHAIR,          // Cross shape
-	POINTING_HAND,      // Pointing hand cursor
-	RESIZE_EW,          // Horizontal resize/move arrow shape
-	RESIZE_NS,          // Vertical resize/move arrow shape
-	RESIZE_NWSE,        // Top-left to bottom-right diagonal resize/move arrow shape
-	RESIZE_NESW,        // The top-right to bottom-left diagonal resize/move arrow shape
-	RESIZE_ALL,         // The omnidirectional resize/move cursor shape
-	NOT_ALLOWED,        // The operation-not-allowed shape
-}
-
-// Gamepad buttons
-enum GamepadButton : CInt
-{
-	UNKNOWN,             // Unknown button, just for error checking
-	LEFT_FACE_UP,        // Gamepad left DPAD up button
-	LEFT_FACE_RIGHT,     // Gamepad left DPAD right button
-	LEFT_FACE_DOWN,      // Gamepad left DPAD down button
-	LEFT_FACE_LEFT,      // Gamepad left DPAD left button
-	RIGHT_FACE_UP,       // Gamepad right button up (i.e. PS3: Triangle, Xbox: Y)
-	RIGHT_FACE_RIGHT,    // Gamepad right button right (i.e. PS3: Circle, Xbox: B)
-	RIGHT_FACE_DOWN,     // Gamepad right button down (i.e. PS3: Cross, Xbox: A)
-	RIGHT_FACE_LEFT,     // Gamepad right button left (i.e. PS3: Square, Xbox: X)
-	LEFT_TRIGGER_1,      // Gamepad top/back trigger left (first), it could be a trailing button
-	LEFT_TRIGGER_2,      // Gamepad top/back trigger left (second), it could be a trailing button
-	RIGHT_TRIGGER_1,     // Gamepad top/back trigger right (first), it could be a trailing button
-	RIGHT_TRIGGER_2,     // Gamepad top/back trigger right (second), it could be a trailing button
-	MIDDLE_LEFT,         // Gamepad center buttons, left one (i.e. PS3: Select)
-	MIDDLE,              // Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX)
-	MIDDLE_RIGHT,        // Gamepad center buttons, right one (i.e. PS3: Start)
-	LEFT_THUMB,          // Gamepad joystick pressed button left
-	RIGHT_THUMB          // Gamepad joystick pressed button right
-}
-
-enum GamepadAxis : CInt
-{
-	LEFT_X,             // Gamepad left stick X axis
-	LEFT_Y,             // Gamepad left stick Y axis
-	RIGHT_X,            // Gamepad right stick X axis
-	RIGHT_Y,            // Gamepad right stick Y axis
-	LEFT_TRIGGER,       // Gamepad back trigger left, pressure level: [1..-1]
-	RIGHT_TRIGGER,      // Gamepad back trigger right, pressure level: [1..-1]
-}
-
-// Material map index
-enum MaterialMapIndex : const CInt
-{
-	ALBEDO = 0,        // Albedo material (same as: MATERIAL_MAP_DIFFUSE)
-	METALNESS,         // Metalness material (same as: MATERIAL_MAP_SPECULAR)
-	NORMAL,            // Normal material
-	ROUGHNESS,         // Roughness material
-	OCCLUSION,         // Ambient occlusion material
-	EMISSION,          // Emission material
-	HEIGHT,            // Heightmap material
-	CUBEMAP,           // Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
-	IRRADIANCE,        // Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
-	PREFILTER,         // Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
-	BRDF,              // Brdf material
-
-	DIFFUSE = ALBEDO,  // #define MATERIAL_MAP_DIFFUSE      MATERIAL_MAP_ALBEDO
-	SPECULAR = METALNESS, // #define MATERIAL_MAP_SPECULAR     MATERIAL_MAP_METALNESS
-}
-
-// Shader location index
-enum ShaderLocationIndex : const CInt
-{
-	VERTEX_POSITION = 0, // Shader location: vertex attribute: position
-	VERTEX_TEXCOORD01,   // Shader location: vertex attribute: texcoord01
-	VERTEX_TEXCOORD02,   // Shader location: vertex attribute: texcoord02
-	VERTEX_NORMAL,       // Shader location: vertex attribute: normal
-	VERTEX_TANGENT,      // Shader location: vertex attribute: tangent
-	VERTEX_COLOR,        // Shader location: vertex attribute: color
-	MATRIX_MVP,          // Shader location: matrix uniform: model-view-projection
-	MATRIX_VIEW,         // Shader location: matrix uniform: view (camera transform)
-	MATRIX_PROJECTION,   // Shader location: matrix uniform: projection
-	MATRIX_MODEL,        // Shader location: matrix uniform: model (transform)
-	MATRIX_NORMAL,       // Shader location: matrix uniform: normal
-	VECTOR_VIEW,         // Shader location: vector uniform: view
-	COLOR_DIFFUSE,       // Shader location: vector uniform: diffuse color
-	COLOR_SPECULAR,      // Shader location: vector uniform: specular color
-	COLOR_AMBIENT,       // Shader location: vector uniform: ambient color
-	MAP_ALBEDO,          // Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE)
-	MAP_METALNESS,       // Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR)
-	MAP_NORMAL,          // Shader location: sampler2d texture: normal
-	MAP_ROUGHNESS,       // Shader location: sampler2d texture: roughness
-	MAP_OCCLUSION,       // Shader location: sampler2d texture: occlusion
-	MAP_EMISSION,        // Shader location: sampler2d texture: emission
-	MAP_HEIGHT,          // Shader location: sampler2d texture: height
-	MAP_CUBEMAP,         // Shader location: samplerCube texture: cubemap
-	MAP_IRRADIANCE,      // Shader location: samplerCube texture: irradiance
-	MAP_PREFILTER,       // Shader location: samplerCube texture: prefilter
-	MAP_BRDF,            // Shader location: sampler2d texture: brdf
-	VERTEX_BONEIDS,      // Shader location: vertex attribute: boneIds
-	VERTEX_BONEWEIGHTS,  // Shader location: vertex attribute: boneWeights
-	BONE_MATRICES,       // Shader location: array of matrices uniform: boneMatrices
-
-	MAP_DIFFUSE = MAP_ALBEDO, // #define SHADER_LOC_MAP_DIFFUSE      SHADER_LOC_MAP_ALBEDO
-	MAP_SPECULAR = MAP_METALNESS, // #define SHADER_LOC_MAP_SPECULAR     SHADER_LOC_MAP_METALNESS
-}
-
-// Shader uniform data type
-enum ShaderUniformDataType : CInt
-{
-	FLOAT,           // Shader uniform type: float
-	VEC2,            // Shader uniform type: vec2 (2 float)
-	VEC3,            // Shader uniform type: vec3 (3 float)
-	VEC4,            // Shader uniform type: vec4 (4 float)
-	INT,             // Shader uniform type: int
-	IVEC2,           // Shader uniform type: ivec2 (2 int)
-	IVEC3,           // Shader uniform type: ivec3 (3 int)
-	IVEC4,           // Shader uniform type: ivec4 (4 int)
-	SAMPLER2D        // Shader uniform type: sampler2d
-}
-
-// Shader attribute data types
-enum ShaderAttributeDataType : CInt
-{
-	FLOAT,            // Shader attribute type: float
-	VEC2,             // Shader attribute type: vec2 (2 float)
-	VEC3,             // Shader attribute type: vec3 (3 float)
-	VEC4              // Shader attribute type: vec4 (4 float)
-}
-
-// Pixel formats
-// NOTE: Support depends on OpenGL version and platform
-enum PixelFormat : const CInt
-{
-	UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
-	UNCOMPRESSED_GRAY_ALPHA,    // 8*2 bpp (2 channels)
-	UNCOMPRESSED_R5G6B5,        // 16 bpp
-	UNCOMPRESSED_R8G8B8,        // 24 bpp
-	UNCOMPRESSED_R5G5B5A1,      // 16 bpp (1 bit alpha)
-	UNCOMPRESSED_R4G4B4A4,      // 16 bpp (4 bit alpha)
-	UNCOMPRESSED_R8G8B8A8,      // 32 bpp
-	UNCOMPRESSED_R32,           // 32 bpp (1 channel - float)
-	UNCOMPRESSED_R32G32B32,     // 32*3 bpp (3 channels - float)
-	UNCOMPRESSED_R32G32B32A32,  // 32*4 bpp (4 channels - float)
-	UNCOMPRESSED_R16,           // 16 bpp (1 channel - half float)
-	UNCOMPRESSED_R16G16B16,     // 16*3 bpp (3 channels - half float)
-	UNCOMPRESSED_R16G16B16A16,  // 16*4 bpp (4 channels - half float)
-	COMPRESSED_DXT1_RGB,        // 4 bpp (no alpha)
-	COMPRESSED_DXT1_RGBA,       // 4 bpp (1 bit alpha)
-	COMPRESSED_DXT3_RGBA,       // 8 bpp
-	COMPRESSED_DXT5_RGBA,       // 8 bpp
-	COMPRESSED_ETC1_RGB,        // 4 bpp
-	COMPRESSED_ETC2_RGB,        // 4 bpp
-	COMPRESSED_ETC2_EAC_RGBA,   // 8 bpp
-	COMPRESSED_PVRT_RGB,        // 4 bpp
-	COMPRESSED_PVRT_RGBA,       // 4 bpp
-	COMPRESSED_ASTC_4X4_RGBA,   // 8 bpp
-	COMPRESSED_ASTC_8X8_RGBA    // 2 bpp
-}
-
-// Texture parameters: filter mode
-// NOTE 1: Filtering considers mipmaps if available in the texture
-// NOTE 2: Filter is accordingly set for minification and magnification
-enum TextureFilter : CInt
-{
-	POINT,               // No filter, just pixel approximation
-	BILINEAR,                // Linear filtering
-	TRILINEAR,               // Trilinear filtering (linear with mipmaps)
-	ANISOTROPIC_4X,          // Anisotropic filtering 4x
-	ANISOTROPIC_8X,          // Anisotropic filtering 8x
-	ANISOTROPIC_16X,         // Anisotropic filtering 16x
-}
-
-// Texture parameters: wrap mode
-enum TextureWrap : CInt
-{
-	REPEAT,                    // Repeats texture in tiled mode
-	CLAMP,                     // Clamps texture to edge pixel in tiled mode
-	MIRROR_REPEAT,             // Mirrors and repeats the texture in tiled mode
-	MIRROR_CLAMP               // Mirrors and clamps to border the texture in tiled mode
-}
-
-// Cubemap layouts
-enum CubemapLayout : CInt
-{
-	AUTO_DETECT,             // Automatically detect layout type
-	LINE_VERTICAL,           // Layout is defined by a vertical line with faces
-	LINE_HORIZONTAL,         // Layout is defined by a horizontal line with faces
-	CROSS_THREE_BY_FOUR,     // Layout is defined by a 3x4 cross with cubemap faces
-	CROSS_FOUR_BY_THREE,     // Layout is defined by a 4x3 cross with cubemap faces
-}
-
-// Font type, defines generation method
-enum FontType : CInt
-{
-	DEFAULT,                   // Default font generation, anti-aliased
-	BITMAP,                    // Bitmap font generation, no anti-aliasing
-	SDF,                       // SDF font generation, requires external shader
-}
-
-// Color blending modes (pre-defined)
-enum BlendMode : CInt
-{
-	ALPHA,                    // Blend textures considering alpha (default)
-	ADDITIVE,                 // Blend textures adding colors
-	MULTIPLIED,               // Blend textures multiplying colors
-	ADD_COLORS,               // Blend textures adding colors (alternative)
-	SUBTRACT_COLORS,          // Blend textures subtracting colors (alternative)
-	ALPHA_PREMULTIPLY,        // Blend premultiplied textures considering alpha
-	CUSTOM,                   // Blend textures using custom src/dst factors (use setBlendFactors())
-	CUSTOM_SEPARATE,          // Blend textures using custom rgb/alpha separate src/dst factors (use setBlendFactorsSeparate())
-}
-
-$assert(BlendMode.ALPHA.ordinal == 0);
-
-
-// Camera system modes
-enum CameraMode : CInt
-{
-	CUSTOM,                  // Camera custom, controlled by user (UpdateCamera() does nothing)
-	FREE,                    // Camera free mode
-	ORBITAL,                 // Camera orbital, around target, zoom supported
-	FIRST_PERSON,            // Camera first person
-	THIRD_PERSON,            // Camera third person
-}
-
-// Camera projection
-enum CameraProjection : CInt
-{
-	PERSPECTIVE,             // Perspective projection
-	ORTHOGRAPHIC,            // Orthographic projection
-}
-
-// N-patch layout
-enum NPatchLayout : CInt
-{
-	NINE_PATCH,              // Npatch layout: 3x3 tiles
-	THREE_PATCH_VERTICAL,    // Npatch layout: 1x3 tiles
-	THREE_PATCH_HORIZONTAL   // Npatch layout: 3x1 tiles
-}
-
-// Callbacks to hook some internal functions
-// WARNING: This callbacks are intended for advance users
-alias TraceLogCallback @if($defined(CVaList)) = fn void(TraceLogLevel logLevel, ZString text, CVaList args);  // Logging: Redirect trace log messages
-alias LoadFileDataCallback = fn char*(ZString file_name, CInt* data_size);             // FileIO: Load binary data
-alias SaveFileDataCallback = fn bool(ZString file_name, void *data, CInt data_size);   // FileIO: Save binary data
-alias LoadFileTextCallback = fn char*(ZString file_name);              // FileIO: Load text data
-alias SaveFileTextCallback = fn bool(ZString file_name, ZString text); // FileIO: Save text data
-
-// Window-related functions
-fn void initWindow(CInt width, CInt height, ZString title) @cname("InitWindow");        // Initialize window and OpenGL context
-fn void closeWindow() @cname("CloseWindow");                                            // Close window and unload OpenGL context
-fn bool windowShouldClose() @cname("WindowShouldClose");                                // Check if application should close (KEY_ESCAPE pressed or windows close icon clicked)
-fn bool isWindowReady() @cname("IsWindowReady");                                        // Check if window has been initialized successfully
-fn bool isWindowFullscreen() @cname("IsWindowFullscreen");                              // Check if window is currently fullscreen
-fn bool isWindowHidden() @cname("IsWindowHidden");                                      // Check if window is currently hidden
-fn bool isWindowMinimized() @cname("IsWindowMinimized");                                // Check if window is currently minimized
-fn bool isWindowMaximized() @cname("IsWindowMaximized");                                // Check if window is currently maximized
-fn bool isWindowFocused() @cname("IsWindowFocused");                                    // Check if window is currently focused
-fn bool isWindowResized() @cname("IsWindowResized");                                    // Check if window has been resized last frame
-fn bool isWindowState(ConfigFlag flag) @cname("IsWindowState");                        // Check if one specific window flag is enabled
-fn void setWindowState(ConfigFlag flags) @cname("SetWindowState");                     // Set window configuration state using flags
-fn void clearWindowState(ConfigFlag flags) @cname("ClearWindowState");                 // Clear window configuration state flags
-fn void toggleFullscreen() @cname("ToggleFullscreen");                                  // Toggle window state: fullscreen/windowed, resizes monitor to match window resolution
-fn void toggleBorderlessWindowed() @cname("ToggleBorderlessWindowed");                  // Toggle window state: borderless windowed, resizes window to match monitor resolution
-fn void maximizeWindow() @cname("MaximizeWindow");                                      // Set window state: maximized, if resizable
-fn void minimizeWindow() @cname("MinimizeWindow");                                      // Set window state: minimized, if resizable
-fn void restoreWindow() @cname("RestoreWindow");                                        // Set window state: not minimized/maximized
-fn void setWindowIcon(Image image) @cname("SetWindowIcon");                             // Set icon for window (single image, RGBA 32bit)
-fn void setWindowIcons(Image *images, CInt count) @cname("SetWindowIcons");             // Set icon for window (multiple images, RGBA 32bit)
-fn void setWindowTitle(ZString title) @cname("SetWindowTitle");                         // Set title for window
-fn void setWindowPosition(CInt x, CInt y) @cname("SetWindowPosition");                  // Set window position on screen
-fn void setWindowMonitor(CInt monitor) @cname("SetWindowMonitor");                      // Set monitor for the current window
-fn void setWindowMinSize(CInt width, CInt height) @cname("SetWindowMinSize");           // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
-fn void setWindowMaxSize(CInt width, CInt height) @cname("SetWindowMaxSize");           // Set window maximum dimensions (for FLAG_WINDOW_RESIZABLE)
-fn void setWindowSize(CInt width, CInt height) @cname("SetWindowSize");                 // Set window dimensions
-fn void setWindowOpacity(float opacity) @cname("SetWindowOpacity");                     // Set window opacity [0.0f..1.0f]
-fn void setWindowFocused() @cname("SetWindowFocused");                                  // Set window focused
-fn void *getWindowHandle() @cname("GetWindowHandle");                                   // Get native window handle
-fn int getScreenWidth() @cname("GetScreenWidth");                                       // Get current screen width
-fn CInt getScreenHeight() @cname("GetScreenHeight");                                    // Get current screen height
-fn CInt getRenderWidth() @cname("GetRenderWidth");                                      // Get current render width (it considers HiDPI)
-fn CInt getRenderHeight() @cname("GetRenderHeight");                                    // Get current render height (it considers HiDPI)
-fn CInt getMonitorCount() @cname("GetMonitorCount");                                    // Get number of connected monitors
-fn CInt getCurrentMonitor() @cname("GetCurrentMonitor");                                // Get current monitor where window is placed
-fn Vector2 getMonitorPosition(CInt monitor) @cname("GetMonitorPosition");               // Get specified monitor position
-fn CInt getMonitorWidth(CInt monitor) @cname("GetMonitorWidth");                        // Get specified monitor width (current video mode used by monitor)
-fn CInt getMonitorHeight(CInt monitor) @cname("GetMonitorHeight");                      // Get specified monitor height (current video mode used by monitor)
-fn CInt getMonitorPhysicalWidth(CInt monitor) @cname("GetMonitorPhysicalWidth");        // Get specified monitor physical width in millimetres
-fn CInt getMonitorPhysicalHeight(CInt monitor) @cname("GetMonitorPhysicalHeight");      // Get specified monitor physical height in millimetres
-fn CInt getMonitorRefreshRate(CInt monitor) @cname("GetMonitorRefreshRate");            // Get specified monitor refresh rate
-fn Vector2 getWindowPosition() @cname("GetWindowPosition");                             // Get window position XY on monitor
-fn Vector2 getWindowScaleDPI() @cname("GetWindowScaleDPI");                             // Get window scale DPI factor
-fn ZString getMonitorName(CInt monitor) @cname("GetMonitorName");                       // Get the human-readable, UTF-8 encoded name of the specified monitor
-fn void setClipboardText(ZString text) @cname("SetClipboardText");                      // Set clipboard text content
-fn ZString getClipboardText() @cname("GetClipboardText");                               // Get clipboard text content
-fn Image getClipboardImage() @cname("GetClipboardImage");                               // Get clipboard image content
-fn void enableEventWaiting() @cname("EnableEventWaiting");                              // Enable waiting for events on EndDrawing(), no automatic event polling
-fn void disableEventWaiting() @cname("DisableEventWaiting");                            // Disable waiting for events on EndDrawing(), automatic events polling
-
-                                                       // Cursor-related functions
-fn void showCursor() @cname("ShowCursor");             // Shows cursor
-fn void hideCursor() @cname("HideCursor");             // Hides cursor
-fn bool isCursorHidden() @cname("IsCursorHidden");     // Check if cursor is not visible
-fn void enableCursor() @cname("EnableCursor");         // Enables cursor (unlock cursor)
-fn void disableCursor() @cname("DisableCursor");       // Disables cursor (lock cursor)
-fn bool isCursorOnScreen() @cname("IsCursorOnScreen"); // Check if cursor is on the screen
-
-// Drawing-related functions
-fn void clearBackground(Color color) @cname("ClearBackground");                               // Set background color (framebuffer clear color)
-fn void beginDrawing() @cname("BeginDrawing");                                                // Setup canvas (framebuffer) to start drawing
-fn void endDrawing() @cname("EndDrawing");                                                    // End canvas drawing and swap buffers (double buffering)
-fn void beginMode2D(Camera2D camera) @cname("BeginMode2D");                                   // Begin 2D mode with custom camera (2D)
-fn void endMode2D() @cname("EndMode2D");                                                      // Ends 2D mode with custom camera
-fn void beginMode3D(Camera3D camera) @cname("BeginMode3D");                                   // Begin 3D mode with custom camera (3D)
-fn void endMode3D() @cname("EndMode3D");                                                      // Ends 3D mode and returns to default 2D orthographic mode
-fn void beginTextureMode(RenderTexture2D target) @cname("BeginTextureMode");                  // Begin drawing to render texture
-fn void endTextureMode() @cname("EndTextureMode");                                            // Ends drawing to render texture
-fn void beginShaderMode(Shader shader) @cname("BeginShaderMode");                             // Begin custom shader drawing
-fn void endShaderMode() @cname("EndShaderMode");                                              // End custom shader drawing (use default shader)
-fn void beginBlendMode(BlendMode mode) @cname("BeginBlendMode");                              // Begin blending mode (alpha, additive, multiplied, subtract, custom)
-fn void endBlendMode() @cname("EndBlendMode");                                                // End blending mode (reset to default: alpha blending)
-fn void beginScissorMode(CInt x, CInt y, CInt width, CInt height) @cname("BeginScissorMode"); // Begin scissor mode (define screen area for following drawing)
-fn void endScissorMode() @cname("EndScissorMode");                                            // End scissor mode
-fn void beginVrStereoMode(VrStereoConfig config) @cname("BeginVrStereoMode");                 // Begin stereo rendering (requires VR simulator)
-fn void endVrStereoMode() @cname("EndVrStereoMode");                                          // End stereo rendering (requires VR simulator)
-
-// VR stereo config functions for VR simulator
-fn VrStereoConfig loadVrStereoConfig(VrDeviceInfo device) @cname("LoadVrStereoConfig"); // Load VR stereo config for VR simulator device parameters
-fn void unloadVrStereoConfig(VrStereoConfig config) @cname("UnloadVrStereoConfig");     // Unload VR stereo config
-
-// Shader management functions
-// NOTE: Shader functionality is not available on OpenGL 1.1
-fn Shader loadShader(ZString vsFileName, ZString fsFileName) @cname("LoadShader");                                                                            // Load shader from files and bind default locations
-fn Shader loadShaderFromMemory(ZString vsCode, ZString fsCode) @cname("LoadShaderFromMemory");                                                                // Load shader from code strings and bind default locations
-fn bool isShaderValid(Shader shader) @cname("IsShaderValid");                                                                                                 // Check if a shader is valid (loaded on GPU)
-fn CInt getShaderLocation(Shader shader, ZString uniformName) @cname("GetShaderLocation");                                                                    // Get shader uniform location
-fn CInt getShaderLocationAttrib(Shader shader, ZString attribName) @cname("GetShaderLocationAttrib");                                                         // Get shader attribute location
-fn void setShaderValue(Shader shader, CInt locIndex, void* value, ShaderUniformDataType uniformType) @cname("SetShaderValue");               // Set shader uniform value
-fn void setShaderValueV(Shader shader, CInt locIndex, void* value, ShaderUniformDataType uniformType, CInt count) @cname("SetShaderValueV"); // Set shader uniform value vector
-fn void setShaderValueMatrix(Shader shader, CInt locIndex, Matrix mat) @cname("SetShaderValueMatrix");                                         // Set shader uniform value (matrix 4x4)
-fn void setShaderValueTexture(Shader shader, CInt locIndex, Texture2D texture) @cname("SetShaderValueTexture");                                // Set shader uniform value for texture (sampler2d)
-fn void unloadShader(Shader shader) @cname("UnloadShader");                                                                                                   // Unload shader from GPU memory (VRAM)
-
-// Screen-space-related functions
-fn Ray getScreenToWorldRay(Vector2 position, Camera camera) @cname("GetScreenToWorldRay");                              // Get a ray trace from screen position (i.e mouse)
-fn Ray getScreenToWorldRayEx(Vector2 position, Camera camera, CInt width, CInt height) @cname("GetScreenToWorldRayEx"); // Get a ray trace from screen position (i.e mouse) in a viewport
-fn Vector2 getWorldToScreen(Vector3 position, Camera camera) @cname("GetWorldToScreen");                                // Get the screen space position for a 3d world space position
-fn Vector2 getWorldToScreenEx(Vector3 position, Camera camera, CInt width, CInt height) @cname("GetWorldToScreenEx");   // Get size position for a 3d world space position
-fn Vector2 getWorldToScreen2D(Vector2 position, Camera2D camera) @cname("GetWorldToScreen2D");                          // Get the screen space position for a 2d camera world space position
-fn Vector2 getScreenToWorld2D(Vector2 position, Camera2D camera) @cname("GetScreenToWorld2D");                          // Get the world space position for a 2d camera screen space position
-fn Matrix getCameraMatrix(Camera camera) @cname("GetCameraMatrix");                                                     // Get camera transform matrix (view matrix)
-fn Matrix getCameraMatrix2D(Camera2D camera) @cname("GetCameraMatrix2D");                                               // Get camera 2d transform matrix
-
-// Timing-related functions
-fn void setTargetFPS(CInt fps) @cname("SetTargetFPS"); // Set target FPS (maximum)
-fn float getFrameTime() @cname("GetFrameTime");        // Get time in seconds for last frame drawn (delta time)
-fn double getTime() @cname("GetTime");                 // Get elapsed time in seconds since InitWindow()
-fn CInt getFPS() @cname("GetFPS");                     // Get current FPS
-
-// Custom frame control functions
-// NOTE: Those functions are intended for advanced users that want full control over the frame processing
-// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents()
-// To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL
-fn void swapScreenBuffer() @cname("SwapScreenBuffer"); // Swap back buffer with front buffer (screen drawing)
-fn void pollInputEvents() @cname("PollInputEvents");   // Register all input events
-fn void waitTime(double seconds) @cname("WaitTime");   // Wait for some time (halt program execution)
-
-// Random values generation functions
-fn void setRandomSeed(CUInt seed) @cname("SetRandomSeed");                                 // Set the seed for the random number generator
-fn CInt getRandomValue(CInt min, CInt max) @cname("GetRandomValue");                       // Get a random value between min and max (both included)
-fn CInt *loadRandomSequence(CUInt count, CInt min, CInt max) @cname("LoadRandomSequence"); // Load random values sequence, no values repeated
-fn void unloadRandomSequence(CInt *sequence) @cname("UnloadRandomSequence");               // Unload random values sequence
-
-// Misc. functions
-fn void takeScreenshot(ZString fileName) @cname("TakeScreenshot");  // Takes a screenshot of current screen (filename extension defines format)
-fn void setConfigFlags(ConfigFlag flags) @cname("SetConfigFlags"); // Setup init configuration flags (view FLAGS)
-fn void openURL(ZString url) @cname("OpenURL");                     // Open URL with default system browser (if available)
-
-// NOTE: Following functions implemented in module [utils]
-//------------------------------------------------------------------
-fn void traceLog(TraceLogLevel logLevel, ZString text, ...) @cname("TraceLog"); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)
-fn void setTraceLogLevel(TraceLogLevel logLevel) @cname("SetTraceLogLevel");    // Set the current threshold (minimum) log level
-fn void *memAlloc(CUInt size) @cname("MemAlloc");                               // Internal memory allocator
-fn void *memRealloc(void *ptr, CUInt size) @cname("MemRealloc");                // Internal memory reallocator
-fn void memFree(void *ptr) @cname("MemFree");                                   // Internal memory free
-
-// Set custom callbacks
-// WARNING: Callbacks setup is intended for advanced users
-fn void setTraceLogCallback(TraceLogCallback callback) @cname("SetTraceLogCallback");             // Set custom trace log
-fn void setLoadFileDataCallback(LoadFileDataCallback callback) @cname("SetLoadFileDataCallback"); // Set custom file binary data loader
-fn void setSaveFileDataCallback(SaveFileDataCallback callback) @cname("SetSaveFileDataCallback"); // Set custom file binary data saver
-fn void setLoadFileTextCallback(LoadFileTextCallback callback) @cname("SetLoadFileTextCallback"); // Set custom file text data loader
-fn void setSaveFileTextCallback(SaveFileTextCallback callback) @cname("SetSaveFileTextCallback"); // Set custom file text data saver
-
-// Files management functions
-fn char* loadFileData(ZString fileName, CInt *dataSize) @cname("LoadFileData");                   // Load file data as byte array (read)
-fn void unloadFileData(char* data) @cname("UnloadFileData");                                      // Unload file data allocated by LoadFileData()
-fn bool saveFileData(ZString fileName, void *data, CInt dataSize) @cname("SaveFileData");         // Save data to file from byte array (write), returns true on success
-fn bool exportDataAsCode(char* data, CInt dataSize, ZString fileName) @cname("ExportDataAsCode"); // Export data to code (.h), returns true on success
-fn ZString loadFileText(ZString fileName) @cname("LoadFileText");                                 // Load text data from file (read), returns a '\0' terminated string
-fn void unloadFileText(ZString ) @cname("UnloadFileText");                                        // Unload file text data allocated by LoadFileText()
-fn bool saveFileText(ZString fileName, ZString text) @cname("SaveFileText");                      // Save text data to file (write), string must be '\0' terminated, returns true on success
-//------------------------------------------------------------------
-
-// File system functions
-fn bool fileExists(ZString fileName) @cname("FileExists");                                                               // Check if file exists
-fn bool directoryExists(ZString dirPath) @cname("DirectoryExists");                                                      // Check if a directory path exists
-fn bool isFileExtension(ZString fileName, ZString ext) @cname("IsFileExtension");                                        // Check file extension (including point: .png, .wav)
-fn CInt getFileLength(ZString fileName) @cname("GetFileLength");                                                         // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)
-fn ZString getFileExtension(ZString fileName) @cname("GetFileExtension");                                                // Get pointer to extension for a filename string (includes dot: '.png')
-fn ZString getFileName(ZString filePath) @cname("GetFileName");                                                          // Get pointer to filename for a path string
-fn ZString getFileNameWithoutExt(ZString filePath) @cname("GetFileNameWithoutExt");                                      // Get filename string without extension (uses static string)
-fn ZString getDirectoryPath(ZString filePath) @cname("GetDirectoryPath");                                                // Get full path for a given fileName with path (uses static string)
-fn ZString getPrevDirectoryPath(ZString dirPath) @cname("GetPrevDirectoryPath");                                         // Get previous directory path for a given path (uses static string)
-fn ZString getWorkingDirectory() @cname("GetWorkingDirectory");                                                          // Get current working directory (uses static string)
-fn ZString getApplicationDirectory() @cname("GetApplicationDirectory");                                                  // Get the directory of the running application (uses static string)
-fn CInt makeDirectory(ZString dirPath) @cname("MakeDirectory");                                                          // Create directories (including full path requested), returns 0 on success
-fn bool changeDirectory(ZString dir) @cname("ChangeDirectory");                                                          // Change working directory, return true on success
-fn bool isPathFile(ZString path) @cname("IsPathFile");                                                                   // Check if a given path is a file or a directory
-fn bool isFileNameValid(ZString fileName) @cname("IsFileNameValid");                                                     // Check if fileName is valid for the platform/OS
-fn FilePathList loadDirectoryFiles(ZString dirPath) @cname("LoadDirectoryFiles");                                        // Load directory filepaths
-fn FilePathList loadDirectoryFilesEx(ZString basePath, ZString filter, bool scanSubdirs) @cname("LoadDirectoryFilesEx"); // Load directory filepaths with extension filtering and recursive directory scan. Use 'DIR' in the filter string to include directories in the result
-fn void unloadDirectoryFiles(FilePathList files) @cname("UnloadDirectoryFiles");                                         // Unload filepaths
-fn bool isFileDropped() @cname("IsFileDropped");                                                                         // Check if a file has been dropped into window
-fn FilePathList loadDroppedFiles() @cname("LoadDroppedFiles");                                                           // Load dropped filepaths
-fn void unloadDroppedFiles(FilePathList files) @cname("UnloadDroppedFiles");                                             // Unload dropped filepaths
-fn long getFileModTime(ZString fileName) @cname("GetFileModTime");                                                       // Get file modification time (last write time)
-
-// Compression/Encoding functionality
-fn char* compressData(char* data, CInt dataSize, CInt *compDataSize) @cname("CompressData");         // Compress data (DEFLATE algorithm), memory must be MemFree()
-fn char* decompressData(char* compData, CInt compDataSize, CInt *dataSize) @cname("DecompressData"); // Decompress data (DEFLATE algorithm), memory must be MemFree()
-fn char* encodeDataBase64(char* data, CInt dataSize, CInt *outputSize) @cname("EncodeDataBase64");   // Encode data to Base64 string, memory must be MemFree()
-fn char* decodeDataBase64(char* data, CInt *outputSize) @cname("DecodeDataBase64");                  // Decode Base64 string data, memory must be MemFree()
-fn CUInt computeCRC32(char *data, CInt dataSize) @cname("ComputeCRC32");                             // Compute CRC32 hash code
-fn CUInt[4]* computeMD5(char *data, CInt dataSize) @cname("ComputeMD5");                             // Compute MD5 hash code, returns static CUInt[4] (16 bytes)
-fn CUInt[5]* computeSHA1(char *data, CInt dataSize) @cname("ComputeSHA1");                           // Compute SHA1 hash code, returns static CUInt[5] (20 bytes)
-
-
-// Automation events functionality
-fn AutomationEventList loadAutomationEventList(ZString fileName) @cname("LoadAutomationEventList");                // Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS
-fn void unloadAutomationEventList(AutomationEventList list) @cname("UnloadAutomationEventList");                   // Unload automation events list from file
-fn bool exportAutomationEventList(AutomationEventList list, ZString fileName) @cname("ExportAutomationEventList"); // Export automation events list as text file
-fn void setAutomationEventList(AutomationEventList *list) @cname("SetAutomationEventList");                        // Set automation event list to record to
-fn void setAutomationEventBaseFrame(CInt frame) @cname("SetAutomationEventBaseFrame");                             // Set automation event internal base frame to start recording
-fn void startAutomationEventRecording() @cname("StartAutomationEventRecording");                                   // Start recording automation events (AutomationEventList must be set)
-fn void stopAutomationEventRecording() @cname("StopAutomationEventRecording");                                     // Stop recording automation events
-fn void playAutomationEvent(AutomationEvent event) @cname("PlayAutomationEvent");                                  // Play a recorded automation event
-
-//------------------------------------------------------------------------------------
-// Input Handling Functions (Module: core)
-//------------------------------------------------------------------------------------
-
-// Input-related functions: keyboard
-fn bool isKeyPressed(KeyboardKey key) @cname("IsKeyPressed");             // Check if a key has been pressed once
-fn bool isKeyPressedRepeat(KeyboardKey key) @cname("IsKeyPressedRepeat"); // Check if a key has been pressed again
-fn bool isKeyDown(KeyboardKey key) @cname("IsKeyDown");                   // Check if a key is being pressed
-fn bool isKeyReleased(KeyboardKey key) @cname("IsKeyReleased");           // Check if a key has been released once
-fn bool isKeyUp(KeyboardKey key) @cname("IsKeyUp");                       // Check if a key is NOT being pressed
-fn KeyboardKey getKeyPressed() @cname("GetKeyPressed");                   // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty
-fn CInt getCharPressed() @cname("GetCharPressed");                        // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty
-fn void setExitKey(KeyboardKey key) @cname("SetExitKey");                 // Set a custom key to exit program (default is ESC)
-
-// Input-related functions: gamepads
-fn bool isGamepadAvailable(CInt gamepad) @cname("IsGamepadAvailable");                                                      // Check if a gamepad is available
-fn ZString getGamepadName(CInt gamepad) @cname("GetGamepadName");                                                           // Get gamepad internal name id
-fn bool isGamepadButtonPressed(CInt gamepad, GamepadButton button) @cname("IsGamepadButtonPressed");                        // Check if a gamepad button has been pressed once
-fn bool isGamepadButtonDown(CInt gamepad, GamepadButton button) @cname("IsGamepadButtonDown");                              // Check if a gamepad button is being pressed
-fn bool isGamepadButtonReleased(CInt gamepad, GamepadButton button) @cname("IsGamepadButtonReleased");                      // Check if a gamepad button has been released once
-fn bool isGamepadButtonUp(CInt gamepad, GamepadButton button) @cname("IsGamepadButtonUp");                                  // Check if a gamepad button is NOT being pressed
-fn GamepadButton getGamepadButtonPressed() @cname("GetGamepadButtonPressed");                                               // Get the last gamepad button pressed
-fn CInt getGamepadAxisCount(CInt gamepad) @cname("GetGamepadAxisCount");                                                    // Get gamepad axis count for a gamepad
-fn float getGamepadAxisMovement(CInt gamepad, GamepadAxis axis) @cname("GetGamepadAxisMovement");                           // Get axis movement value for a gamepad axis
-fn CInt setGamepadMappings(ZString mappings) @cname("SetGamepadMappings");                                                  // Set internal gamepad mappings (SDL_GameControllerDB)
-fn void setGamepadVibration(CInt gamepad, float leftMotor, float rightMotor, float duration) @cname("SetGamepadVibration"); // Set gamepad vibration for both motors (duration in seconds)
-
-// Input-related functions: mouse
-fn bool isMouseButtonPressed(MouseButton button) @cname("IsMouseButtonPressed");   // Check if a mouse button has been pressed once
-fn bool isMouseButtonDown(MouseButton button) @cname("IsMouseButtonDown");         // Check if a mouse button is being pressed
-fn bool isMouseButtonReleased(MouseButton button) @cname("IsMouseButtonReleased"); // Check if a mouse button has been released once
-fn bool isMouseButtonUp(MouseButton button) @cname("IsMouseButtonUp");             // Check if a mouse button is NOT being pressed
-fn CInt getMouseX() @cname("GetMouseX");                                           // Get mouse position X
-fn CInt getMouseY() @cname("GetMouseY");                                           // Get mouse position Y
-fn Vector2 getMousePosition() @cname("GetMousePosition");                          // Get mouse position XY
-fn Vector2 getMouseDelta() @cname("GetMouseDelta");                                // Get mouse delta between frames
-fn void setMousePosition(CInt x, CInt y) @cname("SetMousePosition");               // Set mouse position XY
-fn void setMouseOffset(CInt offsetX, CInt offsetY) @cname("SetMouseOffset");       // Set mouse offset
-fn void setMouseScale(float scaleX, float scaleY) @cname("SetMouseScale");         // Set mouse scaling
-fn float getMouseWheelMove() @cname("GetMouseWheelMove");                          // Get mouse wheel movement for X or Y, whichever is larger
-fn Vector2 getMouseWheelMoveV() @cname("GetMouseWheelMoveV");                      // Get mouse wheel movement for both X and Y
-fn void setMouseCursor(MouseCursor cursor) @cname("SetMouseCursor");               // Set mouse cursor
-
-// Input-related functions: touch
-fn CInt getTouchX() @cname("GetTouchX");                            // Get touch position X for touch point 0 (relative to screen size)
-fn CInt getTouchY() @cname("GetTouchY");                            // Get touch position Y for touch point 0 (relative to screen size)
-fn Vector2 getTouchPosition(CInt index) @cname("GetTouchPosition"); // Get touch position XY for a touch point index (relative to screen size)
-fn CInt getTouchPointId(CInt index) @cname("GetTouchPointId");      // Get touch point identifier for given index
-fn CInt getTouchPointCount() @cname("GetTouchPointCount");          // Get number of touch points
-
-//------------------------------------------------------------------------------------
-// Gestures and Touch Handling Functions (Module: rgestures)
-//------------------------------------------------------------------------------------
-fn void setGesturesEnabled(Gesture flags) @cname("SetGesturesEnabled"); // Enable a set of gestures using flags
-fn bool isGestureDetected(Gesture gesture) @cname("IsGestureDetected"); // Check if a gesture have been detected
-fn Gesture getGestureDetected() @cname("GetGestureDetected");           // Get latest detected gesture
-fn float getGestureHoldDuration() @cname("GetGestureHoldDuration");     // Get gesture hold time in seconds
-fn Vector2 getGestureDragVector() @cname("GetGestureDragVector");       // Get gesture drag vector
-fn float getGestureDragAngle() @cname("GetGestureDragAngle");           // Get gesture drag angle
-fn Vector2 getGesturePinchVector() @cname("GetGesturePinchVector");     // Get gesture pinch delta
-fn float getGesturePinchAngle() @cname("GetGesturePinchAngle");         // Get gesture pinch angle
-
-//------------------------------------------------------------------------------------
-// Camera System Functions (Module: rcamera)
-//------------------------------------------------------------------------------------
-fn void updateCamera(Camera *camera, CameraMode mode) @cname("UpdateCamera");                                      // Update camera position for selected mode
-fn void updateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, float zoom) @cname("UpdateCameraPro"); // Update camera movement/rotation
-
-//------------------------------------------------------------------------------------
-// Basic Shapes Drawing Functions (Module: shapes)
-//------------------------------------------------------------------------------------
-// Set texture and rectangle to be used on shapes drawing
-// NOTE: It can be useful when using basic shapes and one single font,
-// defining a font char white rectangle would allow drawing everything in a single draw call
-fn void setShapesTexture(Texture2D texture, Rectangle source) @cname("SetShapesTexture"); // Set texture and rectangle to be used on shapes drawing
-fn Texture2D getShapesTexture() @cname("GetShapesTexture");                               // Get texture that is used for shapes drawing
-fn Rectangle getShapesTextureRectangle() @cname("GetShapesTextureRectangle");             // Get texture source rectangle that is used for shapes drawing
-
-// Basic shapes drawing functions
-fn void drawPixel(CInt posX, CInt posY, Color color) @cname("DrawPixel");                                                                                          // Draw a pixel using geometry [Can be slow, use with care]
-fn void drawPixelV(Vector2 position, Color color) @cname("DrawPixelV");                                                                                            // Draw a pixel using geometry (Vector version) [Can be slow, use with care]
-fn void drawLine(CInt startPosX, CInt startPosY, CInt endPosX, CInt endPosY, Color color) @cname("DrawLine");                                                      // Draw a line
-fn void drawLineV(Vector2 startPos, Vector2 endPos, Color color) @cname("DrawLineV");                                                                              // Draw a line (using gl lines)
-fn void drawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color) @cname("DrawLineEx");                                                               // Draw a line (using triangles/quads)
-fn void drawLineStrip(Vector2 *points, CInt pointCount, Color color) @cname("DrawLineStrip");                                                                      // Draw lines sequence (using gl lines)
-fn void drawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color) @cname("DrawLineBezier");                                                       // Draw line segment cubic-bezier in-out interpolation
-fn void drawCircle(CInt centerX, CInt centerY, float radius, Color color) @cname("DrawCircle");                                                                    // Draw a color-filled circle
-fn void drawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, CInt segments, Color color) @cname("DrawCircleSector");                   // Draw a piece of a circle
-fn void drawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, CInt segments, Color color) @cname("DrawCircleSectorLines");         // Draw circle sector outline
-fn void drawCircleGradient(CInt centerX, CInt centerY, float radius, Color inner, Color outer) @cname("DrawCircleGradient");                                       // Draw a gradient-filled circle
-fn void drawCircleV(Vector2 center, float radius, Color color) @cname("DrawCircleV");                                                                              // Draw a color-filled circle (Vector version)
-fn void drawCircleLines(CInt centerX, CInt centerY, float radius, Color color) @cname("DrawCircleLines");                                                          // Draw circle outline
-fn void drawCircleLinesV(Vector2 center, float radius, Color color) @cname("DrawCircleLinesV");                                                                    // Draw circle outline (Vector version)
-fn void drawEllipse(CInt centerX, CInt centerY, float radiusH, float radiusV, Color color) @cname("DrawEllipse");                                                  // Draw ellipse
-fn void drawEllipseLines(CInt centerX, CInt centerY, float radiusH, float radiusV, Color color) @cname("DrawEllipseLines");                                        // Draw ellipse outline
-fn void drawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, CInt segments, Color color) @cname("DrawRing");           // Draw ring
-fn void drawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, CInt segments, Color color) @cname("DrawRingLines"); // Draw ring outline
-fn void drawRectangle(CInt posX, CInt posY, CInt width, CInt height, Color color) @cname("DrawRectangle");                                                         // Draw a color-filled rectangle
-fn void drawRectangleV(Vector2 position, Vector2 size, Color color) @cname("DrawRectangleV");                                                                      // Draw a color-filled rectangle (Vector version)
-fn void drawRectangleRec(Rectangle rec, Color color) @cname("DrawRectangleRec");                                                                                   // Draw a color-filled rectangle
-fn void drawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color) @cname("DrawRectanglePro");                                                   // Draw a color-filled rectangle with pro parameters
-fn void drawRectangleGradientV(CInt posX, CInt posY, CInt width, CInt height, Color top, Color bottom) @cname("DrawRectangleGradientV");                           // Draw a vertical-gradient-filled rectangle
-fn void drawRectangleGradientH(CInt posX, CInt posY, CInt width, CInt height, Color left, Color right) @cname("DrawRectangleGradientH");                           // Draw a horizontal-gradient-filled rectangle
-fn void drawRectangleGradientEx(Rectangle rec, Color topLeft, Color bottomLeft, Color topRight, Color bottomRight) @cname("DrawRectangleGradientEx");              // Draw a gradient-filled rectangle with custom vertex colors
-fn void drawRectangleLines(CInt posX, CInt posY, CInt width, CInt height, Color color) @cname("DrawRectangleLines");                                               // Draw rectangle outline
-fn void drawRectangleLinesEx(Rectangle rec, float lineThick, Color color) @cname("DrawRectangleLinesEx");                                                          // Draw rectangle outline with extended parameters
-fn void drawRectangleRounded(Rectangle rec, float roundness, CInt segments, Color color) @cname("DrawRectangleRounded");                                           // Draw rectangle with rounded edges
-fn void drawRectangleRoundedLines(Rectangle rec, float roundness, CInt segments, Color color) @cname("DrawRectangleRoundedLines");                                 // Draw rectangle lines with rounded edges
-fn void drawRectangleRoundedLinesEx(Rectangle rec, float roundness, CInt segments, float lineThick, Color color) @cname("DrawRectangleRoundedLinesEx");            // Draw rectangle with rounded edges outline
-fn void drawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color) @cname("DrawTriangle");                                                                      // Draw a color-filled triangle (vertex in counter-clockwise order!)
-fn void drawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color) @cname("DrawTriangleLines");                                                            // Draw triangle outline (vertex in counter-clockwise order!)
-fn void drawTriangleFan(Vector2 *points, int pointCount, Color color) @cname("DrawTriangleFan");                                                                   // Draw a triangle fan defined by points (first vertex is the center)
-fn void drawTriangleStrip(Vector2 *points, int pointCount, Color color) @cname("DrawTriangleStrip");                                                               // Draw a triangle strip defined by points
-fn void drawPoly(Vector2 center, CInt sides, float radius, float rotation, Color color) @cname("DrawPoly");                                                        // Draw a regular polygon (Vector version)
-fn void drawPolyLines(Vector2 center, CInt sides, float radius, float rotation, Color color) @cname("DrawPolyLines");                                              // Draw a polygon outline of n sides
-fn void drawPolyLinesEx(Vector2 center, CInt sides, float radius, float rotation, float lineThick, Color color) @cname("DrawPolyLinesEx");                         // Draw a polygon outline of n sides with extended parameters
-
-// Splines drawing functions
-fn void drawSplineLinear(Vector2 *points, CInt pointCount, float thick, Color color) @cname("DrawSplineLinear");                                       // Draw spline: Linear, minimum 2 points
-fn void drawSplineBasis(Vector2 *points, CInt pointCount, float thick, Color color) @cname("DrawSplineBasis");                                         // Draw spline: B-Spline, minimum 4 points
-fn void drawSplineCatmullRom(Vector2 *points, CInt pointCount, float thick, Color color) @cname("DrawSplineCatmullRom");                               // Draw spline: Catmull-Rom, minimum 4 points
-fn void drawSplineBezierQuadratic(Vector2 *points, CInt pointCount, float thick, Color color) @cname("DrawSplineBezierQuadratic");                     // Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...]
-fn void drawSplineBezierCubic(Vector2 *points, CInt pointCount, float thick, Color color) @cname("DrawSplineBezierCubic");                             // Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...]
-fn void drawSplineSegmentLinear(Vector2 p1, Vector2 p2, float thick, Color color) @cname("DrawSplineSegmentLinear");                                   // Draw spline segment: Linear, 2 points
-fn void drawSplineSegmentBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color) @cname("DrawSplineSegmentBasis");             // Draw spline segment: B-Spline, 4 points
-fn void drawSplineSegmentCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color) @cname("DrawSplineSegmentCatmullRom");   // Draw spline segment: Catmull-Rom, 4 points
-fn void drawSplineSegmentBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float thick, Color color) @cname("DrawSplineSegmentBezierQuadratic");     // Draw spline segment: Quadratic Bezier, 2 points, 1 control point
-fn void drawSplineSegmentBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float thick, Color color) @cname("DrawSplineSegmentBezierCubic"); // Draw spline segment: Cubic Bezier, 2 points, 2 control points
-
-// Spline segment point evaluation functions, for a given t [0.0f .. 1.0f]
-fn Vector2 getSplinePointLinear(Vector2 startPos, Vector2 endPos, float t) @cname("GetSplinePointLinear");                         // Get (evaluate) spline point: Linear
-fn Vector2 getSplinePointBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t) @cname("GetSplinePointBasis");             // Get (evaluate) spline point: B-Spline
-fn Vector2 getSplinePointCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t) @cname("GetSplinePointCatmullRom");   // Get (evaluate) spline point: Catmull-Rom
-fn Vector2 getSplinePointBezierQuad(Vector2 p1, Vector2 c2, Vector2 p3, float t) @cname("GetSplinePointBezierQuad");               // Get (evaluate) spline point: Quadratic Bezier
-fn Vector2 getSplinePointBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float t) @cname("GetSplinePointBezierCubic"); // Get (evaluate) spline point: Cubic Bezier
-
-// Basic shapes collision detection functions
-fn bool checkCollisionRecs(Rectangle rec1, Rectangle rec2) @cname("CheckCollisionRecs");                                                                    // Check collision between two rectangles
-fn bool checkCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2) @cname("CheckCollisionCircles");                              // Check collision between two circles
-fn bool checkCollisionCircleRec(Vector2 center, float radius, Rectangle rec) @cname("CheckCollisionCircleRec");                                             // Check collision between circle and rectangle
-fn bool checkCollisionCircleLine(Vector2 center, float radius, Vector2 p1, Vector2 p2) @cname("CheckCollisionCircleLine");                                  // Check if circle collides with a line created betweeen two points [p1] and [p2]
-fn bool checkCollisionPointRec(Vector2 point, Rectangle rec) @cname("CheckCollisionPointRec");                                                              // Check if point is inside rectangle
-fn bool checkCollisionPointCircle(Vector2 point, Vector2 center, float radius) @cname("CheckCollisionPointCircle");                                         // Check if point is inside circle
-fn bool checkCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3) @cname("CheckCollisionPointTriangle");                               // Check if point is inside a triangle
-fn bool checkCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, CInt threshold) @cname("CheckCollisionPointLine");                                   // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]
-fn bool checkCollisionPointPoly(Vector2 point, Vector2 *points, CInt pointCount) @cname("CheckCollisionPointPoly");                                         // Check if point is within a polygon described by array of vertices
-fn bool checkCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint) @cname("CheckCollisionLines"); // Check the collision between two lines defined by two points each, returns collision point by reference
-fn Rectangle getCollisionRec(Rectangle rec1, Rectangle rec2) @cname("GetCollisionRec");                                                                     // Get collision rectangle for two rectangles collision
-
-//------------------------------------------------------------------------------------
-// Texture Loading and Drawing Functions (Module: textures)
-//------------------------------------------------------------------------------------
-
-// Image loading functions
-// NOTE: These functions do not require GPU access
-fn Image loadImage(ZString fileName) @cname("LoadImage");                                                                          // Load image from file into CPU memory (RAM)
-fn Image loadImageRaw(ZString fileName, CInt width, CInt height, CInt format, CInt headerSize) @cname("LoadImageRaw");             // Load image from RAW file data
-fn Image loadImageAnim(ZString fileName, CInt *frames) @cname("LoadImageAnim");                                                    // Load image sequence from file (frames appended to image.data)
-fn Image loadImageAnimFromMemory(ZString fileType, char* fileData, CInt dataSize, CInt *frames) @cname("LoadImageAnimFromMemory"); // Load image sequence from memory buffer
-fn Image loadImageFromMemory(ZString fileType, char* fileData, CInt dataSize) @cname("LoadImageFromMemory");                       // Load image from memory buffer, fileType refers to extension: i.e. '.png'
-fn Image loadImageFromTexture(Texture2D texture) @cname("LoadImageFromTexture");                                                   // Load image from GPU texture data
-fn Image loadImageFromScreen() @cname("LoadImageFromScreen");                                                                      // Load image from screen buffer and (screenshot)
-fn bool isImageValid(Image image) @cname("IsImageValid");                                                                          // Check if an image is valid (data and parameters)
-fn void unloadImage(Image image) @cname("UnloadImage");                                                                            // Unload image from CPU memory (RAM)
-fn bool exportImage(Image image, ZString fileName) @cname("ExportImage");                                                          // Export image data to file, returns true on success
-fn char* exportImageToMemory(Image image, ZString fileType, CInt *fileSize) @cname("ExportImageToMemory");                         // Export image to memory buffer
-fn bool exportImageAsCode(Image image, ZString fileName) @cname("ExportImageAsCode");                                              // Export image as code file defining an array of bytes, returns true on success
-
-// Image generation functions
-fn Image genImageColor(CInt width, CInt height, Color color) @cname("GenImageColor");                                               // Generate image: plain color
-fn Image genImageGradientLinear(CInt width, CInt height, CInt direction, Color start, Color end) @cname("GenImageGradientLinear");  // Generate image: linear gradient, direction in degrees [0..360], 0=Vertical gradient
-fn Image genImageGradientRadial(CInt width, CInt height, float density, Color inner, Color outer) @cname("GenImageGradientRadial"); // Generate image: radial gradient
-fn Image genImageGradientSquare(CInt width, CInt height, float density, Color inner, Color outer) @cname("GenImageGradientSquare"); // Generate image: square gradient
-fn Image genImageChecked(CInt width, CInt height, CInt checksX, CInt checksY, Color col1, Color col2) @cname("GenImageChecked");    // Generate image: checked
-fn Image genImageWhiteNoise(CInt width, CInt height, float factor) @cname("GenImageWhiteNoise");                                    // Generate image: white noise
-fn Image genImagePerlinNoise(CInt width, CInt height, CInt offsetX, CInt offsetY, float scale) @cname("GenImagePerlinNoise");       // Generate image: perlin noise
-fn Image genImageCellular(CInt width, CInt height, CInt tileSize) @cname("GenImageCellular");                                       // Generate image: cellular algorithm, bigger tileSize means bigger cells
-fn Image genImageText(CInt width, CInt height, ZString text) @cname("GenImageText");                                                // Generate image: grayscale image from text data
-
-// Image manipulation functions
-fn Image imageCopy(Image image) @cname("ImageCopy");                                                                                        // Create an image duplicate (useful for transformations)
-fn Image imageFromImage(Image image, Rectangle rec) @cname("ImageFromImage");                                                               // Create an image from another image piece
-fn Image imageFromChannel(Image image, CInt selectedChannel) @cname("ImageFromChannel");                                                    // Create an image from a selected channel of another image (GRAYSCALE)
-fn Image imageText(ZString text, CInt fontSize, Color color) @cname("ImageText");                                                           // Create an image from text (default font)
-fn Image imageTextEx(Font font, ZString text, float fontSize, float spacing, Color tint) @cname("ImageTextEx");                             // Create an image from text (custom sprite font)
-fn void imageFormat(Image *image, PixelFormat newFormat) @cname("ImageFormat");                                                             // Convert image data to desired format
-fn void imageToPOT(Image *image, Color fill) @cname("ImageToPOT");                                                                          // Convert image to POT (power-of-two)
-fn void imageCrop(Image *image, Rectangle crop) @cname("ImageCrop");                                                                        // Crop an image to a defined rectangle
-fn void imageAlphaCrop(Image *image, float threshold) @cname("ImageAlphaCrop");                                                             // Crop image depending on alpha value
-fn void imageAlphaClear(Image *image, Color color, float threshold) @cname("ImageAlphaClear");                                              // Clear alpha channel to desired color
-fn void imageAlphaMask(Image *image, Image alphaMask) @cname("ImageAlphaMask");                                                             // Apply alpha mask to image
-fn void imageAlphaPremultiply(Image *image) @cname("ImageAlphaPremultiply");                                                                // Premultiply alpha channel
-fn void imageBlurGaussian(Image *image, CInt blurSize) @cname("ImageBlurGaussian");                                                         // Apply Gaussian blur using a box blur approximation
-fn void imageKernelConvolution(Image *image, float *kernel, CInt kernelSize) @cname("ImageKernelConvolution");                              // Apply custom square convolution kernel to image
-fn void imageResize(Image *image, CInt newWidth, CInt newHeight) @cname("ImageResize");                                                     // Resize image (Bicubic scaling algorithm)
-fn void imageResizeNN(Image *image, CInt newWidth,CInt newHeight) @cname("ImageResizeNN");                                                  // Resize image (Nearest-Neighbor scaling algorithm)
-fn void imageResizeCanvas(Image *image, CInt newWidth, CInt newHeight, CInt offsetX, CInt offsetY, Color fill) @cname("ImageResizeCanvas"); // Resize canvas and fill with color
-fn void imageMipmaps(Image *image) @cname("ImageMipmaps");                                                                                  // Compute all mipmap levels for a provided image
-fn void imageDither(Image *image, CInt rBpp, CInt gBpp, CInt bBpp, CInt aBpp) @cname("ImageDither");                                        // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
-fn void imageFlipVertical(Image *image) @cname("ImageFlipVertical");                                                                        // Flip image vertically
-fn void imageFlipHorizontal(Image *image) @cname("ImageFlipHorizontal");                                                                    // Flip image horizontally
-fn void imageRotate(Image *image, CInt degrees) @cname("ImageRotate");                                                                      // Rotate image by input angle in degrees (-359 to 359)
-fn void imageRotateCW(Image *image) @cname("ImageRotateCW");                                                                                // Rotate image clockwise 90deg
-fn void imageRotateCCW(Image *image) @cname("ImageRotateCCW");                                                                              // Rotate image counter-clockwise 90deg
-fn void imageColorTint(Image *image, Color color) @cname("ImageColorTint");                                                                 // Modify image color: tint
-fn void imageColorInvert(Image *image) @cname("ImageColorInvert");                                                                          // Modify image color: invert
-fn void imageColorGrayscale(Image *image) @cname("ImageColorGrayscale");                                                                    // Modify image color: grayscale
-fn void imageColorContrast(Image *image, float contrast) @cname("ImageColorContrast");                                                      // Modify image color: contrast (-100 to 100)
-fn void imageColorBrightness(Image *image, CInt brightness) @cname("ImageColorBrightness");                                                 // Modify image color: brightness (-255 to 255)
-fn void imageColorReplace(Image *image, Color color, Color replace) @cname("ImageColorReplace");                                            // Modify image color: replace color
-fn Color *loadImageColors(Image image) @cname("LoadImageColors");                                                                           // Load color data from image as a Color array (RGBA - 32bit)
-fn Color *loadImagePalette(Image image, CInt maxPaletteSize, CInt *colorCount) @cname("LoadImagePalette");                                  // Load colors palette from image as a Color array (RGBA - 32bit)
-fn void unloadImageColors(Color *colors) @cname("UnloadImageColors");                                                                       // Unload color data loaded with LoadImageColors()
-fn void unloadImagePalette(Color *colors) @cname("UnloadImagePalette");                                                                     // Unload colors palette loaded with LoadImagePalette()
-fn Rectangle getImageAlphaBorder(Image image, float threshold) @cname("GetImageAlphaBorder");                                               // Get image alpha border rectangle
-fn Color getImageColor(Image image, CInt x, CInt y) @cname("GetImageColor");                                                                // Get image pixel color at (x, y) position
-
-// Image drawing functions
-// NOTE: Image software-rendering functions (CPU)
-fn void imageClearBackground(Image *dst, Color color) @cname("ImageClearBackground");                                                                // Clear image background with given color
-fn void imageDrawPixel(Image *dst, CInt posX, CInt posY, Color color) @cname("ImageDrawPixel");                                                      // Draw pixel within an image
-fn void imageDrawPixelV(Image *dst, Vector2 position, Color color) @cname("ImageDrawPixelV");                                                        // Draw pixel within an image (Vector version)
-fn void imageDrawLine(Image *dst, CInt startPosX, CInt startPosY, CInt endPosX, CInt endPosY, Color color) @cname("ImageDrawLine");                  // Draw line within an image
-fn void imageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color) @cname("ImageDrawLineV");                                                // Draw line within an image (Vector version)
-fn void imageDrawLineEx(Image *dst, Vector2 start, Vector2 end, CInt thick, Color color) @cname("ImageDrawLineEx");                                  // Draw a line defining thickness within an image
-fn void imageDrawCircle(Image *dst, CInt centerX, CInt centerY, CInt radius, Color color) @cname("ImageDrawCircle");                                 // Draw a filled circle within an image
-fn void imageDrawCircleV(Image *dst, Vector2 center, CInt radius, Color color) @cname("ImageDrawCircleV");                                           // Draw a filled circle within an image (Vector version)
-fn void imageDrawCircleLines(Image *dst, CInt centerX, CInt centerY, CInt radius, Color color) @cname("ImageDrawCircleLines");                       // Draw circle outline within an image
-fn void imageDrawCircleLinesV(Image *dst, Vector2 center, CInt radius, Color color) @cname("ImageDrawCircleLinesV");                                 // Draw circle outline within an image (Vector version)
-fn void imageDrawRectangle(Image *dst, CInt posX, CInt posY, CInt width, CInt height, Color color) @cname("ImageDrawRectangle");                     // Draw rectangle within an image
-fn void imageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color) @cname("ImageDrawRectangleV");                                  // Draw rectangle within an image (Vector version)
-fn void imageDrawRectangleRec(Image *dst, Rectangle rec, Color color) @cname("ImageDrawRectangleRec");                                               // Draw rectangle within an image
-fn void imageDrawRectangleLines(Image *dst, Rectangle rec, CInt thick, Color color) @cname("ImageDrawRectangleLines");                               // Draw rectangle lines within an image
-fn void imageDrawTriangle(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color) @cname("ImageDrawTriangle");                                  // Draw triangle within an image
-fn void imageDrawTriangleEx(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color c1, Color c2, Color c3) @cname("ImageDrawTriangleEx");             // Draw triangle with interpolated colors within an image
-fn void imageDrawTriangleLines(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color) @cname("ImageDrawTriangleLines");                        // Draw triangle outline within an image
-fn void imageDrawTriangleFan(Image *dst, Vector2 *points, CInt pointCount, Color color) @cname("ImageDrawTriangleFan");                              // Draw a triangle fan defined by points within an image (first vertex is the center)
-fn void imageDrawTriangleStrip(Image *dst, Vector2 *points, CInt pointCount, Color color) @cname("ImageDrawTriangleStrip");                          // Draw a triangle strip defined by points within an image
-fn void imageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint) @cname("ImageDraw");                                        // Draw a source image within a destination image (tint applied to source)
-fn void imageDrawText(Image *dst, ZString text, CInt posX, CInt posY, CInt fontSize, Color color) @cname("ImageDrawText");                           // Draw text (using default font) within an image (destination)
-fn void imageDrawTextEx(Image *dst, Font font, ZString text, Vector2 position, float fontSize, float spacing, Color tint) @cname("ImageDrawTextEx"); // Draw text (custom sprite font) within an image (destination)
-
-// Texture loading functions
-// NOTE: These functions require GPU access
-fn Texture2D loadTexture(ZString fileName) @cname("LoadTexture");                                     // Load texture from file into GPU memory (VRAM)
-fn Texture2D loadTextureFromImage(Image image) @cname("LoadTextureFromImage");                        // Load texture from image data
-fn TextureCubemap loadTextureCubemap(Image image, CubemapLayout layout) @cname("LoadTextureCubemap"); // Load cubemap from image, multiple image cubemap layouts supported
-fn RenderTexture2D loadRenderTexture(CInt width, CInt height) @cname("LoadRenderTexture");            // Load texture for rendering (framebuffer)
-fn bool isTextureValid(Texture2D texture) @cname("IsTextureValid");                                   // Check if a texture is valid (loaded in GPU)
-fn void unloadTexture(Texture2D texture) @cname("UnloadTexture");                                     // Unload texture from GPU memory (VRAM)
-fn bool isRenderTextureValid(RenderTexture2D target) @cname("IsRenderTextureValid");                  // Check if a render texture is valid (loaded in GPU)
-fn void unloadRenderTexture(RenderTexture2D target) @cname("UnloadRenderTexture");                    // Unload render texture from GPU memory (VRAM)
-fn void updateTexture(Texture2D texture, void *pixels) @cname("UpdateTexture");                       // Update GPU texture with new data
-fn void updateTextureRec(Texture2D texture, Rectangle rec, void *pixels) @cname("UpdateTextureRec");  // Update GPU texture rectangle with new data
-
-// Texture configuration functions
-fn void genTextureMipmaps(Texture2D *texture) @cname("GenTextureMipmaps");                    // Generate GPU mipmaps for a texture
-fn void setTextureFilter(Texture2D texture, TextureFilter filter) @cname("SetTextureFilter"); // Set texture scaling filter mode
-fn void setTextureWrap(Texture2D texture, TextureWrap wrap) @cname("SetTextureWrap");         // Set texture wrapping mode
-
-// Texture drawing functions
-fn void drawTexture(Texture2D texture, CInt posX, CInt posY, Color tint) @cname("DrawTexture");                                                              // Draw a Texture2D
-fn void drawTextureV(Texture2D texture, Vector2 position, Color tint) @cname("DrawTextureV");                                                                // Draw a Texture2D with position defined as Vector2
-fn void drawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint) @cname("DrawTextureEx");                                 // Draw a Texture2D with extended parameters
-fn void drawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint) @cname("DrawTextureRec");                                          // Draw a part of a texture defined by a rectangle
-fn void drawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint) @cname("DrawTexturePro");            // Draw a part of a texture defined by a rectangle with 'pro' parameters
-fn void drawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint) @cname("DrawTextureNPatch"); // Draws a texture (or part of it) that stretches or shrinks nicely
-
-// Color/pixel related functions
-fn bool colorIsEqual(Color col1, Color col2) @cname("ColorIsEqual");                              // Check if two colors are equal
-fn Color fade(Color color, float alpha) @cname("Fade");                                           // Get color with alpha applied, alpha goes from 0.0f to 1.0f
-fn CInt colorToInt(Color color) @cname("ColorToInt");                                             // Get hexadecimal value for a Color (0xRRGGBBAA)
-fn Vector4 colorNormalize(Color color) @cname("ColorNormalize");                                  // Get Color normalized as float [0..1]
-fn Color colorFromNormalized(Vector4 normalized) @cname("ColorFromNormalized");                   // Get Color from normalized values [0..1]
-fn Vector3 colorToHSV(Color color) @cname("ColorToHSV");                                          // Get HSV values for a Color, hue [0..360], saturation/value [0..1]
-fn Color colorFromHSV(float hue, float saturation, float value) @cname("ColorFromHSV");           // Get a Color from HSV values, hue [0..360], saturation/value [0..1]
-fn Color colorTint(Color color, Color tint) @cname("ColorTint");                                  // Get color multiplied with another color
-fn Color colorBrightness(Color color, float factor) @cname("ColorBrightness");                    // Get color with brightness correction, brightness factor goes from -1.0f to 1.0f
-fn Color colorContrast(Color color, float contrast) @cname("ColorContrast");                      // Get color with contrast correction, contrast values between -1.0f and 1.0f
-fn Color colorAlpha(Color color, float alpha) @cname("ColorAlpha");                               // Get color with alpha applied, alpha goes from 0.0f to 1.0f
-fn Color colorAlphaBlend(Color dst, Color src, Color tint) @cname("ColorAlphaBlend");             // Get src alpha-blended into dst color with tint
-fn Color colorLerp(Color color1, Color color2, float factor) @cname("ColorLerp");                 // Get color lerp interpolation between two colors, factor [0.0f..1.0f]
-fn Color getColor(CUInt hexValue) @cname("GetColor");                                             // Get Color structure from hexadecimal value
-fn Color getPixelColor(void *srcPtr, PixelFormat format) @cname("GetPixelColor");                 // Get Color from a source pixel pointer of certain format
-fn void setPixelColor(void *dstPtr, Color color, PixelFormat format) @cname("SetPixelColor");     // Set color formatted into destination pixel pointer
-fn CInt getPixelDataSize(CInt width, CInt height, PixelFormat format) @cname("GetPixelDataSize"); // Get pixel data size in bytes for certain format
-
-//------------------------------------------------------------------------------------
-// Font Loading and Text Drawing Functions (Module: text)
-//------------------------------------------------------------------------------------
-
-// Font loading/unloading functions
-fn Font getFontDefault() @cname("GetFontDefault");                                                                                                               // Get the default Font
-fn Font loadFont(ZString fileName) @cname("LoadFont");                                                                                                           // Load font from file into GPU memory (VRAM)
-fn Font loadFontEx(ZString fileName, CInt fontSize, CInt *codepoints, CInt codepointCount) @cname("LoadFontEx");                                                 // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set, font size is provided in pixels height
-fn Font loadFontFromImage(Image image, Color key, CInt firstChar) @cname("LoadFontFromImage");                                                                   // Load font from Image (XNA style)
-fn Font loadFontFromMemory(ZString fileType, char* fileData, CInt dataSize, CInt fontSize, CInt *codepoints, CInt codepointCount) @cname("LoadFontFromMemory");  // Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
-fn bool isFontValid(Font font) @cname("IsFontValid");                                                                                                            // Check if a font is valid (font data loaded, WARNING: GPU texture not checked)
-fn GlyphInfo *loadFontData(char* fileData, CInt dataSize, CInt fontSize, CInt *codepoints, CInt codepointCount, FontType type) @cname("LoadFontData");           // Load font data for further use
-fn Image genImageFontAtlas(GlyphInfo *glyphs, Rectangle **glyphRecs, CInt glyphCount, CInt fontSize, CInt padding, CInt packMethod) @cname("GenImageFontAtlas"); // Generate image font atlas using chars info
-fn void unloadFontData(GlyphInfo *glyphs, CInt glyphCount) @cname("UnloadFontData");                                                                             // Unload font chars info data (RAM)
-fn void unloadFont(Font font) @cname("UnloadFont");                                                                                                              // Unload font from GPU memory (VRAM)
-fn bool exportFontAsCode(Font font, ZString fileName) @cname("ExportFontAsCode");                                                                                // Export font as code file, returns true on success
-
-// Text drawing functions
-fn void drawFPS(CInt posX, CInt posY) @cname("DrawFPS");                                                                                                                // Draw current FPS
-fn void drawText(ZString text, CInt posX, CInt posY, CInt fontSize, Color color) @cname("DrawText");                                                                    // Draw text (using default font)
-fn void drawTextEx(Font font, ZString text, Vector2 position, float fontSize, float spacing, Color tint) @cname("DrawTextEx");                                          // Draw text using font and additional parameters
-fn void drawTextPro(Font font, ZString text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint) @cname("DrawTextPro");        // Draw text using Font and pro parameters (rotation)
-fn void drawTextCodepoint(Font font, CInt codepoint, Vector2 position, float fontSize, Color tint) @cname("DrawTextCodepoint");                                         // Draw one character (codepoint)
-fn void drawTextCodepoints(Font font, CInt *codepoints, CInt codepointCount, Vector2 position, float fontSize, float spacing, Color tint) @cname("DrawTextCodepoints"); // Draw multiple character (codepoint)
-
-// Text font info functions
-fn void setTextLineSpacing(CInt spacing) @cname("SetTextLineSpacing");                                    // Set vertical line spacing when drawing with line-breaks
-fn CInt measureText(ZString text, CInt fontSize) @cname("MeasureText");                                   // Measure string width for default font
-fn Vector2 measureTextEx(Font font, ZString text, float fontSize, float spacing) @cname("MeasureTextEx"); // Measure string size for Font
-fn CInt getGlyphIndex(Font font, CInt codepoint) @cname("GetGlyphIndex");                                 // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found
-fn GlyphInfo getGlyphInfo(Font font, CInt codepoint) @cname("GetGlyphInfo");                              // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found
-fn Rectangle getGlyphAtlasRec(Font font, CInt codepoint) @cname("GetGlyphAtlasRec");                      // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found
-
-// Text codepoints management functions (unicode characters)
-fn char *loadUTF8(CInt *codepoints, CInt length) @cname("LoadUTF8");                            // Load UTF-8 text encoded from codepoints array
-fn void unloadUTF8(char *text) @cname("UnloadUTF8");                                            // Unload UTF-8 text encoded from codepoints array
-fn CInt *loadCodepoints(ZString text, CInt *count) @cname("LoadCodepoints");                    // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter
-fn void unloadCodepoints(CInt *codepoints) @cname("UnloadCodepoints");                          // Unload codepoints data from memory
-fn CInt getCodepointCount(ZString text) @cname("GetCodepointCount");                            // Get total number of codepoints in a UTF-8 encoded string
-fn CInt getCodepoint(ZString text, CInt *codepointSize) @cname("GetCodepoint");                 // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
-fn CInt getCodepointNext(ZString text, CInt *codepointSize) @cname("GetCodepointNext");         // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
-fn CInt getCodepointPrevious(ZString text, CInt *codepointSize) @cname("GetCodepointPrevious"); // Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
-fn ZString codepointToUTF8(CInt codepoint, CInt *utf8Size) @cname("CodepointToUTF8");           // Encode one codepoint into UTF-8 byte array (array length returned as parameter)
-
-// Text strings management functions (no UTF-8 strings, only byte chars)
-// NOTE: Some strings allocate memory internally for returned strings, just be careful!
-fn CInt textCopy(ZString dst, ZString src) @cname("TextCopy");                            // Copy one string to another, returns bytes copied
-fn bool textIsEqual(ZString text1, ZString text2) @cname("TextIsEqual");                  // Check if two text string are equal
-fn CUInt textLength(ZString text) @cname("TextLength");                                   // Get text length, checks for '\0' ending
-fn ZString textFormat(ZString text, ...) @cname("TextFormat");                            // Text formatting with variables (sprCIntf() style)
-fn ZString textSubtext(ZString text, CInt position, CInt length) @cname("TextSubtext");   // Get a piece of a text string
-fn char *textReplace(ZString text, ZString replace, ZString by) @cname("TextReplace");    // Replace text string (WARNING: memory must be freed!)
-fn char *textInsert(ZString text, ZString insert, CInt position) @cname("TextInsert");    // Insert text in a position (WARNING: memory must be freed!)
-fn ZString textJoin(ZString *textList, CInt count, ZString delimiter) @cname("TextJoin"); // Join text strings with delimiter
-fn ZString *textSplit(ZString text, char delimiter, CInt *count) @cname("TextSplit");     // Split text CInto multiple strings
-fn void textAppend(char *text, ZString append, CInt *position) @cname("TextAppend");      // Append text at specific position and move cursor!
-fn CInt textFindIndex(ZString text, ZString find) @cname("TextFindIndex");                // Find first text occurrence within a string
-fn ZString textToUpper(ZString text) @cname("TextToUpper");                               // Get upper case version of provided string
-fn ZString textToLower(ZString text) @cname("TextToLower");                               // Get lower case version of provided string
-fn ZString textToPascal(ZString text) @cname("TextToPascal");                             // Get Pascal case notation version of provided string
-fn ZString textToSnake(ZString text) @cname("TextToSnake");                               // Get Snake case notation version of provided string
-fn ZString textToCamel(ZString text) @cname("TextToCamel");                               // Get Camel case notation version of provided string
-
-fn CInt textToInteger(ZString text) @cname("TextToInteger");                              // Get integer value from text (negative values not supported)
-fn float textToFloat(ZString text) @cname("TextToFloat");                                 // Get float value from text (negative values not supported)
-
-//------------------------------------------------------------------------------------
-// Basic 3d Shapes Drawing Functions (Module: models)
-//------------------------------------------------------------------------------------
-
-// Basic geometric 3D shapes drawing functions
-fn void drawLine3D(Vector3 startPos, Vector3 endPos, Color color) @cname("DrawLine3D");                                                                   // Draw a line in 3D world space
-fn void drawPoint3D(Vector3 position, Color color) @cname("DrawPoint3D");                                                                                 // Draw a point in 3D space, actually a small line
-fn void drawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color) @cname("DrawCircle3D");                        // Draw a circle in 3D world space
-fn void drawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color) @cname("DrawTriangle3D");                                                         // Draw a color-filled triangle (vertex in counter-clockwise order!)
-fn void drawTriangleStrip3D(Vector3 *points, CInt pointCount, Color color) @cname("DrawTriangleStrip3D");                                                 // Draw a triangle strip defined by points
-fn void drawCube(Vector3 position, float width, float height, float length, Color color) @cname("DrawCube");                                              // Draw cube
-fn void drawCubeV(Vector3 position, Vector3 size, Color color) @cname("DrawCubeV");                                                                       // Draw cube (Vector version)
-fn void drawCubeWires(Vector3 position, float width, float height, float length, Color color) @cname("DrawCubeWires");                                    // Draw cube wires
-fn void drawCubeWiresV(Vector3 position, Vector3 size, Color color) @cname("DrawCubeWiresV");                                                             // Draw cube wires (Vector version)
-fn void drawSphere(Vector3 centerPos, float radius, Color color) @cname("DrawSphere");                                                                    // Draw sphere
-fn void drawSphereEx(Vector3 centerPos, float radius, CInt rings, CInt slices, Color color) @cname("DrawSphereEx");                                       // Draw sphere with extended parameters
-fn void drawSphereWires(Vector3 centerPos, float radius, CInt rings, CInt slices, Color color) @cname("DrawSphereWires");                                 // Draw sphere wires
-fn void drawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, CInt slices, Color color) @cname("DrawCylinder");               // Draw a cylinder/cone
-fn void drawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, CInt sides, Color color) @cname("DrawCylinderEx");           // Draw a cylinder with base at startPos and top at endPos
-fn void drawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, CInt slices, Color color) @cname("DrawCylinderWires");     // Draw a cylinder/cone wires
-fn void drawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, CInt sides, Color color) @cname("DrawCylinderWiresEx"); // Draw a cylinder wires with base at startPos and top at endPos
-fn void drawCapsule(Vector3 startPos, Vector3 endPos, float radius, CInt slices, CInt rings, Color color) @cname("DrawCapsule");                          // Draw a capsule with the center of its sphere caps at startPos and endPos
-fn void drawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, CInt slices, CInt rings, Color color) @cname("DrawCapsuleWires");                // Draw capsule wireframe with the center of its sphere caps at startPos and endPos
-fn void drawPlane(Vector3 centerPos, Vector2 size, Color color) @cname("DrawPlane");                                                                      // Draw a plane XZ
-fn void drawRay(Ray ray, Color color) @cname("DrawRay");                                                                                                  // Draw a ray line
-fn void drawGrid(CInt slices, float spacing) @cname("DrawGrid");                                                                                          // Draw a grid (centered at (0, 0, 0))
-
-//------------------------------------------------------------------------------------
-// Model 3d Loading and Drawing Functions (Module: models)
-//------------------------------------------------------------------------------------
-
-// Model management functions
-fn Model loadModel(ZString fileName) @cname("LoadModel");                      // Load model from files (meshes and materials)
-fn Model loadModelFromMesh(Mesh mesh) @cname("LoadModelFromMesh");             // Load model from generated mesh (default material)
-fn bool isModelValid(Model model) @cname("IsModelValid");                      // Check if a model is valid (loaded in GPU, VAO/VBOs)
-fn void unloadModel(Model model) @cname("UnloadModel");                        // Unload model (including meshes) from memory (RAM and/or VRAM)
-fn BoundingBox getModelBoundingBox(Model model) @cname("GetModelBoundingBox"); // Compute model bounding box limits (considers all meshes)
-
-// Model drawing functions
-fn void drawModel(Model model, Vector3 position, float scale, Color tint) @cname("DrawModel");                                                                                                   // Draw a model (with texture if set)
-fn void drawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint) @cname("DrawModelEx");                                                  // Draw a model with extended parameters
-fn void drawModelWires(Model model, Vector3 position, float scale, Color tint) @cname("DrawModelWires");                                                                                         // Draw a model wires (with texture if set)
-fn void drawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint) @cname("DrawModelWiresEx");                                        // Draw a model wires (with texture if set) with extended parameters
-fn void drawModelPoints(Model model, Vector3 position, float scale, Color tint) @cname("DrawModelPoints");                                                                                       // Draw a model as points
-fn void drawModelPointsEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint) @cname("DrawModelPointsEx");                                      // Draw a model as points with extended parameters
-fn void drawBoundingBox(BoundingBox box, Color color) @cname("DrawBoundingBox");                                                                                                                 // Draw bounding box (wires)
-fn void drawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint) @cname("DrawBillboard");                                                                      // Draw a billboard texture
-fn void drawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint) @cname("DrawBillboardRec");                                             // Draw a billboard texture defined by source
-fn void drawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint) @cname("DrawBillboardPro"); // Draw a billboard texture defined by source and rotation
-
-// Mesh management functions
-fn void uploadMesh(Mesh *mesh, bool dynamic) @cname("UploadMesh");                                                       // Upload mesh vertex data in GPU and provide VAO/VBO ids
-fn void updateMeshBuffer(Mesh mesh, CInt index, void *data, CInt dataSize, CInt offset) @cname("UpdateMeshBuffer");      // Update mesh vertex data in GPU for a specific buffer index
-fn void unloadMesh(Mesh mesh) @cname("UnloadMesh");                                                                      // Unload mesh data from CPU and GPU
-fn void drawMesh(Mesh mesh, Material material, Matrix transform) @cname("DrawMesh");                                     // Draw a 3d mesh with material and transform
-fn void drawMeshInstanced(Mesh mesh, Material material, Matrix *transforms, CInt instances) @cname("DrawMeshInstanced"); // Draw multiple mesh instances with material and different transforms
-fn BoundingBox getMeshBoundingBox(Mesh mesh) @cname("GetMeshBoundingBox");                                               // Compute mesh bounding box limits
-fn void genMeshTangents(Mesh *mesh) @cname("GenMeshTangents");                                                           // Compute mesh tangents
-fn bool exportMesh(Mesh mesh, ZString fileName) @cname("ExportMesh");                                                    // Export mesh data to file, returns true on success
-fn bool exportMeshAsCode(Mesh mesh, ZString fileName) @cname("ExportMeshAsCode");                                        // Export mesh as code file (.h) defining multiple arrays of vertex attributes
-
-// Mesh generation functions
-fn Mesh genMeshPoly(CInt sides, float radius) @cname("GenMeshPoly");                            // Generate polygonal mesh
-fn Mesh genMeshPlane(float width, float length, CInt resX, CInt resZ) @cname("GenMeshPlane");   // Generate plane mesh (with subdivisions)
-fn Mesh genMeshCube(float width, float height, float length) @cname("GenMeshCube");             // Generate cuboid mesh
-fn Mesh genMeshSphere(float radius, CInt rings, CInt slices) @cname("GenMeshSphere");           // Generate sphere mesh (standard sphere)
-fn Mesh genMeshHemiSphere(float radius, CInt rings, CInt slices) @cname("GenMeshHemiSphere");   // Generate half-sphere mesh (no bottom cap)
-fn Mesh genMeshCylinder(float radius, float height, CInt slices) @cname("GenMeshCylinder");     // Generate cylinder mesh
-fn Mesh genMeshCone(float radius, float height, CInt slices) @cname("GenMeshCone");             // Generate cone/pyramid mesh
-fn Mesh genMeshTorus(float radius, float size, CInt radSeg, CInt sides) @cname("GenMeshTorus"); // Generate torus mesh
-fn Mesh genMeshKnot(float radius, float size, CInt radSeg, CInt sides) @cname("GenMeshKnot");   // Generate trefoil knot mesh
-fn Mesh genMeshHeightmap(Image heightmap, Vector3 size) @cname("GenMeshHeightmap");             // Generate heightmap mesh from image data
-fn Mesh genMeshCubicmap(Image cubicmap, Vector3 cubeSize) @cname("GenMeshCubicmap");            // Generate cubes-based map mesh from image data
-
-// Material loading/unloading functions
-fn Material *loadMaterials(ZString fileName, CInt *materialCount) @cname("LoadMaterials");                                // Load materials from model file
-fn Material loadMaterialDefault() @cname("LoadMaterialDefault");                                                          // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
-fn bool isMaterialValid(Material material) @cname("IsMaterialValid");                                                     // Check if a material is valid (shader assigned, map textures loaded in GPU)
-fn void unloadMaterial(Material material) @cname("UnloadMaterial");                                                       // Unload material from GPU memory (VRAM)
-fn void setMaterialTexture(Material *material, MaterialMapIndex mapType, Texture2D texture) @cname("SetMaterialTexture"); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
-fn void setModelMeshMaterial(Model *model, CInt meshId, CInt materialId) @cname("SetModelMeshMaterial");                  // Set material for a mesh
-
-// Model animations loading/unloading functions
-fn ModelAnimation *loadModelAnimations(ZString fileName, CInt *animCount) @cname("LoadModelAnimations");             // Load model animations from file
-fn void updateModelAnimation(Model model, ModelAnimation anim, CInt frame) @cname("UpdateModelAnimation");           // Update model animation pose (CPU)
-fn void updateModelAnimationBones(Model model, ModelAnimation anim, CInt frame) @cname("UpdateModelAnimationBones"); // Update model animation mesh bone matrices (GPU skinning)
-fn void unloadModelAnimation(ModelAnimation anim) @cname("UnloadModelAnimation");                                    // Unload animation data
-fn void unloadModelAnimations(ModelAnimation *animations, CInt animCount) @cname("UnloadModelAnimations");           // Unload animation array data
-fn bool isModelAnimationValid(Model model, ModelAnimation anim) @cname("IsModelAnimationValid");                     // Check model animation skeleton match
-
-// Collision detection functions
-fn bool checkCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2) @cname("CheckCollisionSpheres"); // Check collision between two spheres
-fn bool checkCollisionBoxes(BoundingBox box1, BoundingBox box2) @cname("CheckCollisionBoxes");                                 // Check collision between two bounding boxes
-fn bool checkCollisionBoxSphere(BoundingBox box, Vector3 center, float radius) @cname("CheckCollisionBoxSphere");              // Check collision between box and sphere
-fn RayCollision getRayCollisionSphere(Ray ray, Vector3 center, float radius) @cname("GetRayCollisionSphere");                  // Get collision info between ray and sphere
-fn RayCollision getRayCollisionBox(Ray ray, BoundingBox box) @cname("GetRayCollisionBox");                                     // Get collision info between ray and box
-fn RayCollision getRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform) @cname("GetRayCollisionMesh");                       // Get collision info between ray and mesh
-fn RayCollision getRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3) @cname("GetRayCollisionTriangle");        // Get collision info between ray and triangle
-fn RayCollision getRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4) @cname("GetRayCollisionQuad");    // Get collision info between ray and quad
-
-//------------------------------------------------------------------------------------
-// Audio Loading and Playing Functions (Module: audio)
-//------------------------------------------------------------------------------------
-alias AudioCallback = fn void(void *bufferData, CUInt frames);
-
-// Audio device management functions
-fn void initAudioDevice() @cname("InitAudioDevice");             // Initialize audio device and context
-fn void closeAudioDevice() @cname("CloseAudioDevice");           // Close the audio device and context
-fn bool isAudioDeviceReady() @cname("IsAudioDeviceReady");       // Check if audio device has been initialized successfully
-fn void setMasterVolume(float volume) @cname("SetMasterVolume"); // Set master volume (listener)
-fn float getMasterVolume() @cname("GetMasterVolume");            // Get master volume (listener)
-
-// Wave/Sound loading/unloading functions
-fn Wave loadWave(ZString fileName) @cname("LoadWave");                                                    // Load wave data from file
-fn Wave loadWaveFromMemory(ZString fileType, char* fileData, CInt dataSize) @cname("LoadWaveFromMemory"); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav'
-fn bool isWaveValid(Wave wave) @cname("IsWaveValid");                                                     // Checks if wave data is valid (data loaded and parameters)
-fn Sound loadSound(ZString fileName) @cname("LoadSound");                                                 // Load sound from file
-fn Sound loadSoundFromWave(Wave wave) @cname("LoadSoundFromWave");                                        // Load sound from wave data
-fn Sound loadSoundAlias(Sound source) @cname("LoadSoundAlias");                                           // Create a new sound that shares the same sample data as the source sound, does not own the sound data
-fn bool isSoundValid(Sound sound) @cname("IsSoundValid");                                                 // Checks if a sound is valid (data loaded and buffers initialized)
-fn void updateSound(Sound sound, void *data, CInt sampleCount) @cname("UpdateSound");                     // Update sound buffer with new data
-fn void unloadWave(Wave wave) @cname("UnloadWave");                                                       // Unload wave data
-fn void unloadSound(Sound sound) @cname("UnloadSound");                                                   // Unload sound
-fn void unloadSoundAlias(Sound alias_) @cname("UnloadSoundAlias");                                        // Unload a sound alias (does not deallocate sample data)
-fn bool exportWave(Wave wave, ZString fileName) @cname("ExportWave");                                     // Export wave data to file, returns true on success
-fn bool exportWaveAsCode(Wave wave, ZString fileName) @cname("ExportWaveAsCode");                         // Export wave sample data to code (.h), returns true on success
-
-// Wave/Sound management functions
-fn void playSound(Sound sound) @cname("PlaySound");                                                   // Play a sound
-fn void stopSound(Sound sound) @cname("StopSound");                                                   // Stop playing a sound
-fn void pauseSound(Sound sound) @cname("PauseSound");                                                 // Pause a sound
-fn void resumeSound(Sound sound) @cname("ResumeSound");                                               // Resume a paused sound
-fn bool isSoundPlaying(Sound sound) @cname("IsSoundPlaying");                                         // Check if a sound is currently playing
-fn void setSoundVolume(Sound sound, float volume) @cname("SetSoundVolume");                           // Set volume for a sound (1.0 is max level)
-fn void setSoundPitch(Sound sound, float pitch) @cname("SetSoundPitch");                              // Set pitch for a sound (1.0 is base level)
-fn void setSoundPan(Sound sound, float pan) @cname("SetSoundPan");                                    // Set pan for a sound (0.5 is center)
-fn Wave waveCopy(Wave wave) @cname("WaveCopy");                                                       // Copy a wave to a new wave
-fn void waveCrop(Wave *wave, CInt initFrame, CInt finalFrame) @cname("WaveCrop");                     // Crop a wave to defined frames range
-fn void waveFormat(Wave *wave, CInt sampleRate, CInt sampleSize, CInt channels) @cname("WaveFormat"); // Convert wave data to desired format
-fn float *loadWaveSamples(Wave wave) @cname("LoadWaveSamples");                                       // Load samples data from wave as a 32bit float data array
-fn void unloadWaveSamples(float *samples) @cname("UnloadWaveSamples");                                // Unload samples data loaded with LoadWaveSamples()
-
-// Music management functions
-fn Music loadMusicStream(ZString fileName) @cname("LoadMusicStream");                                                // Load music stream from file
-fn Music loadMusicStreamFromMemory(ZString fileType, char* data, CInt dataSize) @cname("LoadMusicStreamFromMemory"); // Load music stream from data
-fn bool isMusicValid(Music music) @cname("IsMusicValid");                                                            // Checks if a music stream is valid (context and buffers initialized)
-fn void unloadMusicStream(Music music) @cname("UnloadMusicStream");                                                  // Unload music stream
-fn void playMusicStream(Music music) @cname("PlayMusicStream");                                                      // Start music playing
-fn bool isMusicStreamPlaying(Music music) @cname("IsMusicStreamPlaying");                                            // Check if music is playing
-fn void updateMusicStream(Music music) @cname("UpdateMusicStream");                                                  // Updates buffers for music streaming
-fn void stopMusicStream(Music music) @cname("StopMusicStream");                                                      // Stop music playing
-fn void pauseMusicStream(Music music) @cname("PauseMusicStream");                                                    // Pause music playing
-fn void resumeMusicStream(Music music) @cname("ResumeMusicStream");                                                  // Resume playing paused music
-fn void seekMusicStream(Music music, float position) @cname("SeekMusicStream");                                      // Seek music to a position (in seconds)
-fn void setMusicVolume(Music music, float volume) @cname("SetMusicVolume");                                          // Set volume for music (1.0 is max level)
-fn void setMusicPitch(Music music, float pitch) @cname("SetMusicPitch");                                             // Set pitch for a music (1.0 is base level)
-fn void setMusicPan(Music music, float pan) @cname("SetMusicPan");                                                   // Set pan for a music (0.5 is center)
-fn float getMusicTimeLength(Music music) @cname("GetMusicTimeLength");                                               // Get music time length (in seconds)
-fn float getMusicTimePlayed(Music music) @cname("GetMusicTimePlayed");                                               // Get current music time played (in seconds)
-
-// AudioStream management functions
-fn AudioStream loadAudioStream(CUInt sampleRate, CUInt sampleSize, CUInt channels) @cname("LoadAudioStream"); // Load audio stream (to stream raw audio pcm data)
-fn bool isAudioStreamValid(AudioStream stream) @cname("IsAudioStreamValid");                                  // Checks if an audio stream is valid (buffers initialized)
-fn void unloadAudioStream(AudioStream stream) @cname("UnloadAudioStream");                                    // Unload audio stream and free memory
-fn void updateAudioStream(AudioStream stream, void *data, CInt frameCount) @cname("UpdateAudioStream");       // Update audio stream buffers with data
-fn bool isAudioStreamProcessed(AudioStream stream) @cname("IsAudioStreamProcessed");                          // Check if any audio stream buffers requires refill
-fn void playAudioStream(AudioStream stream) @cname("PlayAudioStream");                                        // Play audio stream
-fn void pauseAudioStream(AudioStream stream) @cname("PauseAudioStream");                                      // Pause audio stream
-fn void resumeAudioStream(AudioStream stream) @cname("ResumeAudioStream");                                    // Resume audio stream
-fn bool isAudioStreamPlaying(AudioStream stream) @cname("IsAudioStreamPlaying");                              // Check if audio stream is playing
-fn void stopAudioStream(AudioStream stream) @cname("StopAudioStream");                                        // Stop audio stream
-fn void setAudioStreamVolume(AudioStream stream, float volume) @cname("SetAudioStreamVolume");                // Set volume for audio stream (1.0 is max level)
-fn void setAudioStreamPitch(AudioStream stream, float pitch) @cname("SetAudioStreamPitch");                   // Set pitch for audio stream (1.0 is base level)
-fn void setAudioStreamPan(AudioStream stream, float pan) @cname("SetAudioStreamPan");                         // Set pan for audio stream (0.5 is centered)
-fn void setAudioStreamBufferSizeDefault(CInt size) @cname("SetAudioStreamBufferSizeDefault");                 // Default size for new audio streams
-fn void setAudioStreamCallback(AudioStream stream, AudioCallback callback) @cname("SetAudioStreamCallback");  // Audio thread callback to request new data
-
-fn void attachAudioStreamProcessor(AudioStream stream, AudioCallback processor) @cname("AttachAudioStreamProcessor"); // Attach audio stream processor to stream, receives the samples as 'float'
-fn void detachAudioStreamProcessor(AudioStream stream, AudioCallback processor) @cname("DetachAudioStreamProcessor"); // Detach audio stream processor from stream
-
-fn void attachAudioMixedProcessor(AudioCallback processor) @cname("AttachAudioMixedProcessor"); // Attach audio stream processor to the entire audio pipeline, receives the samples as 'float'
-fn void detachAudioMixedProcessor(AudioCallback processor) @cname("DetachAudioMixedProcessor"); // Detach audio stream processor from the entire audio pipeline
-
-
-//----------------------------------------------------------------------------------
-// Additional Raylib.c3 Mode helper macros
-//----------------------------------------------------------------------------------
-
-<*
- Setup canvas (framebuffer) to start drawing, then calls [block].
- Drawing will end after [block] has finished.
-*>
-macro void @drawing(;@body)
-{
-	beginDrawing();
-	defer endDrawing();
-	@body();
-}
-
-<*
- Setup 2D mode with custom camera to start 2D Mode, then calls [block].
- Mode2D will end after [block] has finished.
-*>
-macro void @mode2D(Camera2D camera ;@body)
-{
-	beginMode2D(camera);
-	defer endMode2D();
-	@body();
-}
-
-<*
- Setup 3D mode with custom camera to start 2D Mode, then calls [block].
- Mode2D will end after [block] has finished.
-*>
-macro void @mode3D(Camera3D camera ;@body)
-{
-	beginMode3D(camera);
-	defer endMode3D();
-	@body();
-}
-
-<*
- Setup texture mode to draw to render texture, then calls [block].
- texture mode will end after [block] has finished.
-*>
-macro void @textureMode(RenderTexture2D texture ;@body)
-{
-	beginTextureMode(texture);
-	defer endTextureMode();
-	@body();
-}
-
-
-<*
- Setup custom shqder mode then calls [block].
- shader mode will end after [block] has finished.
-*>
-macro void @shaderMode(Shader shader ;@body)
-{
-	beginShaderMode(shader);
-	defer endShaderMode();
-	@body();
-}
-
-<*
- Setup blending mode, then calls [block].
- blend mode will end after [block] has finished.
-*>
-macro void @blendMode(BlendMode mode ;@body)
-{
-	beginBlendMode(mode);
-	defer endBlendMode();
-	@body();
-}
-
-<*
- Setup scissor mode then calls [block].
- scissor mode will end after [block] has finished.
-*>
-macro void @scissorMode(CInt x, CInt y, CInt width, CInt height ;@body)
-{
-	beginScissorMode(x, y, width, height);
-	defer endScissorMode();
-	@body();
-}
-
-<*
- Setup stereo rendering mode, then calls [block].
- stereo rendering mode will end after [block] has finished.
-*>
-macro void @vrMode(VrStereoConfig config ;@body)
-{
-	beginVrStereoMode(config);
-	defer endVrStereoMode();
-	@body();
-}
-
-
-<*
- Setup rl drawing mode, then calls [block].
- rlBegin will end after [block] has finished.
-*>
-macro void @rlMode(CInt mode ;@body)
-{
-	rlBegin(mode);
-	defer rlEnd();
-	@body();
-}
-
-//----------------------------------------------------------------------------------
-// Enumerators Definition
-//----------------------------------------------------------------------------------
-// System/Window config flags
-// NOTE: Every bit registers one state (use it with bit masks)
-// By default all flags are set to 0
-
-enum ConfigFlag : const uint
-{
-	VSYNC_HINT         = 0x00000040,   // Set to try enabling V-Sync on GPU
-	FULLSCREEN_MODE    = 0x00000002,   // Set to run program in fullscreen
-	WINDOW_RESIZABLE   = 0x00000004,   // Set to allow resizable window
-	WINDOW_UNDECORATED = 0x00000008,   // Set to disable window decoration (frame and buttons)
-	WINDOW_HIDDEN      = 0x00000080,   // Set to hide window
-	WINDOW_MINIMIZED   = 0x00000200,   // Set to minimize window (iconify)
-	WINDOW_MAXIMIZED   = 0x00000400,   // Set to maximize window (expanded to monitor)
-	WINDOW_UNFOCUSED   = 0x00000800,   // Set to window non focused
-	WINDOW_TOPMOST     = 0x00001000,   // Set to window always on top
-	WINDOW_ALWAYS_RUN  = 0x00000100,   // Set to allow windows running while minimized
-	WINDOW_TRANSPARENT = 0x00000010,   // Set to allow transparent framebuffer
-	WINDOW_HIGHDPI     = 0x00002000,   // Set to support HighDPI
-	MSAA_4X_HINT       = 0x00000020,   // Set to try enabling MSAA 4X
-	INTERLACED_HINT    = 0x00010000,   // Set to try enabling interlaced video format (for V3D)
-}
-
-// Keyboard keys (US keyboard layout)
-// NOTE: Use GetKeyPressed() to allow redefining
-// required keys for alternative layouts
-
-typedef KeyboardKey = int;
-
-const KeyboardKey KEY_NULL            = 0;        // Key: NULL; used for no key pressed
-				// Alphanumeric keys
-const KeyboardKey KEY_APOSTROPHE      = 39;       // Key: '
-const KeyboardKey KEY_COMMA           = 44;       // Key: ;
-const KeyboardKey KEY_MINUS           = 45;       // Key: -
-const KeyboardKey KEY_PERIOD          = 46;       // Key: .
-const KeyboardKey KEY_SLASH           = 47;       // Key: /
-const KeyboardKey KEY_ZERO            = 48;       // Key: 0
-const KeyboardKey KEY_ONE             = 49;       // Key: 1
-const KeyboardKey KEY_TWO             = 50;       // Key: 2
-const KeyboardKey KEY_THREE           = 51;       // Key: 3
-const KeyboardKey KEY_FOUR            = 52;       // Key: 4
-const KeyboardKey KEY_FIVE            = 53;       // Key: 5
-const KeyboardKey KEY_SIX             = 54;       // Key: 6
-const KeyboardKey KEY_SEVEN           = 55;       // Key: 7
-const KeyboardKey KEY_EIGHT           = 56;       // Key: 8
-const KeyboardKey KEY_NINE            = 57;       // Key: 9
-const KeyboardKey KEY_SEMICOLON       = 59;       // Key: ;
-const KeyboardKey KEY_EQUAL           = 61;       // Key: =
-const KeyboardKey KEY_A               = 65;       // Key: A | a
-const KeyboardKey KEY_B               = 66;       // Key: B | b
-const KeyboardKey KEY_C               = 67;       // Key: C | c
-const KeyboardKey KEY_D               = 68;       // Key: D | d
-const KeyboardKey KEY_E               = 69;       // Key: E | e
-const KeyboardKey KEY_F               = 70;       // Key: F | f
-const KeyboardKey KEY_G               = 71;       // Key: G | g
-const KeyboardKey KEY_H               = 72;       // Key: H | h
-const KeyboardKey KEY_I               = 73;       // Key: I | i
-const KeyboardKey KEY_J               = 74;       // Key: J | j
-const KeyboardKey KEY_K               = 75;       // Key: K | k
-const KeyboardKey KEY_L               = 76;       // Key: L | l
-const KeyboardKey KEY_M               = 77;       // Key: M | m
-const KeyboardKey KEY_N               = 78;       // Key: N | n
-const KeyboardKey KEY_O               = 79;       // Key: O | o
-const KeyboardKey KEY_P               = 80;       // Key: P | p
-const KeyboardKey KEY_Q               = 81;       // Key: Q | q
-const KeyboardKey KEY_R               = 82;       // Key: R | r
-const KeyboardKey KEY_S               = 83;       // Key: S | s
-const KeyboardKey KEY_T               = 84;       // Key: T | t
-const KeyboardKey KEY_U               = 85;       // Key: U | u
-const KeyboardKey KEY_V               = 86;       // Key: V | v
-const KeyboardKey KEY_W               = 87;       // Key: W | w
-const KeyboardKey KEY_X               = 88;       // Key: X | x
-const KeyboardKey KEY_Y               = 89;       // Key: Y | y
-const KeyboardKey KEY_Z               = 90;       // Key: Z | z
-const KeyboardKey KEY_LEFT_BRACKET    = 91;       // Key: [
-const KeyboardKey KEY_BACKSLASH       = 92;       // Key: '\'
-const KeyboardKey KEY_RIGHT_BRACKET   = 93;       // Key: ]
-const KeyboardKey KEY_GRAVE           = 96;       // Key: `
-// Function keys
-const KeyboardKey KEY_SPACE           = 32;       // Key: Space
-const KeyboardKey KEY_ESCAPE          = 256;      // Key: Esc
-const KeyboardKey KEY_ENTER           = 257;      // Key: Enter
-const KeyboardKey KEY_TAB             = 258;      // Key: Tab
-const KeyboardKey KEY_BACKSPACE       = 259;      // Key: Backspace
-const KeyboardKey KEY_INSERT          = 260;      // Key: Ins
-const KeyboardKey KEY_DELETE          = 261;      // Key: Del
-const KeyboardKey KEY_RIGHT           = 262;      // Key: Cursor right
-const KeyboardKey KEY_LEFT            = 263;      // Key: Cursor left
-const KeyboardKey KEY_DOWN            = 264;      // Key: Cursor down
-const KeyboardKey KEY_UP              = 265;      // Key: Cursor up
-const KeyboardKey KEY_PAGE_UP         = 266;      // Key: Page up
-const KeyboardKey KEY_PAGE_DOWN       = 267;      // Key: Page down
-const KeyboardKey KEY_HOME            = 268;      // Key: Home
-const KeyboardKey KEY_END             = 269;      // Key: End
-const KeyboardKey KEY_CAPS_LOCK       = 280;      // Key: Caps lock
-const KeyboardKey KEY_SCROLL_LOCK     = 281;      // Key: Scroll down
-const KeyboardKey KEY_NUM_LOCK        = 282;      // Key: Num lock
-const KeyboardKey KEY_PRINT_SCREEN    = 283;      // Key: Print screen
-const KeyboardKey KEY_PAUSE           = 284;      // Key: Pause
-const KeyboardKey KEY_F1              = 290;      // Key: F1
-const KeyboardKey KEY_F2              = 291;      // Key: F2
-const KeyboardKey KEY_F3              = 292;      // Key: F3
-const KeyboardKey KEY_F4              = 293;      // Key: F4
-const KeyboardKey KEY_F5              = 294;      // Key: F5
-const KeyboardKey KEY_F6              = 295;      // Key: F6
-const KeyboardKey KEY_F7              = 296;      // Key: F7
-const KeyboardKey KEY_F8              = 297;      // Key: F8
-const KeyboardKey KEY_F9              = 298;      // Key: F9
-const KeyboardKey KEY_F10             = 299;      // Key: F10
-const KeyboardKey KEY_F11             = 300;      // Key: F11
-const KeyboardKey KEY_F12             = 301;      // Key: F12
-const KeyboardKey KEY_LEFT_SHIFT      = 340;      // Key: Shift left
-const KeyboardKey KEY_LEFT_CONTROL    = 341;      // Key: Control left
-const KeyboardKey KEY_LEFT_ALT        = 342;      // Key: Alt left
-const KeyboardKey KEY_LEFT_SUPER      = 343;      // Key: Super left
-const KeyboardKey KEY_RIGHT_SHIFT     = 344;      // Key: Shift right
-const KeyboardKey KEY_RIGHT_CONTROL   = 345;      // Key: Control right
-const KeyboardKey KEY_RIGHT_ALT       = 346;      // Key: Alt right
-const KeyboardKey KEY_RIGHT_SUPER     = 347;      // Key: Super right
-const KeyboardKey KEY_KB_MENU         = 348;      // Key: KB menu
-// Keypad keys
-const KeyboardKey KEY_KP_0            = 320;      // Key: Keypad 0
-const KeyboardKey KEY_KP_1            = 321;      // Key: Keypad 1
-const KeyboardKey KEY_KP_2            = 322;      // Key: Keypad 2
-const KeyboardKey KEY_KP_3            = 323;      // Key: Keypad 3
-const KeyboardKey KEY_KP_4            = 324;      // Key: Keypad 4
-const KeyboardKey KEY_KP_5            = 325;      // Key: Keypad 5
-const KeyboardKey KEY_KP_6            = 326;      // Key: Keypad 6
-const KeyboardKey KEY_KP_7            = 327;      // Key: Keypad 7
-const KeyboardKey KEY_KP_8            = 328;      // Key: Keypad 8
-const KeyboardKey KEY_KP_9            = 329;      // Key: Keypad 9
-const KeyboardKey KEY_KP_DECIMAL      = 330;      // Key: Keypad .
-const KeyboardKey KEY_KP_DIVIDE       = 331;      // Key: Keypad /
-const KeyboardKey KEY_KP_MULTIPLY     = 332;      // Key: Keypad *
-const KeyboardKey KEY_KP_SUBTRACT     = 333;      // Key: Keypad -
-const KeyboardKey KEY_KP_ADD          = 334;      // Key: Keypad +
-const KeyboardKey KEY_KP_ENTER        = 335;      // Key: Keypad Enter
-const KeyboardKey KEY_KP_EQUAL        = 336;      // Key: Keypad =
-// Android key buttons
-const KeyboardKey KEY_BACK            = 4;        // Key: Android back button
-const KeyboardKey KEY_MENU            = 82;       // Key: Android menu button
-const KeyboardKey KEY_VOLUME_UP       = 24;       // Key: Android volume up button
-const KeyboardKey KEY_VOLUME_DOWN     = 25;       // Key: Android volume down button
-
-// Gesture
-// NOTE: It could be used as flags to enable only some gestures
-enum Gesture : const int
-{
-	NONE        = 0,      // No gesture
-	TAP         = 1,        // Tap gesture
-	DOUBLETAP   = 2,        // Double tap gesture
-	HOLD        = 4,        // Hold gesture
-	DRAG        = 8,        // Drag gesture
-	SWIPE_RIGHT = 16,       // Swipe right gesture
-	SWIPE_LEFT  = 32,       // Swipe left gesture
-	SWIPE_UP    = 64,       // Swipe up gesture
-	SWIPE_DOWN  = 128,      // Swipe down gesture
-	PINCH_IN    = 256,      // Pinch in gesture
-	PINCH_OUT   = 512,      // Pinch out gesture
-}
-
-// rlgl.h
-typedef FramebufferAttachType = int;
-
-const FramebufferAttachType RL_ATTACHMENT_COLOR_CHANNEL0 = 0;       // Framebuffer attachment type: color 0
-const FramebufferAttachType RL_ATTACHMENT_COLOR_CHANNEL1 = 1;       // Framebuffer attachment type: color 1
-const FramebufferAttachType RL_ATTACHMENT_COLOR_CHANNEL2 = 2;       // Framebuffer attachment type: color 2
-const FramebufferAttachType RL_ATTACHMENT_COLOR_CHANNEL3 = 3;       // Framebuffer attachment type: color 3
-const FramebufferAttachType RL_ATTACHMENT_COLOR_CHANNEL4 = 4;       // Framebuffer attachment type: color 4
-const FramebufferAttachType RL_ATTACHMENT_COLOR_CHANNEL5 = 5;       // Framebuffer attachment type: color 5
-const FramebufferAttachType RL_ATTACHMENT_COLOR_CHANNEL6 = 6;       // Framebuffer attachment type: color 6
-const FramebufferAttachType RL_ATTACHMENT_COLOR_CHANNEL7 = 7;       // Framebuffer attachment type: color 7
-const FramebufferAttachType RL_ATTACHMENT_DEPTH = 100;              // Framebuffer attachment type: depth
-const FramebufferAttachType RL_ATTACHMENT_STENCIL = 200;            // Framebuffer attachment type: stencil
-
-typedef FramebufferAttachTextureType = int;
-
-const FramebufferAttachTextureType RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0;   // Framebuffer texture attachment type: cubemap, +X side
-const FramebufferAttachTextureType RL_ATTACHMENT_CUBEMAP_NEGATIVE_X = 1;   // Framebuffer texture attachment type: cubemap, -X side
-const FramebufferAttachTextureType RL_ATTACHMENT_CUBEMAP_POSITIVE_Y = 2;   // Framebuffer texture attachment type: cubemap, +Y side
-const FramebufferAttachTextureType RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y = 3;   // Framebuffer texture attachment type: cubemap, -Y side
-const FramebufferAttachTextureType RL_ATTACHMENT_CUBEMAP_POSITIVE_Z = 4;   // Framebuffer texture attachment type: cubemap, +Z side
-const FramebufferAttachTextureType RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z = 5;   // Framebuffer texture attachment type: cubemap, -Z side
-const FramebufferAttachTextureType RL_ATTACHMENT_TEXTURE2D = 100;          // Framebuffer texture attachment type: texture2d
-const FramebufferAttachTextureType RL_ATTACHMENT_RENDERBUFFER = 200;       // Framebuffer texture attachment type: renderbuffer
-
-const RL_LINES = 0x0001;        // GL_LINES
-const RL_TRIANGLES = 0x0004;    // GL_TRIANGLES
-const RL_QUADS = 0x0007;        // GL_QUADS
-
-
-//------------------------------------------------------------------------------------
-// Functions Declaration - Matrix operations
-//------------------------------------------------------------------------------------
-fn void rlMatrixMode(CInt mode);                      // Choose the current matrix to be transformed
-fn void rlPushMatrix();                          // Push the current matrix to stack
-fn void rlPopMatrix();                           // Pop latest inserted matrix from stack
-fn void rlLoadIdentity();                        // Reset current matrix to identity matrix
-fn void rlTranslatef(float x, float y, float z);     // Multiply the current matrix by a translation matrix
-fn void rlRotatef(float angle, float x, float y, float z); // Multiply the current matrix by a rotation matrix
-fn void rlScalef(float x, float y, float z);         // Multiply the current matrix by a scaling matrix
-fn void rlMultMatrixf(float *matf);            // Multiply the current matrix by another matrix
-fn void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar);
-fn void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar);
-fn void rlViewport(CInt x, CInt y, CInt width, CInt height); // Set the viewport area
-fn void rlSetClipPlanes(double nearPlane, double farPlane);    // Set clip planes distances
-fn double rlGetCullDistanceNear();               // Get cull plane distance near
-fn double rlGetCullDistanceFar();                // Get cull plane distance far
-
-//------------------------------------------------------------------------------------
-// Functions Declaration - Vertex level operations
-//------------------------------------------------------------------------------------
-fn void rlBegin(CInt mode);                           // Initialize drawing mode (how to organize vertex)
-fn void rlEnd();                                 // Finish vertex providing
-fn void rlVertex2i(CInt x, CInt y);                    // Define one vertex (position) - 2 CInt
-fn void rlVertex2f(float x, float y);                // Define one vertex (position) - 2 float
-fn void rlVertex3f(float x, float y, float z);       // Define one vertex (position) - 3 float
-fn void rlTexCoord2f(float x, float y);              // Define one vertex (texture coordinate) - 2 float
-fn void rlNormal3f(float x, float y, float z);       // Define one vertex (normal) - 3 float
-fn void rlColor4ub(char r, char g, char b, char a); // Define one vertex (color) - 4 byte
-fn void rlColor3f(float x, float y, float z);        // Define one vertex (color) - 3 float
-fn void rlColor4f(float x, float y, float z, float w); // Define one vertex (color) - 4 float
-
-//------------------------------------------------------------------------------------
-// Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2)
-// NOTE: This functions are used to completely abstract raylib code from OpenGL layer,
-// some of them are direct wrappers over OpenGL calls, some others are custom
-//------------------------------------------------------------------------------------
-
-// Vertex buffers state
-fn bool rlEnableVertexArray(CUInt vaoId);     // Enable vertex array (VAO, if supported)
-fn void rlDisableVertexArray();                  // Disable vertex array (VAO, if supported)
-fn void rlEnableVertexBuffer(CUInt id);       // Enable vertex buffer (VBO)
-fn void rlDisableVertexBuffer();                 // Disable vertex buffer (VBO)
-fn void rlEnableVertexBufferElement(CUInt id); // Enable vertex buffer element (VBO element)
-fn void rlDisableVertexBufferElement();          // Disable vertex buffer element (VBO element)
-fn void rlEnableVertexAttribute(CUInt index); // Enable vertex attribute index
-fn void rlDisableVertexAttribute(CUInt index); // Disable vertex attribute index
-fn void rlEnableStatePointer(ShaderAttributeDataType vertexAttribType, void *buffer); // Enable attribute state pointer
-fn void rlDisableStatePointer(ShaderAttributeDataType vertexAttribType); // Disable attribute state pointer
-
-// Textures state
-fn void rlActiveTextureSlot(CInt slot);               // Select and active a texture slot
-fn void rlEnableTexture(CUInt id);            // Enable texture
-fn void rlDisableTexture();                      // Disable texture
-fn void rlEnableTextureCubemap(CUInt id);     // Enable texture cubemap
-fn void rlDisableTextureCubemap();               // Disable texture cubemap
-fn void rlTextureParameters(CUInt id, CInt param, CInt value); // Set texture parameters (filter, wrap)
-fn void rlCubemapParameters(CUInt id, CInt param, CInt value); // Set cubemap parameters (filter, wrap)
-
-// Shader state
-fn void rlEnableShader(CUInt id);             // Enable shader program
-fn void rlDisableShader();                       // Disable shader program
-
-// Framebuffer state
-fn void rlEnableFramebuffer(CUInt id);        // Enable render texture (fbo)
-fn void rlDisableFramebuffer();                  // Disable render texture (fbo), return to default framebuffer
-fn CUInt rlGetActiveFramebuffer();        // Get the currently active render texture (fbo), 0 for default framebuffer
-fn void rlActiveDrawBuffers(CInt count);              // Activate multiple draw color buffers
-fn void rlBlitFramebuffer(CInt srcX, CInt srcY, CInt srcWidth, CInt srcHeight, CInt dstX, CInt dstY, CInt dstWidth, CInt dstHeight, CInt bufferMask); // Blit active framebuffer to main framebuffer
-fn void rlBindFramebuffer(CUInt target, CUInt framebuffer); // Bind framebuffer (FBO)
-
-// General render state
-fn void rlEnableColorBlend();                    // Enable color blending
-fn void rlDisableColorBlend();                   // Disable color blending
-fn void rlEnableDepthTest();                     // Enable depth test
-fn void rlDisableDepthTest();                    // Disable depth test
-fn void rlEnableDepthMask();                     // Enable depth write
-fn void rlDisableDepthMask();                    // Disable depth write
-fn void rlEnableBackfaceCulling();               // Enable backface culling
-fn void rlDisableBackfaceCulling();              // Disable backface culling
-fn void rlColorMask(bool r, bool g, bool b, bool a); // Color mask control
-fn void rlSetCullFace(CInt mode);                     // Set face culling mode
-fn void rlEnableScissorTest();                   // Enable scissor test
-fn void rlDisableScissorTest();                  // Disable scissor test
-fn void rlScissor(CInt x, CInt y, CInt width, CInt height); // Scissor test
-fn void rlEnablePointMode();                     // Enable point mode
-fn void rlDisablePointMode();                    // Disable point mode
-fn void rlSetPointSize(float size);                  // Set the point drawing size
-fn float rlGetPointSize();                       // Get the point drawing size
-fn void rlEnableWireMode();                      // Enable wire mode
-fn void rlDisableWireMode();                     // Disable wire mode
-fn void rlSetLineWidth(float width);                 // Set the line drawing width
-fn float rlGetLineWidth();                       // Get the line drawing width
-fn void rlEnableSmoothLines();                   // Enable line aliasing
-fn void rlDisableSmoothLines();                  // Disable line aliasing
-fn void rlEnableStereoRender();                  // Enable stereo rendering
-fn void rlDisableStereoRender();                 // Disable stereo rendering
-fn bool rlIsStereoRenderEnabled();               // Check if stereo render is enabled
-
-fn void rlClearColor(char r, char g, char b, char a); // Clear color buffer with color
-fn void rlClearScreenBuffers();                  // Clear used screen buffers (color and depth)
-fn void rlCheckErrors();                         // Check and log OpenGL error codes
-fn void rlSetBlendMode(BlendMode mode);                    // Set blending mode
-fn void rlSetBlendFactors(CInt glSrcFactor, CInt glDstFactor, CInt glEquation); // Set blending mode factor and equation (using OpenGL factors)
-fn void rlSetBlendFactorsSeparate(CInt glSrcRGB, CInt glDstRGB, CInt glSrcAlpha, CInt glDstAlpha, CInt glEqRGB, CInt glEqAlpha); // Set blending mode factors and equations separately (using OpenGL factors)
-
-
-//------------------------------------------------------------------------------------
-// Functions Declaration - rlgl functionality
-//------------------------------------------------------------------------------------
-// rlgl initialization functions
-fn void rlglInit(CInt width, CInt height);             // Initialize rlgl (buffers, shaders, textures, states)
-fn void rlglClose();                             // De-initialize rlgl (buffers, shaders, textures)
-fn void rlLoadExtensions(void *loader);              // Load OpenGL extensions (loader function required)
-fn void *rlGetProcAddress(ZString procName);     // Get OpenGL procedure address
-fn CInt rlGetVersion();                           // Get current OpenGL version
-fn void rlSetFramebufferWidth(CInt width);            // Set current framebuffer width
-fn CInt rlGetFramebufferWidth();                  // Get default framebuffer width
-fn void rlSetFramebufferHeight(CInt height);          // Set current framebuffer height
-fn CInt rlGetFramebufferHeight();                 // Get default framebuffer height
-
-fn CUInt rlGetTextureIdDefault();         // Get default texture id
-fn CUInt rlGetShaderIdDefault();          // Get default shader id
-fn CInt *rlGetShaderLocsDefault();                // Get default shader locations
-
-// Render batch management
-// NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode
-// but this render batch API is exposed in case of custom batches are required
-fn void rlSetTexture(CUInt id);               // Set current texture for render batch and check buffers limits
-
-
-// raymath.h
-// Add two vectors (v1 + v2)
-fn Vector2 vector2Add(Vector2 v1, Vector2 v2) @cname("Vector2Add");
-// Add vector and float value
-fn Vector2 vector2AddValue(Vector2 v, float add) @cname("Vector2AddValue");
-// Calculate the signed angle from v1 to v2, relative to the origin (0, 0)
-// NOTE: Coordinate system convention: positive X right, positive Y down,
-// positive angles appear clockwise, and negative angles appear counterclockwise
-fn float vector2Angle(Vector2 v1, Vector2 v2) @cname("Vector2Angle");
-// Clamp the components of the vector between
-// min and max values specified by the given vectors
-fn Vector2 vector2Clamp(Vector2 v, Vector2 min, Vector2 max) @cname("Vector2Clamp");
-// Clamp the magnitude of the vector between two min and max values
-fn Vector2 vector2ClampValue(Vector2 v, float min, float max) @cname("Vector2ClampValue");
-// Calculate two vectors cross product
-fn float vector2CrossProduct(Vector2 v1, Vector2 v2) @cname("Vector2CrossProduct");
-// Calculate distance between two vectors
-fn float vector2Distance(Vector2 v1, Vector2 v2) @cname("Vector2Distance");
-// Calculate square distance between two vectors
-fn float vector2DistanceSqr(Vector2 v1, Vector2 v2) @cname("Vector2DistanceSqr");
-// Divide vector by vector
-fn Vector2 vector2Divide(Vector2 v1, Vector2 v2) @cname("Vector2Divide");
-// Calculate two vectors dot product
-fn float vector2DotProduct(Vector2 v1, Vector2 v2) @cname("Vector2DotProduct");
-// Check whether two given vectors are almost equal
-fn int vector2Equals(Vector2 p, Vector2 q) @cname("Vector2Equals");
-// Invert the given vector
-fn Vector2 vector2Invert(Vector2 v) @cname("Vector2Invert");
-// Calculate vector length
-fn float vector2Length(Vector2 v) @cname("Vector2Length");
-// Calculate vector square length
-fn float vector2LengthSqr(Vector2 v) @cname("Vector2LengthSqr");
-// Calculate linear interpolation between two vectors
-fn Vector2 vector2Lerp(Vector2 v1, Vector2 v2, float amount) @cname("Vector2Lerp");
-// Calculate angle defined by a two vectors line
-// NOTE: Parameters need to be normalized
-// Current implementation should be aligned with glm::angle
-fn float vector2LineAngle(Vector2 start, Vector2 end) @cname("Vector2LineAngle");
-// Get max value for each pair of components
-fn Vector2 vector2Max(Vector2 v1, Vector2 v2) @cname("Vector2Max");
-// Get min value for each pair of components
-fn Vector2 vector2Min(Vector2 v1, Vector2 v2) @cname("Vector2Min");
-// Move Vector towards target
-fn Vector2 vector2MoveTowards(Vector2 v, Vector2 target, float maxDistance) @cname("Vector2MoveTowards");
-// Multiply vector by vector
-fn Vector2 vector2Multiply(Vector2 v1, Vector2 v2) @cname("Vector2Multiply");
-// Negate vector
-fn Vector2 vector2Negate(Vector2 v) @cname("Vector2Negate");
-// Normalize provided vector
-fn Vector2 vector2Normalize(Vector2 v) @cname("Vector2Normalize");
-// Vector with components value 1.0f
-fn Vector2 vector2One() @cname("Vector2One");
-// Calculate reflected vector to normal
-fn Vector2 vector2Reflect(Vector2 v, Vector2 normal) @cname("Vector2Reflect");
-// Compute the direction of a refracted ray
-// v: normalized direction of the incoming ray
-// n: normalized normal vector of the interface of two optical media
-// r: ratio of the refractive index of the medium from where the ray comes
-//    to the refractive index of the medium on the other side of the surface
-fn Vector2 vector2Refract(Vector2 v, Vector2 n, float r) @cname("Vector2Refract");
-// Rotate vector by angle
-fn Vector2 vector2Rotate(Vector2 v, float angle) @cname("Vector2Rotate");
-// Scale vector (multiply by value)
-fn Vector2 vector2Scale(Vector2 v, float scale) @cname("Vector2Scale");
-// Subtract two vectors (v1 - v2)
-fn Vector2 vector2Subtract(Vector2 v1, Vector2 v2) @cname("Vector2Subtract");
-// Subtract vector by float value
-fn Vector2 vector2SubtractValue(Vector2 v, float sub) @cname("Vector2SubtractValue");
-// Transforms a Vector2 by a given Matrix
-fn Vector2 vector2Transform(Vector2 v, Matrix mat) @cname("Vector2Transform");
-// Vector with components value 0.0f
-fn Vector2 vector2Zero() @cname("Vector2Zero");
-
-// Add two vectors
-fn Vector3 vector3Add(Vector3 v1, Vector3 v2) @cname("Vector3Add");
-// Add vector and float value
-fn Vector3 vector3AddValue(Vector3 v, float add) @cname("Vector3AddValue");
-// Calculate angle between two vectors
-fn float vector3Angle(Vector3 v1, Vector3 v2) @cname("Vector3Angle");
-// Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c)
-// NOTE: Assumes P is on the plane of the triangle
-fn Vector3 vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c) @cname("Vector3Barycenter");
-// Clamp the components of the vector between
-// min and max values specified by the given vectors
-fn Vector3 vector3Clamp(Vector3 v, Vector3 min, Vector3 max) @cname("Vector3Clamp");
-// Clamp the magnitude of the vector between two values
-fn Vector3 vector3ClampValue(Vector3 v, float min, float max) @cname("Vector3ClampValue");
-// Calculate two vectors cross product
-fn Vector3 vector3CrossProduct(Vector3 v1, Vector3 v2) @cname("Vector3CrossProduct");
-// Calculate cubic hermite interpolation between two vectors and their tangents
-// as described in the GLTF 2.0 specification: https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#interpolation-cubic
-fn Vector3 vector3CubicHermite(Vector3 v1, Vector3 tangent1, Vector3 v2, Vector3 tangent2, float amount) @cname("Vector3CubicHermite");
-// Calculate square distance between two vectors
-fn float vector3Distance(Vector3 v1, Vector3 v2) @cname("Vector3Distance");
-// Calculate square distance between two vectors
-fn float vector3DistanceSqr(Vector3 v1, Vector3 v2) @cname("Vector3DistanceSqr");
-// Divide vector by vector
-fn Vector3 vector3Divide(Vector3 v1, Vector3 v2) @cname("Vector3Divide");
-// Calculate two vectors dot product
-fn float vector3DotProduct(Vector3 v1, Vector3 v2) @cname("Vector3DotProduct");
-// Check whether two given vectors are almost equal
-fn int vector3Equals(Vector3 p, Vector3 q) @cname("Vector3Equals");
-// Invert the given vector
-fn Vector3 vector3Invert(Vector3 v) @cname("Vector3Invert");
-// Calculate vector length
-fn float vector3Length(Vector3 v) @cname("Vector3Length");
-// Calculate vector square length
-fn float vector3LengthSqr(Vector3 v) @cname("Vector3LengthSqr");
-// Calculate linear interpolation between two vectors
-fn Vector3 vector3Lerp(Vector3 v1, Vector3 v2, float amount) @cname("Vector3Lerp");
-// Get max value for each pair of components
-fn Vector3 vector3Max(Vector3 v1, Vector3 v2) @cname("Vector3Max");
-// Get min value for each pair of components
-fn Vector3 vector3Min(Vector3 v1, Vector3 v2) @cname("Vector3Min");
-// Move Vector towards target
-fn Vector3 vector3MoveTowards(Vector3 v, Vector3 target, float maxDistance) @cname("Vector3MoveTowards");
-// Multiply vector by vector
-fn Vector3 vector3Multiply(Vector3 v1, Vector3 v2) @cname("Vector3Multiply");
-// Negate provided vector (invert direction)
-fn Vector3 vector3Negate(Vector3 v) @cname("Vector3Negate");
-// Normalize provided vector
-fn Vector3 vector3Normalize(Vector3 v) @cname("Vector3Normalize");
-// Vector with components value 1.0f
-fn Vector3 vector3One() @cname("Vector3One");
-// Orthonormalize provided vectors
-// Makes vectors normalized and orthogonal to each other
-// Gram-Schmidt function implementation
-fn void vector3OrthoNormalize(Vector3 *v1, Vector3 *v2) @cname("Vector3OrthoNormalize");
-// Calculate one vector perpendicular vector
-fn Vector3 vector3Perpendicular(Vector3 v) @cname("Vector3Perpendicular");
-//Calculate the projection of the vector v1 on to v2
-fn Vector3 vector3Project(Vector3 v1, Vector3 v2) @cname("Vector3Project");
-// Calculate reflected vector to normal
-fn Vector3 vector3Reflect(Vector3 v, Vector3 normal) @cname("Vector3Reflect");
-// Compute the direction of a refracted ray
-// v: normalized direction of the incoming ray
-// n: normalized normal vector of the interface of two optical media
-// r: ratio of the refractive index of the medium from where the ray comes
-//    to the refractive index of the medium on the other side of the surface
-fn Vector3 vector3Refract(Vector3 v, Vector3 n, float r) @cname("Vector3Refract");
-//Calculate the rejection of the vector v1 on to v2
-fn Vector3 vector3Reject(Vector3 v1, Vector3 v2) @cname("Vector3Reject");
-// Rotates a vector around an axis
-fn Vector3 vector3RotateByAxisAngle(Vector3 v, Vector3 axis, float angle) @cname("Vector3RotateByAxisAngle");
-// Transform a vector by quaternion rotation
-fn Vector3 vector3RotateByQuaternion(Vector3 v, Quaternion q) @cname("Vector3RotateByQuaternion");
-// Multiply vector by scalar
-fn Vector3 vector3Scale(Vector3 v, float scalar) @cname("Vector3Scale");
-// Subtract two vectors
-fn Vector3 vector3Subtract(Vector3 v1, Vector3 v2) @cname("Vector3Subtract");
-// Subtract vector by float value
-fn Vector3 vector3SubtractValue(Vector3 v, float sub) @cname("Vector3SubtractValue");
-
-// Get Vector3 as float array
-// fn float3 vector3ToFloatV(Vector3 v) @cname("Vector3ToFloatV"); // ? float3 == float[<3>]
-
-// Transforms a Vector3 by a given Matrix
-fn Vector3 vector3Transform(Vector3 v, Matrix mat) @cname("Vector3Transform");
-// Projects a Vector3 from screen space into object space
-// NOTE: We are avoiding calling other raymath functions despite available
-fn Vector3 vector3Unproject(Vector3 source, Matrix projection, Matrix view) @cname("Vector3Unproject");
-// Vector with components value 0.0f
-fn Vector3 vector3Zero() @cname("Vector3Zero");
-
-fn Vector4 vector4Add(Vector4 v1, Vector4 v2) @cname("Vector4Add");
-fn Vector4 vector4AddValue(Vector4 v, float add) @cname("Vector4AddValue");
-// Calculate distance between two vectors
-fn float vector4Distance(Vector4 v1, Vector4 v2) @cname("Vector4Distance");
-// Calculate square distance between two vectors
-fn float vector4DistanceSqr(Vector4 v1, Vector4 v2) @cname("Vector4DistanceSqr");
-// Divide vector by vector
-fn Vector4 vector4Divide(Vector4 v1, Vector4 v2) @cname("Vector4Divide");
-fn float vector4DotProduct(Vector4 v1, Vector4 v2) @cname("Vector4DotProduct");
-// Check whether two given vectors are almost equal
-fn int vector4Equals(Vector4 p, Vector4 q) @cname("Vector4Equals");
-// Invert the given vector
-fn Vector4 vector4Invert(Vector4 v) @cname("Vector4Invert");
-fn float vector4Length(Vector4 v) @cname("Vector4Length");
-fn float vector4LengthSqr(Vector4 v) @cname("Vector4LengthSqr");
-// Calculate linear interpolation between two vectors
-fn Vector4 vector4Lerp(Vector4 v1, Vector4 v2, float amount) @cname("Vector4Lerp");
-// Get max value for each pair of components
-fn Vector4 vector4Max(Vector4 v1, Vector4 v2) @cname("Vector4Max");
-// Get min value for each pair of components
-fn Vector4 vector4Min(Vector4 v1, Vector4 v2) @cname("Vector4Min");
-// Move Vector towards target
-fn Vector4 vector4MoveTowards(Vector4 v, Vector4 target, float maxDistance) @cname("Vector4MoveTowards");
-// Multiply vector by vector
-fn Vector4 vector4Multiply(Vector4 v1, Vector4 v2) @cname("Vector4Multiply");
-// Negate vector
-fn Vector4 vector4Negate(Vector4 v) @cname("Vector4Negate");
-// Normalize provided vector
-fn Vector4 vector4Normalize(Vector4 v) @cname("Vector4Normalize");
-fn Vector4 vector4One() @cname("Vector4One");
-fn Vector4 vector4Scale(Vector4 v, float scale) @cname("Vector4Scale");
-fn Vector4 vector4Subtract(Vector4 v1, Vector4 v2) @cname("Vector4Subtract");
-fn Vector4 vector4SubtractValue(Vector4 v, float add) @cname("Vector4SubtractValue");
-fn Vector4 vector4Zero() @cname("Vector4Zero");
-
-// Add two matrices
-fn Matrix matrixAdd(Matrix left, Matrix right) @cname("MatrixAdd");
-// Decompose a transformation matrix into its rotational, translational and scaling components
-fn void matrixDecompose(Matrix mat, Vector3 *translation, Quaternion *rotation, Vector3 *scale) @cname("MatrixDecompose");
-// Compute matrix determinant
-fn float matrixDeterminant(Matrix mat) @cname("MatrixDeterminant");
-// Get perspective projection matrix
-fn Matrix matrixFrustum(double left, double right, double bottom, double top, double nearPlane, double farPlane) @cname("MatrixFrustum");
-// Get identity matrix
-fn Matrix matrixIdentity() @cname("MatrixIdentity");
-// Invert provided matrix
-fn  Matrix matrixInvert(Matrix mat) @cname("MatrixInvert");
-// Get camera look-at matrix (view matrix)
-fn Matrix matrixLookAt(Vector3 eye, Vector3 target, Vector3 up) @cname("MatrixLookAt");
-// Get two matrix multiplication
-// NOTE: When multiplying matrices... the order matters!
-fn Matrix matrixMultiply(Matrix left, Matrix right) @cname("MatrixMultiply");
-// Get orthographic projection matrix
-fn Matrix matrixOrtho(double left, double right, double bottom, double top, double nearPlane, double farPlane) @cname("MatrixOrtho");
-// Get perspective projection matrix
-// NOTE: Fovy angle must be provided in radians
-fn Matrix matrixPerspective(double fovY, double aspect, double nearPlane, double farPlane) @cname("MatrixPerspective");
-// Create rotation matrix from axis and angle
-// NOTE: Angle should be provided in radians
-fn Matrix matrixRotate(Vector3 axis, float angle) @cname("MatrixRotate");
-// Get x-rotation matrix
-// NOTE: Angle must be provided in radians
-fn Matrix matrixRotateX(float angle) @cname("MatrixRotateX");
-// Get zyx-rotation matrix
-// NOTE: Angle must be provided in radians
-fn Matrix matrixRotateXYZ(Vector3 angle) @cname("MatrixRotateXYZ");
-// Get y-rotation matrix
-// NOTE: Angle must be provided in radians
-fn Matrix matrixRotateY(float angle) @cname("MatrixRotateY");
-// Get z-rotation matrix
-// NOTE: Angle must be provided in radians
-fn Matrix matrixRotateZ(float angle) @cname("MatrixRotateZ");
-// Get zyx-rotation matrix
-// NOTE: Angle must be provided in radians
-fn Matrix matrixRotateZYX(Vector3 angle) @cname("MatrixRotateZYX");
-// Get scaling matrix
-fn Matrix matrixScale(float x, float y, float z) @cname("MatrixScale");
-// Subtract two matrices (left - right)
-fn Matrix matrixSubtract(Matrix left, Matrix right) @cname("MatrixSubtract");
-
-// Get float array of matrix data
-// fn float16 matrixToFloatV(Matrix mat) @cname("MatrixToFloatV"); // float16 == float[<16>] ??
-
-// Get the trace of the matrix (sum of the values along the diagonal)
-fn float matrixTrace(Matrix mat) @cname("MatrixTrace");
-// Get translation matrix
-fn  Matrix matrixTranslate(float x, float y, float z) @cname("MatrixTranslate");
-// Transposes provided matrix
-fn Matrix matrixTranspose(Matrix mat) @cname("MatrixTranspose");
-
-// Add two quaternions
-fn Quaternion quaternionAdd(Quaternion q1, Quaternion q2) @cname("QuaternionAdd");
-// Add quaternion and float value
-fn Quaternion quaternionAddValue(Quaternion q, float add) @cname("QuaternionAddValue");
-// Calculate quaternion cubic spline interpolation using Cubic Hermite Spline algorithm
-// as described in the GLTF 2.0 specification: https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#interpolation-cubic
-fn Quaternion quaternionCubicHermiteSpline(Quaternion q1, Quaternion outTangent1, Quaternion q2, Quaternion inTangent2, float t) @cname("QuaternionCubicHermiteSpline");
-// Divide two quaternions
-fn Quaternion quaternionDivide(Quaternion q1, Quaternion q2) @cname("QuaternionDivide");
-// Check whether two given quaternions are almost equal
-fn int quaternionEquals(Quaternion p, Quaternion q) @cname("QuaternionEquals");
-// Get rotation quaternion for an angle and axis
-// NOTE: Angle must be provided in radians
-fn Quaternion quaternionFromAxisAngle(Vector3 axis, float angle) @cname("QuaternionFromAxisAngle");
-// Get the quaternion equivalent to Euler angles
-// NOTE: Rotation order is ZYX
-fn Quaternion quaternionFromEuler(float pitch, float yaw, float roll) @cname("QuaternionFromEuler");
-// Get a quaternion for a given rotation matrix
-fn Quaternion quaternionFromMatrix(Matrix mat) @cname("QuaternionFromMatrix");
-// Calculate quaternion based on the rotation from one vector to another
-fn Quaternion quaternionFromVector3ToVector3(Vector3 from, Vector3 to) @cname("QuaternionFromVector3ToVector3");
-// Get identity quaternion
-fn Quaternion quaternionIdentity() @cname("QuaternionIdentity");
-// Invert provided quaternion
-fn Quaternion quaternionInvert(Quaternion q) @cname("QuaternionInvert");
-// Computes the length of a quaternion
-fn float quaternionLength(Quaternion q) @cname("QuaternionLength");
-// Calculate linear interpolation between two quaternions
-fn Quaternion quaternionLerp(Quaternion q1, Quaternion q2, float amount) @cname("QuaternionLerp");
-// Calculate two quaternion multiplication
-fn Quaternion quaternionMultiply(Quaternion q1, Quaternion q2) @cname("QuaternionMultiply");
-// Calculate slerp-optimized interpolation between two quaternions
-fn Quaternion quaternionNlerp(Quaternion q1, Quaternion q2, float amount) @cname("QuaternionNlerp");
-// Normalize provided quaternion
-fn Quaternion quaternionNormalize(Quaternion q) @cname("QuaternionNormalize");
-// Scale quaternion by float value
-fn Quaternion quaternionScale(Quaternion q, float mul) @cname("QuaternionScale");
-// Calculates spherical linear interpolation between two quaternions
-fn Quaternion quaternionSlerp(Quaternion q1, Quaternion q2, float amount) @cname("QuaternionSlerp");
-// Subtract two quaternions
-fn Quaternion quaternionSubtract(Quaternion q1, Quaternion q2) @cname("QuaternionSubtract");
-// Subtract quaternion and float value
-fn Quaternion quaternionSubtractValue(Quaternion q, float sub) @cname("QuaternionSubtractValue");
-// Get the rotation angle and axis for a given quaternion
-fn void quaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle) @cname("QuaternionToAxisAngle");
-// Get the Euler angles equivalent to quaternion (roll, pitch, yaw)
-// NOTE: Angles are returned in a Vector3 struct in radians
-fn Vector3 quaternionToEuler(Quaternion q) @cname("QuaternionToEuler");
-// Get a matrix for a given quaternion
-fn Matrix quaternionToMatrix(Quaternion q) @cname("QuaternionToMatrix");
-// Transform a quaternion given a transformation matrix
-fn Quaternion quaternionTransform(Quaternion q, Matrix mat) @cname("QuaternionTransform");
-
-
-// rcamera.h
-// Moves the camera in its forward direction
-fn void cameraMoveForward(Camera *camera, float distance, bool moveInWorldPlane) @cname("CameraMoveForward");
-// Moves the camera target in its current right direction
-fn void cameraMoveRight(Camera *camera, float distance, bool moveInWorldPlane) @cname("CameraMoveRight");
-// Moves the camera position closer/farther to/from the camera target
-fn void cameraMoveToTarget(Camera *camera, float delta) @cname("CameraMoveToTarget");
-// Moves the camera in its up direction
-fn void cameraMoveUp(Camera *camera, float distance) @cname("CameraMoveUp");
-// Rotates the camera around its right vector, pitch is "looking up and down"
-//  - lockView prevents camera overrotation (aka "somersaults")
-//  - rotateAroundTarget defines if rotation is around target or around its position
-//  - rotateUp rotates the up direction as well (typically only usefull in CAMERA_FREE)
-// NOTE: angle must be provided in radians
-fn void cameraPitch(Camera *camera, float angle, bool lockView, bool rotateAroundTarget, bool rotateUp) @cname("CameraPitch");
-// Rotates the camera around its forward vector
-// Roll is "turning your head sideways to the left or right"
-// Note: angle must be provided in radians
-fn void cameraRoll(Camera *camera, float angle) @cname("CameraRoll");
-// Rotates the camera around its up vector
-// Yaw is "looking left and right"
-// If rotateAroundTarget is false, the camera rotates around its position
-// Note: angle must be provided in radians
-fn void cameraYaw(Camera *camera, float angle, bool rotateAroundTarget) @cname("CameraYaw");
diff --git a/libraries/raylib55.c3l/wasm32/libraylib.a b/libraries/raylib55.c3l/wasm32/libraylib.a
deleted file mode 100644
index 4cdbfa6..0000000
Binary files a/libraries/raylib55.c3l/wasm32/libraylib.a and /dev/null differ
diff --git a/libraries/raylib55.c3l/windows-x64/raylib.lib b/libraries/raylib55.c3l/windows-x64/raylib.lib
deleted file mode 100644
index 736bdec..0000000
Binary files a/libraries/raylib55.c3l/windows-x64/raylib.lib and /dev/null differ
diff --git a/libraries/sqlite3.c3l/sqlite.c3i b/libraries/sqlite3.c3l/sqlite.c3i
index 5f07ed7..199f129 100644
--- a/libraries/sqlite3.c3l/sqlite.c3i
+++ b/libraries/sqlite3.c3l/sqlite.c3i
@@ -3,7 +3,7 @@
 
 module sqlite3;
 
-enum SqliteResult : const int
+constdef SqliteResult : int
 {
 
 	OK         =  0,   /* Successful result */
@@ -39,7 +39,7 @@ enum SqliteResult : const int
 	DONE       = 101,  /* step() has finished executing */
 }
 
-enum SqliteColumnType : const int
+constdef SqliteColumnType : int
 {
 	INTEGER  = 1,
 	FLOAT    = 2,
diff --git a/libraries/vulkan.c3l/vk10.c3i b/libraries/vulkan.c3l/vk10.c3i
index fe2bdbe..022cba1 100644
--- a/libraries/vulkan.c3l/vk10.c3i
+++ b/libraries/vulkan.c3l/vk10.c3i
@@ -72,20 +72,20 @@ typedef VkQueryPool = uptr;
 typedef VkFramebuffer = uptr;
 typedef VkRenderPass = uptr;
 typedef VkPipelineCache = uptr;
-enum VkAttachmentLoadOp  : const int
+constdef VkAttachmentLoadOp : int
 {
     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAttachmentStoreOp  : const int
+constdef VkAttachmentStoreOp  : int
 {
     VK_ATTACHMENT_STORE_OP_STORE = 0,
     VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
     VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBlendFactor  : const int
+constdef VkBlendFactor  : int
 {
     VK_BLEND_FACTOR_ZERO = 0,
     VK_BLEND_FACTOR_ONE = 1,
@@ -108,7 +108,7 @@ enum VkBlendFactor  : const int
     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
     VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBlendOp  : const int
+constdef VkBlendOp  : int
 {
     VK_BLEND_OP_ADD = 0,
     VK_BLEND_OP_SUBTRACT = 1,
@@ -117,7 +117,7 @@ enum VkBlendOp  : const int
     VK_BLEND_OP_MAX = 4,
     VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBorderColor  : const int
+constdef VkBorderColor : int
 {
     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
@@ -127,19 +127,19 @@ enum VkBorderColor  : const int
     VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
     VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineCacheHeaderVersion  : const int
+constdef VkPipelineCacheHeaderVersion  : int
 {
     VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
     VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBufferCreateFlagBits  : const int
+constdef VkBufferCreateFlagBits  : int
 {
     VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1,
     VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2,
     VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 4,
     VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBufferUsageFlagBits  : const int
+constdef VkBufferUsageFlagBits : int
 {
     VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 1,
     VK_BUFFER_USAGE_TRANSFER_DST_BIT = 2,
@@ -152,7 +152,7 @@ enum VkBufferUsageFlagBits  : const int
     VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 256,
     VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkColorComponentFlagBits  : const int
+constdef VkColorComponentFlagBits : int
 {
     VK_COLOR_COMPONENT_R_BIT = 1,
     VK_COLOR_COMPONENT_G_BIT = 2,
@@ -160,7 +160,7 @@ enum VkColorComponentFlagBits  : const int
     VK_COLOR_COMPONENT_A_BIT = 8,
     VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkComponentSwizzle  : const int
+constdef VkComponentSwizzle : int
 {
     VK_COMPONENT_SWIZZLE_IDENTITY = 0,
     VK_COMPONENT_SWIZZLE_ZERO = 1,
@@ -171,36 +171,36 @@ enum VkComponentSwizzle  : const int
     VK_COMPONENT_SWIZZLE_A = 6,
     VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandPoolCreateFlagBits  : const int
+constdef VkCommandPoolCreateFlagBits : int
 {
     VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1,
     VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2,
     VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandPoolResetFlagBits  : const int
+constdef VkCommandPoolResetFlagBits : int
 {
     VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1,
     VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferResetFlagBits  : const int
+constdef VkCommandBufferResetFlagBits : int
 {
     VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1,
     VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferLevel  : const int
+constdef VkCommandBufferLevel : int
 {
     VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
     VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
     VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferUsageFlagBits  : const int
+constdef VkCommandBufferUsageFlagBits : int
 {
     VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 1,
     VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 2,
     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 4,
     VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCompareOp  : const int
+constdef VkCompareOp : int
 {
     VK_COMPARE_OP_NEVER = 0,
     VK_COMPARE_OP_LESS = 1,
@@ -212,7 +212,7 @@ enum VkCompareOp  : const int
     VK_COMPARE_OP_ALWAYS = 7,
     VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCullModeFlagBits  : const int
+constdef VkCullModeFlagBits : int
 {
     VK_CULL_MODE_NONE = 0,
     VK_CULL_MODE_FRONT_BIT = 1,
@@ -220,7 +220,7 @@ enum VkCullModeFlagBits  : const int
     VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
     VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorType  : const int
+constdef VkDescriptorType : int
 {
     VK_DESCRIPTOR_TYPE_SAMPLER = 0,
     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
@@ -235,7 +235,7 @@ enum VkDescriptorType  : const int
     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDynamicState  : const int
+constdef VkDynamicState : int
 {
     VK_DYNAMIC_STATE_VIEWPORT = 0,
     VK_DYNAMIC_STATE_SCISSOR = 1,
@@ -248,19 +248,19 @@ enum VkDynamicState  : const int
     VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFenceCreateFlagBits  : const int
+constdef VkFenceCreateFlagBits : int
 {
     VK_FENCE_CREATE_SIGNALED_BIT = 1,
     VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPolygonMode  : const int
+constdef VkPolygonMode : int
 {
     VK_POLYGON_MODE_FILL = 0,
     VK_POLYGON_MODE_LINE = 1,
     VK_POLYGON_MODE_POINT = 2,
     VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFormat  : const int
+constdef VkFormat : int
 {
     VK_FORMAT_UNDEFINED = 0,
     VK_FORMAT_R4G4_UNORM_PACK8 = 1,
@@ -449,7 +449,7 @@ enum VkFormat  : const int
     VK_FORMAT_ASTC_12X12_SRGB_BLOCK = 184,
     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFormatFeatureFlagBits  : const int
+constdef VkFormatFeatureFlagBits : int
 {
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 1,
     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 2,
@@ -466,13 +466,13 @@ enum VkFormatFeatureFlagBits  : const int
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 4096,
     VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFrontFace  : const int
+constdef VkFrontFace : int
 {
     VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
     VK_FRONT_FACE_CLOCKWISE = 1,
     VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageAspectFlagBits  : const int
+constdef VkImageAspectFlagBits : int
 {
     VK_IMAGE_ASPECT_COLOR_BIT = 1,
     VK_IMAGE_ASPECT_DEPTH_BIT = 2,
@@ -480,7 +480,7 @@ enum VkImageAspectFlagBits  : const int
     VK_IMAGE_ASPECT_METADATA_BIT = 8,
     VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageCreateFlagBits  : const int
+constdef VkImageCreateFlagBits : int
 {
     VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 1,
     VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 2,
@@ -489,7 +489,7 @@ enum VkImageCreateFlagBits  : const int
     VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 16,
     VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageLayout  : const int
+constdef VkImageLayout : int
 {
     VK_IMAGE_LAYOUT_UNDEFINED = 0,
     VK_IMAGE_LAYOUT_GENERAL = 1,
@@ -502,20 +502,20 @@ enum VkImageLayout  : const int
     VK_IMAGE_LAYOUT_PREINITIALIZED = 8,
     VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageTiling  : const int
+constdef VkImageTiling : int
 {
     VK_IMAGE_TILING_OPTIMAL = 0,
     VK_IMAGE_TILING_LINEAR = 1,
     VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageType  : const int
+constdef VkImageType : int
 {
     VK_IMAGE_TYPE_1D = 0,
     VK_IMAGE_TYPE_2D = 1,
     VK_IMAGE_TYPE_3D = 2,
     VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageUsageFlagBits  : const int
+constdef VkImageUsageFlagBits : int
 {
     VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 1,
     VK_IMAGE_USAGE_TRANSFER_DST_BIT = 2,
@@ -527,7 +527,7 @@ enum VkImageUsageFlagBits  : const int
     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 128,
     VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageViewType  : const int
+constdef VkImageViewType : int
 {
     VK_IMAGE_VIEW_TYPE_1D = 0,
     VK_IMAGE_VIEW_TYPE_2D = 1,
@@ -538,19 +538,19 @@ enum VkImageViewType  : const int
     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
     VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSharingMode  : const int
+constdef VkSharingMode : int
 {
     VK_SHARING_MODE_EXCLUSIVE = 0,
     VK_SHARING_MODE_CONCURRENT = 1,
     VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkIndexType  : const int
+constdef VkIndexType : int
 {
     VK_INDEX_TYPE_UINT16 = 0,
     VK_INDEX_TYPE_UINT32 = 1,
     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkLogicOp  : const int
+constdef VkLogicOp : int
 {
     VK_LOGIC_OP_CLEAR = 0,
     VK_LOGIC_OP_AND = 1,
@@ -570,12 +570,12 @@ enum VkLogicOp  : const int
     VK_LOGIC_OP_SET = 15,
     VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkMemoryHeapFlagBits  : const int
+constdef VkMemoryHeapFlagBits : int
 {
     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1,
     VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAccessFlagBits  : const int
+constdef VkAccessFlagBits : int
 {
     VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 1,
     VK_ACCESS_INDEX_READ_BIT = 2,
@@ -596,7 +596,7 @@ enum VkAccessFlagBits  : const int
     VK_ACCESS_MEMORY_WRITE_BIT = 65536,
     VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkMemoryPropertyFlagBits  : const int
+constdef VkMemoryPropertyFlagBits : int
 {
     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 1,
     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 2,
@@ -605,7 +605,7 @@ enum VkMemoryPropertyFlagBits  : const int
     VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 16,
     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPhysicalDeviceType  : const int
+constdef VkPhysicalDeviceType : int
 {
     VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
@@ -614,20 +614,20 @@ enum VkPhysicalDeviceType  : const int
     VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
     VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineBindPoint  : const int
+constdef VkPipelineBindPoint : int
 {
     VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
     VK_PIPELINE_BIND_POINT_COMPUTE = 1,
     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineCreateFlagBits  : const int
+constdef VkPipelineCreateFlagBits : int
 {
     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1,
     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2,
     VK_PIPELINE_CREATE_DERIVATIVE_BIT = 4,
     VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPrimitiveTopology  : const int
+constdef VkPrimitiveTopology : int
 {
     VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
     VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
@@ -642,12 +642,12 @@ enum VkPrimitiveTopology  : const int
     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
     VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryControlFlagBits  : const int
+constdef VkQueryControlFlagBits : int
 {
     VK_QUERY_CONTROL_PRECISE_BIT = 1,
     VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryPipelineStatisticFlagBits  : const int
+constdef VkQueryPipelineStatisticFlagBits : int
 {
     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 1,
     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 2,
@@ -662,7 +662,7 @@ enum VkQueryPipelineStatisticFlagBits  : const int
     VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 1024,
     VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryResultFlagBits  : const int
+constdef VkQueryResultFlagBits : int
 {
     VK_QUERY_RESULT_64_BIT = 1,
     VK_QUERY_RESULT_WAIT_BIT = 2,
@@ -670,14 +670,14 @@ enum VkQueryResultFlagBits  : const int
     VK_QUERY_RESULT_PARTIAL_BIT = 8,
     VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryType  : const int
+constdef VkQueryType : int
 {
     VK_QUERY_TYPE_OCCLUSION = 0,
     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
     VK_QUERY_TYPE_TIMESTAMP = 2,
     VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueueFlagBits  : const int
+constdef VkQueueFlagBits : int
 {
     VK_QUEUE_GRAPHICS_BIT = 1,
     VK_QUEUE_COMPUTE_BIT = 2,
@@ -685,13 +685,13 @@ enum VkQueueFlagBits  : const int
     VK_QUEUE_SPARSE_BINDING_BIT = 8,
     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSubpassContents  : const int
+constdef VkSubpassContents : int
 {
     VK_SUBPASS_CONTENTS_INLINE = 0,
     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkResult  : const int
+constdef VkResult : int
 {
     VK_SUCCESS = 0,
     VK_NOT_READY = 1,
@@ -714,7 +714,7 @@ enum VkResult  : const int
     VK_ERROR_UNKNOWN = -13,
     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkShaderStageFlagBits  : const int
+constdef VkShaderStageFlagBits : int
 {
     VK_SHADER_STAGE_VERTEX_BIT = 1,
     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 2,
@@ -726,12 +726,12 @@ enum VkShaderStageFlagBits  : const int
     VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
     VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSparseMemoryBindFlagBits  : const int
+constdef VkSparseMemoryBindFlagBits : int
 {
     VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1,
     VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStencilFaceFlagBits  : const int
+constdef VkStencilFaceFlagBits : int
 {
     VK_STENCIL_FACE_FRONT_BIT = 1,
     VK_STENCIL_FACE_BACK_BIT = 2,
@@ -739,7 +739,7 @@ enum VkStencilFaceFlagBits  : const int
     VK_STENCIL_FRONT_AND_BACK = 0x00000003,
     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStencilOp  : const int
+constdef VkStencilOp : int
 {
     VK_STENCIL_OP_KEEP = 0,
     VK_STENCIL_OP_ZERO = 1,
@@ -751,7 +751,7 @@ enum VkStencilOp  : const int
     VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
     VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStructureType  : const int
+constdef VkStructureType : int
 {
     VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
@@ -804,7 +804,7 @@ enum VkStructureType  : const int
     VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48,
     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSystemAllocationScope  : const int
+constdef VkSystemAllocationScope : int
 {
     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
@@ -813,12 +813,12 @@ enum VkSystemAllocationScope  : const int
     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
     VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkInternalAllocationType  : const int
+constdef VkInternalAllocationType : int
 {
     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
     VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerAddressMode  : const int
+constdef VkSamplerAddressMode : int
 {
     VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
@@ -826,25 +826,25 @@ enum VkSamplerAddressMode  : const int
     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFilter  : const int
+constdef VkFilter : int
 {
     VK_FILTER_NEAREST = 0,
     VK_FILTER_LINEAR = 1,
     VK_FILTER_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerMipmapMode  : const int
+constdef VkSamplerMipmapMode : int
 {
     VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
     VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkVertexInputRate  : const int
+constdef VkVertexInputRate : int
 {
     VK_VERTEX_INPUT_RATE_VERTEX = 0,
     VK_VERTEX_INPUT_RATE_INSTANCE = 1,
     VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineStageFlagBits  : const int
+constdef VkPipelineStageFlagBits : int
 {
     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 1,
     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 2,
@@ -865,14 +865,14 @@ enum VkPipelineStageFlagBits  : const int
     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 65536,
     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSparseImageFormatFlagBits  : const int
+constdef VkSparseImageFormatFlagBits : int
 {
     VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 1,
     VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 2,
     VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 4,
     VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSampleCountFlagBits  : const int
+constdef VkSampleCountFlagBits : int
 {
     VK_SAMPLE_COUNT_1_BIT = 1,
     VK_SAMPLE_COUNT_2_BIT = 2,
@@ -883,22 +883,22 @@ enum VkSampleCountFlagBits  : const int
     VK_SAMPLE_COUNT_64_BIT = 64,
     VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAttachmentDescriptionFlagBits  : const int
+constdef VkAttachmentDescriptionFlagBits : int
 {
     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1,
     VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorPoolCreateFlagBits  : const int
+constdef VkDescriptorPoolCreateFlagBits : int
 {
     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1,
     VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDependencyFlagBits  : const int
+constdef VkDependencyFlagBits : int
 {
     VK_DEPENDENCY_BY_REGION_BIT = 1,
     VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkObjectType  : const int
+constdef VkObjectType : int
 {
     VK_OBJECT_TYPE_UNKNOWN = 0,
     VK_OBJECT_TYPE_INSTANCE = 1,
@@ -928,7 +928,7 @@ enum VkObjectType  : const int
     VK_OBJECT_TYPE_COMMAND_POOL = 25,
     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkVendorId  : const int
+constdef VkVendorId : int
 {
     VK_VENDOR_ID_KHRONOS = 0x10000,
     VK_VENDOR_ID_VIV = 0x10001,
diff --git a/libraries/vulkan.c3l/vk11.c3i b/libraries/vulkan.c3l/vk11.c3i
index 567b128..5fdc1fd 100644
--- a/libraries/vulkan.c3l/vk11.c3i
+++ b/libraries/vulkan.c3l/vk11.c3i
@@ -79,20 +79,20 @@ typedef VkRenderPass = uptr;
 typedef VkPipelineCache = uptr;
 typedef VkDescriptorUpdateTemplate = uptr;
 typedef VkSamplerYcbcrConversion = uptr;
-enum VkAttachmentLoadOp  : const int
+constdef VkAttachmentLoadOp : int
 {
     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAttachmentStoreOp  : const int
+constdef VkAttachmentStoreOp : int
 {
     VK_ATTACHMENT_STORE_OP_STORE = 0,
     VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
     VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBlendFactor  : const int
+constdef VkBlendFactor : int
 {
     VK_BLEND_FACTOR_ZERO = 0,
     VK_BLEND_FACTOR_ONE = 1,
@@ -115,7 +115,7 @@ enum VkBlendFactor  : const int
     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
     VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBlendOp  : const int
+constdef VkBlendOp : int
 {
     VK_BLEND_OP_ADD = 0,
     VK_BLEND_OP_SUBTRACT = 1,
@@ -124,7 +124,7 @@ enum VkBlendOp  : const int
     VK_BLEND_OP_MAX = 4,
     VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBorderColor  : const int
+constdef VkBorderColor : int
 {
     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
@@ -134,17 +134,17 @@ enum VkBorderColor  : const int
     VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
     VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineCacheHeaderVersion  : const int
+constdef VkPipelineCacheHeaderVersion : int
 {
     VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
     VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDeviceQueueCreateFlagBits  : const int
+constdef VkDeviceQueueCreateFlagBits : int
 {
     VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 1,
     VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBufferCreateFlagBits  : const int
+constdef VkBufferCreateFlagBits : int
 {
     VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1,
     VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2,
@@ -152,7 +152,7 @@ enum VkBufferCreateFlagBits  : const int
     VK_BUFFER_CREATE_PROTECTED_BIT = 8,
     VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBufferUsageFlagBits  : const int
+constdef VkBufferUsageFlagBits : int
 {
     VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 1,
     VK_BUFFER_USAGE_TRANSFER_DST_BIT = 2,
@@ -165,7 +165,7 @@ enum VkBufferUsageFlagBits  : const int
     VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 256,
     VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkColorComponentFlagBits  : const int
+constdef VkColorComponentFlagBits : int
 {
     VK_COLOR_COMPONENT_R_BIT = 1,
     VK_COLOR_COMPONENT_G_BIT = 2,
@@ -173,7 +173,7 @@ enum VkColorComponentFlagBits  : const int
     VK_COLOR_COMPONENT_A_BIT = 8,
     VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkComponentSwizzle  : const int
+constdef VkComponentSwizzle : int
 {
     VK_COMPONENT_SWIZZLE_IDENTITY = 0,
     VK_COMPONENT_SWIZZLE_ZERO = 1,
@@ -184,37 +184,37 @@ enum VkComponentSwizzle  : const int
     VK_COMPONENT_SWIZZLE_A = 6,
     VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandPoolCreateFlagBits  : const int
+constdef VkCommandPoolCreateFlagBits : int
 {
     VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1,
     VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2,
     VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 4,
     VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandPoolResetFlagBits  : const int
+constdef VkCommandPoolResetFlagBits : int
 {
     VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1,
     VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferResetFlagBits  : const int
+constdef VkCommandBufferResetFlagBits : int
 {
     VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1,
     VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferLevel  : const int
+constdef VkCommandBufferLevel : int
 {
     VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
     VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
     VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferUsageFlagBits  : const int
+constdef VkCommandBufferUsageFlagBits : int
 {
     VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 1,
     VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 2,
     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 4,
     VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCompareOp  : const int
+constdef VkCompareOp : int
 {
     VK_COMPARE_OP_NEVER = 0,
     VK_COMPARE_OP_LESS = 1,
@@ -226,7 +226,7 @@ enum VkCompareOp  : const int
     VK_COMPARE_OP_ALWAYS = 7,
     VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCullModeFlagBits  : const int
+constdef VkCullModeFlagBits : int
 {
     VK_CULL_MODE_NONE = 0,
     VK_CULL_MODE_FRONT_BIT = 1,
@@ -234,7 +234,7 @@ enum VkCullModeFlagBits  : const int
     VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
     VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorType  : const int
+constdef VkDescriptorType : int
 {
     VK_DESCRIPTOR_TYPE_SAMPLER = 0,
     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
@@ -249,7 +249,7 @@ enum VkDescriptorType  : const int
     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDynamicState  : const int
+constdef VkDynamicState : int
 {
     VK_DYNAMIC_STATE_VIEWPORT = 0,
     VK_DYNAMIC_STATE_SCISSOR = 1,
@@ -262,19 +262,19 @@ enum VkDynamicState  : const int
     VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFenceCreateFlagBits  : const int
+constdef VkFenceCreateFlagBits : int
 {
     VK_FENCE_CREATE_SIGNALED_BIT = 1,
     VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPolygonMode  : const int
+constdef VkPolygonMode : int
 {
     VK_POLYGON_MODE_FILL = 0,
     VK_POLYGON_MODE_LINE = 1,
     VK_POLYGON_MODE_POINT = 2,
     VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFormat  : const int
+constdef VkFormat : int
 {
     VK_FORMAT_UNDEFINED = 0,
     VK_FORMAT_R4G4_UNORM_PACK8 = 1,
@@ -497,7 +497,7 @@ enum VkFormat  : const int
     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,
     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFormatFeatureFlagBits  : const int
+constdef VkFormatFeatureFlagBits : int
 {
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 1,
     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 2,
@@ -523,13 +523,13 @@ enum VkFormatFeatureFlagBits  : const int
     VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 8388608,
     VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFrontFace  : const int
+constdef VkFrontFace : int
 {
     VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
     VK_FRONT_FACE_CLOCKWISE = 1,
     VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageAspectFlagBits  : const int
+constdef VkImageAspectFlagBits : int
 {
     VK_IMAGE_ASPECT_COLOR_BIT = 1,
     VK_IMAGE_ASPECT_DEPTH_BIT = 2,
@@ -540,7 +540,7 @@ enum VkImageAspectFlagBits  : const int
     VK_IMAGE_ASPECT_PLANE_2_BIT = 64,
     VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageCreateFlagBits  : const int
+constdef VkImageCreateFlagBits : int
 {
     VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 1,
     VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 2,
@@ -556,7 +556,7 @@ enum VkImageCreateFlagBits  : const int
     VK_IMAGE_CREATE_DISJOINT_BIT = 512,
     VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageLayout  : const int
+constdef VkImageLayout : int
 {
     VK_IMAGE_LAYOUT_UNDEFINED = 0,
     VK_IMAGE_LAYOUT_GENERAL = 1,
@@ -571,20 +571,20 @@ enum VkImageLayout  : const int
     VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001,
     VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageTiling  : const int
+constdef VkImageTiling : int
 {
     VK_IMAGE_TILING_OPTIMAL = 0,
     VK_IMAGE_TILING_LINEAR = 1,
     VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageType  : const int
+constdef VkImageType : int
 {
     VK_IMAGE_TYPE_1D = 0,
     VK_IMAGE_TYPE_2D = 1,
     VK_IMAGE_TYPE_3D = 2,
     VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageUsageFlagBits  : const int
+constdef VkImageUsageFlagBits : int
 {
     VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 1,
     VK_IMAGE_USAGE_TRANSFER_DST_BIT = 2,
@@ -596,7 +596,7 @@ enum VkImageUsageFlagBits  : const int
     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 128,
     VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageViewType  : const int
+constdef VkImageViewType : int
 {
     VK_IMAGE_VIEW_TYPE_1D = 0,
     VK_IMAGE_VIEW_TYPE_2D = 1,
@@ -607,19 +607,19 @@ enum VkImageViewType  : const int
     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
     VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSharingMode  : const int
+constdef VkSharingMode : int
 {
     VK_SHARING_MODE_EXCLUSIVE = 0,
     VK_SHARING_MODE_CONCURRENT = 1,
     VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkIndexType  : const int
+constdef VkIndexType : int
 {
     VK_INDEX_TYPE_UINT16 = 0,
     VK_INDEX_TYPE_UINT32 = 1,
     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkLogicOp  : const int
+constdef VkLogicOp : int
 {
     VK_LOGIC_OP_CLEAR = 0,
     VK_LOGIC_OP_AND = 1,
@@ -639,13 +639,13 @@ enum VkLogicOp  : const int
     VK_LOGIC_OP_SET = 15,
     VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkMemoryHeapFlagBits  : const int
+constdef VkMemoryHeapFlagBits : int
 {
     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1,
     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 2,
     VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAccessFlagBits  : const int
+constdef VkAccessFlagBits : int
 {
     VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 1,
     VK_ACCESS_INDEX_READ_BIT = 2,
@@ -666,7 +666,7 @@ enum VkAccessFlagBits  : const int
     VK_ACCESS_MEMORY_WRITE_BIT = 65536,
     VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkMemoryPropertyFlagBits  : const int
+constdef VkMemoryPropertyFlagBits : int
 {
     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 1,
     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 2,
@@ -676,7 +676,7 @@ enum VkMemoryPropertyFlagBits  : const int
     VK_MEMORY_PROPERTY_PROTECTED_BIT = 32,
     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPhysicalDeviceType  : const int
+constdef VkPhysicalDeviceType : int
 {
     VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
@@ -685,13 +685,13 @@ enum VkPhysicalDeviceType  : const int
     VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
     VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineBindPoint  : const int
+constdef VkPipelineBindPoint : int
 {
     VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
     VK_PIPELINE_BIND_POINT_COMPUTE = 1,
     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineCreateFlagBits  : const int
+constdef VkPipelineCreateFlagBits : int
 {
     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1,
     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2,
@@ -701,7 +701,7 @@ enum VkPipelineCreateFlagBits  : const int
     VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
     VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPrimitiveTopology  : const int
+constdef VkPrimitiveTopology : int
 {
     VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
     VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
@@ -716,12 +716,12 @@ enum VkPrimitiveTopology  : const int
     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
     VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryControlFlagBits  : const int
+constdef VkQueryControlFlagBits : int
 {
     VK_QUERY_CONTROL_PRECISE_BIT = 1,
     VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryPipelineStatisticFlagBits  : const int
+constdef VkQueryPipelineStatisticFlagBits : int
 {
     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 1,
     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 2,
@@ -736,7 +736,7 @@ enum VkQueryPipelineStatisticFlagBits  : const int
     VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 1024,
     VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryResultFlagBits  : const int
+constdef VkQueryResultFlagBits : int
 {
     VK_QUERY_RESULT_64_BIT = 1,
     VK_QUERY_RESULT_WAIT_BIT = 2,
@@ -744,14 +744,14 @@ enum VkQueryResultFlagBits  : const int
     VK_QUERY_RESULT_PARTIAL_BIT = 8,
     VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryType  : const int
+constdef VkQueryType : int
 {
     VK_QUERY_TYPE_OCCLUSION = 0,
     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
     VK_QUERY_TYPE_TIMESTAMP = 2,
     VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueueFlagBits  : const int
+constdef VkQueueFlagBits : int
 {
     VK_QUEUE_GRAPHICS_BIT = 1,
     VK_QUEUE_COMPUTE_BIT = 2,
@@ -760,13 +760,13 @@ enum VkQueueFlagBits  : const int
     VK_QUEUE_PROTECTED_BIT = 16,
     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSubpassContents  : const int
+constdef VkSubpassContents : int
 {
     VK_SUBPASS_CONTENTS_INLINE = 0,
     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkResult  : const int
+constdef VkResult : int
 {
     VK_SUCCESS = 0,
     VK_NOT_READY = 1,
@@ -791,7 +791,7 @@ enum VkResult  : const int
     VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003,
     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkShaderStageFlagBits  : const int
+constdef VkShaderStageFlagBits : int
 {
     VK_SHADER_STAGE_VERTEX_BIT = 1,
     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 2,
@@ -803,12 +803,12 @@ enum VkShaderStageFlagBits  : const int
     VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
     VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSparseMemoryBindFlagBits  : const int
+constdef VkSparseMemoryBindFlagBits : int
 {
     VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1,
     VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStencilFaceFlagBits  : const int
+constdef VkStencilFaceFlagBits : int
 {
     VK_STENCIL_FACE_FRONT_BIT = 1,
     VK_STENCIL_FACE_BACK_BIT = 2,
@@ -816,7 +816,7 @@ enum VkStencilFaceFlagBits  : const int
     VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStencilOp  : const int
+constdef VkStencilOp : int
 {
     VK_STENCIL_OP_KEEP = 0,
     VK_STENCIL_OP_ZERO = 1,
@@ -828,7 +828,7 @@ enum VkStencilOp  : const int
     VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
     VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStructureType  : const int
+constdef VkStructureType : int
 {
     VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
@@ -948,7 +948,7 @@ enum VkStructureType  : const int
     VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSystemAllocationScope  : const int
+constdef VkSystemAllocationScope : int
 {
     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
@@ -957,12 +957,12 @@ enum VkSystemAllocationScope  : const int
     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
     VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkInternalAllocationType  : const int
+constdef VkInternalAllocationType : int
 {
     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
     VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerAddressMode  : const int
+constdef VkSamplerAddressMode : int
 {
     VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
@@ -970,25 +970,25 @@ enum VkSamplerAddressMode  : const int
     VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3,
     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFilter  : const int
+constdef VkFilter : int
 {
     VK_FILTER_NEAREST = 0,
     VK_FILTER_LINEAR = 1,
     VK_FILTER_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerMipmapMode  : const int
+constdef VkSamplerMipmapMode : int
 {
     VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
     VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkVertexInputRate  : const int
+constdef VkVertexInputRate : int
 {
     VK_VERTEX_INPUT_RATE_VERTEX = 0,
     VK_VERTEX_INPUT_RATE_INSTANCE = 1,
     VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineStageFlagBits  : const int
+constdef VkPipelineStageFlagBits : int
 {
     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 1,
     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 2,
@@ -1009,14 +1009,14 @@ enum VkPipelineStageFlagBits  : const int
     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 65536,
     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSparseImageFormatFlagBits  : const int
+constdef VkSparseImageFormatFlagBits : int
 {
     VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 1,
     VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 2,
     VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 4,
     VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSampleCountFlagBits  : const int
+constdef VkSampleCountFlagBits : int
 {
     VK_SAMPLE_COUNT_1_BIT = 1,
     VK_SAMPLE_COUNT_2_BIT = 2,
@@ -1027,24 +1027,24 @@ enum VkSampleCountFlagBits  : const int
     VK_SAMPLE_COUNT_64_BIT = 64,
     VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAttachmentDescriptionFlagBits  : const int
+constdef VkAttachmentDescriptionFlagBits : int
 {
     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1,
     VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorPoolCreateFlagBits  : const int
+constdef VkDescriptorPoolCreateFlagBits : int
 {
     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1,
     VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDependencyFlagBits  : const int
+constdef VkDependencyFlagBits : int
 {
     VK_DEPENDENCY_BY_REGION_BIT = 1,
     VK_DEPENDENCY_DEVICE_GROUP_BIT = 4,
     VK_DEPENDENCY_VIEW_LOCAL_BIT = 2,
     VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkObjectType  : const int
+constdef VkObjectType : int
 {
     VK_OBJECT_TYPE_UNKNOWN = 0,
     VK_OBJECT_TYPE_INSTANCE = 1,
@@ -1076,18 +1076,18 @@ enum VkObjectType  : const int
     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,
     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorUpdateTemplateType  : const int
+constdef VkDescriptorUpdateTemplateType : int
 {
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPointClippingBehavior  : const int
+constdef VkPointClippingBehavior : int
 {
     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
     VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalMemoryHandleTypeFlagBits  : const int
+constdef VkExternalMemoryHandleTypeFlagBits : int
 {
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
@@ -1098,14 +1098,14 @@ enum VkExternalMemoryHandleTypeFlagBits  : const int
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 64,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalMemoryFeatureFlagBits  : const int
+constdef VkExternalMemoryFeatureFlagBits : int
 {
     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1,
     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 2,
     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 4,
     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalSemaphoreHandleTypeFlagBits  : const int
+constdef VkExternalSemaphoreHandleTypeFlagBits : int
 {
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
@@ -1115,18 +1115,18 @@ enum VkExternalSemaphoreHandleTypeFlagBits  : const int
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 16,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalSemaphoreFeatureFlagBits  : const int
+constdef VkExternalSemaphoreFeatureFlagBits : int
 {
     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1,
     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2,
     VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSemaphoreImportFlagBits  : const int
+constdef VkSemaphoreImportFlagBits : int
 {
     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1,
     VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalFenceHandleTypeFlagBits  : const int
+constdef VkExternalFenceHandleTypeFlagBits : int
 {
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
@@ -1134,18 +1134,18 @@ enum VkExternalFenceHandleTypeFlagBits  : const int
     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 8,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalFenceFeatureFlagBits  : const int
+constdef VkExternalFenceFeatureFlagBits : int
 {
     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1,
     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2,
     VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFenceImportFlagBits  : const int
+constdef VkFenceImportFlagBits : int
 {
     VK_FENCE_IMPORT_TEMPORARY_BIT = 1,
     VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPeerMemoryFeatureFlagBits  : const int
+constdef VkPeerMemoryFeatureFlagBits : int
 {
     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 1,
     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 2,
@@ -1153,12 +1153,12 @@ enum VkPeerMemoryFeatureFlagBits  : const int
     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 8,
     VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkMemoryAllocateFlagBits  : const int
+constdef VkMemoryAllocateFlagBits : int
 {
     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1,
     VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSubgroupFeatureFlagBits  : const int
+constdef VkSubgroupFeatureFlagBits : int
 {
     VK_SUBGROUP_FEATURE_BASIC_BIT = 1,
     VK_SUBGROUP_FEATURE_VOTE_BIT = 2,
@@ -1170,13 +1170,13 @@ enum VkSubgroupFeatureFlagBits  : const int
     VK_SUBGROUP_FEATURE_QUAD_BIT = 128,
     VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkTessellationDomainOrigin  : const int
+constdef VkTessellationDomainOrigin : int
 {
     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
     VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerYcbcrModelConversion  : const int
+constdef VkSamplerYcbcrModelConversion : int
 {
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
@@ -1185,19 +1185,19 @@ enum VkSamplerYcbcrModelConversion  : const int
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerYcbcrRange  : const int
+constdef VkSamplerYcbcrRange : int
 {
     VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
     VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkChromaLocation  : const int
+constdef VkChromaLocation : int
 {
     VK_CHROMA_LOCATION_COSITED_EVEN = 0,
     VK_CHROMA_LOCATION_MIDPOINT = 1,
     VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkVendorId  : const int
+constdef VkVendorId : int
 {
     VK_VENDOR_ID_KHRONOS = 0x10000,
     VK_VENDOR_ID_VIV = 0x10001,
diff --git a/libraries/vulkan.c3l/vk12.c3i b/libraries/vulkan.c3l/vk12.c3i
index a3d39ea..8d6c580 100644
--- a/libraries/vulkan.c3l/vk12.c3i
+++ b/libraries/vulkan.c3l/vk12.c3i
@@ -79,20 +79,20 @@ typedef VkRenderPass = uptr;
 typedef VkPipelineCache = uptr;
 typedef VkDescriptorUpdateTemplate = uptr;
 typedef VkSamplerYcbcrConversion = uptr;
-enum VkAttachmentLoadOp  : const int
+constdef VkAttachmentLoadOp : int
 {
     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAttachmentStoreOp  : const int
+constdef VkAttachmentStoreOp : int
 {
     VK_ATTACHMENT_STORE_OP_STORE = 0,
     VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
     VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBlendFactor  : const int
+constdef VkBlendFactor : int
 {
     VK_BLEND_FACTOR_ZERO = 0,
     VK_BLEND_FACTOR_ONE = 1,
@@ -115,7 +115,7 @@ enum VkBlendFactor  : const int
     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
     VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBlendOp  : const int
+constdef VkBlendOp : int
 {
     VK_BLEND_OP_ADD = 0,
     VK_BLEND_OP_SUBTRACT = 1,
@@ -124,7 +124,7 @@ enum VkBlendOp  : const int
     VK_BLEND_OP_MAX = 4,
     VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBorderColor  : const int
+constdef VkBorderColor : int
 {
     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
@@ -134,27 +134,27 @@ enum VkBorderColor  : const int
     VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
     VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFramebufferCreateFlagBits  : const int
+constdef VkFramebufferCreateFlagBits : int
 {
     VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 1,
     VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineCacheHeaderVersion  : const int
+constdef VkPipelineCacheHeaderVersion : int
 {
     VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
     VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorSetLayoutCreateFlagBits  : const int
+constdef VkDescriptorSetLayoutCreateFlagBits : int
 {
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 2,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDeviceQueueCreateFlagBits  : const int
+constdef VkDeviceQueueCreateFlagBits : int
 {
     VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 1,
     VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBufferCreateFlagBits  : const int
+constdef VkBufferCreateFlagBits : int
 {
     VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1,
     VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2,
@@ -163,7 +163,7 @@ enum VkBufferCreateFlagBits  : const int
     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 16,
     VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBufferUsageFlagBits  : const int
+constdef VkBufferUsageFlagBits : int
 {
     VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 1,
     VK_BUFFER_USAGE_TRANSFER_DST_BIT = 2,
@@ -177,7 +177,7 @@ enum VkBufferUsageFlagBits  : const int
     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 131072,
     VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkColorComponentFlagBits  : const int
+constdef VkColorComponentFlagBits : int
 {
     VK_COLOR_COMPONENT_R_BIT = 1,
     VK_COLOR_COMPONENT_G_BIT = 2,
@@ -185,7 +185,7 @@ enum VkColorComponentFlagBits  : const int
     VK_COLOR_COMPONENT_A_BIT = 8,
     VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkComponentSwizzle  : const int
+constdef VkComponentSwizzle : int
 {
     VK_COMPONENT_SWIZZLE_IDENTITY = 0,
     VK_COMPONENT_SWIZZLE_ZERO = 1,
@@ -196,37 +196,37 @@ enum VkComponentSwizzle  : const int
     VK_COMPONENT_SWIZZLE_A = 6,
     VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandPoolCreateFlagBits  : const int
+constdef VkCommandPoolCreateFlagBits : int
 {
     VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1,
     VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2,
     VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 4,
     VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandPoolResetFlagBits  : const int
+constdef VkCommandPoolResetFlagBits : int
 {
     VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1,
     VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferResetFlagBits  : const int
+constdef VkCommandBufferResetFlagBits : int
 {
     VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1,
     VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferLevel  : const int
+constdef VkCommandBufferLevel : int
 {
     VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
     VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
     VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferUsageFlagBits  : const int
+constdef VkCommandBufferUsageFlagBits : int
 {
     VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 1,
     VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 2,
     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 4,
     VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCompareOp  : const int
+constdef VkCompareOp : int
 {
     VK_COMPARE_OP_NEVER = 0,
     VK_COMPARE_OP_LESS = 1,
@@ -238,7 +238,7 @@ enum VkCompareOp  : const int
     VK_COMPARE_OP_ALWAYS = 7,
     VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCullModeFlagBits  : const int
+constdef VkCullModeFlagBits : int
 {
     VK_CULL_MODE_NONE = 0,
     VK_CULL_MODE_FRONT_BIT = 1,
@@ -246,7 +246,7 @@ enum VkCullModeFlagBits  : const int
     VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
     VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorType  : const int
+constdef VkDescriptorType : int
 {
     VK_DESCRIPTOR_TYPE_SAMPLER = 0,
     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
@@ -261,7 +261,7 @@ enum VkDescriptorType  : const int
     VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10,
     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDynamicState  : const int
+constdef VkDynamicState : int
 {
     VK_DYNAMIC_STATE_VIEWPORT = 0,
     VK_DYNAMIC_STATE_SCISSOR = 1,
@@ -274,19 +274,19 @@ enum VkDynamicState  : const int
     VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8,
     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFenceCreateFlagBits  : const int
+constdef VkFenceCreateFlagBits : int
 {
     VK_FENCE_CREATE_SIGNALED_BIT = 1,
     VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPolygonMode  : const int
+constdef VkPolygonMode : int
 {
     VK_POLYGON_MODE_FILL = 0,
     VK_POLYGON_MODE_LINE = 1,
     VK_POLYGON_MODE_POINT = 2,
     VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFormat  : const int
+constdef VkFormat : int
 {
     VK_FORMAT_UNDEFINED = 0,
     VK_FORMAT_R4G4_UNORM_PACK8 = 1,
@@ -509,7 +509,7 @@ enum VkFormat  : const int
     VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033,
     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFormatFeatureFlagBits  : const int
+constdef VkFormatFeatureFlagBits : int
 {
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 1,
     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 2,
@@ -536,13 +536,13 @@ enum VkFormatFeatureFlagBits  : const int
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 65536,
     VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFrontFace  : const int
+constdef VkFrontFace : int
 {
     VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
     VK_FRONT_FACE_CLOCKWISE = 1,
     VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageAspectFlagBits  : const int
+constdef VkImageAspectFlagBits : int
 {
     VK_IMAGE_ASPECT_COLOR_BIT = 1,
     VK_IMAGE_ASPECT_DEPTH_BIT = 2,
@@ -553,7 +553,7 @@ enum VkImageAspectFlagBits  : const int
     VK_IMAGE_ASPECT_PLANE_2_BIT = 64,
     VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageCreateFlagBits  : const int
+constdef VkImageCreateFlagBits : int
 {
     VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 1,
     VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 2,
@@ -569,7 +569,7 @@ enum VkImageCreateFlagBits  : const int
     VK_IMAGE_CREATE_DISJOINT_BIT = 512,
     VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageLayout  : const int
+constdef VkImageLayout : int
 {
     VK_IMAGE_LAYOUT_UNDEFINED = 0,
     VK_IMAGE_LAYOUT_GENERAL = 1,
@@ -588,20 +588,20 @@ enum VkImageLayout  : const int
     VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003,
     VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageTiling  : const int
+constdef VkImageTiling : int
 {
     VK_IMAGE_TILING_OPTIMAL = 0,
     VK_IMAGE_TILING_LINEAR = 1,
     VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageType  : const int
+constdef VkImageType : int
 {
     VK_IMAGE_TYPE_1D = 0,
     VK_IMAGE_TYPE_2D = 1,
     VK_IMAGE_TYPE_3D = 2,
     VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageUsageFlagBits  : const int
+constdef VkImageUsageFlagBits : int
 {
     VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 1,
     VK_IMAGE_USAGE_TRANSFER_DST_BIT = 2,
@@ -613,7 +613,7 @@ enum VkImageUsageFlagBits  : const int
     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 128,
     VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageViewType  : const int
+constdef VkImageViewType : int
 {
     VK_IMAGE_VIEW_TYPE_1D = 0,
     VK_IMAGE_VIEW_TYPE_2D = 1,
@@ -624,19 +624,19 @@ enum VkImageViewType  : const int
     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
     VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSharingMode  : const int
+constdef VkSharingMode : int
 {
     VK_SHARING_MODE_EXCLUSIVE = 0,
     VK_SHARING_MODE_CONCURRENT = 1,
     VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkIndexType  : const int
+constdef VkIndexType : int
 {
     VK_INDEX_TYPE_UINT16 = 0,
     VK_INDEX_TYPE_UINT32 = 1,
     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkLogicOp  : const int
+constdef VkLogicOp : int
 {
     VK_LOGIC_OP_CLEAR = 0,
     VK_LOGIC_OP_AND = 1,
@@ -656,13 +656,13 @@ enum VkLogicOp  : const int
     VK_LOGIC_OP_SET = 15,
     VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkMemoryHeapFlagBits  : const int
+constdef VkMemoryHeapFlagBits : int
 {
     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1,
     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 2,
     VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAccessFlagBits  : const int
+constdef VkAccessFlagBits : int
 {
     VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 1,
     VK_ACCESS_INDEX_READ_BIT = 2,
@@ -683,7 +683,7 @@ enum VkAccessFlagBits  : const int
     VK_ACCESS_MEMORY_WRITE_BIT = 65536,
     VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkMemoryPropertyFlagBits  : const int
+constdef VkMemoryPropertyFlagBits : int
 {
     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 1,
     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 2,
@@ -693,7 +693,7 @@ enum VkMemoryPropertyFlagBits  : const int
     VK_MEMORY_PROPERTY_PROTECTED_BIT = 32,
     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPhysicalDeviceType  : const int
+constdef VkPhysicalDeviceType : int
 {
     VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
@@ -702,13 +702,13 @@ enum VkPhysicalDeviceType  : const int
     VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
     VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineBindPoint  : const int
+constdef VkPipelineBindPoint : int
 {
     VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
     VK_PIPELINE_BIND_POINT_COMPUTE = 1,
     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineCreateFlagBits  : const int
+constdef VkPipelineCreateFlagBits : int
 {
     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1,
     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2,
@@ -718,7 +718,7 @@ enum VkPipelineCreateFlagBits  : const int
     VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT,
     VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPrimitiveTopology  : const int
+constdef VkPrimitiveTopology : int
 {
     VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
     VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
@@ -733,12 +733,12 @@ enum VkPrimitiveTopology  : const int
     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
     VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryControlFlagBits  : const int
+constdef VkQueryControlFlagBits : int
 {
     VK_QUERY_CONTROL_PRECISE_BIT = 1,
     VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryPipelineStatisticFlagBits  : const int
+constdef VkQueryPipelineStatisticFlagBits : int
 {
     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 1,
     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 2,
@@ -753,7 +753,7 @@ enum VkQueryPipelineStatisticFlagBits  : const int
     VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 1024,
     VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryResultFlagBits  : const int
+constdef VkQueryResultFlagBits : int
 {
     VK_QUERY_RESULT_64_BIT = 1,
     VK_QUERY_RESULT_WAIT_BIT = 2,
@@ -761,14 +761,14 @@ enum VkQueryResultFlagBits  : const int
     VK_QUERY_RESULT_PARTIAL_BIT = 8,
     VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryType  : const int
+constdef VkQueryType : int
 {
     VK_QUERY_TYPE_OCCLUSION = 0,
     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
     VK_QUERY_TYPE_TIMESTAMP = 2,
     VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueueFlagBits  : const int
+constdef VkQueueFlagBits : int
 {
     VK_QUEUE_GRAPHICS_BIT = 1,
     VK_QUEUE_COMPUTE_BIT = 2,
@@ -777,13 +777,13 @@ enum VkQueueFlagBits  : const int
     VK_QUEUE_PROTECTED_BIT = 16,
     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSubpassContents  : const int
+constdef VkSubpassContents : int
 {
     VK_SUBPASS_CONTENTS_INLINE = 0,
     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkResult  : const int
+constdef VkResult : int
 {
     VK_SUCCESS = 0,
     VK_NOT_READY = 1,
@@ -810,7 +810,7 @@ enum VkResult  : const int
     VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000,
     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkShaderStageFlagBits  : const int
+constdef VkShaderStageFlagBits : int
 {
     VK_SHADER_STAGE_VERTEX_BIT = 1,
     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 2,
@@ -822,12 +822,12 @@ enum VkShaderStageFlagBits  : const int
     VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
     VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSparseMemoryBindFlagBits  : const int
+constdef VkSparseMemoryBindFlagBits : int
 {
     VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1,
     VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStencilFaceFlagBits  : const int
+constdef VkStencilFaceFlagBits : int
 {
     VK_STENCIL_FACE_FRONT_BIT = 1,
     VK_STENCIL_FACE_BACK_BIT = 2,
@@ -835,7 +835,7 @@ enum VkStencilFaceFlagBits  : const int
     VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK,
     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStencilOp  : const int
+constdef VkStencilOp : int
 {
     VK_STENCIL_OP_KEEP = 0,
     VK_STENCIL_OP_ZERO = 1,
@@ -847,7 +847,7 @@ enum VkStencilOp  : const int
     VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
     VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStructureType  : const int
+constdef VkStructureType : int
 {
     VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
@@ -1017,7 +1017,7 @@ enum VkStructureType  : const int
     VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004,
     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSystemAllocationScope  : const int
+constdef VkSystemAllocationScope : int
 {
     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
@@ -1026,12 +1026,12 @@ enum VkSystemAllocationScope  : const int
     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
     VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkInternalAllocationType  : const int
+constdef VkInternalAllocationType : int
 {
     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
     VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerAddressMode  : const int
+constdef VkSamplerAddressMode : int
 {
     VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
@@ -1040,25 +1040,25 @@ enum VkSamplerAddressMode  : const int
     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFilter  : const int
+constdef VkFilter : int
 {
     VK_FILTER_NEAREST = 0,
     VK_FILTER_LINEAR = 1,
     VK_FILTER_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerMipmapMode  : const int
+constdef VkSamplerMipmapMode : int
 {
     VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
     VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkVertexInputRate  : const int
+constdef VkVertexInputRate : int
 {
     VK_VERTEX_INPUT_RATE_VERTEX = 0,
     VK_VERTEX_INPUT_RATE_INSTANCE = 1,
     VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineStageFlagBits  : const int
+constdef VkPipelineStageFlagBits : int
 {
     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 1,
     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 2,
@@ -1079,14 +1079,14 @@ enum VkPipelineStageFlagBits  : const int
     VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 65536,
     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSparseImageFormatFlagBits  : const int
+constdef VkSparseImageFormatFlagBits : int
 {
     VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 1,
     VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 2,
     VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 4,
     VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSampleCountFlagBits  : const int
+constdef VkSampleCountFlagBits : int
 {
     VK_SAMPLE_COUNT_1_BIT = 1,
     VK_SAMPLE_COUNT_2_BIT = 2,
@@ -1097,25 +1097,25 @@ enum VkSampleCountFlagBits  : const int
     VK_SAMPLE_COUNT_64_BIT = 64,
     VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAttachmentDescriptionFlagBits  : const int
+constdef VkAttachmentDescriptionFlagBits : int
 {
     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1,
     VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorPoolCreateFlagBits  : const int
+constdef VkDescriptorPoolCreateFlagBits : int
 {
     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1,
     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 2,
     VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDependencyFlagBits  : const int
+constdef VkDependencyFlagBits : int
 {
     VK_DEPENDENCY_BY_REGION_BIT = 1,
     VK_DEPENDENCY_DEVICE_GROUP_BIT = 4,
     VK_DEPENDENCY_VIEW_LOCAL_BIT = 2,
     VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkObjectType  : const int
+constdef VkObjectType : int
 {
     VK_OBJECT_TYPE_UNKNOWN = 0,
     VK_OBJECT_TYPE_INSTANCE = 1,
@@ -1147,18 +1147,18 @@ enum VkObjectType  : const int
     VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000,
     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorUpdateTemplateType  : const int
+constdef VkDescriptorUpdateTemplateType : int
 {
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPointClippingBehavior  : const int
+constdef VkPointClippingBehavior : int
 {
     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
     VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkResolveModeFlagBits  : const int
+constdef VkResolveModeFlagBits : int
 {
     VK_RESOLVE_MODE_NONE = 0,
     VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 1,
@@ -1167,7 +1167,7 @@ enum VkResolveModeFlagBits  : const int
     VK_RESOLVE_MODE_MAX_BIT = 8,
     VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorBindingFlagBits  : const int
+constdef VkDescriptorBindingFlagBits : int
 {
     VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 1,
     VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 2,
@@ -1175,18 +1175,18 @@ enum VkDescriptorBindingFlagBits  : const int
     VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 8,
     VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSemaphoreType  : const int
+constdef VkSemaphoreType : int
 {
     VK_SEMAPHORE_TYPE_BINARY = 0,
     VK_SEMAPHORE_TYPE_TIMELINE = 1,
     VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSemaphoreWaitFlagBits  : const int
+constdef VkSemaphoreWaitFlagBits : int
 {
     VK_SEMAPHORE_WAIT_ANY_BIT = 1,
     VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalMemoryHandleTypeFlagBits  : const int
+constdef VkExternalMemoryHandleTypeFlagBits : int
 {
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
@@ -1197,14 +1197,14 @@ enum VkExternalMemoryHandleTypeFlagBits  : const int
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 64,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalMemoryFeatureFlagBits  : const int
+constdef VkExternalMemoryFeatureFlagBits : int
 {
     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1,
     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 2,
     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 4,
     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalSemaphoreHandleTypeFlagBits  : const int
+constdef VkExternalSemaphoreHandleTypeFlagBits : int
 {
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
@@ -1214,18 +1214,18 @@ enum VkExternalSemaphoreHandleTypeFlagBits  : const int
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 16,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalSemaphoreFeatureFlagBits  : const int
+constdef VkExternalSemaphoreFeatureFlagBits : int
 {
     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1,
     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2,
     VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSemaphoreImportFlagBits  : const int
+constdef VkSemaphoreImportFlagBits : int
 {
     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1,
     VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalFenceHandleTypeFlagBits  : const int
+constdef VkExternalFenceHandleTypeFlagBits : int
 {
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
@@ -1233,18 +1233,18 @@ enum VkExternalFenceHandleTypeFlagBits  : const int
     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 8,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalFenceFeatureFlagBits  : const int
+constdef VkExternalFenceFeatureFlagBits : int
 {
     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1,
     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2,
     VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFenceImportFlagBits  : const int
+constdef VkFenceImportFlagBits : int
 {
     VK_FENCE_IMPORT_TEMPORARY_BIT = 1,
     VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPeerMemoryFeatureFlagBits  : const int
+constdef VkPeerMemoryFeatureFlagBits : int
 {
     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 1,
     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 2,
@@ -1252,14 +1252,14 @@ enum VkPeerMemoryFeatureFlagBits  : const int
     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 8,
     VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkMemoryAllocateFlagBits  : const int
+constdef VkMemoryAllocateFlagBits : int
 {
     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1,
     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 2,
     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 4,
     VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSubgroupFeatureFlagBits  : const int
+constdef VkSubgroupFeatureFlagBits : int
 {
     VK_SUBGROUP_FEATURE_BASIC_BIT = 1,
     VK_SUBGROUP_FEATURE_VOTE_BIT = 2,
@@ -1271,13 +1271,13 @@ enum VkSubgroupFeatureFlagBits  : const int
     VK_SUBGROUP_FEATURE_QUAD_BIT = 128,
     VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkTessellationDomainOrigin  : const int
+constdef VkTessellationDomainOrigin : int
 {
     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
     VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerYcbcrModelConversion  : const int
+constdef VkSamplerYcbcrModelConversion : int
 {
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
@@ -1286,33 +1286,33 @@ enum VkSamplerYcbcrModelConversion  : const int
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerYcbcrRange  : const int
+constdef VkSamplerYcbcrRange : int
 {
     VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
     VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkChromaLocation  : const int
+constdef VkChromaLocation : int
 {
     VK_CHROMA_LOCATION_COSITED_EVEN = 0,
     VK_CHROMA_LOCATION_MIDPOINT = 1,
     VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerReductionMode  : const int
+constdef VkSamplerReductionMode : int
 {
     VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0,
     VK_SAMPLER_REDUCTION_MODE_MIN = 1,
     VK_SAMPLER_REDUCTION_MODE_MAX = 2,
     VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkShaderFloatControlsIndependence  : const int
+constdef VkShaderFloatControlsIndependence : int
 {
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0,
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1,
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2,
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkVendorId  : const int
+constdef VkVendorId : int
 {
     VK_VENDOR_ID_KHRONOS = 0x10000,
     VK_VENDOR_ID_VIV = 0x10001,
@@ -1324,7 +1324,7 @@ enum VkVendorId  : const int
     VK_VENDOR_ID_MOBILEYE = 0x10007,
     VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDriverId  : const int
+constdef VkDriverId : int
 {
     VK_DRIVER_ID_AMD_PROPRIETARY = 1,
     VK_DRIVER_ID_AMD_OPEN_SOURCE = 2,
diff --git a/libraries/vulkan.c3l/vk13.c3i b/libraries/vulkan.c3l/vk13.c3i
index 69c1f16..503b21e 100644
--- a/libraries/vulkan.c3l/vk13.c3i
+++ b/libraries/vulkan.c3l/vk13.c3i
@@ -79,21 +79,21 @@ typedef VkPipelineCache = uptr;
 typedef VkDescriptorUpdateTemplate = uptr;
 typedef VkSamplerYcbcrConversion = uptr;
 typedef VkPrivateDataSlot = uptr;
-enum VkAttachmentLoadOp  : const int
+constdef VkAttachmentLoadOp : int
 {
     VK_ATTACHMENT_LOAD_OP_LOAD = 0,
     VK_ATTACHMENT_LOAD_OP_CLEAR = 1,
     VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2,
     VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAttachmentStoreOp  : const int
+constdef VkAttachmentStoreOp : int
 {
     VK_ATTACHMENT_STORE_OP_STORE = 0,
     VK_ATTACHMENT_STORE_OP_DONT_CARE = 1,
     VK_ATTACHMENT_STORE_OP_NONE = 1000301000,
     VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBlendFactor  : const int
+constdef VkBlendFactor : int
 {
     VK_BLEND_FACTOR_ZERO = 0,
     VK_BLEND_FACTOR_ONE = 1,
@@ -116,7 +116,7 @@ enum VkBlendFactor  : const int
     VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18,
     VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBlendOp  : const int
+constdef VkBlendOp : int
 {
     VK_BLEND_OP_ADD = 0,
     VK_BLEND_OP_SUBTRACT = 1,
@@ -125,7 +125,7 @@ enum VkBlendOp  : const int
     VK_BLEND_OP_MAX = 4,
     VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBorderColor  : const int
+constdef VkBorderColor : int
 {
     VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0,
     VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1,
@@ -135,38 +135,38 @@ enum VkBorderColor  : const int
     VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5,
     VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFramebufferCreateFlagBits  : const int
+constdef VkFramebufferCreateFlagBits : int
 {
     VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 1,
     VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineCacheHeaderVersion  : const int
+constdef VkPipelineCacheHeaderVersion : int
 {
     VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1,
     VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineCacheCreateFlagBits  : const int
+constdef VkPipelineCacheCreateFlagBits : int
 {
     VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 1,
     VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineShaderStageCreateFlagBits  : const int
+constdef VkPipelineShaderStageCreateFlagBits : int
 {
     VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 1,
     VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 2,
     VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorSetLayoutCreateFlagBits  : const int
+constdef VkDescriptorSetLayoutCreateFlagBits : int
 {
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 2,
     VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDeviceQueueCreateFlagBits  : const int
+constdef VkDeviceQueueCreateFlagBits : int
 {
     VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 1,
     VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBufferCreateFlagBits  : const int
+constdef VkBufferCreateFlagBits : int
 {
     VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 1,
     VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 2,
@@ -175,7 +175,7 @@ enum VkBufferCreateFlagBits  : const int
     VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 16,
     VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkBufferUsageFlagBits  : const int
+constdef VkBufferUsageFlagBits : int
 {
     VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 1,
     VK_BUFFER_USAGE_TRANSFER_DST_BIT = 2,
@@ -189,7 +189,7 @@ enum VkBufferUsageFlagBits  : const int
     VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 131072,
     VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkColorComponentFlagBits  : const int
+constdef VkColorComponentFlagBits : int
 {
     VK_COLOR_COMPONENT_R_BIT = 1,
     VK_COLOR_COMPONENT_G_BIT = 2,
@@ -197,7 +197,7 @@ enum VkColorComponentFlagBits  : const int
     VK_COLOR_COMPONENT_A_BIT = 8,
     VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkComponentSwizzle  : const int
+constdef VkComponentSwizzle : int
 {
     VK_COMPONENT_SWIZZLE_IDENTITY = 0,
     VK_COMPONENT_SWIZZLE_ZERO = 1,
@@ -208,37 +208,37 @@ enum VkComponentSwizzle  : const int
     VK_COMPONENT_SWIZZLE_A = 6,
     VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandPoolCreateFlagBits  : const int
+constdef VkCommandPoolCreateFlagBits : int
 {
     VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 1,
     VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 2,
     VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 4,
     VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandPoolResetFlagBits  : const int
+constdef VkCommandPoolResetFlagBits : int
 {
     VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 1,
     VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferResetFlagBits  : const int
+constdef VkCommandBufferResetFlagBits : int
 {
     VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 1,
     VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferLevel  : const int
+constdef VkCommandBufferLevel : int
 {
     VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0,
     VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1,
     VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCommandBufferUsageFlagBits  : const int
+constdef VkCommandBufferUsageFlagBits : int
 {
     VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 1,
     VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 2,
     VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 4,
     VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCompareOp  : const int
+constdef VkCompareOp : int
 {
     VK_COMPARE_OP_NEVER = 0,
     VK_COMPARE_OP_LESS = 1,
@@ -250,7 +250,7 @@ enum VkCompareOp  : const int
     VK_COMPARE_OP_ALWAYS = 7,
     VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkCullModeFlagBits  : const int
+constdef VkCullModeFlagBits : int
 {
     VK_CULL_MODE_NONE = 0,
     VK_CULL_MODE_FRONT_BIT = 1,
@@ -258,7 +258,7 @@ enum VkCullModeFlagBits  : const int
     VK_CULL_MODE_FRONT_AND_BACK = 0x00000003,
     VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorType  : const int
+constdef VkDescriptorType : int
 {
     VK_DESCRIPTOR_TYPE_SAMPLER = 0,
     VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1,
@@ -274,7 +274,7 @@ enum VkDescriptorType  : const int
     VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000,
     VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDynamicState  : const int
+constdef VkDynamicState : int
 {
     VK_DYNAMIC_STATE_VIEWPORT = 0,
     VK_DYNAMIC_STATE_SCISSOR = 1,
@@ -302,19 +302,19 @@ enum VkDynamicState  : const int
     VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004,
     VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFenceCreateFlagBits  : const int
+constdef VkFenceCreateFlagBits : int
 {
     VK_FENCE_CREATE_SIGNALED_BIT = 1,
     VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPolygonMode  : const int
+constdef VkPolygonMode : int
 {
     VK_POLYGON_MODE_FILL = 0,
     VK_POLYGON_MODE_LINE = 1,
     VK_POLYGON_MODE_POINT = 2,
     VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFormat  : const int
+constdef VkFormat : int
 {
     VK_FORMAT_UNDEFINED = 0,
     VK_FORMAT_R4G4_UNORM_PACK8 = 1,
@@ -557,7 +557,7 @@ enum VkFormat  : const int
     VK_FORMAT_ASTC_12X12_SFLOAT_BLOCK = 1000066013,
     VK_FORMAT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFormatFeatureFlagBits  : const int
+constdef VkFormatFeatureFlagBits : int
 {
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 1,
     VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 2,
@@ -584,13 +584,13 @@ enum VkFormatFeatureFlagBits  : const int
     VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 65536,
     VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFrontFace  : const int
+constdef VkFrontFace : int
 {
     VK_FRONT_FACE_COUNTER_CLOCKWISE = 0,
     VK_FRONT_FACE_CLOCKWISE = 1,
     VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageAspectFlagBits  : const int
+constdef VkImageAspectFlagBits : int
 {
     VK_IMAGE_ASPECT_COLOR_BIT = 1,
     VK_IMAGE_ASPECT_DEPTH_BIT = 2,
@@ -602,7 +602,7 @@ enum VkImageAspectFlagBits  : const int
     VK_IMAGE_ASPECT_NONE = 0,
     VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageCreateFlagBits  : const int
+constdef VkImageCreateFlagBits : int
 {
     VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 1,
     VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 2,
@@ -618,7 +618,7 @@ enum VkImageCreateFlagBits  : const int
     VK_IMAGE_CREATE_DISJOINT_BIT = 512,
     VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageLayout  : const int
+constdef VkImageLayout : int
 {
     VK_IMAGE_LAYOUT_UNDEFINED = 0,
     VK_IMAGE_LAYOUT_GENERAL = 1,
@@ -639,20 +639,20 @@ enum VkImageLayout  : const int
     VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001,
     VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageTiling  : const int
+constdef VkImageTiling : int
 {
     VK_IMAGE_TILING_OPTIMAL = 0,
     VK_IMAGE_TILING_LINEAR = 1,
     VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageType  : const int
+constdef VkImageType : int
 {
     VK_IMAGE_TYPE_1D = 0,
     VK_IMAGE_TYPE_2D = 1,
     VK_IMAGE_TYPE_3D = 2,
     VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageUsageFlagBits  : const int
+constdef VkImageUsageFlagBits : int
 {
     VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 1,
     VK_IMAGE_USAGE_TRANSFER_DST_BIT = 2,
@@ -664,7 +664,7 @@ enum VkImageUsageFlagBits  : const int
     VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 128,
     VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkImageViewType  : const int
+constdef VkImageViewType : int
 {
     VK_IMAGE_VIEW_TYPE_1D = 0,
     VK_IMAGE_VIEW_TYPE_2D = 1,
@@ -675,19 +675,19 @@ enum VkImageViewType  : const int
     VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6,
     VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSharingMode  : const int
+constdef VkSharingMode : int
 {
     VK_SHARING_MODE_EXCLUSIVE = 0,
     VK_SHARING_MODE_CONCURRENT = 1,
     VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkIndexType  : const int
+constdef VkIndexType : int
 {
     VK_INDEX_TYPE_UINT16 = 0,
     VK_INDEX_TYPE_UINT32 = 1,
     VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkLogicOp  : const int
+constdef VkLogicOp : int
 {
     VK_LOGIC_OP_CLEAR = 0,
     VK_LOGIC_OP_AND = 1,
@@ -707,13 +707,13 @@ enum VkLogicOp  : const int
     VK_LOGIC_OP_SET = 15,
     VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkMemoryHeapFlagBits  : const int
+constdef VkMemoryHeapFlagBits : int
 {
     VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 1,
     VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 2,
     VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAccessFlagBits  : const int
+constdef VkAccessFlagBits : int
 {
     VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 1,
     VK_ACCESS_INDEX_READ_BIT = 2,
@@ -735,7 +735,7 @@ enum VkAccessFlagBits  : const int
     VK_ACCESS_NONE = 0,
     VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkMemoryPropertyFlagBits  : const int
+constdef VkMemoryPropertyFlagBits : int
 {
     VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 1,
     VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 2,
@@ -745,7 +745,7 @@ enum VkMemoryPropertyFlagBits  : const int
     VK_MEMORY_PROPERTY_PROTECTED_BIT = 32,
     VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPhysicalDeviceType  : const int
+constdef VkPhysicalDeviceType : int
 {
     VK_PHYSICAL_DEVICE_TYPE_OTHER = 0,
     VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1,
@@ -754,13 +754,13 @@ enum VkPhysicalDeviceType  : const int
     VK_PHYSICAL_DEVICE_TYPE_CPU = 4,
     VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineBindPoint  : const int
+constdef VkPipelineBindPoint : int
 {
     VK_PIPELINE_BIND_POINT_GRAPHICS = 0,
     VK_PIPELINE_BIND_POINT_COMPUTE = 1,
     VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineCreateFlagBits  : const int
+constdef VkPipelineCreateFlagBits : int
 {
     VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 1,
     VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 2,
@@ -772,7 +772,7 @@ enum VkPipelineCreateFlagBits  : const int
     VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 512,
     VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPrimitiveTopology  : const int
+constdef VkPrimitiveTopology : int
 {
     VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0,
     VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1,
@@ -787,12 +787,12 @@ enum VkPrimitiveTopology  : const int
     VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10,
     VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryControlFlagBits  : const int
+constdef VkQueryControlFlagBits : int
 {
     VK_QUERY_CONTROL_PRECISE_BIT = 1,
     VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryPipelineStatisticFlagBits  : const int
+constdef VkQueryPipelineStatisticFlagBits : int
 {
     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 1,
     VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 2,
@@ -807,7 +807,7 @@ enum VkQueryPipelineStatisticFlagBits  : const int
     VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 1024,
     VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryResultFlagBits  : const int
+constdef VkQueryResultFlagBits : int
 {
     VK_QUERY_RESULT_64_BIT = 1,
     VK_QUERY_RESULT_WAIT_BIT = 2,
@@ -815,14 +815,14 @@ enum VkQueryResultFlagBits  : const int
     VK_QUERY_RESULT_PARTIAL_BIT = 8,
     VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueryType  : const int
+constdef VkQueryType : int
 {
     VK_QUERY_TYPE_OCCLUSION = 0,
     VK_QUERY_TYPE_PIPELINE_STATISTICS = 1,
     VK_QUERY_TYPE_TIMESTAMP = 2,
     VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkQueueFlagBits  : const int
+constdef VkQueueFlagBits : int
 {
     VK_QUEUE_GRAPHICS_BIT = 1,
     VK_QUEUE_COMPUTE_BIT = 2,
@@ -831,13 +831,13 @@ enum VkQueueFlagBits  : const int
     VK_QUEUE_PROTECTED_BIT = 16,
     VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSubpassContents  : const int
+constdef VkSubpassContents : int
 {
     VK_SUBPASS_CONTENTS_INLINE = 0,
     VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1,
     VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkResult  : const int
+constdef VkResult : int
 {
     VK_SUCCESS = 0,
     VK_NOT_READY = 1,
@@ -865,7 +865,7 @@ enum VkResult  : const int
     VK_PIPELINE_COMPILE_REQUIRED = 1000297000,
     VK_RESULT_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkShaderStageFlagBits  : const int
+constdef VkShaderStageFlagBits : int
 {
     VK_SHADER_STAGE_VERTEX_BIT = 1,
     VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 2,
@@ -877,12 +877,12 @@ enum VkShaderStageFlagBits  : const int
     VK_SHADER_STAGE_ALL = 0x7FFFFFFF,
     VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSparseMemoryBindFlagBits  : const int
+constdef VkSparseMemoryBindFlagBits : int
 {
     VK_SPARSE_MEMORY_BIND_METADATA_BIT = 1,
     VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStencilFaceFlagBits  : const int
+constdef VkStencilFaceFlagBits : int
 {
     VK_STENCIL_FACE_FRONT_BIT = 1,
     VK_STENCIL_FACE_BACK_BIT = 2,
@@ -890,7 +890,7 @@ enum VkStencilFaceFlagBits  : const int
     VK_STENCIL_FRONT_AND_BACK = 0x00000003,
     VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStencilOp  : const int
+constdef VkStencilOp : int
 {
     VK_STENCIL_OP_KEEP = 0,
     VK_STENCIL_OP_ZERO = 1,
@@ -902,7 +902,7 @@ enum VkStencilOp  : const int
     VK_STENCIL_OP_DECREMENT_AND_WRAP = 7,
     VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkStructureType  : const int
+constdef VkStructureType : int
 {
     VK_STRUCTURE_TYPE_APPLICATION_INFO = 0,
     VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1,
@@ -1124,7 +1124,7 @@ enum VkStructureType  : const int
     VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003,
     VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSystemAllocationScope  : const int
+constdef VkSystemAllocationScope : int
 {
     VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0,
     VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1,
@@ -1133,12 +1133,12 @@ enum VkSystemAllocationScope  : const int
     VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4,
     VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkInternalAllocationType  : const int
+constdef VkInternalAllocationType : int
 {
     VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0,
     VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerAddressMode  : const int
+constdef VkSamplerAddressMode : int
 {
     VK_SAMPLER_ADDRESS_MODE_REPEAT = 0,
     VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1,
@@ -1147,25 +1147,25 @@ enum VkSamplerAddressMode  : const int
     VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4,
     VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFilter  : const int
+constdef VkFilter : int
 {
     VK_FILTER_NEAREST = 0,
     VK_FILTER_LINEAR = 1,
     VK_FILTER_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerMipmapMode  : const int
+constdef VkSamplerMipmapMode : int
 {
     VK_SAMPLER_MIPMAP_MODE_NEAREST = 0,
     VK_SAMPLER_MIPMAP_MODE_LINEAR = 1,
     VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkVertexInputRate  : const int
+constdef VkVertexInputRate : int
 {
     VK_VERTEX_INPUT_RATE_VERTEX = 0,
     VK_VERTEX_INPUT_RATE_INSTANCE = 1,
     VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineStageFlagBits  : const int
+constdef VkPipelineStageFlagBits : int
 {
     VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 1,
     VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 2,
@@ -1187,14 +1187,14 @@ enum VkPipelineStageFlagBits  : const int
     VK_PIPELINE_STAGE_NONE = 0,
     VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSparseImageFormatFlagBits  : const int
+constdef VkSparseImageFormatFlagBits : int
 {
     VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 1,
     VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 2,
     VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 4,
     VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSampleCountFlagBits  : const int
+constdef VkSampleCountFlagBits : int
 {
     VK_SAMPLE_COUNT_1_BIT = 1,
     VK_SAMPLE_COUNT_2_BIT = 2,
@@ -1205,25 +1205,25 @@ enum VkSampleCountFlagBits  : const int
     VK_SAMPLE_COUNT_64_BIT = 64,
     VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkAttachmentDescriptionFlagBits  : const int
+constdef VkAttachmentDescriptionFlagBits : int
 {
     VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 1,
     VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorPoolCreateFlagBits  : const int
+constdef VkDescriptorPoolCreateFlagBits : int
 {
     VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 1,
     VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 2,
     VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDependencyFlagBits  : const int
+constdef VkDependencyFlagBits : int
 {
     VK_DEPENDENCY_BY_REGION_BIT = 1,
     VK_DEPENDENCY_DEVICE_GROUP_BIT = 4,
     VK_DEPENDENCY_VIEW_LOCAL_BIT = 2,
     VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkObjectType  : const int
+constdef VkObjectType : int
 {
     VK_OBJECT_TYPE_UNKNOWN = 0,
     VK_OBJECT_TYPE_INSTANCE = 1,
@@ -1256,23 +1256,23 @@ enum VkObjectType  : const int
     VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000,
     VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkEventCreateFlagBits  : const int
+constdef VkEventCreateFlagBits : int
 {
     VK_EVENT_CREATE_DEVICE_ONLY_BIT = 1,
     VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorUpdateTemplateType  : const int
+constdef VkDescriptorUpdateTemplateType : int
 {
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0,
     VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPointClippingBehavior  : const int
+constdef VkPointClippingBehavior : int
 {
     VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0,
     VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1,
     VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkResolveModeFlagBits  : const int
+constdef VkResolveModeFlagBits : int
 {
     VK_RESOLVE_MODE_NONE = 0,
     VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 1,
@@ -1281,7 +1281,7 @@ enum VkResolveModeFlagBits  : const int
     VK_RESOLVE_MODE_MAX_BIT = 8,
     VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDescriptorBindingFlagBits  : const int
+constdef VkDescriptorBindingFlagBits : int
 {
     VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 1,
     VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 2,
@@ -1289,13 +1289,13 @@ enum VkDescriptorBindingFlagBits  : const int
     VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 8,
     VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSemaphoreType  : const int
+constdef VkSemaphoreType : int
 {
     VK_SEMAPHORE_TYPE_BINARY = 0,
     VK_SEMAPHORE_TYPE_TIMELINE = 1,
     VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPipelineCreationFeedbackFlagBits  : const int
+constdef VkPipelineCreationFeedbackFlagBits : int
 {
     VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 1,
     VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = 1,
@@ -1305,12 +1305,12 @@ enum VkPipelineCreationFeedbackFlagBits  : const int
     VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = 4,
     VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSemaphoreWaitFlagBits  : const int
+constdef VkSemaphoreWaitFlagBits : int
 {
     VK_SEMAPHORE_WAIT_ANY_BIT = 1,
     VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkToolPurposeFlagBits  : const int
+constdef VkToolPurposeFlagBits : int
 {
     VK_TOOL_PURPOSE_VALIDATION_BIT = 1,
     VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = 1,
@@ -1478,7 +1478,7 @@ const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_
 const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 8589934592;
 const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 8589934592;
 
-enum VkRenderingFlagBits  : const int
+constdef VkRenderingFlagBits : int
 {
     VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 1,
     VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = 1,
@@ -1488,7 +1488,7 @@ enum VkRenderingFlagBits  : const int
     VK_RENDERING_RESUMING_BIT_KHR = 4,
     VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalMemoryHandleTypeFlagBits  : const int
+constdef VkExternalMemoryHandleTypeFlagBits : int
 {
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
@@ -1499,14 +1499,14 @@ enum VkExternalMemoryHandleTypeFlagBits  : const int
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 64,
     VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalMemoryFeatureFlagBits  : const int
+constdef VkExternalMemoryFeatureFlagBits : int
 {
     VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 1,
     VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 2,
     VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 4,
     VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalSemaphoreHandleTypeFlagBits  : const int
+constdef VkExternalSemaphoreHandleTypeFlagBits : int
 {
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
@@ -1516,18 +1516,18 @@ enum VkExternalSemaphoreHandleTypeFlagBits  : const int
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 16,
     VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalSemaphoreFeatureFlagBits  : const int
+constdef VkExternalSemaphoreFeatureFlagBits : int
 {
     VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 1,
     VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 2,
     VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSemaphoreImportFlagBits  : const int
+constdef VkSemaphoreImportFlagBits : int
 {
     VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 1,
     VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalFenceHandleTypeFlagBits  : const int
+constdef VkExternalFenceHandleTypeFlagBits : int
 {
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 1,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 2,
@@ -1535,18 +1535,18 @@ enum VkExternalFenceHandleTypeFlagBits  : const int
     VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 8,
     VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkExternalFenceFeatureFlagBits  : const int
+constdef VkExternalFenceFeatureFlagBits : int
 {
     VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 1,
     VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 2,
     VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkFenceImportFlagBits  : const int
+constdef VkFenceImportFlagBits : int
 {
     VK_FENCE_IMPORT_TEMPORARY_BIT = 1,
     VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkPeerMemoryFeatureFlagBits  : const int
+constdef VkPeerMemoryFeatureFlagBits : int
 {
     VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 1,
     VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 2,
@@ -1554,14 +1554,14 @@ enum VkPeerMemoryFeatureFlagBits  : const int
     VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 8,
     VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkMemoryAllocateFlagBits  : const int
+constdef VkMemoryAllocateFlagBits : int
 {
     VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 1,
     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 2,
     VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 4,
     VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSubgroupFeatureFlagBits  : const int
+constdef VkSubgroupFeatureFlagBits : int
 {
     VK_SUBGROUP_FEATURE_BASIC_BIT = 1,
     VK_SUBGROUP_FEATURE_VOTE_BIT = 2,
@@ -1573,13 +1573,13 @@ enum VkSubgroupFeatureFlagBits  : const int
     VK_SUBGROUP_FEATURE_QUAD_BIT = 128,
     VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkTessellationDomainOrigin  : const int
+constdef VkTessellationDomainOrigin : int
 {
     VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0,
     VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1,
     VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerYcbcrModelConversion  : const int
+constdef VkSamplerYcbcrModelConversion : int
 {
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1,
@@ -1588,39 +1588,39 @@ enum VkSamplerYcbcrModelConversion  : const int
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4,
     VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerYcbcrRange  : const int
+constdef VkSamplerYcbcrRange : int
 {
     VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0,
     VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1,
     VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkChromaLocation  : const int
+constdef VkChromaLocation : int
 {
     VK_CHROMA_LOCATION_COSITED_EVEN = 0,
     VK_CHROMA_LOCATION_MIDPOINT = 1,
     VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSamplerReductionMode  : const int
+constdef VkSamplerReductionMode : int
 {
     VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0,
     VK_SAMPLER_REDUCTION_MODE_MIN = 1,
     VK_SAMPLER_REDUCTION_MODE_MAX = 2,
     VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkShaderFloatControlsIndependence  : const int
+constdef VkShaderFloatControlsIndependence : int
 {
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0,
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1,
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2,
     VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkSubmitFlagBits  : const int
+constdef VkSubmitFlagBits : int
 {
     VK_SUBMIT_PROTECTED_BIT = 1,
     VK_SUBMIT_PROTECTED_BIT_KHR = 1,
     VK_SUBMIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkVendorId  : const int
+constdef VkVendorId : int
 {
     VK_VENDOR_ID_KHRONOS = 0x10000,
     VK_VENDOR_ID_VIV = 0x10001,
@@ -1632,7 +1632,7 @@ enum VkVendorId  : const int
     VK_VENDOR_ID_MOBILEYE = 0x10007,
     VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF
 }
-enum VkDriverId  : const int
+constdef VkDriverId : int
 {
     VK_DRIVER_ID_AMD_PROPRIETARY = 1,
     VK_DRIVER_ID_AMD_OPEN_SOURCE = 2,