runtime.h

Go to the documentation of this file.

 
#ifndef MAPLIBRE_NATIVE_C_RUNTIME_H
#define MAPLIBRE_NATIVE_C_RUNTIME_H
 
#ifndef __cplusplus
#include <stdbool.h>
#endif
 
#include <stddef.h>
#include <stdint.h>
 
#include "base.h"
#include "completion.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum mln_network_status : uint32_t {
  MLN_NETWORK_STATUS_ONLINE = 1,
  MLN_NETWORK_STATUS_OFFLINE = 2,
} mln_network_status;
 
typedef enum mln_ambient_cache_operation : uint32_t {
  MLN_AMBIENT_CACHE_OPERATION_RESET_DATABASE = 1,
  MLN_AMBIENT_CACHE_OPERATION_PACK_DATABASE = 2,
  MLN_AMBIENT_CACHE_OPERATION_INVALIDATE = 3,
  MLN_AMBIENT_CACHE_OPERATION_CLEAR = 4,
} mln_ambient_cache_operation;
 
typedef int64_t mln_offline_region_id;
 
typedef enum mln_offline_region_definition_type : uint32_t {
  MLN_OFFLINE_REGION_DEFINITION_TILE_PYRAMID = 1,
  MLN_OFFLINE_REGION_DEFINITION_GEOMETRY = 2,
} mln_offline_region_definition_type;
 
typedef enum mln_offline_region_download_state : uint32_t {
  MLN_OFFLINE_REGION_DOWNLOAD_INACTIVE = 0,
  MLN_OFFLINE_REGION_DOWNLOAD_ACTIVE = 1,
} mln_offline_region_download_state;

typedef struct mln_offline_region_status {
  uint32_t download_state MLN_BINDING("enum=mln_offline_region_download_state");
  uint64_t completed_resource_count;
  uint64_t completed_resource_size;
  uint64_t completed_tile_count;
  uint64_t required_tile_count;
  uint64_t completed_tile_size;
  uint64_t required_resource_count;
  bool required_resource_count_is_precise;
  bool complete;
} mln_offline_region_status;

typedef enum mln_runtime_event_type : uint32_t {
  MLN_RUNTIME_EVENT_MAP_CAMERA_WILL_CHANGE = 1,
  MLN_RUNTIME_EVENT_MAP_CAMERA_IS_CHANGING = 2,
  MLN_RUNTIME_EVENT_MAP_CAMERA_DID_CHANGE = 3,
  MLN_RUNTIME_EVENT_MAP_STYLE_LOADED = 4,
  MLN_RUNTIME_EVENT_MAP_LOADING_STARTED = 5,
  MLN_RUNTIME_EVENT_MAP_LOADING_FINISHED = 6,
  MLN_RUNTIME_EVENT_MAP_LOADING_FAILED = 7,
  MLN_RUNTIME_EVENT_MAP_IDLE = 8,
  MLN_RUNTIME_EVENT_MAP_RENDER_ERROR = 10,
  MLN_RUNTIME_EVENT_MAP_RENDER_FRAME_STARTED = 13,
  MLN_RUNTIME_EVENT_MAP_RENDER_FRAME_FINISHED = 14,
  MLN_RUNTIME_EVENT_MAP_RENDER_MAP_STARTED = 15,
  MLN_RUNTIME_EVENT_MAP_RENDER_MAP_FINISHED = 16,
  MLN_RUNTIME_EVENT_MAP_STYLE_IMAGE_MISSING = 17,
  MLN_RUNTIME_EVENT_MAP_TILE_ACTION = 18,
  MLN_RUNTIME_EVENT_OFFLINE_REGION_STATUS_CHANGED = 19,
  MLN_RUNTIME_EVENT_OFFLINE_REGION_RESPONSE_ERROR = 20,
  MLN_RUNTIME_EVENT_OFFLINE_REGION_TILE_COUNT_LIMIT_EXCEEDED = 21,
  MLN_RUNTIME_EVENT_MAP_SOURCE_CHANGED = 23,
} mln_runtime_event_type;

