;;;; Generated from raylib-5.5.h by `flan generate-c`. Do not edit this file.
;;;;
;;;; Every line here was read out of the C header named by `headers`, and
;;;; the next regeneration overwrites the file — so a correction made here
;;;; is destroyed without anybody being told. Corrections go in `bindings`
;;;; beside it, which is read *while* these lines are made: `exclude` drops
;;;; a function, `name` gives one a Flan name the kebab rule would not.
;;;; Anything neither directive can express is a hand-written declare-c in
;;;; the package's own .flan, which wins over this file and is left alone.
;;;;
;;;; Regenerating compares the package against the header first and
;;;; refuses to write when they disagree, so this file and the
;;;; hand-written declarations beside it agreed with raylib-5.5.h when it was made.

declare-c(is-window-fullscreen, [], bool, "IsWindowFullscreen")

declare-c(is-window-hidden, [], bool, "IsWindowHidden")

declare-c(is-window-minimized, [], bool, "IsWindowMinimized")

declare-c(is-window-maximized, [], bool, "IsWindowMaximized")

declare-c(is-window-focused, [], bool, "IsWindowFocused")

declare-c(is-window-resized, [], bool, "IsWindowResized")

declare-c(is-window-state, [flag u32], bool, "IsWindowState")

declare-c(set-window-state, [flags u32], "SetWindowState")

declare-c(clear-window-state, [flags u32], "ClearWindowState")

declare-c(toggle-fullscreen, [], "ToggleFullscreen")

declare-c(toggle-borderless-windowed, [], "ToggleBorderlessWindowed")

declare-c(maximize-window, [], "MaximizeWindow")

declare-c(minimize-window, [], "MinimizeWindow")

declare-c(restore-window, [], "RestoreWindow")

declare-c(set-window-icon, [image Image], "SetWindowIcon")

declare-c(set-window-icons, [images Ptr(Image) count i32], "SetWindowIcons")

declare-c(set-window-title, [title str], "SetWindowTitle")

declare-c(set-window-position, [x i32 y i32], "SetWindowPosition")

declare-c(set-window-monitor, [monitor i32], "SetWindowMonitor")

declare-c(set-window-min-size, [width i32 height i32], "SetWindowMinSize")

declare-c(set-window-max-size, [width i32 height i32], "SetWindowMaxSize")

declare-c(set-window-size, [width i32 height i32], "SetWindowSize")

declare-c(set-window-opacity, [opacity f32], "SetWindowOpacity")

declare-c(set-window-focused, [], "SetWindowFocused")

declare-c(get-window-handle, [], Ptr(u8), "GetWindowHandle")

declare-c(get-render-width, [], i32, "GetRenderWidth")

declare-c(get-render-height, [], i32, "GetRenderHeight")

declare-c(get-monitor-count, [], i32, "GetMonitorCount")

declare-c(get-current-monitor, [], i32, "GetCurrentMonitor")

declare-c(get-monitor-position, [monitor i32], Vector2, "GetMonitorPosition")

declare-c(get-monitor-width, [monitor i32], i32, "GetMonitorWidth")

declare-c(get-monitor-height, [monitor i32], i32, "GetMonitorHeight")

declare-c(get-monitor-physical-width, [monitor i32], i32,
          "GetMonitorPhysicalWidth")

declare-c(get-monitor-physical-height, [monitor i32], i32,
          "GetMonitorPhysicalHeight")

declare-c(get-monitor-refresh-rate, [monitor i32], i32, "GetMonitorRefreshRate")

declare-c(get-window-position, [], Vector2, "GetWindowPosition")

declare-c(get-window-scale-dpi, [], Vector2, "GetWindowScaleDPI")

declare-c(get-monitor-name, [monitor i32], str, "GetMonitorName")

declare-c(set-clipboard-text, [text str], "SetClipboardText")

declare-c(get-clipboard-text, [], str, "GetClipboardText")

declare-c(get-clipboard-image, [], Image, "GetClipboardImage")

declare-c(enable-event-waiting, [], "EnableEventWaiting")

declare-c(disable-event-waiting, [], "DisableEventWaiting")

declare-c(enable-cursor, [], "EnableCursor")

declare-c(disable-cursor, [], "DisableCursor")

declare-c(is-cursor-on-screen, [], bool, "IsCursorOnScreen")

declare-c(end-shader-mode, [], "EndShaderMode")

declare-c(begin-blend-mode, [mode i32], "BeginBlendMode")

declare-c(end-blend-mode, [], "EndBlendMode")

declare-c(end-vr-stereo-mode, [], "EndVrStereoMode")

declare-c(get-screen-to-world-ray-ex,
          [position Vector2 camera Camera3D width i32 height i32], Ray,
          "GetScreenToWorldRayEx")

