void glps_audio_stream_destroy(glps_audio_stream * am);

void glps_audio_stream_pause(glps_audio_stream * am);

void glps_audio_stream_resume(glps_audio_stream * am);

void glps_audio_stream_set_position(glps_audio_stream * am, unsigned int position);

void glps_audio_stream_set_volume(glps_audio_stream * am, float volume);

void glps_audio_stream_stop(glps_audio_stream * am);

typedef DWORD gthread_attr_t;          /**< Thread attribute type for Windows */

typedef pthread_attr_t gthread_attr_t;    /**< Thread attribute type for POSIX */

typedef CONDITION_VARIABLE gthread_cond_t; /**< Condition variable type for Windows */

typedef pthread_cond_t gthread_cond_t;       /**< Condition variable type for POSIX */

typedef int gthread_condattr_t;            /**< Condition variable attribute type (unused) */

typedef pthread_condattr_t gthread_condattr_t; /**< Condition variable attribute type for POSIX */

typedef CRITICAL_SECTION gthread_mutex_t; /**< Mutex type for Windows */

typedef pthread_mutex_t gthread_mutex_t;       /**< Mutex type for POSIX */

typedef int gthread_mutexattr_t;           /**< Mutex attribute type (unused) */

typedef pthread_mutexattr_t gthread_mutexattr_t; /**< Mutex attribute type for POSIX */

typedef HANDLE gthread_t;              /**< Thread handle type for Windows */

typedef pthread_t gthread_t;              /**< Thread handle type for POSIX */

int glps_thread_attr_destroy(gthread_attr_t * attr);

int glps_thread_attr_getdetachstate(const gthread_attr_t * attr, int * detachstate);

int glps_thread_attr_init(gthread_attr_t * attr);

int glps_thread_attr_setdetachstate(gthread_attr_t * attr, int detachstate);

int glps_thread_cond_broadcast(gthread_cond_t * cond);

int glps_thread_cond_destroy(gthread_cond_t * cond);

int glps_thread_cond_init(gthread_cond_t * cond, const gthread_condattr_t * attr);

int glps_thread_cond_signal(gthread_cond_t * cond);

int glps_thread_cond_wait(gthread_cond_t * cond, gthread_mutex_t * mutex);

int glps_thread_detach(gthread_t thread);

int glps_thread_equal(gthread_t t1, gthread_t t2);

void glps_thread_exit(void * retval);

int glps_thread_join(gthread_t thread, void ** retval);

int glps_thread_mutex_destroy(gthread_mutex_t * mutex);

int glps_thread_mutex_init(gthread_mutex_t * mutex, const gthread_mutexattr_t * attr);

int glps_thread_mutex_lock(gthread_mutex_t * mutex);

int glps_thread_mutex_trylock(gthread_mutex_t * mutex);

int glps_thread_mutex_unlock(gthread_mutex_t * mutex);

gthread_t glps_thread_self();

typedef struct glps_timer {
    uint64_t start_time_ms;    /**< Start time of the timer in milliseconds. */
    uint64_t end_time_ms;      /**< End time of the timer in milliseconds. */
    uint64_t duration_ms;      /**< Duration of the timer in milliseconds. */
    timer_callback callback;   /**< Function to call when the timer expires. */
    void *callback_arg;        /**< Argument to pass to the callback function. */
    bool is_valid;             /**< Indicates if the timer is currently valid/active. */
} glps_timer;

glps_timer *glps_timer_init();

void glps_timer_check_and_call(glps_timer * timer);

void glps_timer_destroy(glps_timer * timer);

double glps_timer_elapsed_ms(glps_timer * timer);

double glps_timer_elapsed_us(glps_timer * timer);

void glps_timer_start(glps_timer * timer, uint64_t duration_ms, timer_callback callback, void * arg);

void glps_timer_stop(glps_timer * timer);

void *glps_get_proc_addr(const char * name);

void *glps_wm_get_display(glps_WindowManager * wm);

glps_WindowManager *glps_wm_init();

void *glps_wm_window_get_native_ptr(glps_WindowManager * wm, size_t window_id);

void glps_wm_cursor_change(glps_WindowManager * wm, GLPS_CURSOR_TYPE cursor_type);

void glps_wm_destroy(glps_WindowManager * wm);

double glps_wm_get_fps(glps_WindowManager * wm, size_t window_id);

uint8_t glps_wm_get_platform();

size_t glps_wm_get_window_count(glps_WindowManager * wm);

void glps_wm_set_window_background_transparent(glps_WindowManager * wm, size_t window_id);

void glps_wm_set_window_blur(glps_WindowManager * wm, size_t window_id, bool enable, int blur_radius);

void glps_wm_set_window_ctx_curr(glps_WindowManager * wm, size_t window_id);

void glps_wm_set_window_opacity(glps_WindowManager * wm, size_t window_id, float opacity);

bool glps_wm_should_close(glps_WindowManager * wm);

void glps_wm_swap_buffers(glps_WindowManager * wm, size_t window_id);

void glps_wm_swap_interval(glps_WindowManager * wm, unsigned int swap_interval);

void glps_wm_toggle_window_decorations(glps_WindowManager * wm, bool state, size_t window_id);

void glps_wm_vk_create_surface(glps_WindowManager * wm, size_t window_id, VkInstance * instance, VkSurfaceKHR * surface);

void glps_wm_vk_free_extensions_arr(glps_VulkanExtensionArray * extensions);

glps_VulkanExtensionArray glps_wm_vk_get_extensions_arr();

void glps_wm_window_destroy(glps_WindowManager * wm, size_t window_id);

void glps_wm_window_is_resizable(glps_WindowManager * wm, bool state, size_t window_id);

void glps_wm_window_update(glps_WindowManager * wm, size_t window_id);