typedef enum MLN_BINDING("kind=bitmask") mln_runtime_event_mask : uint64_t {
  MLN_RUNTIME_EVENT_MASK_NONE = 0,
  MLN_RUNTIME_EVENT_MASK_MAP_CAMERA_WILL_CHANGE = 1ULL
    << MLN_RUNTIME_EVENT_MAP_CAMERA_WILL_CHANGE,
  MLN_RUNTIME_EVENT_MASK_MAP_CAMERA_IS_CHANGING = 1ULL
    << MLN_RUNTIME_EVENT_MAP_CAMERA_IS_CHANGING,
  MLN_RUNTIME_EVENT_MASK_MAP_CAMERA_DID_CHANGE = 1ULL
    << MLN_RUNTIME_EVENT_MAP_CAMERA_DID_CHANGE,
  MLN_RUNTIME_EVENT_MASK_MAP_STYLE_LOADED = 1ULL
    << MLN_RUNTIME_EVENT_MAP_STYLE_LOADED,
  MLN_RUNTIME_EVENT_MASK_MAP_LOADING_STARTED = 1ULL
    << MLN_RUNTIME_EVENT_MAP_LOADING_STARTED,
  MLN_RUNTIME_EVENT_MASK_MAP_LOADING_FINISHED = 1ULL
    << MLN_RUNTIME_EVENT_MAP_LOADING_FINISHED,
  MLN_RUNTIME_EVENT_MASK_MAP_LOADING_FAILED = 1ULL
    << MLN_RUNTIME_EVENT_MAP_LOADING_FAILED,
  MLN_RUNTIME_EVENT_MASK_MAP_IDLE = 1ULL << MLN_RUNTIME_EVENT_MAP_IDLE,
  MLN_RUNTIME_EVENT_MASK_MAP_RENDER_ERROR = 1ULL
    << MLN_RUNTIME_EVENT_MAP_RENDER_ERROR,
  MLN_RUNTIME_EVENT_MASK_MAP_RENDER_FRAME_STARTED = 1ULL
    << MLN_RUNTIME_EVENT_MAP_RENDER_FRAME_STARTED,
  MLN_RUNTIME_EVENT_MASK_MAP_RENDER_FRAME_FINISHED = 1ULL
    << MLN_RUNTIME_EVENT_MAP_RENDER_FRAME_FINISHED,
  MLN_RUNTIME_EVENT_MASK_MAP_RENDER_MAP_STARTED = 1ULL
    << MLN_RUNTIME_EVENT_MAP_RENDER_MAP_STARTED,
  MLN_RUNTIME_EVENT_MASK_MAP_RENDER_MAP_FINISHED = 1ULL
    << MLN_RUNTIME_EVENT_MAP_RENDER_MAP_FINISHED,
  MLN_RUNTIME_EVENT_MASK_MAP_STYLE_IMAGE_MISSING = 1ULL
    << MLN_RUNTIME_EVENT_MAP_STYLE_IMAGE_MISSING,
  MLN_RUNTIME_EVENT_MASK_MAP_TILE_ACTION = 1ULL
    << MLN_RUNTIME_EVENT_MAP_TILE_ACTION,
  MLN_RUNTIME_EVENT_MASK_OFFLINE_REGION_STATUS_CHANGED = 1ULL
    << MLN_RUNTIME_EVENT_OFFLINE_REGION_STATUS_CHANGED,
  MLN_RUNTIME_EVENT_MASK_OFFLINE_REGION_RESPONSE_ERROR = 1ULL
    << MLN_RUNTIME_EVENT_OFFLINE_REGION_RESPONSE_ERROR,
  MLN_RUNTIME_EVENT_MASK_OFFLINE_REGION_TILE_COUNT_LIMIT_EXCEEDED = 1ULL
    << MLN_RUNTIME_EVENT_OFFLINE_REGION_TILE_COUNT_LIMIT_EXCEEDED,
  MLN_RUNTIME_EVENT_MASK_MAP_SOURCE_CHANGED = 1ULL
    << MLN_RUNTIME_EVENT_MAP_SOURCE_CHANGED,
  MLN_RUNTIME_EVENT_MASK_ALL_MAP_EVENTS =
      MLN_RUNTIME_EVENT_MASK_MAP_CAMERA_WILL_CHANGE |
    MLN_RUNTIME_EVENT_MASK_MAP_CAMERA_IS_CHANGING |
    MLN_RUNTIME_EVENT_MASK_MAP_CAMERA_DID_CHANGE |
    MLN_RUNTIME_EVENT_MASK_MAP_STYLE_LOADED |
    MLN_RUNTIME_EVENT_MASK_MAP_LOADING_STARTED |
    MLN_RUNTIME_EVENT_MASK_MAP_LOADING_FINISHED |
    MLN_RUNTIME_EVENT_MASK_MAP_LOADING_FAILED |
    MLN_RUNTIME_EVENT_MASK_MAP_IDLE | MLN_RUNTIME_EVENT_MASK_MAP_RENDER_ERROR |
    MLN_RUNTIME_EVENT_MASK_MAP_RENDER_FRAME_STARTED |
    MLN_RUNTIME_EVENT_MASK_MAP_RENDER_FRAME_FINISHED |
    MLN_RUNTIME_EVENT_MASK_MAP_RENDER_MAP_STARTED |
    MLN_RUNTIME_EVENT_MASK_MAP_RENDER_MAP_FINISHED |
    MLN_RUNTIME_EVENT_MASK_MAP_STYLE_IMAGE_MISSING |
    MLN_RUNTIME_EVENT_MASK_MAP_TILE_ACTION |
    MLN_RUNTIME_EVENT_MASK_MAP_SOURCE_CHANGED,
  MLN_RUNTIME_EVENT_MASK_ALL_RUNTIME_EVENTS =
      MLN_RUNTIME_EVENT_MASK_OFFLINE_REGION_STATUS_CHANGED |
    MLN_RUNTIME_EVENT_MASK_OFFLINE_REGION_RESPONSE_ERROR |
    MLN_RUNTIME_EVENT_MASK_OFFLINE_REGION_TILE_COUNT_LIMIT_EXCEEDED,
  MLN_RUNTIME_EVENT_MASK_ALL = MLN_RUNTIME_EVENT_MASK_ALL_MAP_EVENTS |
    MLN_RUNTIME_EVENT_MASK_ALL_RUNTIME_EVENTS,
} mln_runtime_event_mask;