declare-c(get-world-to-screen-ex,
          [position Vector3 camera Camera3D width i32 height i32], Vector2,
          "GetWorldToScreenEx")

declare-c(get-camera-matrix, [camera Camera3D], Matrix, "GetCameraMatrix")

declare-c(get-camera-matrix-2d, [camera Camera2D], Matrix, "GetCameraMatrix2D")

declare-c(swap-screen-buffer, [], "SwapScreenBuffer")

declare-c(poll-input-events, [], "PollInputEvents")

declare-c(wait-time, [seconds f64], "WaitTime")

declare-c(set-random-seed, [seed u32], "SetRandomSeed")

declare-c(get-random-value, [min i32 max i32], i32, "GetRandomValue")

declare-c(load-random-sequence, [count u32 min i32 max i32], Ptr(i32),
          "LoadRandomSequence")

declare-c(unload-random-sequence, [sequence Ptr(i32)], "UnloadRandomSequence")

declare-c(take-screenshot, [file-name str], "TakeScreenshot")

declare-c(open-url, [url str], "OpenURL")

declare-c(load-file-data, [file-name str data-size Ptr(i32)], Ptr(u8),
          "LoadFileData")

declare-c(unload-file-data, [data Ptr(u8)], "UnloadFileData")

declare-c(save-file-data, [file-name str data Ptr(u8) data-size i32], bool,
          "SaveFileData")

declare-c(export-data-as-code, [data Ptr(const u8) data-size i32 file-name str],
          bool, "ExportDataAsCode")

declare-c(file-exists, [file-name str], bool, "FileExists")

declare-c(directory-exists, [dir-path str], bool, "DirectoryExists")

declare-c(is-file-extension, [file-name str ext str], bool, "IsFileExtension")

declare-c(get-file-length, [file-name str], i32, "GetFileLength")

declare-c(get-file-extension, [file-name str], str, "GetFileExtension")

declare-c(get-file-name, [file-path str], str, "GetFileName")

declare-c(get-file-name-without-ext, [file-path str], str,
          "GetFileNameWithoutExt")

declare-c(get-directory-path, [file-path str], str, "GetDirectoryPath")

declare-c(get-prev-directory-path, [dir-path str], str, "GetPrevDirectoryPath")

declare-c(get-working-directory, [], str, "GetWorkingDirectory")

declare-c(get-application-directory, [], str, "GetApplicationDirectory")

declare-c(make-directory, [dir-path str], i32, "MakeDirectory")

declare-c(change-directory, [dir str], bool, "ChangeDirectory")

declare-c(is-path-file, [path str], bool, "IsPathFile")

declare-c(is-file-name-valid, [file-name str], bool, "IsFileNameValid")

declare-c(is-file-dropped, [], bool, "IsFileDropped")

declare-c(compress-data,
          [data Ptr(const u8) data-size i32 comp-data-size Ptr(i32)], Ptr(u8),
          "CompressData")

declare-c(decompress-data,
          [comp-data Ptr(const u8) comp-data-size i32 data-size Ptr(i32)],
          Ptr(u8), "DecompressData")

declare-c(decode-data-base-64, [data Ptr(const u8) output-size Ptr(i32)],
          Ptr(u8), "DecodeDataBase64")

declare-c(compute-crc32, [data Ptr(u8) data-size i32], u32, "ComputeCRC32")

declare-c(compute-md5, [data Ptr(u8) data-size i32], Ptr(u32), "ComputeMD5")

declare-c(compute-sha1, [data Ptr(u8) data-size i32], Ptr(u32), "ComputeSHA1")

declare-c(set-automation-event-base-frame, [frame i32],
          "SetAutomationEventBaseFrame")

declare-c(start-automation-event-recording, [], "StartAutomationEventRecording")

declare-c(stop-automation-event-recording, [], "StopAutomationEventRecording")

declare-c(get-key-pressed-raw, [], i32, "GetKeyPressed")

declare-c(get-char-pressed-raw, [], i32, "GetCharPressed")

declare-c(get-gamepad-name, [gamepad i32], str, "GetGamepadName")

declare-c(set-gamepad-mappings, [mappings str], i32, "SetGamepadMappings")

declare-c(set-gamepad-vibration,
          [gamepad i32 left-motor f32 right-motor f32 duration f32],
          "SetGamepadVibration")

declare-c(get-mouse-x, [], i32, "GetMouseX")

declare-c(get-mouse-y, [], i32, "GetMouseY")

declare-c(get-mouse-delta, [], Vector2, "GetMouseDelta")

declare-c(set-mouse-position, [x i32 y i32], "SetMousePosition")

declare-c(set-mouse-offset, [offset-x i32 offset-y i32], "SetMouseOffset")

