text: #ifndef WASMER_H
  #define WASMER_H
  
  #include <stdarg.h>
  #include <stdbool.h>
  #include <stdint.h>
  #include <stdlib.h>
  
  /**
   * List of export/import kinds.
   */
  enum wasmer_import_export_kind {
    WASM_FUNCTION,
    WASM_GLOBAL,
    WASM_MEMORY,
    WASM_TABLE,
  };
  typedef uint32_t wasmer_import_export_kind;
  
  typedef enum {
    WASMER_OK = 1,
    WASMER_ERROR = 2,
  } wasmer_result_t;
  
  enum wasmer_value_tag {
    WASM_I32,
    WASM_I64,
    WASM_F32,
    WASM_F64,
  };
  typedef uint32_t wasmer_value_tag;
  
  typedef struct {
  
  } wasmer_module_t;
  
  /**
   * Opaque pointer to `NamedExportDescriptor`.
   */
  typedef struct {
  
  } wasmer_export_descriptor_t;
  
  typedef struct {
    const uint8_t *bytes;
    uint32_t bytes_len;
  } wasmer_byte_array;
  
  /**
   * Opaque pointer to `NamedExportDescriptors`.
   */
  typedef struct {
  
  } wasmer_export_descriptors_t;
  
  /**
   * Opaque pointer to `wasmer_export_t`.
   */
  typedef struct {
  
  } wasmer_export_func_t;
  
  typedef union {
    int32_t I32;
    int64_t I64;
    float F32;
    double F64;
  } wasmer_value;
  
  typedef struct {
    wasmer_value_tag tag;
    wasmer_value value;
  } wasmer_value_t;
  
  /**
   * Opaque pointer to `NamedExport`.
   */
  typedef struct {
  
  } wasmer_export_t;
  
  typedef struct {
  
  } wasmer_memory_t;
  
  /**
   * Opaque pointer to `NamedExports`.
   */
  typedef struct {
  
  } wasmer_exports_t;
  
  typedef struct {
  
  } wasmer_global_t;
  
  typedef struct {
    bool mutable_;
    wasmer_value_tag kind;
  } wasmer_global_descriptor_t;
  
  typedef struct {
  
  } wasmer_import_descriptor_t;
  
  typedef struct {
  
  } wasmer_import_descriptors_t;
  
  typedef struct {
  
  } wasmer_import_func_t;
  
  typedef struct {
  
  } wasmer_import_object_t;
  
  typedef struct {
  
  } wasmer_table_t;
  
  /**
   * Union of import/export value.
   */
  typedef union {
    const wasmer_import_func_t *func;
    const wasmer_table_t *table;
    const wasmer_memory_t *memory;
    const wasmer_global_t *global;
  } wasmer_import_export_value;
  
  typedef struct {
    wasmer_byte_array module_name;
    wasmer_byte_array import_name;
    wasmer_import_export_kind tag;
    wasmer_import_export_value value;
  } wasmer_import_t;
  
  typedef struct {
  
  } wasmer_instance_t;
  
  typedef struct {
  
  } wasmer_instance_context_t;
  
  typedef struct {
    bool has_some;
    uint32_t some;
  } wasmer_limit_option_t;
  
  typedef struct {
    uint32_t min;
    wasmer_limit_option_t max;
  } wasmer_limits_t;
  
  typedef struct {
  
  } wasmer_serialized_module_t;
  
  typedef struct {
  
  } wasmer_trampoline_buffer_builder_t;
  
  typedef struct {
  
  } wasmer_trampoline_callable_t;
  
  typedef struct {
  
  } wasmer_trampoline_buffer_t;
  
  /**
   * Creates a new Module from the given wasm bytes.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_compile(wasmer_module_t **module,
                                 uint8_t *wasm_bytes,
                                 uint32_t wasm_bytes_len);
  
  /**
   * Gets export descriptor kind
   */
  wasmer_import_export_kind wasmer_export_descriptor_kind(wasmer_export_descriptor_t *export_);
  
  /**
   * Gets name for the export descriptor
   */
  wasmer_byte_array wasmer_export_descriptor_name(wasmer_export_descriptor_t *export_descriptor);
  
  /**
   * Gets export descriptors for the given module
   *
   * The caller owns the object and should call `wasmer_export_descriptors_destroy` to free it.
   */
  void wasmer_export_descriptors(const wasmer_module_t *module,
                                 wasmer_export_descriptors_t **export_descriptors);
  
  /**
   * Frees the memory for the given export descriptors
   */
  void wasmer_export_descriptors_destroy(wasmer_export_descriptors_t *export_descriptors);
  
  /**
   * Gets export descriptor by index
   */
  wasmer_export_descriptor_t *wasmer_export_descriptors_get(wasmer_export_descriptors_t *export_descriptors,
                                                            int idx);
  
  /**
   * Gets the length of the export descriptors
   */
  int wasmer_export_descriptors_len(wasmer_export_descriptors_t *exports);
  
  /**
   * Calls a `func` with the provided parameters.
   * Results are set using the provided `results` pointer.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_export_func_call(const wasmer_export_func_t *func,
                                          const wasmer_value_t *params,
                                          unsigned int params_len,
                                          wasmer_value_t *results,
                                          unsigned int results_len);
  
  /**
   * Sets the params buffer to the parameter types of the given wasmer_export_func_t
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_export_func_params(const wasmer_export_func_t *func,
                                            wasmer_value_tag *params,
                                            uint32_t params_len);
  
  /**
   * Sets the result parameter to the arity of the params of the wasmer_export_func_t
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_export_func_params_arity(const wasmer_export_func_t *func, uint32_t *result);
  
  /**
   * Sets the returns buffer to the parameter types of the given wasmer_export_func_t
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_export_func_returns(const wasmer_export_func_t *func,
                                             wasmer_value_tag *returns,
                                             uint32_t returns_len);
  
  /**
   * Sets the result parameter to the arity of the returns of the wasmer_export_func_t
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_export_func_returns_arity(const wasmer_export_func_t *func,
                                                   uint32_t *result);
  
  /**
   * Gets wasmer_export kind
   */
  wasmer_import_export_kind wasmer_export_kind(wasmer_export_t *export_);
  
  /**
   * Gets name from wasmer_export
   */
  wasmer_byte_array wasmer_export_name(wasmer_export_t *export_);
  
  /**
   * Gets export func from export
   */
  const wasmer_export_func_t *wasmer_export_to_func(const wasmer_export_t *export_);
  
  /**
   * Gets a memory pointer from an export pointer.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_export_to_memory(const wasmer_export_t *export_, wasmer_memory_t **memory);
  
  /**
   * Frees the memory for the given exports
   */
  void wasmer_exports_destroy(wasmer_exports_t *exports);
  
  /**
   * Gets wasmer_export by index
   */
  wasmer_export_t *wasmer_exports_get(wasmer_exports_t *exports, int idx);
  
  /**
   * Gets the length of the exports
   */
  int wasmer_exports_len(wasmer_exports_t *exports);
  
  /**
   * Frees memory for the given Global
   */
  void wasmer_global_destroy(wasmer_global_t *global);
  
  /**
   * Gets the value stored by the given Global
   */
  wasmer_value_t wasmer_global_get(wasmer_global_t *global);
  
  /**
   * Returns a descriptor (type, mutability) of the given Global
   */
  wasmer_global_descriptor_t wasmer_global_get_descriptor(wasmer_global_t *global);
  
  /**
   * Creates a new Global and returns a pointer to it.
   * The caller owns the object and should call `wasmer_global_destroy` to free it.
   */
  wasmer_global_t *wasmer_global_new(wasmer_value_t value, bool mutable_);
  
  /**
   * Sets the value stored by the given Global
   */
  void wasmer_global_set(wasmer_global_t *global, wasmer_value_t value);
  
  /**
   * Gets export descriptor kind
   */
  wasmer_import_export_kind wasmer_import_descriptor_kind(wasmer_import_descriptor_t *export_);
  
  /**
   * Gets module name for the import descriptor
   */
  wasmer_byte_array wasmer_import_descriptor_module_name(wasmer_import_descriptor_t *import_descriptor);
  
  /**
   * Gets name for the import descriptor
   */
  wasmer_byte_array wasmer_import_descriptor_name(wasmer_import_descriptor_t *import_descriptor);
  
  /**
   * Gets import descriptors for the given module
   *
   * The caller owns the object and should call `wasmer_import_descriptors_destroy` to free it.
   */
  void wasmer_import_descriptors(const wasmer_module_t *module,
                                 wasmer_import_descriptors_t **import_descriptors);
  
  /**
   * Frees the memory for the given import descriptors
   */
  void wasmer_import_descriptors_destroy(wasmer_import_descriptors_t *import_descriptors);
  
  /**
   * Gets import descriptor by index
   */
  wasmer_import_descriptor_t *wasmer_import_descriptors_get(wasmer_import_descriptors_t *import_descriptors,
                                                            unsigned int idx);
  
  /**
   * Gets the length of the import descriptors
   */
  unsigned int wasmer_import_descriptors_len(wasmer_import_descriptors_t *exports);
  
  /**
   * Frees memory for the given Func
   */
  void wasmer_import_func_destroy(wasmer_import_func_t *func);
  
  /**
   * Creates new func
   *
   * The caller owns the object and should call `wasmer_import_func_destroy` to free it.
   */
  wasmer_import_func_t *wasmer_import_func_new(void (*func)(void *data),
                                               const wasmer_value_tag *params,
                                               unsigned int params_len,
                                               const wasmer_value_tag *returns,
                                               unsigned int returns_len);
  
  /**
   * Sets the params buffer to the parameter types of the given wasmer_import_func_t
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_import_func_params(const wasmer_import_func_t *func,
                                            wasmer_value_tag *params,
                                            unsigned int params_len);
  
  /**
   * Sets the result parameter to the arity of the params of the wasmer_import_func_t
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_import_func_params_arity(const wasmer_import_func_t *func, uint32_t *result);
  
  /**
   * Sets the returns buffer to the parameter types of the given wasmer_import_func_t
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_import_func_returns(const wasmer_import_func_t *func,
                                             wasmer_value_tag *returns,
                                             unsigned int returns_len);
  
  /**
   * Sets the result parameter to the arity of the returns of the wasmer_import_func_t
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_import_func_returns_arity(const wasmer_import_func_t *func,
                                                   uint32_t *result);
  
  /**
   * Frees memory of the given ImportObject
   */
  void wasmer_import_object_destroy(wasmer_import_object_t *import_object);
  
  /**
   * Extends an existing import object with new imports
   */
  wasmer_result_t wasmer_import_object_extend(wasmer_import_object_t *import_object,
                                              wasmer_import_t *imports,
                                              unsigned int imports_len);
  
  /**
   * Creates a new empty import object.
   * See also `wasmer_import_object_append`
   */
  wasmer_import_object_t *wasmer_import_object_new(void);
  
  /**
   * Calls an instances exported function by `name` with the provided parameters.
   * Results are set using the provided `results` pointer.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_instance_call(wasmer_instance_t *instance,
                                       const char *name,
                                       const wasmer_value_t *params,
                                       uint32_t params_len,
                                       wasmer_value_t *results,
                                       uint32_t results_len);
  
  /**
   * Gets the `data` field within the context.
   */
  void *wasmer_instance_context_data_get(const wasmer_instance_context_t *ctx);
  
  /**
   * Sets the `data` field of the instance context. This context will be
   * passed to all imported function for instance.
   */
  void wasmer_instance_context_data_set(wasmer_instance_t *instance, void *data_ptr);
  
  /**
   * Extracts the instance's context and returns it.
   */
  const wasmer_instance_context_t *wasmer_instance_context_get(wasmer_instance_t *instance);
  
  /**
   * Gets the memory within the context at the index `memory_idx`.
   * The index is always 0 until multiple memories are supported.
   */
  const wasmer_memory_t *wasmer_instance_context_memory(const wasmer_instance_context_t *ctx,
                                                        uint32_t _memory_idx);
  
  /**
   * Frees memory for the given Instance
   */
  void wasmer_instance_destroy(wasmer_instance_t *instance);
  
  /**
   * Gets Exports for the given instance
   *
   * The caller owns the object and should call `wasmer_exports_destroy` to free it.
   */
  void wasmer_instance_exports(wasmer_instance_t *instance, wasmer_exports_t **exports);
  
  /**
   * Creates a new Instance from the given wasm bytes and imports.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_instantiate(wasmer_instance_t **instance,
                                     uint8_t *wasm_bytes,
                                     uint32_t wasm_bytes_len,
                                     wasmer_import_t *imports,
                                     int imports_len);
  
  /**
   * Gets the length in bytes of the last error.
   * This can be used to dynamically allocate a buffer with the correct number of
   * bytes needed to store a message.
   *
   * # Example
   *
   * ```c
   * int error_len = wasmer_last_error_length();
   * char *error_str = malloc(error_len);
   * ```
   */
  int wasmer_last_error_length(void);
  
  /**
   * Stores the last error message into the provided buffer up to the given `length`.
   * The `length` parameter must be large enough to store the last error message.
   *
   * Returns the length of the string in bytes.
   * Returns `-1` if an error occurs.
   *
   * # Example
   *
   * ```c
   * int error_len = wasmer_last_error_length();
   * char *error_str = malloc(error_len);
   * wasmer_last_error_message(error_str, error_len);
   * printf("Error str: `%s`\n", error_str);
   * ```
   */
  int wasmer_last_error_message(char *buffer, int length);
  
  /**
   * Gets the start pointer to the bytes within a Memory
   */
  uint8_t *wasmer_memory_data(const wasmer_memory_t *mem);
  
  /**
   * Gets the size in bytes of a Memory
   */
  uint32_t wasmer_memory_data_length(wasmer_memory_t *mem);
  
  /**
   * Frees memory for the given Memory
   */
  void wasmer_memory_destroy(wasmer_memory_t *memory);
  
  /**
   * Grows a Memory by the given number of pages.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_memory_grow(wasmer_memory_t *memory, uint32_t delta);
  
  /**
   * Returns the current length in pages of the given memory
   */
  uint32_t wasmer_memory_length(const wasmer_memory_t *memory);
  
  /**
   * Creates a new Memory for the given descriptor and initializes the given
   * pointer to pointer to a pointer to the new memory.
   *
   * The caller owns the object and should call `wasmer_memory_destroy` to free it.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_memory_new(wasmer_memory_t **memory, wasmer_limits_t limits);
  
  /**
   * Deserialize the given serialized module.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_module_deserialize(wasmer_module_t **module,
                                            const wasmer_serialized_module_t *serialized_module);
  
  /**
   * Frees memory for the given Module
   */
  void wasmer_module_destroy(wasmer_module_t *module);
  
  /**
   * Given:
   * * A prepared `wasmer` import-object
   * * A compiled wasmer module
   *
   * Instantiates a wasmer instance
   */
  wasmer_result_t wasmer_module_import_instantiate(wasmer_instance_t **instance,
                                                   const wasmer_module_t *module,
                                                   const wasmer_import_object_t *import_object);
  
  /**
   * Creates a new Instance from the given module and imports.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_module_instantiate(const wasmer_module_t *module,
                                            wasmer_instance_t **instance,
                                            wasmer_import_t *imports,
                                            int imports_len);
  
  /**
   * Serialize the given Module.
   *
   * The caller owns the object and should call `wasmer_serialized_module_destroy` to free it.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_module_serialize(wasmer_serialized_module_t **serialized_module,
                                          const wasmer_module_t *module);
  
  /**
   * Get bytes of the serialized module.
   */
  wasmer_byte_array wasmer_serialized_module_bytes(const wasmer_serialized_module_t *serialized_module);
  
  /**
   * Frees memory for the given serialized Module.
   */
  void wasmer_serialized_module_destroy(wasmer_serialized_module_t *serialized_module);
  
  /**
   * Transform a sequence of bytes into a serialized module.
   *
   * The caller owns the object and should call `wasmer_serialized_module_destroy` to free it.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_serialized_module_from_bytes(wasmer_serialized_module_t **serialized_module,
                                                      const uint8_t *serialized_module_bytes,
                                                      uint32_t serialized_module_bytes_length);
  
  /**
   * Frees memory for the given Table
   */
  void wasmer_table_destroy(wasmer_table_t *table);
  
  /**
   * Grows a Table by the given number of elements.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_table_grow(wasmer_table_t *table, uint32_t delta);
  
  /**
   * Returns the current length of the given Table
   */
  uint32_t wasmer_table_length(wasmer_table_t *table);
  
  /**
   * Creates a new Table for the given descriptor and initializes the given
   * pointer to pointer to a pointer to the new Table.
   *
   * The caller owns the object and should call `wasmer_table_destroy` to free it.
   *
   * Returns `wasmer_result_t::WASMER_OK` upon success.
   *
   * Returns `wasmer_result_t::WASMER_ERROR` upon failure. Use `wasmer_last_error_length`
   * and `wasmer_last_error_message` to get an error message.
   */
  wasmer_result_t wasmer_table_new(wasmer_table_t **table, wasmer_limits_t limits);
  
  /**
   * Adds a callinfo trampoline to the builder.
   */
  uintptr_t wasmer_trampoline_buffer_builder_add_callinfo_trampoline(wasmer_trampoline_buffer_builder_t *builder,
                                                                     const wasmer_trampoline_callable_t *func,
                                                                     const void *ctx,
                                                                     uint32_t num_params);
  
  /**
   * Adds a context trampoline to the builder.
   */
  uintptr_t wasmer_trampoline_buffer_builder_add_context_trampoline(wasmer_trampoline_buffer_builder_t *builder,
                                                                    const wasmer_trampoline_callable_t *func,
                                                                    const void *ctx);
  
  /**
   * Finalizes the trampoline builder into an executable buffer.
   */
  wasmer_trampoline_buffer_t *wasmer_trampoline_buffer_builder_build(wasmer_trampoline_buffer_builder_t *builder);
  
  /**
   * Creates a new trampoline builder.
   */
  wasmer_trampoline_buffer_builder_t *wasmer_trampoline_buffer_builder_new(void);
  
  /**
   * Destroys the trampoline buffer if not null.
   */
  void wasmer_trampoline_buffer_destroy(wasmer_trampoline_buffer_t *buffer);
  
  /**
   * Returns the callable pointer for the trampoline with index `idx`.
   */
  const wasmer_trampoline_callable_t *wasmer_trampoline_buffer_get_trampoline(const wasmer_trampoline_buffer_t *buffer,
                                                                              uintptr_t idx);
  
  /**
   * Returns the context added by `add_context_trampoline`, from within the callee function.
   */
  void *wasmer_trampoline_get_context(void);
  
  /**
   * Returns true for valid wasm bytes and false for invalid bytes
   */
  bool wasmer_validate(const uint8_t *wasm_bytes, uint32_t wasm_bytes_len);
  
  #endif /* WASMER_H */
  