typedef enum mln_runtime_event_source_type : uint32_t {
  MLN_RUNTIME_EVENT_SOURCE_RUNTIME = 0,
  MLN_RUNTIME_EVENT_SOURCE_MAP = 1,
} mln_runtime_event_source_type;

typedef enum mln_runtime_event_payload_type : uint32_t {
  MLN_RUNTIME_EVENT_PAYLOAD_NONE = 0,
  MLN_RUNTIME_EVENT_PAYLOAD_RENDER_FRAME = 1,
  MLN_RUNTIME_EVENT_PAYLOAD_RENDER_MAP = 2,
  MLN_RUNTIME_EVENT_PAYLOAD_TILE_ACTION = 4,
  MLN_RUNTIME_EVENT_PAYLOAD_OFFLINE_REGION_STATUS = 5,
  MLN_RUNTIME_EVENT_PAYLOAD_OFFLINE_REGION_RESPONSE_ERROR = 6,
  MLN_RUNTIME_EVENT_PAYLOAD_OFFLINE_REGION_TILE_COUNT_LIMIT = 7,
} mln_runtime_event_payload_type;

typedef enum mln_camera_change_mode : uint32_t {
  MLN_CAMERA_CHANGE_MODE_IMMEDIATE = 0,
  MLN_CAMERA_CHANGE_MODE_ANIMATED = 1,
} mln_camera_change_mode;

typedef enum mln_render_mode : uint32_t {
  MLN_RENDER_MODE_PARTIAL = 0,
  MLN_RENDER_MODE_FULL = 1,
} mln_render_mode;

typedef enum mln_tile_operation : uint32_t {
  MLN_TILE_OPERATION_REQUESTED_FROM_CACHE = 0,
  MLN_TILE_OPERATION_REQUESTED_FROM_NETWORK = 1,
  MLN_TILE_OPERATION_LOAD_FROM_NETWORK = 2,
  MLN_TILE_OPERATION_LOAD_FROM_CACHE = 3,
  MLN_TILE_OPERATION_START_PARSE = 4,
  MLN_TILE_OPERATION_END_PARSE = 5,
  MLN_TILE_OPERATION_ERROR = 6,
  MLN_TILE_OPERATION_CANCELLED = 7,
  MLN_TILE_OPERATION_NULL = 8,
} mln_tile_operation;
 