declare-c(set-mouse-scale, [scale-x f32 scale-y f32], "SetMouseScale")

declare-c(get-mouse-wheel-move-v, [], Vector2, "GetMouseWheelMoveV")

declare-c(update-camera-pro,
          [camera Ptr(Camera3D) movement Vector3 rotation Vector3 zoom f32],
          "UpdateCameraPro")

declare-c(draw-line-strip-raw,
          [points Ptr(const Vector2) point-count i32 color Color],
          "DrawLineStrip")

declare-c(draw-line-bezier,
          [start-pos Vector2 end-pos Vector2 thick f32 color Color],
          "DrawLineBezier")

declare-c(draw-circle-sector,
          [center Vector2 radius f32 start-angle f32 end-angle f32 segments i32 color Color],
          "DrawCircleSector")

declare-c(draw-circle-sector-lines,
          [center Vector2 radius f32 start-angle f32 end-angle f32 segments i32 color Color],
          "DrawCircleSectorLines")

declare-c(draw-circle-gradient,
          [center-x i32 center-y i32 radius f32 inner Color outer Color],
          "DrawCircleGradient")

declare-c(draw-rectangle-pro,
          [rec Rectangle origin Vector2 rotation f32 color Color],
          "DrawRectanglePro")

declare-c(draw-rectangle-gradient-v,
          [pos-x i32 pos-y i32 width i32 height i32 top Color bottom Color],
          "DrawRectangleGradientV")

declare-c(draw-rectangle-gradient-h,
          [pos-x i32 pos-y i32 width i32 height i32 left Color right Color],
          "DrawRectangleGradientH")

declare-c(draw-rectangle-gradient-ex,
          [rec Rectangle top-left Color bottom-left Color top-right Color bottom-right Color],
          "DrawRectangleGradientEx")

declare-c(draw-triangle-fan-raw,
          [points Ptr(const Vector2) point-count i32 color Color],
          "DrawTriangleFan")

declare-c(draw-triangle-strip-raw,
          [points Ptr(const Vector2) point-count i32 color Color],
          "DrawTriangleStrip")

declare-c(draw-poly,
          [center Vector2 sides i32 radius f32 rotation f32 color Color],
          "DrawPoly")

declare-c(draw-poly-lines,
          [center Vector2 sides i32 radius f32 rotation f32 color Color],
          "DrawPolyLines")

declare-c(draw-poly-lines-ex,
          [center Vector2 sides i32 radius f32 rotation f32 line-thick f32 color Color],
          "DrawPolyLinesEx")

declare-c(draw-spline-linear-raw,
          [points Ptr(const Vector2) point-count i32 thick f32 color Color],
          "DrawSplineLinear")

declare-c(draw-spline-basis-raw,
          [points Ptr(const Vector2) point-count i32 thick f32 color Color],
          "DrawSplineBasis")

declare-c(draw-spline-catmull-rom-raw,
          [points Ptr(const Vector2) point-count i32 thick f32 color Color],
          "DrawSplineCatmullRom")

declare-c(draw-spline-bezier-quadratic-raw,
          [points Ptr(const Vector2) point-count i32 thick f32 color Color],
          "DrawSplineBezierQuadratic")

declare-c(draw-spline-bezier-cubic-raw,
          [points Ptr(const Vector2) point-count i32 thick f32 color Color],
          "DrawSplineBezierCubic")

declare-c(draw-spline-segment-linear,
          [p-1 Vector2 p-2 Vector2 thick f32 color Color],
          "DrawSplineSegmentLinear")

declare-c(draw-spline-segment-basis,
          [p-1 Vector2 p-2 Vector2 p-3 Vector2 p-4 Vector2 thick f32 color Color],
          "DrawSplineSegmentBasis")

declare-c(draw-spline-segment-catmull-rom,
          [p-1 Vector2 p-2 Vector2 p-3 Vector2 p-4 Vector2 thick f32 color Color],
          "DrawSplineSegmentCatmullRom")

declare-c(draw-spline-segment-bezier-quadratic,
          [p-1 Vector2 c-2 Vector2 p-3 Vector2 thick f32 color Color],
          "DrawSplineSegmentBezierQuadratic")

declare-c(draw-spline-segment-bezier-cubic,
          [p-1 Vector2 c-2 Vector2 c-3 Vector2 p-4 Vector2 thick f32 color Color],
          "DrawSplineSegmentBezierCubic")

declare-c(get-spline-point-linear, [start-pos Vector2 end-pos Vector2 t f32],
          Vector2, "GetSplinePointLinear")

declare-c(get-spline-point-basis,
          [p-1 Vector2 p-2 Vector2 p-3 Vector2 p-4 Vector2 t f32], Vector2,
          "GetSplinePointBasis")

declare-c(get-spline-point-catmull-rom,
          [p-1 Vector2 p-2 Vector2 p-3 Vector2 p-4 Vector2 t f32], Vector2,
          "GetSplinePointCatmullRom")

declare-c(get-spline-point-bezier-quad,
          [p-1 Vector2 c-2 Vector2 p-3 Vector2 t f32], Vector2,
          "GetSplinePointBezierQuad")

declare-c(get-spline-point-bezier-cubic,
          [p-1 Vector2 c-2 Vector2 c-3 Vector2 p-4 Vector2 t f32], Vector2,
          "GetSplinePointBezierCubic")

declare-c(load-image-raw,
          [file-name str width i32 height i32 format i32 header-size i32],
          Image, "LoadImageRaw")

declare-c(load-image-anim, [file-name str frames Ptr(i32)], Image,
          "LoadImageAnim")

declare-c(load-image-anim-from-memory,
          [file-type str file-data Ptr(const u8) data-size i32 frames Ptr(i32)],
          Image, "LoadImageAnimFromMemory")

declare-c(load-image-from-texture, [texture Texture2D], Image,
          "LoadImageFromTexture")

declare-c(load-image-from-screen, [], Image, "LoadImageFromScreen")

declare-c(export-image-to-memory,
          [image Image file-type str file-size Ptr(i32)], Ptr(u8),
          "ExportImageToMemory")

declare-c(export-image-as-code, [image Image file-name str], bool,
          "ExportImageAsCode")

declare-c(gen-image-gradient-linear,
          [width i32 height i32 direction i32 start Color end Color], Image,
          "GenImageGradientLinear")

declare-c(gen-image-gradient-radial,
          [width i32 height i32 density f32 inner Color outer Color], Image,
          "GenImageGradientRadial")

declare-c(gen-image-gradient-square,
          [width i32 height i32 density f32 inner Color outer Color], Image,
          "GenImageGradientSquare")

declare-c(gen-image-checked,
          [width i32 height i32 checks-x i32 checks-y i32 col-1 Color col-2 Color],
          Image, "GenImageChecked")

declare-c(gen-image-white-noise, [width i32 height i32 factor f32], Image,
          "GenImageWhiteNoise")

declare-c(gen-image-perlin-noise,
          [width i32 height i32 offset-x i32 offset-y i32 scale f32], Image,
          "GenImagePerlinNoise")

declare-c(gen-image-cellular, [width i32 height i32 tile-size i32], Image,
          "GenImageCellular")

declare-c(gen-image-text, [width i32 height i32 text str], Image,
          "GenImageText")

declare-c(image-copy, [image Image], Image, "ImageCopy")

declare-c(image-from-channel, [image Image selected-channel i32], Image,
          "ImageFromChannel")

declare-c(image-text, [text str font-size i32 color Color], Image, "ImageText")

declare-c(image-text-ex,
          [font Font text str font-size f32 spacing f32 tint Color], Image,
          "ImageTextEx")

declare-c(image-to-pot, [image Ptr(Image) fill Color], "ImageToPOT")

declare-c(image-alpha-crop, [image Ptr(Image) threshold f32], "ImageAlphaCrop")

declare-c(image-alpha-clear, [image Ptr(Image) color Color threshold f32],
          "ImageAlphaClear")

declare-c(image-alpha-mask, [image Ptr(Image) alpha-mask Image],
          "ImageAlphaMask")

declare-c(image-alpha-premultiply, [image Ptr(Image)], "ImageAlphaPremultiply")

declare-c(image-blur-gaussian, [image Ptr(Image) blur-size i32],
          "ImageBlurGaussian")

declare-c(image-kernel-convolution,
          [image Ptr(Image) kernel Ptr(const f32) kernel-size i32],
          "ImageKernelConvolution")

declare-c(image-resize-canvas,
          [image Ptr(Image) new-width i32 new-height i32 offset-x i32 offset-y i32 fill Color],
          "ImageResizeCanvas")

declare-c(image-mipmaps, [image Ptr(Image)], "ImageMipmaps")

declare-c(image-dither,
          [image Ptr(Image) r-bpp i32 g-bpp i32 b-bpp i32 a-bpp i32],
          "ImageDither")

declare-c(image-rotate, [image Ptr(Image) degrees i32], "ImageRotate")

declare-c(image-rotate-cw, [image Ptr(Image)], "ImageRotateCW")

declare-c(image-rotate-ccw, [image Ptr(Image)], "ImageRotateCCW")

declare-c(image-color-tint, [image Ptr(Image) color Color], "ImageColorTint")

declare-c(image-color-invert, [image Ptr(Image)], "ImageColorInvert")

declare-c(image-color-grayscale, [image Ptr(Image)], "ImageColorGrayscale")