typedef enum mln_resource_kind : uint32_t {
  MLN_RESOURCE_KIND_UNKNOWN = 0,
  MLN_RESOURCE_KIND_STYLE = 1,
  MLN_RESOURCE_KIND_SOURCE = 2,
  MLN_RESOURCE_KIND_TILE = 3,
  MLN_RESOURCE_KIND_GLYPHS = 4,
  MLN_RESOURCE_KIND_SPRITE_IMAGE = 5,
  MLN_RESOURCE_KIND_SPRITE_JSON = 6,
  MLN_RESOURCE_KIND_IMAGE = 7,
} mln_resource_kind;
 
typedef enum mln_resource_loading_method : uint32_t {
  MLN_RESOURCE_LOADING_METHOD_ALL = 0,
  MLN_RESOURCE_LOADING_METHOD_CACHE_ONLY = 1,
  MLN_RESOURCE_LOADING_METHOD_NETWORK_ONLY = 2,
} mln_resource_loading_method;
 
typedef enum mln_resource_priority : uint32_t {
  MLN_RESOURCE_PRIORITY_REGULAR = 0,
  MLN_RESOURCE_PRIORITY_LOW = 1,
} mln_resource_priority;
 
typedef enum mln_resource_usage : uint32_t {
  MLN_RESOURCE_USAGE_ONLINE = 0,
  MLN_RESOURCE_USAGE_OFFLINE = 1,
} mln_resource_usage;
 
typedef enum mln_resource_storage_policy : uint32_t {
  MLN_RESOURCE_STORAGE_POLICY_PERMANENT = 0,
  MLN_RESOURCE_STORAGE_POLICY_VOLATILE = 1,
} mln_resource_storage_policy;

typedef enum mln_resource_response_status : uint32_t {
  MLN_RESOURCE_RESPONSE_STATUS_OK = 0,
  MLN_RESOURCE_RESPONSE_STATUS_ERROR = 1,
  MLN_RESOURCE_RESPONSE_STATUS_NO_CONTENT = 2,
  MLN_RESOURCE_RESPONSE_STATUS_NOT_MODIFIED = 3,
} mln_resource_response_status;
 
typedef enum mln_resource_error_reason : uint32_t {
  MLN_RESOURCE_ERROR_REASON_NONE = 0,
  MLN_RESOURCE_ERROR_REASON_NOT_FOUND = 1,
  MLN_RESOURCE_ERROR_REASON_SERVER = 2,
  MLN_RESOURCE_ERROR_REASON_CONNECTION = 3,
  MLN_RESOURCE_ERROR_REASON_RATE_LIMIT = 4,
  MLN_RESOURCE_ERROR_REASON_OTHER = 5,
} mln_resource_error_reason;
 
typedef enum mln_resource_provider_decision : uint32_t {
  MLN_RESOURCE_PROVIDER_DECISION_PASS_THROUGH = 0,
  MLN_RESOURCE_PROVIDER_DECISION_HANDLE = 1,
} mln_resource_provider_decision;