declare-c(image-color-contrast, [image Ptr(Image) contrast f32],
          "ImageColorContrast")

declare-c(image-color-brightness, [image Ptr(Image) brightness i32],
          "ImageColorBrightness")

declare-c(image-color-replace, [image Ptr(Image) color Color replace Color],
          "ImageColorReplace")

declare-c(load-image-colors, [image Image], Ptr(Color), "LoadImageColors")

declare-c(load-image-palette,
          [image Image max-palette-size i32 color-count Ptr(i32)], Ptr(Color),
          "LoadImagePalette")

declare-c(unload-image-colors, [colors Ptr(Color)], "UnloadImageColors")

declare-c(unload-image-palette, [colors Ptr(Color)], "UnloadImagePalette")

declare-c(get-image-alpha-border, [image Image threshold f32], Rectangle,
          "GetImageAlphaBorder")

declare-c(image-clear-background, [dst Ptr(Image) color Color],
          "ImageClearBackground")

declare-c(image-draw-pixel-v, [dst Ptr(Image) position Vector2 color Color],
          "ImageDrawPixelV")

declare-c(image-draw-line,
          [dst Ptr(Image) start-pos-x i32 start-pos-y i32 end-pos-x i32 end-pos-y i32 color Color],
          "ImageDrawLine")

declare-c(image-draw-line-v,
          [dst Ptr(Image) start Vector2 end Vector2 color Color],
          "ImageDrawLineV")

declare-c(image-draw-line-ex,
          [dst Ptr(Image) start Vector2 end Vector2 thick i32 color Color],
          "ImageDrawLineEx")

declare-c(image-draw-circle,
          [dst Ptr(Image) center-x i32 center-y i32 radius i32 color Color],
          "ImageDrawCircle")

declare-c(image-draw-circle-v,
          [dst Ptr(Image) center Vector2 radius i32 color Color],
          "ImageDrawCircleV")

declare-c(image-draw-circle-lines,
          [dst Ptr(Image) center-x i32 center-y i32 radius i32 color Color],
          "ImageDrawCircleLines")

declare-c(image-draw-circle-lines-v,
          [dst Ptr(Image) center Vector2 radius i32 color Color],
          "ImageDrawCircleLinesV")

declare-c(image-draw-rectangle,
          [dst Ptr(Image) pos-x i32 pos-y i32 width i32 height i32 color Color],
          "ImageDrawRectangle")

declare-c(image-draw-rectangle-v,
          [dst Ptr(Image) position Vector2 size Vector2 color Color],
          "ImageDrawRectangleV")

declare-c(image-draw-rectangle-rec, [dst Ptr(Image) rec Rectangle color Color],
          "ImageDrawRectangleRec")

declare-c(image-draw-rectangle-lines,
          [dst Ptr(Image) rec Rectangle thick i32 color Color],
          "ImageDrawRectangleLines")

declare-c(image-draw-triangle,
          [dst Ptr(Image) v-1 Vector2 v-2 Vector2 v-3 Vector2 color Color],
          "ImageDrawTriangle")

declare-c(image-draw-triangle-ex,
          [dst Ptr(Image) v-1 Vector2 v-2 Vector2 v-3 Vector2 c-1 Color c-2 Color c-3 Color],
          "ImageDrawTriangleEx")

declare-c(image-draw-triangle-lines,
          [dst Ptr(Image) v-1 Vector2 v-2 Vector2 v-3 Vector2 color Color],
          "ImageDrawTriangleLines")

declare-c(image-draw-triangle-fan-raw,
          [dst Ptr(Image) points Ptr(Vector2) point-count i32 color Color],
          "ImageDrawTriangleFan")

declare-c(image-draw-triangle-strip-raw,
          [dst Ptr(Image) points Ptr(Vector2) point-count i32 color Color],
          "ImageDrawTriangleStrip")

declare-c(image-draw,
          [dst Ptr(Image) src Image src-rec Rectangle dst-rec Rectangle tint Color],
          "ImageDraw")

declare-c(image-draw-text,
          [dst Ptr(Image) text str pos-x i32 pos-y i32 font-size i32 color Color],
          "ImageDrawText")

declare-c(image-draw-text-ex,
          [dst Ptr(Image) font Font text str position Vector2 font-size f32 spacing f32 tint Color],
          "ImageDrawTextEx")

declare-c(load-texture-cubemap, [image Image layout i32], Texture2D,
          "LoadTextureCubemap")

declare-c(update-texture, [texture Texture2D pixels Ptr(const u8)],
          "UpdateTexture")

declare-c(update-texture-rec,
          [texture Texture2D rec Rectangle pixels Ptr(const u8)],
          "UpdateTextureRec")

declare-c(gen-texture-mipmaps, [texture Ptr(Texture2D)], "GenTextureMipmaps")

declare-c(set-texture-wrap, [texture Texture2D wrap i32], "SetTextureWrap")

declare-c(color-is-equal, [col-1 Color col-2 Color], bool, "ColorIsEqual")

declare-c(color-to-int, [color Color], i32, "ColorToInt")

declare-c(color-to-hsv, [color Color], Vector3, "ColorToHSV")

declare-c(color-from-hsv, [hue f32 saturation f32 value f32], Color,
          "ColorFromHSV")

declare-c(color-tint, [color Color tint Color], Color, "ColorTint")

declare-c(color-brightness, [color Color factor f32], Color, "ColorBrightness")

declare-c(color-contrast, [color Color contrast f32], Color, "ColorContrast")

declare-c(color-alpha, [color Color alpha f32], Color, "ColorAlpha")

declare-c(color-alpha-blend, [dst Color src Color tint Color], Color,
          "ColorAlphaBlend")

declare-c(color-lerp, [color-1 Color color-2 Color factor f32], Color,
          "ColorLerp")

declare-c(get-pixel-color, [src-ptr Ptr(u8) format i32], Color, "GetPixelColor")

declare-c(set-pixel-color, [dst-ptr Ptr(u8) color Color format i32],
          "SetPixelColor")

declare-c(get-pixel-data-size, [width i32 height i32 format i32], i32,
          "GetPixelDataSize")

declare-c(load-font-from-image, [image Image key Color first-char i32], Font,
          "LoadFontFromImage")

declare-c(load-font-from-memory,
          [file-type str file-data Ptr(const u8) data-size i32 font-size i32 codepoints Ptr(i32) codepoint-count i32],
          Font, "LoadFontFromMemory")

declare-c(load-font-data,
          [file-data Ptr(const u8) data-size i32 font-size i32 codepoints Ptr(i32) codepoint-count i32 type i32],
          Ptr(GlyphInfo), "LoadFontData")

declare-c(gen-image-font-atlas,
          [glyphs Ptr(const GlyphInfo) glyph-recs Ptr(Ptr(Rectangle)) glyph-count i32 font-size i32 padding i32 pack-method i32],
          Image, "GenImageFontAtlas")

declare-c(unload-font-data, [glyphs Ptr(GlyphInfo) glyph-count i32],
          "UnloadFontData")

declare-c(export-font-as-code, [font Font file-name str], bool,
          "ExportFontAsCode")

declare-c(draw-text-pro,
          [font Font text str position Vector2 origin Vector2 rotation f32 font-size f32 spacing f32 tint Color],
          "DrawTextPro")

declare-c(draw-text-codepoints,
          [font Font codepoints Ptr(const i32) codepoint-count i32 position Vector2 font-size f32 spacing f32 tint Color],
          "DrawTextCodepoints")

declare-c(set-text-line-spacing, [spacing i32], "SetTextLineSpacing")

declare-c(load-codepoints, [text str count Ptr(i32)], Ptr(i32),
          "LoadCodepoints")

declare-c(unload-codepoints, [codepoints Ptr(i32)], "UnloadCodepoints")

declare-c(get-codepoint-count, [text str], i32, "GetCodepointCount")

declare-c(get-codepoint, [text str codepoint-size Ptr(i32)], i32,
          "GetCodepoint")

declare-c(get-codepoint-next, [text str codepoint-size Ptr(i32)], i32,
          "GetCodepointNext")

declare-c(codepoint-to-utf8, [codepoint i32 utf-8size Ptr(i32)], str,
          "CodepointToUTF8")

declare-c(text-is-equal, [text-1 str text-2 str], bool, "TextIsEqual")

declare-c(text-length, [text str], u32, "TextLength")

declare-c(text-subtext, [text str position i32 length i32], str, "TextSubtext")

declare-c(text-join, [text-list Ptr(const Ptr(i8)) count i32 delimiter str],
          str, "TextJoin")

declare-c(text-split, [text str delimiter i8 count Ptr(i32)], Ptr(Ptr(i8)),
          "TextSplit")

declare-c(text-find-index, [text str find str], i32, "TextFindIndex")

declare-c(text-to-upper, [text str], str, "TextToUpper")

declare-c(text-to-lower, [text str], str, "TextToLower")

declare-c(text-to-pascal, [text str], str, "TextToPascal")

declare-c(text-to-snake, [text str], str, "TextToSnake")

declare-c(text-to-camel, [text str], str, "TextToCamel")

declare-c(text-to-integer, [text str], i32, "TextToInteger")

declare-c(text-to-float, [text str], f32, "TextToFloat")

declare-c(draw-line-3d, [start-pos Vector3 end-pos Vector3 color Color],
          "DrawLine3D")