MLN_API mln_status mln_network_get_status(
  uint32_t* out_status MLN_BINDING("direction=out;enum=mln_network_status"),
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_API mln_status mln_network_set_status(
  uint32_t status MLN_BINDING("enum=mln_network_status"),
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

typedef struct mln_runtime_options {
  uint32_t size;
  mln_buffer_view asset_path MLN_BINDING("optional=empty");
  mln_buffer_view cache_path MLN_BINDING("optional=empty");
} mln_runtime_options;

typedef struct mln_rendering_stats {
  double encoding_time;
  double rendering_time;
  int64_t frame_count;
  int64_t draw_call_count;
  int64_t total_draw_call_count;
} mln_rendering_stats;

typedef struct mln_runtime_event_render_frame {
  uint32_t mode MLN_BINDING("enum=mln_render_mode");
  bool needs_repaint;
  bool placement_changed;
  mln_rendering_stats stats;
} mln_runtime_event_render_frame;

typedef struct mln_runtime_event_render_map {
  uint32_t mode MLN_BINDING("enum=mln_render_mode");
} mln_runtime_event_render_map;

typedef struct mln_tile_id {
  uint32_t overscaled_z;
  int32_t wrap;
  uint32_t canonical_z;
  uint32_t canonical_x;
  uint32_t canonical_y;
} mln_tile_id;

typedef struct mln_runtime_event_tile_action {
  uint32_t operation MLN_BINDING("enum=mln_tile_operation");
  mln_tile_id tile_id;
} mln_runtime_event_tile_action;

typedef struct mln_runtime_event_offline_region_status {
  mln_offline_region_id region_id;
  mln_offline_region_status status;
} mln_runtime_event_offline_region_status;

typedef struct mln_runtime_event_offline_region_response_error {
  mln_offline_region_id region_id;
  uint32_t reason MLN_BINDING("enum=mln_resource_error_reason");
} mln_runtime_event_offline_region_response_error;

typedef struct mln_runtime_event_offline_region_tile_count_limit {
  mln_offline_region_id region_id;
  uint64_t limit;
} mln_runtime_event_offline_region_tile_count_limit;

typedef union mln_runtime_event_payload {
  mln_runtime_event_render_frame render_frame
    MLN_BINDING("variant=MLN_RUNTIME_EVENT_PAYLOAD_RENDER_FRAME");
  mln_runtime_event_render_map render_map
    MLN_BINDING("variant=MLN_RUNTIME_EVENT_PAYLOAD_RENDER_MAP");
  mln_runtime_event_tile_action tile_action
    MLN_BINDING("variant=MLN_RUNTIME_EVENT_PAYLOAD_TILE_ACTION");
  mln_runtime_event_offline_region_status offline_region_status
    MLN_BINDING("variant=MLN_RUNTIME_EVENT_PAYLOAD_OFFLINE_REGION_STATUS");
  mln_runtime_event_offline_region_response_error offline_region_response_error
    MLN_BINDING(
      "variant=MLN_RUNTIME_EVENT_PAYLOAD_OFFLINE_REGION_RESPONSE_ERROR"
    );
  mln_runtime_event_offline_region_tile_count_limit
    offline_region_tile_count_limit MLN_BINDING(
      "variant=MLN_RUNTIME_EVENT_PAYLOAD_OFFLINE_REGION_TILE_COUNT_LIMIT"
    );
} mln_runtime_event_payload;

typedef struct mln_runtime_event {
  uint32_t type MLN_BINDING("enum=mln_runtime_event_type");
  uint32_t source_type MLN_BINDING("enum=mln_runtime_event_source_type");
  uint64_t source;
  uint64_t generation;
  int32_t code;
  uint32_t payload_type MLN_BINDING("enum=mln_runtime_event_payload_type");
  mln_buffer_view message;
  mln_runtime_event_payload payload MLN_BINDING(
    "tag=payload_type;empty_variant=MLN_RUNTIME_EVENT_PAYLOAD_NONE"
  );
} mln_runtime_event;

typedef struct mln_event_batch_view {
  uint32_t size;
  uint32_t event_size;
  const mln_runtime_event* events
    MLN_BINDING("length=event_count;stride=event_size");
  size_t event_count;
} mln_event_batch_view;

MLN_BINDING("delivery=MLN_DELIVERY_TYPE_RUNTIME_EVENTS")
typedef void (*mln_runtime_event_callback)(
  void* user_data, const mln_event_batch_view* events
);

typedef struct mln_runtime_event_handler {
  uint32_t size;
  mln_runtime_event_callback callback MLN_BINDING("nullable=true");
  void* user_data MLN_BINDING("kind=context");
  mln_user_data_release release_user_data;
  mln_delivery_queue queue MLN_BINDING("kind=delivery_queue");
} mln_runtime_event_handler MLN_BINDING(
  "kind=callback_registration;release=release_user_data"
);

typedef enum MLN_BINDING("kind=bitmask") mln_resource_kind_mask : uint32_t {
  MLN_RESOURCE_KIND_MASK_UNKNOWN = 1U << MLN_RESOURCE_KIND_UNKNOWN,
  MLN_RESOURCE_KIND_MASK_STYLE = 1U << MLN_RESOURCE_KIND_STYLE,
  MLN_RESOURCE_KIND_MASK_SOURCE = 1U << MLN_RESOURCE_KIND_SOURCE,
  MLN_RESOURCE_KIND_MASK_TILE = 1U << MLN_RESOURCE_KIND_TILE,
  MLN_RESOURCE_KIND_MASK_GLYPHS = 1U << MLN_RESOURCE_KIND_GLYPHS,
  MLN_RESOURCE_KIND_MASK_SPRITE_IMAGE = 1U << MLN_RESOURCE_KIND_SPRITE_IMAGE,
  MLN_RESOURCE_KIND_MASK_SPRITE_JSON = 1U << MLN_RESOURCE_KIND_SPRITE_JSON,
  MLN_RESOURCE_KIND_MASK_IMAGE = 1U << MLN_RESOURCE_KIND_IMAGE,
  MLN_RESOURCE_KIND_MASK_ALL = MLN_RESOURCE_KIND_MASK_UNKNOWN |
    MLN_RESOURCE_KIND_MASK_STYLE | MLN_RESOURCE_KIND_MASK_SOURCE |
    MLN_RESOURCE_KIND_MASK_TILE | MLN_RESOURCE_KIND_MASK_GLYPHS |
    MLN_RESOURCE_KIND_MASK_SPRITE_IMAGE | MLN_RESOURCE_KIND_MASK_SPRITE_JSON |
    MLN_RESOURCE_KIND_MASK_IMAGE,
} mln_resource_kind_mask;
 
// This block uses line comments because its examples contain URL patterns that
// a block comment cannot carry.

typedef enum MLN_BINDING("kind=bitmask") mln_url_match_flags : uint32_t {
  MLN_URL_MATCH_EXACT = 0U,
  MLN_URL_MATCH_GLOB = 1U << 0U,
} mln_url_match_flags;

typedef struct mln_resource_route {
  uint32_t kinds MLN_BINDING("enum=mln_resource_kind_mask");
  uint32_t flags MLN_BINDING("enum=mln_url_match_flags");
  mln_buffer_view url;
} mln_resource_route;

MLN_API mln_resource_route mln_resource_route_default(void) MLN_NOEXCEPT;

typedef struct mln_http_header {
  mln_buffer_view name;
  mln_buffer_view value;
} mln_http_header;

typedef struct mln_http_header_rule {
  uint32_t kinds MLN_BINDING("enum=mln_resource_kind_mask");
  uint32_t flags MLN_BINDING("enum=mln_url_match_flags");
  mln_buffer_view url;
  const mln_http_header* headers MLN_BINDING("length=header_count");
  size_t header_count;
} mln_http_header_rule;

MLN_API mln_http_header_rule mln_http_header_rule_default(void) MLN_NOEXCEPT;

MLN_BINDING("delivery=MLN_DELIVERY_TYPE_RESOURCE_TRANSFORM")
typedef void (*mln_resource_transform_callback)(
  void* user_data, uint32_t kind MLN_BINDING("enum=mln_resource_kind"),
  const char* url,
  mln_resource_transform_request request MLN_BINDING("ownership=owned")
);

typedef struct mln_resource_transform {
  uint32_t size;
  mln_resource_transform_callback callback;
  void* user_data MLN_BINDING("kind=context");
  mln_user_data_release release_user_data;
  mln_delivery_queue queue MLN_BINDING("kind=delivery_queue");
} mln_resource_transform MLN_BINDING(
  "kind=callback_registration;release=release_user_data"
);
 
typedef struct mln_http_header_transform_response {
  uint32_t size;
  void* context MLN_BINDING("kind=context;lifetime=call");
} mln_http_header_transform_response MLN_BINDING("kind=callback_response");

MLN_API mln_status mln_http_header_transform_response_set_header(
  mln_http_header_transform_response* response, mln_buffer_view name,
  mln_buffer_view value, mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_BINDING("failure=MLN_STATUS_NATIVE_ERROR")
typedef mln_status (*mln_http_header_transform_callback)(
  void* user_data, uint32_t kind MLN_BINDING("enum=mln_resource_kind"),
  const char* url,
  mln_http_header_transform_response* out_response MLN_BINDING("direction=out")
);

typedef struct mln_http_header_transform {
  uint32_t size;
  mln_http_header_transform_callback callback MLN_BINDING("nullable=true");
  void* user_data MLN_BINDING("kind=context");
  mln_user_data_release release_user_data;
  const mln_http_header_rule* rules MLN_BINDING("length=rule_count");
  size_t rule_count;
} mln_http_header_transform MLN_BINDING(
  "kind=callback_registration;release=release_user_data"
);

typedef struct mln_resource_range {
  uint64_t start;
  uint64_t end;
} mln_resource_range;

typedef enum MLN_BINDING("kind=bitmask") mln_resource_request_field : uint32_t {
  MLN_RESOURCE_REQUEST_RANGE = 1U << 0U,
  MLN_RESOURCE_REQUEST_PRIOR_MODIFIED = 1U << 1U,
  MLN_RESOURCE_REQUEST_PRIOR_EXPIRES = 1U << 2U,
} mln_resource_request_field;
 
typedef struct mln_resource_request_info {
  uint32_t size;
  uint32_t fields MLN_BINDING("enum=mln_resource_request_field");
  const char* requested_url MLN_BINDING("nullable=true");
  const char* resolved_url MLN_BINDING("nullable=true");
  uint32_t kind MLN_BINDING("enum=mln_resource_kind");
  uint32_t loading_method MLN_BINDING("enum=mln_resource_loading_method");
  uint32_t priority MLN_BINDING("enum=mln_resource_priority");
  uint32_t usage MLN_BINDING("enum=mln_resource_usage");
  uint32_t storage_policy MLN_BINDING("enum=mln_resource_storage_policy");
  mln_resource_range range
    MLN_BINDING("mask=fields;bit=MLN_RESOURCE_REQUEST_RANGE");
  int64_t prior_modified_unix_ms
    MLN_BINDING("mask=fields;bit=MLN_RESOURCE_REQUEST_PRIOR_MODIFIED");
  int64_t prior_expires_unix_ms
    MLN_BINDING("mask=fields;bit=MLN_RESOURCE_REQUEST_PRIOR_EXPIRES");
  const char* prior_etag MLN_BINDING("nullable=true");
  const uint8_t* prior_data
    MLN_BINDING("length=prior_data_size;encoding=bytes");
  size_t prior_data_size;
} mln_resource_request_info;

typedef enum MLN_BINDING(
  "kind=bitmask"
) mln_resource_response_field : uint32_t {
  MLN_RESOURCE_RESPONSE_MODIFIED = 1U << 0U,
  MLN_RESOURCE_RESPONSE_EXPIRES = 1U << 1U,
  MLN_RESOURCE_RESPONSE_RETRY_AFTER = 1U << 2U,
} mln_resource_response_field;

typedef struct mln_resource_response {
  uint32_t size;
  uint32_t fields MLN_BINDING("enum=mln_resource_response_field");
  uint32_t status MLN_BINDING("enum=mln_resource_response_status");
  uint32_t error_reason MLN_BINDING("enum=mln_resource_error_reason");
  const uint8_t* bytes MLN_BINDING("length=byte_count;encoding=bytes");
  size_t byte_count;
  mln_buffer_view error_message MLN_BINDING("optional=empty");
  bool must_revalidate;
  int64_t modified_unix_ms
    MLN_BINDING("mask=fields;bit=MLN_RESOURCE_RESPONSE_MODIFIED");
  int64_t expires_unix_ms
    MLN_BINDING("mask=fields;bit=MLN_RESOURCE_RESPONSE_EXPIRES");
  mln_buffer_view etag MLN_BINDING("optional=empty");
  int64_t retry_after_unix_ms
    MLN_BINDING("mask=fields;bit=MLN_RESOURCE_RESPONSE_RETRY_AFTER");
} mln_resource_response;

MLN_BINDING(
  "enum=mln_resource_provider_decision;"
  "failure=4294967295;"
  "delivery=MLN_DELIVERY_TYPE_RESOURCE_REQUEST;"
  "decision_handle=handle;"
  "decision_accept=MLN_RESOURCE_PROVIDER_DECISION_HANDLE"
)
typedef uint32_t (*mln_resource_provider_callback)(
  void* user_data, const mln_resource_request_info* request,
  mln_resource_request handle
);

MLN_BINDING(
  "delivery=MLN_DELIVERY_TYPE_RESOURCE_REQUEST_CANCEL;"
  "borrowed_owner=handle"
)
typedef void (*mln_resource_request_cancel_callback)(
  void* user_data, mln_resource_request handle
);

typedef struct mln_resource_request_cancel_handler {
  uint32_t size;
  mln_resource_request_cancel_callback callback;
  void* user_data MLN_BINDING("kind=context");
  mln_user_data_release release_user_data;
  mln_delivery_queue queue MLN_BINDING("kind=delivery_queue");
} mln_resource_request_cancel_handler MLN_BINDING(
  "kind=callback_registration;release=release_user_data"
);

typedef struct mln_resource_provider {
  uint32_t size;
  mln_resource_provider_callback callback;
  void* user_data MLN_BINDING("kind=context");
  mln_user_data_release release_user_data;
  mln_delivery_queue queue MLN_BINDING("kind=delivery_queue");
  const mln_resource_route* routes MLN_BINDING("length=route_count");
  size_t route_count;
} mln_resource_provider MLN_BINDING(
  "kind=callback_registration;release=release_user_data"
);

MLN_API mln_runtime_options mln_runtime_options_default(void) MLN_NOEXCEPT;

MLN_BINDING("blocks=thread_start")
MLN_API mln_status mln_runtime_create(
  const mln_runtime_options* options,
  mln_runtime* out_runtime MLN_BINDING("direction=out"),
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_BINDING("execution=operation")
MLN_API mln_status mln_runtime_set_resource_provider(
  mln_runtime runtime, const mln_resource_provider* provider,
  const mln_completion* completion, mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_BINDING("execution=operation")
MLN_API mln_status mln_runtime_clear_resource_provider(
  mln_runtime runtime, const mln_completion* completion,
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_API mln_status mln_resource_request_complete(
  mln_resource_request handle, const mln_resource_response* response,
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_API mln_status mln_resource_request_pass_through(
  mln_resource_request handle, mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_API mln_status mln_resource_request_is_cancelled(
  mln_resource_request handle, bool* out_cancelled MLN_BINDING("direction=out"),
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_BINDING("accepted_unless=out_cancelled")
MLN_API mln_status mln_resource_request_set_cancel_callback(
  mln_resource_request handle,
  const mln_resource_request_cancel_handler* handler,
  bool* out_cancelled MLN_BINDING("direction=out"),
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_API void mln_resource_request_release(
  mln_resource_request handle
) MLN_NOEXCEPT;

MLN_BINDING("execution=operation")
MLN_API mln_status mln_runtime_set_resource_transform(
  mln_runtime runtime, const mln_resource_transform* transform,
  const mln_completion* completion, mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_BINDING("execution=operation")
MLN_API mln_status mln_runtime_clear_resource_transform(
  mln_runtime runtime, const mln_completion* completion,
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_API mln_status mln_resource_transform_request_complete(
  mln_resource_transform_request request, mln_buffer_view url,
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_API void mln_resource_transform_request_release(
  mln_resource_transform_request request
) MLN_NOEXCEPT;

MLN_BINDING("execution=operation")
MLN_API mln_status mln_runtime_set_http_header_transform(
  mln_runtime runtime, const mln_http_header_transform* transform,
  const mln_completion* completion, mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_BINDING("execution=operation")
MLN_API mln_status mln_runtime_clear_http_header_transform(
  mln_runtime runtime, const mln_completion* completion,
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_BINDING("execution=operation")
MLN_API mln_status mln_runtime_run_ambient_cache_operation(
  mln_runtime runtime,
  uint32_t operation MLN_BINDING("enum=mln_ambient_cache_operation"),
  const mln_completion* completion, mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_BINDING("execution=operation")
MLN_API mln_status mln_runtime_set_maximum_ambient_cache_size(
  mln_runtime runtime, uint64_t size, const mln_completion* completion,
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_BINDING("execution=lifecycle")
MLN_API mln_status mln_runtime_release(
  mln_runtime runtime, const mln_completion* completion,
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_API mln_status mln_runtime_dispose(
  mln_runtime runtime, mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_BINDING("execution=operation")
MLN_API mln_status mln_runtime_set_event_handler(
  mln_runtime runtime, const mln_runtime_event_handler* handler,
  const mln_completion* completion, mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_BINDING("execution=operation")
MLN_API mln_status mln_runtime_clear_event_handler(
  mln_runtime runtime, const mln_completion* completion,
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_API mln_status mln_runtime_set_event_mask(
  mln_runtime runtime, uint64_t mask MLN_BINDING("enum=mln_runtime_event_mask"),
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;

MLN_API mln_status mln_runtime_get_event_mask(
  mln_runtime runtime,
  uint64_t* out_mask MLN_BINDING("direction=out;enum=mln_runtime_event_mask"),
  mln_diagnostic* out_diagnostic
) MLN_NOEXCEPT;
 
#ifdef __cplusplus
}
#endif
 
#endif  // MAPLIBRE_NATIVE_C_RUNTIME_H