declare-c(draw-point-3d, [position Vector3 color Color], "DrawPoint3D")

declare-c(draw-circle-3d,
          [center Vector3 radius f32 rotation-axis Vector3 rotation-angle f32 color Color],
          "DrawCircle3D")

declare-c(draw-triangle-3d, [v-1 Vector3 v-2 Vector3 v-3 Vector3 color Color],
          "DrawTriangle3D")

declare-c(draw-triangle-strip-3d-raw,
          [points Ptr(const Vector3) point-count i32 color Color],
          "DrawTriangleStrip3D")

declare-c(draw-cube-wires-v, [position Vector3 size Vector3 color Color],
          "DrawCubeWiresV")

declare-c(draw-sphere-ex,
          [center-pos Vector3 radius f32 rings i32 slices i32 color Color],
          "DrawSphereEx")

declare-c(draw-cylinder,
          [position Vector3 radius-top f32 radius-bottom f32 height f32 slices i32 color Color],
          "DrawCylinder")

declare-c(draw-cylinder-ex,
          [start-pos Vector3 end-pos Vector3 start-radius f32 end-radius f32 sides i32 color Color],
          "DrawCylinderEx")

declare-c(draw-cylinder-wires,
          [position Vector3 radius-top f32 radius-bottom f32 height f32 slices i32 color Color],
          "DrawCylinderWires")

declare-c(draw-cylinder-wires-ex,
          [start-pos Vector3 end-pos Vector3 start-radius f32 end-radius f32 sides i32 color Color],
          "DrawCylinderWiresEx")

declare-c(draw-capsule,
          [start-pos Vector3 end-pos Vector3 radius f32 slices i32 rings i32 color Color],
          "DrawCapsule")

declare-c(draw-capsule-wires,
          [start-pos Vector3 end-pos Vector3 radius f32 slices i32 rings i32 color Color],
          "DrawCapsuleWires")

declare-c(draw-plane, [center-pos Vector3 size Vector2 color Color],
          "DrawPlane")

declare-c(load-model, [file-name str], Model, "LoadModel")

declare-c(load-model-from-mesh, [mesh Mesh], Model, "LoadModelFromMesh")

declare-c(is-model-valid, [model Model], bool, "IsModelValid")

declare-c(unload-model, [model Model], "UnloadModel")

declare-c(get-model-bounding-box, [model Model], BoundingBox,
          "GetModelBoundingBox")

declare-c(draw-model, [model Model position Vector3 scale f32 tint Color],
          "DrawModel")

declare-c(draw-model-ex,
          [model Model position Vector3 rotation-axis Vector3 rotation-angle f32 scale Vector3 tint Color],
          "DrawModelEx")

declare-c(draw-model-wires, [model Model position Vector3 scale f32 tint Color],
          "DrawModelWires")

declare-c(draw-model-wires-ex,
          [model Model position Vector3 rotation-axis Vector3 rotation-angle f32 scale Vector3 tint Color],
          "DrawModelWiresEx")

declare-c(draw-model-points,
          [model Model position Vector3 scale f32 tint Color],
          "DrawModelPoints")

declare-c(draw-model-points-ex,
          [model Model position Vector3 rotation-axis Vector3 rotation-angle f32 scale Vector3 tint Color],
          "DrawModelPointsEx")

declare-c(draw-bounding-box, [box BoundingBox color Color], "DrawBoundingBox")

declare-c(draw-billboard,
          [camera Camera3D texture Texture2D position Vector3 scale f32 tint Color],
          "DrawBillboard")

declare-c(draw-billboard-rec,
          [camera Camera3D texture Texture2D source Rectangle position Vector3 size Vector2 tint Color],
          "DrawBillboardRec")

declare-c(draw-billboard-pro,
          [camera Camera3D texture Texture2D source Rectangle position Vector3 up Vector3 size Vector2 origin Vector2 rotation f32 tint Color],
          "DrawBillboardPro")

declare-c(upload-mesh, [mesh Ptr(Mesh) dynamic bool], "UploadMesh")

declare-c(update-mesh-buffer,
          [mesh Mesh index i32 data Ptr(const u8) data-size i32 offset i32],
          "UpdateMeshBuffer")

declare-c(unload-mesh, [mesh Mesh], "UnloadMesh")

declare-c(get-mesh-bounding-box, [mesh Mesh], BoundingBox, "GetMeshBoundingBox")

declare-c(gen-mesh-tangents, [mesh Ptr(Mesh)], "GenMeshTangents")

declare-c(export-mesh, [mesh Mesh file-name str], bool, "ExportMesh")

declare-c(export-mesh-as-code, [mesh Mesh file-name str], bool,
          "ExportMeshAsCode")

declare-c(gen-mesh-poly, [sides i32 radius f32], Mesh, "GenMeshPoly")

declare-c(gen-mesh-plane, [width f32 length f32 res-x i32 res-z i32], Mesh,
          "GenMeshPlane")

declare-c(gen-mesh-cube, [width f32 height f32 length f32], Mesh, "GenMeshCube")

declare-c(gen-mesh-sphere, [radius f32 rings i32 slices i32], Mesh,
          "GenMeshSphere")

declare-c(gen-mesh-hemi-sphere, [radius f32 rings i32 slices i32], Mesh,
          "GenMeshHemiSphere")

declare-c(gen-mesh-cylinder, [radius f32 height f32 slices i32], Mesh,
          "GenMeshCylinder")

declare-c(gen-mesh-cone, [radius f32 height f32 slices i32], Mesh,
          "GenMeshCone")

declare-c(gen-mesh-torus, [radius f32 size f32 rad-seg i32 sides i32], Mesh,
          "GenMeshTorus")

declare-c(gen-mesh-knot, [radius f32 size f32 rad-seg i32 sides i32], Mesh,
          "GenMeshKnot")

declare-c(gen-mesh-heightmap, [heightmap Image size Vector3], Mesh,
          "GenMeshHeightmap")

declare-c(gen-mesh-cubicmap, [cubicmap Image cube-size Vector3], Mesh,
          "GenMeshCubicmap")

declare-c(set-model-mesh-material,
          [model Ptr(Model) mesh-id i32 material-id i32],
          "SetModelMeshMaterial")

declare-c(check-collision-spheres,
          [center-1 Vector3 radius-1 f32 center-2 Vector3 radius-2 f32], bool,
          "CheckCollisionSpheres")

declare-c(check-collision-boxes, [box-1 BoundingBox box-2 BoundingBox], bool,
          "CheckCollisionBoxes")

declare-c(check-collision-box-sphere,
          [box BoundingBox center Vector3 radius f32], bool,
          "CheckCollisionBoxSphere")

declare-c(get-ray-collision-sphere, [ray Ray center Vector3 radius f32],
          RayCollision, "GetRayCollisionSphere")

declare-c(get-ray-collision-box, [ray Ray box BoundingBox], RayCollision,
          "GetRayCollisionBox")

declare-c(get-ray-collision-mesh, [ray Ray mesh Mesh transform Matrix],
          RayCollision, "GetRayCollisionMesh")

declare-c(get-ray-collision-triangle,
          [ray Ray p-1 Vector3 p-2 Vector3 p-3 Vector3], RayCollision,
          "GetRayCollisionTriangle")

declare-c(get-ray-collision-quad,
          [ray Ray p-1 Vector3 p-2 Vector3 p-3 Vector3 p-4 Vector3],
          RayCollision, "GetRayCollisionQuad")

declare-c(load-wave-from-memory,
          [file-type str file-data Ptr(const u8) data-size i32], Wave,
          "LoadWaveFromMemory")

declare-c(update-sound, [sound Sound data Ptr(const u8) sample-count i32],
          "UpdateSound")

declare-c(export-wave-as-code, [wave Wave file-name str], bool,
          "ExportWaveAsCode")

declare-c(load-music-stream-from-memory,
          [file-type str data Ptr(const u8) data-size i32], Music,
          "LoadMusicStreamFromMemory")

declare-c(load-audio-stream, [sample-rate u32 sample-size u32 channels u32],
          AudioStream, "LoadAudioStream")

declare-c(is-audio-stream-valid, [stream AudioStream], bool,
          "IsAudioStreamValid")

declare-c(unload-audio-stream, [stream AudioStream], "UnloadAudioStream")

declare-c(update-audio-stream,
          [stream AudioStream data Ptr(const u8) frame-count i32],
          "UpdateAudioStream")

declare-c(is-audio-stream-processed, [stream AudioStream], bool,
          "IsAudioStreamProcessed")

declare-c(play-audio-stream, [stream AudioStream], "PlayAudioStream")

declare-c(pause-audio-stream, [stream AudioStream], "PauseAudioStream")

declare-c(resume-audio-stream, [stream AudioStream], "ResumeAudioStream")

declare-c(is-audio-stream-playing, [stream AudioStream], bool,
          "IsAudioStreamPlaying")

declare-c(stop-audio-stream, [stream AudioStream], "StopAudioStream")

declare-c(set-audio-stream-volume, [stream AudioStream volume f32],
          "SetAudioStreamVolume")

declare-c(set-audio-stream-pitch, [stream AudioStream pitch f32],
          "SetAudioStreamPitch")

declare-c(set-audio-stream-pan, [stream AudioStream pan f32],
          "SetAudioStreamPan")

declare-c(set-audio-stream-buffer-size-default, [size i32],
          "SetAudioStreamBufferSizeDefault")