6448410382

Committed 08 Oct 2023 03:12PM UTC coverage: 72.768% (+1.6%) from 71.197%

Build # 6448410382

Build Type

Pull #14

github

Committed by

juancastillo0

Commit Message

use flutter example assets for wasi and threads tests

Pull Request Pull Request #14: Wit component generator package release

Run Details

128 of 128 new or added lines in 9 files covered. (100.0%)

2103 of 2890 relevant lines covered (72.77%)

1.66 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.6

/packages/wasm_run/lib/src/bridge_generated.io.dart

// AUTO GENERATED FILE, DO NOT EDIT.
// Generated by `flutter_rust_bridge`@ 1.82.1.
// ignore_for_file: non_constant_identifier_names, unused_element, duplicate_ignore, directives_ordering, curly_braces_in_flow_control_structures, unnecessary_lambdas, slash_for_doc_comments, prefer_const_literals_to_create_immutables, implicit_dynamic_list_literal, duplicate_import, unused_import, unnecessary_import, prefer_single_quotes, prefer_const_constructors, use_super_parameters, always_use_package_imports, annotate_overrides, invalid_use_of_protected_member, constant_identifier_names, invalid_use_of_internal_member, prefer_is_empty, unnecessary_const

import 'dart:convert';
import 'dart:async';
import 'package:meta/meta.dart';
import 'package:flutter_rust_bridge/flutter_rust_bridge.dart';
import 'bridge_generated.dart';
export 'bridge_generated.dart';
import 'dart:ffi' as ffi;

class WasmRunDartPlatform extends FlutterRustBridgeBase<WasmRunDartWire> {
  WasmRunDartPlatform(ffi.DynamicLibrary dylib) : super(WasmRunDartWire(dylib));

// Section: api2wire

  @protected
  wire_ArcRwLockSharedMemory api2wire_ArcRwLockSharedMemory(
      ArcRwLockSharedMemory raw) {
    final ptr = inner.new_ArcRwLockSharedMemory();
    _api_fill_to_wire_ArcRwLockSharedMemory(raw, ptr);
    return ptr;
  }

  @protected
  wire_ArcStdSyncMutexModule api2wire_ArcStdSyncMutexModule(
      ArcStdSyncMutexModule raw) {
    final ptr = inner.new_ArcStdSyncMutexModule();
    _api_fill_to_wire_ArcStdSyncMutexModule(raw, ptr);
    return ptr;
  }

  @protected
  wire_CallStack api2wire_CallStack(CallStack raw) {
    final ptr = inner.new_CallStack();
    _api_fill_to_wire_CallStack(raw, ptr);
    return ptr;
  }

  @protected
  wire_Global api2wire_Global(Global raw) {
    final ptr = inner.new_Global();
    _api_fill_to_wire_Global(raw, ptr);
    return ptr;
  }

  @protected
  wire_Memory api2wire_Memory(Memory raw) {
    final ptr = inner.new_Memory();
    _api_fill_to_wire_Memory(raw, ptr);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_uint_8_list> api2wire_String(String raw) {
    return api2wire_uint_8_list(utf8.encoder.convert(raw));
  }

  @protected
  ffi.Pointer<wire_StringList> api2wire_StringList(List<String> raw) {
    final ans = inner.new_StringList_0(raw.length);
    for (var i = 0; i < raw.length; i++) {
      ans.ref.ptr[i] = api2wire_String(raw[i]);
    }
    return ans;
  }

  @protected
  wire_Table api2wire_Table(Table raw) {
    final ptr = inner.new_Table();
    _api_fill_to_wire_Table(raw, ptr);
    return ptr;
  }

  @protected
  wire_WFunc api2wire_WFunc(WFunc raw) {
    final ptr = inner.new_WFunc();
    _api_fill_to_wire_WFunc(raw, ptr);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_WFunc> api2wire_box_autoadd_WFunc(WFunc raw) {
    final ptr = inner.new_box_autoadd_WFunc_0();
    _api_fill_to_wire_WFunc(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_Atomics> api2wire_box_autoadd_atomics(Atomics raw) {
    final ptr = inner.new_box_autoadd_atomics_0();
    _api_fill_to_wire_atomics(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<ffi.Bool> api2wire_box_autoadd_bool(bool raw) {
    return inner.new_box_autoadd_bool_0(api2wire_bool(raw));
  }

  @protected
  ffi.Pointer<wire_CompiledModule> api2wire_box_autoadd_compiled_module(
      CompiledModule raw) {
    final ptr = inner.new_box_autoadd_compiled_module_0();
    _api_fill_to_wire_compiled_module(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_MemoryTy> api2wire_box_autoadd_memory_ty(MemoryTy raw) {
    final ptr = inner.new_box_autoadd_memory_ty_0();
    _api_fill_to_wire_memory_ty(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_ModuleConfig> api2wire_box_autoadd_module_config(
      ModuleConfig raw) {
    final ptr = inner.new_box_autoadd_module_config_0();
    _api_fill_to_wire_module_config(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_ModuleConfigWasmi> api2wire_box_autoadd_module_config_wasmi(
      ModuleConfigWasmi raw) {
    final ptr = inner.new_box_autoadd_module_config_wasmi_0();
    _api_fill_to_wire_module_config_wasmi(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_ModuleConfigWasmtime>
      api2wire_box_autoadd_module_config_wasmtime(ModuleConfigWasmtime raw) {
    final ptr = inner.new_box_autoadd_module_config_wasmtime_0();
    _api_fill_to_wire_module_config_wasmtime(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_TableArgs> api2wire_box_autoadd_table_args(TableArgs raw) {
    final ptr = inner.new_box_autoadd_table_args_0();
    _api_fill_to_wire_table_args(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<ffi.Uint32> api2wire_box_autoadd_u32(int raw) {
    return inner.new_box_autoadd_u32_0(api2wire_u32(raw));
  }

  @protected
  ffi.Pointer<ffi.Uint64> api2wire_box_autoadd_u64(int raw) {
    return inner.new_box_autoadd_u64_0(api2wire_u64(raw));
  }

  @protected
  ffi.Pointer<ffi.UintPtr> api2wire_box_autoadd_usize(int raw) {
    return inner.new_box_autoadd_usize_0(api2wire_usize(raw));
  }

  @protected
  ffi.Pointer<wire_WasiConfigNative> api2wire_box_autoadd_wasi_config_native(
      WasiConfigNative raw) {
    final ptr = inner.new_box_autoadd_wasi_config_native_0();
    _api_fill_to_wire_wasi_config_native(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_WasiStackLimits> api2wire_box_autoadd_wasi_stack_limits(
      WasiStackLimits raw) {
    final ptr = inner.new_box_autoadd_wasi_stack_limits_0();
    _api_fill_to_wire_wasi_stack_limits(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_WasmRunInstanceId> api2wire_box_autoadd_wasm_run_instance_id(
      WasmRunInstanceId raw) {
    final ptr = inner.new_box_autoadd_wasm_run_instance_id_0();
    _api_fill_to_wire_wasm_run_instance_id(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_WasmRunModuleId> api2wire_box_autoadd_wasm_run_module_id(
      WasmRunModuleId raw) {
    final ptr = inner.new_box_autoadd_wasm_run_module_id_0();
    _api_fill_to_wire_wasm_run_module_id(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_WasmRunSharedMemory>
      api2wire_box_autoadd_wasm_run_shared_memory(WasmRunSharedMemory raw) {
    final ptr = inner.new_box_autoadd_wasm_run_shared_memory_0();
    _api_fill_to_wire_wasm_run_shared_memory(raw, ptr.ref);
    return ptr;
  }

  @protected
  ffi.Pointer<wire_WasmVal> api2wire_box_autoadd_wasm_val(WasmVal raw) {
    final ptr = inner.new_box_autoadd_wasm_val_0();
    _api_fill_to_wire_wasm_val(raw, ptr.ref);
    return ptr;
  }

  @protected
  int api2wire_i64(int raw) {
    return raw;
  }

  @protected
  ffi.Pointer<wire_list_env_variable> api2wire_list_env_variable(
      List<EnvVariable> raw) {
    final ans = inner.new_list_env_variable_0(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      _api_fill_to_wire_env_variable(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_list_module_import> api2wire_list_module_import(
      List<ModuleImport> raw) {
    final ans = inner.new_list_module_import_0(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      _api_fill_to_wire_module_import(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_list_preopened_dir> api2wire_list_preopened_dir(
      List<PreopenedDir> raw) {
    final ans = inner.new_list_preopened_dir_0(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      _api_fill_to_wire_preopened_dir(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_list_value_ty> api2wire_list_value_ty(List<ValueTy> raw) {
    final ans = inner.new_list_value_ty_0(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      ans.ref.ptr[i] = api2wire_value_ty(raw[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_list_wasm_val> api2wire_list_wasm_val(List<WasmVal> raw) {
    final ans = inner.new_list_wasm_val_0(raw.length);
    for (var i = 0; i < raw.length; ++i) {
      _api_fill_to_wire_wasm_val(raw[i], ans.ref.ptr[i]);
    }
    return ans;
  }

  @protected
  ffi.Pointer<wire_WFunc> api2wire_opt_box_autoadd_WFunc(WFunc? raw) {
    return raw == null ? ffi.nullptr : api2wire_box_autoadd_WFunc(raw);
  }

  @protected
  ffi.Pointer<ffi.Bool> api2wire_opt_box_autoadd_bool(bool? raw) {
    return raw == null ? ffi.nullptr : api2wire_box_autoadd_bool(raw);
  }

  @protected
  ffi.Pointer<wire_ModuleConfigWasmi>
      api2wire_opt_box_autoadd_module_config_wasmi(ModuleConfigWasmi? raw) {
    return raw == null
        ? ffi.nullptr
        : api2wire_box_autoadd_module_config_wasmi(raw);
  }

  @protected
  ffi.Pointer<wire_ModuleConfigWasmtime>
      api2wire_opt_box_autoadd_module_config_wasmtime(
          ModuleConfigWasmtime? raw) {
    return raw == null
        ? ffi.nullptr
        : api2wire_box_autoadd_module_config_wasmtime(raw);
  }

  @protected
  ffi.Pointer<ffi.Uint32> api2wire_opt_box_autoadd_u32(int? raw) {
    return raw == null ? ffi.nullptr : api2wire_box_autoadd_u32(raw);
  }

  @protected
  ffi.Pointer<ffi.Uint64> api2wire_opt_box_autoadd_u64(int? raw) {
    return raw == null ? ffi.nullptr : api2wire_box_autoadd_u64(raw);
  }

  @protected
  ffi.Pointer<ffi.UintPtr> api2wire_opt_box_autoadd_usize(int? raw) {
    return raw == null ? ffi.nullptr : api2wire_box_autoadd_usize(raw);
  }

  @protected
  ffi.Pointer<wire_WasiConfigNative>
      api2wire_opt_box_autoadd_wasi_config_native(WasiConfigNative? raw) {
    return raw == null
        ? ffi.nullptr
        : api2wire_box_autoadd_wasi_config_native(raw);
  }

  @protected
  ffi.Pointer<wire_WasiStackLimits> api2wire_opt_box_autoadd_wasi_stack_limits(
      WasiStackLimits? raw) {
    return raw == null
        ? ffi.nullptr
        : api2wire_box_autoadd_wasi_stack_limits(raw);
  }

  @protected
  int api2wire_u64(int raw) {
    return raw;
  }

  @protected
  ffi.Pointer<wire_uint_8_list> api2wire_u8_array_16(U8Array16 raw) {
    final ans = inner.new_uint_8_list_0(16);
    ans.ref.ptr.asTypedList(16).setAll(0, raw);
    return ans;
  }

  @protected
  ffi.Pointer<wire_uint_8_list> api2wire_uint_8_list(Uint8List raw) {
    final ans = inner.new_uint_8_list_0(raw.length);
    ans.ref.ptr.asTypedList(raw.length).setAll(0, raw);
    return ans;
  }

// Section: finalizer

  late final OpaqueTypeFinalizer _ArcRwLockSharedMemoryFinalizer =
      OpaqueTypeFinalizer(inner._drop_opaque_ArcRwLockSharedMemoryPtr);
  OpaqueTypeFinalizer get ArcRwLockSharedMemoryFinalizer =>
      _ArcRwLockSharedMemoryFinalizer;
  late final OpaqueTypeFinalizer _ArcStdSyncMutexModuleFinalizer =
      OpaqueTypeFinalizer(inner._drop_opaque_ArcStdSyncMutexModulePtr);
  OpaqueTypeFinalizer get ArcStdSyncMutexModuleFinalizer =>
      _ArcStdSyncMutexModuleFinalizer;
  late final OpaqueTypeFinalizer _CallStackFinalizer =
      OpaqueTypeFinalizer(inner._drop_opaque_CallStackPtr);
  OpaqueTypeFinalizer get CallStackFinalizer => _CallStackFinalizer;
  late final OpaqueTypeFinalizer _GlobalFinalizer =
      OpaqueTypeFinalizer(inner._drop_opaque_GlobalPtr);
  OpaqueTypeFinalizer get GlobalFinalizer => _GlobalFinalizer;
  late final OpaqueTypeFinalizer _MemoryFinalizer =
      OpaqueTypeFinalizer(inner._drop_opaque_MemoryPtr);
  OpaqueTypeFinalizer get MemoryFinalizer => _MemoryFinalizer;
  late final OpaqueTypeFinalizer _TableFinalizer =
      OpaqueTypeFinalizer(inner._drop_opaque_TablePtr);
  OpaqueTypeFinalizer get TableFinalizer => _TableFinalizer;
  late final OpaqueTypeFinalizer _WFuncFinalizer =
      OpaqueTypeFinalizer(inner._drop_opaque_WFuncPtr);
  OpaqueTypeFinalizer get WFuncFinalizer => _WFuncFinalizer;
// Section: api_fill_to_wire

  void _api_fill_to_wire_ArcRwLockSharedMemory(
      ArcRwLockSharedMemory apiObj, wire_ArcRwLockSharedMemory wireObj) {
    wireObj.ptr = apiObj.shareOrMove();
  }

  void _api_fill_to_wire_ArcStdSyncMutexModule(
      ArcStdSyncMutexModule apiObj, wire_ArcStdSyncMutexModule wireObj) {
    wireObj.ptr = apiObj.shareOrMove();
  }

  void _api_fill_to_wire_CallStack(CallStack apiObj, wire_CallStack wireObj) {
    wireObj.ptr = apiObj.shareOrMove();
  }

  void _api_fill_to_wire_Global(Global apiObj, wire_Global wireObj) {
    wireObj.ptr = apiObj.shareOrMove();
  }

  void _api_fill_to_wire_Memory(Memory apiObj, wire_Memory wireObj) {
    wireObj.ptr = apiObj.shareOrMove();
  }

  void _api_fill_to_wire_Table(Table apiObj, wire_Table wireObj) {
    wireObj.ptr = apiObj.shareOrMove();
  }

  void _api_fill_to_wire_WFunc(WFunc apiObj, wire_WFunc wireObj) {
    wireObj.ptr = apiObj.shareOrMove();
  }

  void _api_fill_to_wire_atomics(Atomics apiObj, wire_Atomics wireObj) {
    wireObj.field0 = api2wire_usize(apiObj.field0);
  }

  void _api_fill_to_wire_box_autoadd_WFunc(
      WFunc apiObj, ffi.Pointer<wire_WFunc> wireObj) {
    _api_fill_to_wire_WFunc(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_atomics(
      Atomics apiObj, ffi.Pointer<wire_Atomics> wireObj) {
    _api_fill_to_wire_atomics(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_compiled_module(
      CompiledModule apiObj, ffi.Pointer<wire_CompiledModule> wireObj) {
    _api_fill_to_wire_compiled_module(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_memory_ty(
      MemoryTy apiObj, ffi.Pointer<wire_MemoryTy> wireObj) {
    _api_fill_to_wire_memory_ty(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_module_config(
      ModuleConfig apiObj, ffi.Pointer<wire_ModuleConfig> wireObj) {
    _api_fill_to_wire_module_config(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_module_config_wasmi(
      ModuleConfigWasmi apiObj, ffi.Pointer<wire_ModuleConfigWasmi> wireObj) {
    _api_fill_to_wire_module_config_wasmi(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_module_config_wasmtime(
      ModuleConfigWasmtime apiObj,
      ffi.Pointer<wire_ModuleConfigWasmtime> wireObj) {
    _api_fill_to_wire_module_config_wasmtime(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_table_args(
      TableArgs apiObj, ffi.Pointer<wire_TableArgs> wireObj) {
    _api_fill_to_wire_table_args(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_wasi_config_native(
      WasiConfigNative apiObj, ffi.Pointer<wire_WasiConfigNative> wireObj) {
    _api_fill_to_wire_wasi_config_native(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_wasi_stack_limits(
      WasiStackLimits apiObj, ffi.Pointer<wire_WasiStackLimits> wireObj) {
    _api_fill_to_wire_wasi_stack_limits(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_wasm_run_instance_id(
      WasmRunInstanceId apiObj, ffi.Pointer<wire_WasmRunInstanceId> wireObj) {
    _api_fill_to_wire_wasm_run_instance_id(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_wasm_run_module_id(
      WasmRunModuleId apiObj, ffi.Pointer<wire_WasmRunModuleId> wireObj) {
    _api_fill_to_wire_wasm_run_module_id(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_wasm_run_shared_memory(
      WasmRunSharedMemory apiObj,
      ffi.Pointer<wire_WasmRunSharedMemory> wireObj) {
    _api_fill_to_wire_wasm_run_shared_memory(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_box_autoadd_wasm_val(
      WasmVal apiObj, ffi.Pointer<wire_WasmVal> wireObj) {
    _api_fill_to_wire_wasm_val(apiObj, wireObj.ref);
  }

  void _api_fill_to_wire_compiled_module(
      CompiledModule apiObj, wire_CompiledModule wireObj) {
    wireObj.field0 = api2wire_ArcStdSyncMutexModule(apiObj.field0);
  }

  void _api_fill_to_wire_env_variable(
      EnvVariable apiObj, wire_EnvVariable wireObj) {
    wireObj.name = api2wire_String(apiObj.name);
    wireObj.value = api2wire_String(apiObj.value);
  }

  void _api_fill_to_wire_external_value(
      ExternalValue apiObj, wire_ExternalValue wireObj) {
    if (apiObj is ExternalValue_Func) {
      var pre_field0 = api2wire_WFunc(apiObj.field0);
      wireObj.tag = 0;
      wireObj.kind = inner.inflate_ExternalValue_Func();
      wireObj.kind.ref.Func.ref.field0 = pre_field0;
      return;
    }
    if (apiObj is ExternalValue_Global) {
      var pre_field0 = api2wire_Global(apiObj.field0);
      wireObj.tag = 1;
      wireObj.kind = inner.inflate_ExternalValue_Global();
      wireObj.kind.ref.Global.ref.field0 = pre_field0;
      return;
    }
    if (apiObj is ExternalValue_Table) {
      var pre_field0 = api2wire_Table(apiObj.field0);
      wireObj.tag = 2;
      wireObj.kind = inner.inflate_ExternalValue_Table();
      wireObj.kind.ref.Table.ref.field0 = pre_field0;
      return;
    }
    if (apiObj is ExternalValue_Memory) {
      var pre_field0 = api2wire_Memory(apiObj.field0);
      wireObj.tag = 3;
      wireObj.kind = inner.inflate_ExternalValue_Memory();
      wireObj.kind.ref.Memory.ref.field0 = pre_field0;
      return;
    }
    if (apiObj is ExternalValue_SharedMemory) {
      var pre_field0 =
          api2wire_box_autoadd_wasm_run_shared_memory(apiObj.field0);
      wireObj.tag = 4;
      wireObj.kind = inner.inflate_ExternalValue_SharedMemory();
      wireObj.kind.ref.SharedMemory.ref.field0 = pre_field0;
      return;
    }
  }

  void _api_fill_to_wire_memory_ty(MemoryTy apiObj, wire_MemoryTy wireObj) {
    wireObj.shared = api2wire_bool(apiObj.shared);
    wireObj.minimum = api2wire_u32(apiObj.minimum);
    wireObj.maximum = api2wire_opt_box_autoadd_u32(apiObj.maximum);
  }

  void _api_fill_to_wire_module_config(
      ModuleConfig apiObj, wire_ModuleConfig wireObj) {
    wireObj.multi_value = api2wire_opt_box_autoadd_bool(apiObj.multiValue);
    wireObj.bulk_memory = api2wire_opt_box_autoadd_bool(apiObj.bulkMemory);
    wireObj.reference_types =
        api2wire_opt_box_autoadd_bool(apiObj.referenceTypes);
    wireObj.consume_fuel = api2wire_opt_box_autoadd_bool(apiObj.consumeFuel);
    wireObj.wasmi = api2wire_opt_box_autoadd_module_config_wasmi(apiObj.wasmi);
    wireObj.wasmtime =
        api2wire_opt_box_autoadd_module_config_wasmtime(apiObj.wasmtime);
  }

  void _api_fill_to_wire_module_config_wasmi(
      ModuleConfigWasmi apiObj, wire_ModuleConfigWasmi wireObj) {
    wireObj.stack_limits =
        api2wire_opt_box_autoadd_wasi_stack_limits(apiObj.stackLimits);
    wireObj.cached_stacks = api2wire_opt_box_autoadd_usize(apiObj.cachedStacks);
    wireObj.mutable_global =
        api2wire_opt_box_autoadd_bool(apiObj.mutableGlobal);
    wireObj.sign_extension =
        api2wire_opt_box_autoadd_bool(apiObj.signExtension);
    wireObj.saturating_float_to_int =
        api2wire_opt_box_autoadd_bool(apiObj.saturatingFloatToInt);
    wireObj.tail_call = api2wire_opt_box_autoadd_bool(apiObj.tailCall);
    wireObj.extended_const =
        api2wire_opt_box_autoadd_bool(apiObj.extendedConst);
    wireObj.floats = api2wire_opt_box_autoadd_bool(apiObj.floats);
  }

  void _api_fill_to_wire_module_config_wasmtime(
      ModuleConfigWasmtime apiObj, wire_ModuleConfigWasmtime wireObj) {
    wireObj.debug_info = api2wire_opt_box_autoadd_bool(apiObj.debugInfo);
    wireObj.wasm_backtrace =
        api2wire_opt_box_autoadd_bool(apiObj.wasmBacktrace);
    wireObj.native_unwind_info =
        api2wire_opt_box_autoadd_bool(apiObj.nativeUnwindInfo);
    wireObj.max_wasm_stack =
        api2wire_opt_box_autoadd_usize(apiObj.maxWasmStack);
    wireObj.wasm_threads = api2wire_opt_box_autoadd_bool(apiObj.wasmThreads);
    wireObj.wasm_simd = api2wire_opt_box_autoadd_bool(apiObj.wasmSimd);
    wireObj.wasm_relaxed_simd =
        api2wire_opt_box_autoadd_bool(apiObj.wasmRelaxedSimd);
    wireObj.relaxed_simd_deterministic =
        api2wire_opt_box_autoadd_bool(apiObj.relaxedSimdDeterministic);
    wireObj.wasm_multi_memory =
        api2wire_opt_box_autoadd_bool(apiObj.wasmMultiMemory);
    wireObj.wasm_memory64 = api2wire_opt_box_autoadd_bool(apiObj.wasmMemory64);
    wireObj.static_memory_maximum_size =
        api2wire_opt_box_autoadd_u64(apiObj.staticMemoryMaximumSize);
    wireObj.static_memory_forced =
        api2wire_opt_box_autoadd_bool(apiObj.staticMemoryForced);
    wireObj.static_memory_guard_size =
        api2wire_opt_box_autoadd_u64(apiObj.staticMemoryGuardSize);
    wireObj.parallel_compilation =
        api2wire_opt_box_autoadd_bool(apiObj.parallelCompilation);
    wireObj.generate_address_map =
        api2wire_opt_box_autoadd_bool(apiObj.generateAddressMap);
  }

  void _api_fill_to_wire_module_import(
      ModuleImport apiObj, wire_ModuleImport wireObj) {
    wireObj.module = api2wire_String(apiObj.module);
    wireObj.name = api2wire_String(apiObj.name);
    _api_fill_to_wire_external_value(apiObj.value, wireObj.value);
  }

  void _api_fill_to_wire_opt_box_autoadd_WFunc(
      WFunc? apiObj, ffi.Pointer<wire_WFunc> wireObj) {
    if (apiObj != null) _api_fill_to_wire_box_autoadd_WFunc(apiObj, wireObj);
  }

  void _api_fill_to_wire_opt_box_autoadd_module_config_wasmi(
      ModuleConfigWasmi? apiObj, ffi.Pointer<wire_ModuleConfigWasmi> wireObj) {
    if (apiObj != null)
      _api_fill_to_wire_box_autoadd_module_config_wasmi(apiObj, wireObj);
  }

  void _api_fill_to_wire_opt_box_autoadd_module_config_wasmtime(
      ModuleConfigWasmtime? apiObj,
      ffi.Pointer<wire_ModuleConfigWasmtime> wireObj) {
    if (apiObj != null)
      _api_fill_to_wire_box_autoadd_module_config_wasmtime(apiObj, wireObj);
  }

  void _api_fill_to_wire_opt_box_autoadd_wasi_config_native(
      WasiConfigNative? apiObj, ffi.Pointer<wire_WasiConfigNative> wireObj) {
    if (apiObj != null)
      _api_fill_to_wire_box_autoadd_wasi_config_native(apiObj, wireObj);
  }

  void _api_fill_to_wire_opt_box_autoadd_wasi_stack_limits(
      WasiStackLimits? apiObj, ffi.Pointer<wire_WasiStackLimits> wireObj) {
    if (apiObj != null)
      _api_fill_to_wire_box_autoadd_wasi_stack_limits(apiObj, wireObj);
  }

  void _api_fill_to_wire_preopened_dir(
      PreopenedDir apiObj, wire_PreopenedDir wireObj) {
    wireObj.wasm_guest_path = api2wire_String(apiObj.wasmGuestPath);
    wireObj.host_path = api2wire_String(apiObj.hostPath);
  }

  void _api_fill_to_wire_table_args(TableArgs apiObj, wire_TableArgs wireObj) {
    wireObj.minimum = api2wire_u32(apiObj.minimum);
    wireObj.maximum = api2wire_opt_box_autoadd_u32(apiObj.maximum);
  }

  void _api_fill_to_wire_wasi_config_native(
      WasiConfigNative apiObj, wire_WasiConfigNative wireObj) {
    wireObj.capture_stdout = api2wire_bool(apiObj.captureStdout);
    wireObj.capture_stderr = api2wire_bool(apiObj.captureStderr);
    wireObj.inherit_stdin = api2wire_bool(apiObj.inheritStdin);
    wireObj.inherit_env = api2wire_bool(apiObj.inheritEnv);
    wireObj.inherit_args = api2wire_bool(apiObj.inheritArgs);
    wireObj.args = api2wire_StringList(apiObj.args);
    wireObj.env = api2wire_list_env_variable(apiObj.env);
    wireObj.preopened_files = api2wire_StringList(apiObj.preopenedFiles);
    wireObj.preopened_dirs = api2wire_list_preopened_dir(apiObj.preopenedDirs);
  }

  void _api_fill_to_wire_wasi_stack_limits(
      WasiStackLimits apiObj, wire_WasiStackLimits wireObj) {
    wireObj.initial_value_stack_height =
        api2wire_usize(apiObj.initialValueStackHeight);
    wireObj.maximum_value_stack_height =
        api2wire_usize(apiObj.maximumValueStackHeight);
    wireObj.maximum_recursion_depth =
        api2wire_usize(apiObj.maximumRecursionDepth);
  }

  void _api_fill_to_wire_wasm_run_instance_id(
      WasmRunInstanceId apiObj, wire_WasmRunInstanceId wireObj) {
    wireObj.field0 = api2wire_u32(apiObj.field0);
  }

  void _api_fill_to_wire_wasm_run_module_id(
      WasmRunModuleId apiObj, wire_WasmRunModuleId wireObj) {
    wireObj.field0 = api2wire_u32(apiObj.field0);
    wireObj.field1 = api2wire_CallStack(apiObj.field1);
  }

  void _api_fill_to_wire_wasm_run_shared_memory(
      WasmRunSharedMemory apiObj, wire_WasmRunSharedMemory wireObj) {
    wireObj.field0 = api2wire_ArcRwLockSharedMemory(apiObj.field0);
  }

  void _api_fill_to_wire_wasm_val(WasmVal apiObj, wire_WasmVal wireObj) {
    if (apiObj is WasmVal_i32) {
      var pre_field0 = api2wire_i32(apiObj.field0);
      wireObj.tag = 0;
      wireObj.kind = inner.inflate_WasmVal_i32();
      wireObj.kind.ref.i32.ref.field0 = pre_field0;
      return;
    }
    if (apiObj is WasmVal_i64) {
      var pre_field0 = api2wire_i64(apiObj.field0);
      wireObj.tag = 1;
      wireObj.kind = inner.inflate_WasmVal_i64();
      wireObj.kind.ref.i64.ref.field0 = pre_field0;
      return;
    }
    if (apiObj is WasmVal_f32) {
      var pre_field0 = api2wire_f32(apiObj.field0);
      wireObj.tag = 2;
      wireObj.kind = inner.inflate_WasmVal_f32();
      wireObj.kind.ref.f32.ref.field0 = pre_field0;
      return;
    }
    if (apiObj is WasmVal_f64) {
      var pre_field0 = api2wire_f64(apiObj.field0);
      wireObj.tag = 3;
      wireObj.kind = inner.inflate_WasmVal_f64();
      wireObj.kind.ref.f64.ref.field0 = pre_field0;
      return;
    }
    if (apiObj is WasmVal_v128) {
      var pre_field0 = api2wire_u8_array_16(apiObj.field0);
      wireObj.tag = 4;
      wireObj.kind = inner.inflate_WasmVal_v128();
      wireObj.kind.ref.v128.ref.field0 = pre_field0;
      return;
    }
    if (apiObj is WasmVal_funcRef) {
      var pre_field0 = api2wire_opt_box_autoadd_WFunc(apiObj.field0);
      wireObj.tag = 5;
      wireObj.kind = inner.inflate_WasmVal_funcRef();
      wireObj.kind.ref.funcRef.ref.field0 = pre_field0;
      return;
    }
    if (apiObj is WasmVal_externRef) {
      var pre_field0 = api2wire_opt_box_autoadd_u32(apiObj.field0);
      wireObj.tag = 6;
      wireObj.kind = inner.inflate_WasmVal_externRef();
      wireObj.kind.ref.externRef.ref.field0 = pre_field0;
      return;
    }
  }
}

// ignore_for_file: camel_case_types, non_constant_identifier_names, avoid_positional_boolean_parameters, annotate_overrides, constant_identifier_names

// AUTO GENERATED FILE, DO NOT EDIT.
//
// Generated by `package:ffigen`.
// ignore_for_file: type=lint

/// generated by flutter_rust_bridge
class WasmRunDartWire implements FlutterRustBridgeWireBase {
  @internal
  late final dartApi = DartApiDl(init_frb_dart_api_dl);

  /// Holds the symbol lookup function.
  final ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
      _lookup;

  /// The symbols are looked up in [dynamicLibrary].
  WasmRunDartWire(ffi.DynamicLibrary dynamicLibrary)
      : _lookup = dynamicLibrary.lookup;

  /// The symbols are looked up with [lookup].
  WasmRunDartWire.fromLookup(
      ffi.Pointer<T> Function<T extends ffi.NativeType>(String symbolName)
          lookup)
      : _lookup = lookup;

  void store_dart_post_cobject(
    DartPostCObjectFnType ptr,
  ) {
    return _store_dart_post_cobject(
      ptr,
    );
  }

  late final _store_dart_post_cobjectPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(DartPostCObjectFnType)>>(
          'store_dart_post_cobject');
  late final _store_dart_post_cobject = _store_dart_post_cobjectPtr
      .asFunction<void Function(DartPostCObjectFnType)>();

  Object get_dart_object(
    int ptr,
  ) {
    return _get_dart_object(
      ptr,
    );
  }

  late final _get_dart_objectPtr =
      _lookup<ffi.NativeFunction<ffi.Handle Function(ffi.UintPtr)>>(
          'get_dart_object');
  late final _get_dart_object =
      _get_dart_objectPtr.asFunction<Object Function(int)>();

  void drop_dart_object(
    int ptr,
  ) {
    return _drop_dart_object(
      ptr,
    );
  }

  late final _drop_dart_objectPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.UintPtr)>>(
          'drop_dart_object');
  late final _drop_dart_object =
      _drop_dart_objectPtr.asFunction<void Function(int)>();

  int new_dart_opaque(
    Object handle,
  ) {
    return _new_dart_opaque(
      handle,
    );
  }

  late final _new_dart_opaquePtr =
      _lookup<ffi.NativeFunction<ffi.UintPtr Function(ffi.Handle)>>(
          'new_dart_opaque');
  late final _new_dart_opaque =
      _new_dart_opaquePtr.asFunction<int Function(Object)>();

  int init_frb_dart_api_dl(
    ffi.Pointer<ffi.Void> obj,
  ) {
    return _init_frb_dart_api_dl(
      obj,
    );
  }

  late final _init_frb_dart_api_dlPtr =
      _lookup<ffi.NativeFunction<ffi.IntPtr Function(ffi.Pointer<ffi.Void>)>>(
          'init_frb_dart_api_dl');
  late final _init_frb_dart_api_dl = _init_frb_dart_api_dlPtr
      .asFunction<int Function(ffi.Pointer<ffi.Void>)>();

  WireSyncReturn wire_module_builder(
    ffi.Pointer<wire_CompiledModule> module,
    ffi.Pointer<ffi.UintPtr> num_threads,
    ffi.Pointer<wire_WasiConfigNative> wasi_config,
  ) {
    return _wire_module_builder(
      module,
      num_threads,
      wasi_config,
    );
  }

  late final _wire_module_builderPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_CompiledModule>,
              ffi.Pointer<ffi.UintPtr>,
              ffi.Pointer<wire_WasiConfigNative>)>>('wire_module_builder');
  late final _wire_module_builder = _wire_module_builderPtr.asFunction<
      WireSyncReturn Function(ffi.Pointer<wire_CompiledModule>,
          ffi.Pointer<ffi.UintPtr>, ffi.Pointer<wire_WasiConfigNative>)>();

  void wire_parse_wat_format(
    int port_,
    ffi.Pointer<wire_uint_8_list> wat,
  ) {
    return _wire_parse_wat_format(
      port_,
      wat,
    );
  }

  late final _wire_parse_wat_formatPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64,
              ffi.Pointer<wire_uint_8_list>)>>('wire_parse_wat_format');
  late final _wire_parse_wat_format = _wire_parse_wat_formatPtr
      .asFunction<void Function(int, ffi.Pointer<wire_uint_8_list>)>();

  void wire_compile_wasm(
    int port_,
    ffi.Pointer<wire_uint_8_list> module_wasm,
    ffi.Pointer<wire_ModuleConfig> config,
  ) {
    return _wire_compile_wasm(
      port_,
      module_wasm,
      config,
    );
  }

  late final _wire_compile_wasmPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_ModuleConfig>)>>('wire_compile_wasm');
  late final _wire_compile_wasm = _wire_compile_wasmPtr.asFunction<
      void Function(int, ffi.Pointer<wire_uint_8_list>,
          ffi.Pointer<wire_ModuleConfig>)>();

  WireSyncReturn wire_compile_wasm_sync(
    ffi.Pointer<wire_uint_8_list> module_wasm,
    ffi.Pointer<wire_ModuleConfig> config,
  ) {
    return _wire_compile_wasm_sync(
      module_wasm,
      config,
    );
  }

  late final _wire_compile_wasm_syncPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_uint_8_list>,
              ffi.Pointer<wire_ModuleConfig>)>>('wire_compile_wasm_sync');
  late final _wire_compile_wasm_sync = _wire_compile_wasm_syncPtr.asFunction<
      WireSyncReturn Function(
          ffi.Pointer<wire_uint_8_list>, ffi.Pointer<wire_ModuleConfig>)>();

  WireSyncReturn wire_wasm_features_for_config(
    ffi.Pointer<wire_ModuleConfig> config,
  ) {
    return _wire_wasm_features_for_config(
      config,
    );
  }

  late final _wire_wasm_features_for_configPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_ModuleConfig>)>>(
      'wire_wasm_features_for_config');
  late final _wire_wasm_features_for_config = _wire_wasm_features_for_configPtr
      .asFunction<WireSyncReturn Function(ffi.Pointer<wire_ModuleConfig>)>();

  WireSyncReturn wire_wasm_runtime_features() {
    return _wire_wasm_runtime_features();
  }

  late final _wire_wasm_runtime_featuresPtr =
      _lookup<ffi.NativeFunction<WireSyncReturn Function()>>(
          'wire_wasm_runtime_features');
  late final _wire_wasm_runtime_features =
      _wire_wasm_runtime_featuresPtr.asFunction<WireSyncReturn Function()>();

  WireSyncReturn wire_exports__method__WasmRunInstanceId(
    ffi.Pointer<wire_WasmRunInstanceId> that,
  ) {
    return _wire_exports__method__WasmRunInstanceId(
      that,
    );
  }

  late final _wire_exports__method__WasmRunInstanceIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunInstanceId>)>>(
      'wire_exports__method__WasmRunInstanceId');
  late final _wire_exports__method__WasmRunInstanceId =
      _wire_exports__method__WasmRunInstanceIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunInstanceId>)>();

  WireSyncReturn wire_instantiate_sync__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
  ) {
    return _wire_instantiate_sync__method__WasmRunModuleId(
      that,
    );
  }

  late final _wire_instantiate_sync__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>)>>(
      'wire_instantiate_sync__method__WasmRunModuleId');
  late final _wire_instantiate_sync__method__WasmRunModuleId =
      _wire_instantiate_sync__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>)>();

  void wire_instantiate__method__WasmRunModuleId(
    int port_,
    ffi.Pointer<wire_WasmRunModuleId> that,
  ) {
    return _wire_instantiate__method__WasmRunModuleId(
      port_,
      that,
    );
  }

  late final _wire_instantiate__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_WasmRunModuleId>)>>(
      'wire_instantiate__method__WasmRunModuleId');
  late final _wire_instantiate__method__WasmRunModuleId =
      _wire_instantiate__method__WasmRunModuleIdPtr
          .asFunction<void Function(int, ffi.Pointer<wire_WasmRunModuleId>)>();

  WireSyncReturn wire_link_imports__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    ffi.Pointer<wire_list_module_import> imports,
  ) {
    return _wire_link_imports__method__WasmRunModuleId(
      that,
      imports,
    );
  }

  late final _wire_link_imports__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
                  ffi.Pointer<wire_list_module_import>)>>(
      'wire_link_imports__method__WasmRunModuleId');
  late final _wire_link_imports__method__WasmRunModuleId =
      _wire_link_imports__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              ffi.Pointer<wire_list_module_import>)>();

  void wire_stdio_stream__method__WasmRunModuleId(
    int port_,
    ffi.Pointer<wire_WasmRunModuleId> that,
    int kind,
  ) {
    return _wire_stdio_stream__method__WasmRunModuleId(
      port_,
      that,
      kind,
    );
  }

  late final _wire_stdio_stream__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_WasmRunModuleId>,
              ffi.Int32)>>('wire_stdio_stream__method__WasmRunModuleId');
  late final _wire_stdio_stream__method__WasmRunModuleId =
      _wire_stdio_stream__method__WasmRunModuleIdPtr.asFunction<
          void Function(int, ffi.Pointer<wire_WasmRunModuleId>, int)>();

  void wire_dispose__method__WasmRunModuleId(
    int port_,
    ffi.Pointer<wire_WasmRunModuleId> that,
  ) {
    return _wire_dispose__method__WasmRunModuleId(
      port_,
      that,
    );
  }

  late final _wire_dispose__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_WasmRunModuleId>)>>(
      'wire_dispose__method__WasmRunModuleId');
  late final _wire_dispose__method__WasmRunModuleId =
      _wire_dispose__method__WasmRunModuleIdPtr
          .asFunction<void Function(int, ffi.Pointer<wire_WasmRunModuleId>)>();

  WireSyncReturn wire_call_function_handle_sync__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_WFunc func,
    ffi.Pointer<wire_list_wasm_val> args,
  ) {
    return _wire_call_function_handle_sync__method__WasmRunModuleId(
      that,
      func,
      args,
    );
  }

  late final _wire_call_function_handle_sync__method__WasmRunModuleIdPtr =
      _lookup<
              ffi.NativeFunction<
                  WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
                      wire_WFunc, ffi.Pointer<wire_list_wasm_val>)>>(
          'wire_call_function_handle_sync__method__WasmRunModuleId');
  late final _wire_call_function_handle_sync__method__WasmRunModuleId =
      _wire_call_function_handle_sync__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>, wire_WFunc,
              ffi.Pointer<wire_list_wasm_val>)>();

  void wire_call_function_handle__method__WasmRunModuleId(
    int port_,
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_WFunc func,
    ffi.Pointer<wire_list_wasm_val> args,
  ) {
    return _wire_call_function_handle__method__WasmRunModuleId(
      port_,
      that,
      func,
      args,
    );
  }

  late final _wire_call_function_handle__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(ffi.Int64, ffi.Pointer<wire_WasmRunModuleId>,
                  wire_WFunc, ffi.Pointer<wire_list_wasm_val>)>>(
      'wire_call_function_handle__method__WasmRunModuleId');
  late final _wire_call_function_handle__method__WasmRunModuleId =
      _wire_call_function_handle__method__WasmRunModuleIdPtr.asFunction<
          void Function(int, ffi.Pointer<wire_WasmRunModuleId>, wire_WFunc,
              ffi.Pointer<wire_list_wasm_val>)>();

  void wire_call_function_handle_parallel__method__WasmRunModuleId(
    int port_,
    ffi.Pointer<wire_WasmRunModuleId> that,
    ffi.Pointer<wire_uint_8_list> func_name,
    ffi.Pointer<wire_list_wasm_val> args,
    int num_tasks,
  ) {
    return _wire_call_function_handle_parallel__method__WasmRunModuleId(
      port_,
      that,
      func_name,
      args,
      num_tasks,
    );
  }

  late final _wire_call_function_handle_parallel__method__WasmRunModuleIdPtr =
      _lookup<
              ffi.NativeFunction<
                  ffi.Void Function(
                      ffi.Int64,
                      ffi.Pointer<wire_WasmRunModuleId>,
                      ffi.Pointer<wire_uint_8_list>,
                      ffi.Pointer<wire_list_wasm_val>,
                      ffi.UintPtr)>>(
          'wire_call_function_handle_parallel__method__WasmRunModuleId');
  late final _wire_call_function_handle_parallel__method__WasmRunModuleId =
      _wire_call_function_handle_parallel__method__WasmRunModuleIdPtr
          .asFunction<
              void Function(
                  int,
                  ffi.Pointer<wire_WasmRunModuleId>,
                  ffi.Pointer<wire_uint_8_list>,
                  ffi.Pointer<wire_list_wasm_val>,
                  int)>();

  WireSyncReturn wire_worker_execution__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    int worker_index,
    ffi.Pointer<wire_list_wasm_val> results,
  ) {
    return _wire_worker_execution__method__WasmRunModuleId(
      that,
      worker_index,
      results,
    );
  }

  late final _wire_worker_execution__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
                  ffi.UintPtr, ffi.Pointer<wire_list_wasm_val>)>>(
      'wire_worker_execution__method__WasmRunModuleId');
  late final _wire_worker_execution__method__WasmRunModuleId =
      _wire_worker_execution__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>, int,
              ffi.Pointer<wire_list_wasm_val>)>();

  WireSyncReturn wire_get_function_type__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_WFunc func,
  ) {
    return _wire_get_function_type__method__WasmRunModuleId(
      that,
      func,
    );
  }

  late final _wire_get_function_type__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              wire_WFunc)>>('wire_get_function_type__method__WasmRunModuleId');
  late final _wire_get_function_type__method__WasmRunModuleId =
      _wire_get_function_type__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_WFunc)>();

  WireSyncReturn wire_create_function__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    int function_pointer,
    int function_id,
    ffi.Pointer<wire_list_value_ty> param_types,
    ffi.Pointer<wire_list_value_ty> result_types,
  ) {
    return _wire_create_function__method__WasmRunModuleId(
      that,
      function_pointer,
      function_id,
      param_types,
      result_types,
    );
  }

  late final _wire_create_function__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(
                  ffi.Pointer<wire_WasmRunModuleId>,
                  ffi.UintPtr,
                  ffi.Uint32,
                  ffi.Pointer<wire_list_value_ty>,
                  ffi.Pointer<wire_list_value_ty>)>>(
      'wire_create_function__method__WasmRunModuleId');
  late final _wire_create_function__method__WasmRunModuleId =
      _wire_create_function__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>,
              int,
              int,
              ffi.Pointer<wire_list_value_ty>,
              ffi.Pointer<wire_list_value_ty>)>();

  WireSyncReturn wire_create_memory__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    ffi.Pointer<wire_MemoryTy> memory_type,
  ) {
    return _wire_create_memory__method__WasmRunModuleId(
      that,
      memory_type,
    );
  }

  late final _wire_create_memory__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
                  ffi.Pointer<wire_MemoryTy>)>>(
      'wire_create_memory__method__WasmRunModuleId');
  late final _wire_create_memory__method__WasmRunModuleId =
      _wire_create_memory__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, ffi.Pointer<wire_MemoryTy>)>();

  WireSyncReturn wire_create_global__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    ffi.Pointer<wire_WasmVal> value,
    bool mutable_,
  ) {
    return _wire_create_global__method__WasmRunModuleId(
      that,
      value,
      mutable_,
    );
  }

  late final _wire_create_global__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>,
              ffi.Pointer<wire_WasmVal>,
              ffi.Bool)>>('wire_create_global__method__WasmRunModuleId');
  late final _wire_create_global__method__WasmRunModuleId =
      _wire_create_global__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              ffi.Pointer<wire_WasmVal>, bool)>();

  WireSyncReturn wire_create_table__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    ffi.Pointer<wire_WasmVal> value,
    ffi.Pointer<wire_TableArgs> table_type,
  ) {
    return _wire_create_table__method__WasmRunModuleId(
      that,
      value,
      table_type,
    );
  }

  late final _wire_create_table__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
                  ffi.Pointer<wire_WasmVal>, ffi.Pointer<wire_TableArgs>)>>(
      'wire_create_table__method__WasmRunModuleId');
  late final _wire_create_table__method__WasmRunModuleId =
      _wire_create_table__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              ffi.Pointer<wire_WasmVal>, ffi.Pointer<wire_TableArgs>)>();

  WireSyncReturn wire_get_global_type__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Global global,
  ) {
    return _wire_get_global_type__method__WasmRunModuleId(
      that,
      global,
    );
  }

  late final _wire_get_global_type__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              wire_Global)>>('wire_get_global_type__method__WasmRunModuleId');
  late final _wire_get_global_type__method__WasmRunModuleId =
      _wire_get_global_type__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_Global)>();

  WireSyncReturn wire_get_global_value__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Global global,
  ) {
    return _wire_get_global_value__method__WasmRunModuleId(
      that,
      global,
    );
  }

  late final _wire_get_global_value__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              wire_Global)>>('wire_get_global_value__method__WasmRunModuleId');
  late final _wire_get_global_value__method__WasmRunModuleId =
      _wire_get_global_value__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_Global)>();

  WireSyncReturn wire_set_global_value__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Global global,
    ffi.Pointer<wire_WasmVal> value,
  ) {
    return _wire_set_global_value__method__WasmRunModuleId(
      that,
      global,
      value,
    );
  }

  late final _wire_set_global_value__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
                  wire_Global, ffi.Pointer<wire_WasmVal>)>>(
      'wire_set_global_value__method__WasmRunModuleId');
  late final _wire_set_global_value__method__WasmRunModuleId =
      _wire_set_global_value__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              wire_Global, ffi.Pointer<wire_WasmVal>)>();

  WireSyncReturn wire_get_memory_type__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Memory memory,
  ) {
    return _wire_get_memory_type__method__WasmRunModuleId(
      that,
      memory,
    );
  }

  late final _wire_get_memory_type__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              wire_Memory)>>('wire_get_memory_type__method__WasmRunModuleId');
  late final _wire_get_memory_type__method__WasmRunModuleId =
      _wire_get_memory_type__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_Memory)>();

  WireSyncReturn wire_get_memory_data__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Memory memory,
  ) {
    return _wire_get_memory_data__method__WasmRunModuleId(
      that,
      memory,
    );
  }

  late final _wire_get_memory_data__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              wire_Memory)>>('wire_get_memory_data__method__WasmRunModuleId');
  late final _wire_get_memory_data__method__WasmRunModuleId =
      _wire_get_memory_data__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_Memory)>();

  WireSyncReturn wire_get_memory_data_pointer__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Memory memory,
  ) {
    return _wire_get_memory_data_pointer__method__WasmRunModuleId(
      that,
      memory,
    );
  }

  late final _wire_get_memory_data_pointer__method__WasmRunModuleIdPtr =
      _lookup<
              ffi.NativeFunction<
                  WireSyncReturn Function(
                      ffi.Pointer<wire_WasmRunModuleId>, wire_Memory)>>(
          'wire_get_memory_data_pointer__method__WasmRunModuleId');
  late final _wire_get_memory_data_pointer__method__WasmRunModuleId =
      _wire_get_memory_data_pointer__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_Memory)>();

  WireSyncReturn
      wire_get_memory_data_pointer_and_length__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Memory memory,
  ) {
    return _wire_get_memory_data_pointer_and_length__method__WasmRunModuleId(
      that,
      memory,
    );
  }

  late final _wire_get_memory_data_pointer_and_length__method__WasmRunModuleIdPtr =
      _lookup<
              ffi.NativeFunction<
                  WireSyncReturn Function(
                      ffi.Pointer<wire_WasmRunModuleId>, wire_Memory)>>(
          'wire_get_memory_data_pointer_and_length__method__WasmRunModuleId');
  late final _wire_get_memory_data_pointer_and_length__method__WasmRunModuleId =
      _wire_get_memory_data_pointer_and_length__method__WasmRunModuleIdPtr
          .asFunction<
              WireSyncReturn Function(
                  ffi.Pointer<wire_WasmRunModuleId>, wire_Memory)>();

  WireSyncReturn wire_read_memory__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Memory memory,
    int offset,
    int bytes,
  ) {
    return _wire_read_memory__method__WasmRunModuleId(
      that,
      memory,
      offset,
      bytes,
    );
  }

  late final _wire_read_memory__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>,
              wire_Memory,
              ffi.UintPtr,
              ffi.UintPtr)>>('wire_read_memory__method__WasmRunModuleId');
  late final _wire_read_memory__method__WasmRunModuleId =
      _wire_read_memory__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_Memory, int, int)>();

  WireSyncReturn wire_get_memory_pages__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Memory memory,
  ) {
    return _wire_get_memory_pages__method__WasmRunModuleId(
      that,
      memory,
    );
  }

  late final _wire_get_memory_pages__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              wire_Memory)>>('wire_get_memory_pages__method__WasmRunModuleId');
  late final _wire_get_memory_pages__method__WasmRunModuleId =
      _wire_get_memory_pages__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_Memory)>();

  WireSyncReturn wire_write_memory__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Memory memory,
    int offset,
    ffi.Pointer<wire_uint_8_list> buffer,
  ) {
    return _wire_write_memory__method__WasmRunModuleId(
      that,
      memory,
      offset,
      buffer,
    );
  }

  late final _wire_write_memory__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
                  wire_Memory, ffi.UintPtr, ffi.Pointer<wire_uint_8_list>)>>(
      'wire_write_memory__method__WasmRunModuleId');
  late final _wire_write_memory__method__WasmRunModuleId =
      _wire_write_memory__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              wire_Memory, int, ffi.Pointer<wire_uint_8_list>)>();

  WireSyncReturn wire_grow_memory__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Memory memory,
    int pages,
  ) {
    return _wire_grow_memory__method__WasmRunModuleId(
      that,
      memory,
      pages,
    );
  }

  late final _wire_grow_memory__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>,
              wire_Memory,
              ffi.Uint32)>>('wire_grow_memory__method__WasmRunModuleId');
  late final _wire_grow_memory__method__WasmRunModuleId =
      _wire_grow_memory__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_Memory, int)>();

  WireSyncReturn wire_get_table_size__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Table table,
  ) {
    return _wire_get_table_size__method__WasmRunModuleId(
      that,
      table,
    );
  }

  late final _wire_get_table_size__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              wire_Table)>>('wire_get_table_size__method__WasmRunModuleId');
  late final _wire_get_table_size__method__WasmRunModuleId =
      _wire_get_table_size__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_Table)>();

  WireSyncReturn wire_get_table_type__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Table table,
  ) {
    return _wire_get_table_type__method__WasmRunModuleId(
      that,
      table,
    );
  }

  late final _wire_get_table_type__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              wire_Table)>>('wire_get_table_type__method__WasmRunModuleId');
  late final _wire_get_table_type__method__WasmRunModuleId =
      _wire_get_table_type__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_Table)>();

  WireSyncReturn wire_grow_table__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Table table,
    int delta,
    ffi.Pointer<wire_WasmVal> value,
  ) {
    return _wire_grow_table__method__WasmRunModuleId(
      that,
      table,
      delta,
      value,
    );
  }

  late final _wire_grow_table__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
                  wire_Table, ffi.Uint32, ffi.Pointer<wire_WasmVal>)>>(
      'wire_grow_table__method__WasmRunModuleId');
  late final _wire_grow_table__method__WasmRunModuleId =
      _wire_grow_table__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>, wire_Table,
              int, ffi.Pointer<wire_WasmVal>)>();

  WireSyncReturn wire_get_table__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Table table,
    int index,
  ) {
    return _wire_get_table__method__WasmRunModuleId(
      that,
      table,
      index,
    );
  }

  late final _wire_get_table__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>, wire_Table,
              ffi.Uint32)>>('wire_get_table__method__WasmRunModuleId');
  late final _wire_get_table__method__WasmRunModuleId =
      _wire_get_table__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>, wire_Table, int)>();

  WireSyncReturn wire_set_table__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Table table,
    int index,
    ffi.Pointer<wire_WasmVal> value,
  ) {
    return _wire_set_table__method__WasmRunModuleId(
      that,
      table,
      index,
      value,
    );
  }

  late final _wire_set_table__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
                  wire_Table, ffi.Uint32, ffi.Pointer<wire_WasmVal>)>>(
      'wire_set_table__method__WasmRunModuleId');
  late final _wire_set_table__method__WasmRunModuleId =
      _wire_set_table__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>, wire_Table,
              int, ffi.Pointer<wire_WasmVal>)>();

  WireSyncReturn wire_fill_table__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    wire_Table table,
    int index,
    ffi.Pointer<wire_WasmVal> value,
    int len,
  ) {
    return _wire_fill_table__method__WasmRunModuleId(
      that,
      table,
      index,
      value,
      len,
    );
  }

  late final _wire_fill_table__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunModuleId>,
              wire_Table,
              ffi.Uint32,
              ffi.Pointer<wire_WasmVal>,
              ffi.Uint32)>>('wire_fill_table__method__WasmRunModuleId');
  late final _wire_fill_table__method__WasmRunModuleId =
      _wire_fill_table__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>, wire_Table,
              int, ffi.Pointer<wire_WasmVal>, int)>();

  WireSyncReturn wire_add_fuel__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    int delta,
  ) {
    return _wire_add_fuel__method__WasmRunModuleId(
      that,
      delta,
    );
  }

  late final _wire_add_fuel__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              ffi.Uint64)>>('wire_add_fuel__method__WasmRunModuleId');
  late final _wire_add_fuel__method__WasmRunModuleId =
      _wire_add_fuel__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>, int)>();

  WireSyncReturn wire_fuel_consumed__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
  ) {
    return _wire_fuel_consumed__method__WasmRunModuleId(
      that,
    );
  }

  late final _wire_fuel_consumed__method__WasmRunModuleIdPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>)>>(
      'wire_fuel_consumed__method__WasmRunModuleId');
  late final _wire_fuel_consumed__method__WasmRunModuleId =
      _wire_fuel_consumed__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>)>();

  WireSyncReturn wire_consume_fuel__method__WasmRunModuleId(
    ffi.Pointer<wire_WasmRunModuleId> that,
    int delta,
  ) {
    return _wire_consume_fuel__method__WasmRunModuleId(
      that,
      delta,
    );
  }

  late final _wire_consume_fuel__method__WasmRunModuleIdPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>,
              ffi.Uint64)>>('wire_consume_fuel__method__WasmRunModuleId');
  late final _wire_consume_fuel__method__WasmRunModuleId =
      _wire_consume_fuel__method__WasmRunModuleIdPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunModuleId>, int)>();

  WireSyncReturn wire_create_shared_memory__method__CompiledModule(
    ffi.Pointer<wire_CompiledModule> that,
    ffi.Pointer<wire_MemoryTy> memory_type,
  ) {
    return _wire_create_shared_memory__method__CompiledModule(
      that,
      memory_type,
    );
  }

  late final _wire_create_shared_memory__method__CompiledModulePtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_CompiledModule>,
                  ffi.Pointer<wire_MemoryTy>)>>(
      'wire_create_shared_memory__method__CompiledModule');
  late final _wire_create_shared_memory__method__CompiledModule =
      _wire_create_shared_memory__method__CompiledModulePtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_CompiledModule>, ffi.Pointer<wire_MemoryTy>)>();

  WireSyncReturn wire_get_module_imports__method__CompiledModule(
    ffi.Pointer<wire_CompiledModule> that,
  ) {
    return _wire_get_module_imports__method__CompiledModule(
      that,
    );
  }

  late final _wire_get_module_imports__method__CompiledModulePtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_CompiledModule>)>>(
      'wire_get_module_imports__method__CompiledModule');
  late final _wire_get_module_imports__method__CompiledModule =
      _wire_get_module_imports__method__CompiledModulePtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_CompiledModule>)>();

  WireSyncReturn wire_get_module_exports__method__CompiledModule(
    ffi.Pointer<wire_CompiledModule> that,
  ) {
    return _wire_get_module_exports__method__CompiledModule(
      that,
    );
  }

  late final _wire_get_module_exports__method__CompiledModulePtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_CompiledModule>)>>(
      'wire_get_module_exports__method__CompiledModule');
  late final _wire_get_module_exports__method__CompiledModule =
      _wire_get_module_exports__method__CompiledModulePtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_CompiledModule>)>();

  WireSyncReturn wire_ty__method__WasmRunSharedMemory(
    ffi.Pointer<wire_WasmRunSharedMemory> that,
  ) {
    return _wire_ty__method__WasmRunSharedMemory(
      that,
    );
  }

  late final _wire_ty__method__WasmRunSharedMemoryPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunSharedMemory>)>>(
      'wire_ty__method__WasmRunSharedMemory');
  late final _wire_ty__method__WasmRunSharedMemory =
      _wire_ty__method__WasmRunSharedMemoryPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunSharedMemory>)>();

  WireSyncReturn wire_size__method__WasmRunSharedMemory(
    ffi.Pointer<wire_WasmRunSharedMemory> that,
  ) {
    return _wire_size__method__WasmRunSharedMemory(
      that,
    );
  }

  late final _wire_size__method__WasmRunSharedMemoryPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunSharedMemory>)>>(
      'wire_size__method__WasmRunSharedMemory');
  late final _wire_size__method__WasmRunSharedMemory =
      _wire_size__method__WasmRunSharedMemoryPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunSharedMemory>)>();

  WireSyncReturn wire_data_size__method__WasmRunSharedMemory(
    ffi.Pointer<wire_WasmRunSharedMemory> that,
  ) {
    return _wire_data_size__method__WasmRunSharedMemory(
      that,
    );
  }

  late final _wire_data_size__method__WasmRunSharedMemoryPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunSharedMemory>)>>(
      'wire_data_size__method__WasmRunSharedMemory');
  late final _wire_data_size__method__WasmRunSharedMemory =
      _wire_data_size__method__WasmRunSharedMemoryPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunSharedMemory>)>();

  WireSyncReturn wire_data_pointer__method__WasmRunSharedMemory(
    ffi.Pointer<wire_WasmRunSharedMemory> that,
  ) {
    return _wire_data_pointer__method__WasmRunSharedMemory(
      that,
    );
  }

  late final _wire_data_pointer__method__WasmRunSharedMemoryPtr = _lookup<
          ffi.NativeFunction<
              WireSyncReturn Function(ffi.Pointer<wire_WasmRunSharedMemory>)>>(
      'wire_data_pointer__method__WasmRunSharedMemory');
  late final _wire_data_pointer__method__WasmRunSharedMemory =
      _wire_data_pointer__method__WasmRunSharedMemoryPtr.asFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunSharedMemory>)>();

  WireSyncReturn wire_grow__method__WasmRunSharedMemory(
    ffi.Pointer<wire_WasmRunSharedMemory> that,
    int delta,
  ) {
    return _wire_grow__method__WasmRunSharedMemory(
      that,
      delta,
    );
  }

  late final _wire_grow__method__WasmRunSharedMemoryPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(ffi.Pointer<wire_WasmRunSharedMemory>,
              ffi.Uint64)>>('wire_grow__method__WasmRunSharedMemory');
  late final _wire_grow__method__WasmRunSharedMemory =
      _wire_grow__method__WasmRunSharedMemoryPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunSharedMemory>, int)>();

  void wire_atomics__method__WasmRunSharedMemory(
    int port_,
    ffi.Pointer<wire_WasmRunSharedMemory> that,
  ) {
    return _wire_atomics__method__WasmRunSharedMemory(
      port_,
      that,
    );
  }

  late final _wire_atomics__method__WasmRunSharedMemoryPtr = _lookup<
          ffi.NativeFunction<
              ffi.Void Function(
                  ffi.Int64, ffi.Pointer<wire_WasmRunSharedMemory>)>>(
      'wire_atomics__method__WasmRunSharedMemory');
  late final _wire_atomics__method__WasmRunSharedMemory =
      _wire_atomics__method__WasmRunSharedMemoryPtr.asFunction<
          void Function(int, ffi.Pointer<wire_WasmRunSharedMemory>)>();

  WireSyncReturn wire_atomic_notify__method__WasmRunSharedMemory(
    ffi.Pointer<wire_WasmRunSharedMemory> that,
    int addr,
    int count,
  ) {
    return _wire_atomic_notify__method__WasmRunSharedMemory(
      that,
      addr,
      count,
    );
  }

  late final _wire_atomic_notify__method__WasmRunSharedMemoryPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunSharedMemory>,
              ffi.Uint64,
              ffi.Uint32)>>('wire_atomic_notify__method__WasmRunSharedMemory');
  late final _wire_atomic_notify__method__WasmRunSharedMemory =
      _wire_atomic_notify__method__WasmRunSharedMemoryPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunSharedMemory>, int, int)>();

  WireSyncReturn wire_atomic_wait32__method__WasmRunSharedMemory(
    ffi.Pointer<wire_WasmRunSharedMemory> that,
    int addr,
    int expected,
  ) {
    return _wire_atomic_wait32__method__WasmRunSharedMemory(
      that,
      addr,
      expected,
    );
  }

  late final _wire_atomic_wait32__method__WasmRunSharedMemoryPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunSharedMemory>,
              ffi.Uint64,
              ffi.Uint32)>>('wire_atomic_wait32__method__WasmRunSharedMemory');
  late final _wire_atomic_wait32__method__WasmRunSharedMemory =
      _wire_atomic_wait32__method__WasmRunSharedMemoryPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunSharedMemory>, int, int)>();

  WireSyncReturn wire_atomic_wait64__method__WasmRunSharedMemory(
    ffi.Pointer<wire_WasmRunSharedMemory> that,
    int addr,
    int expected,
  ) {
    return _wire_atomic_wait64__method__WasmRunSharedMemory(
      that,
      addr,
      expected,
    );
  }

  late final _wire_atomic_wait64__method__WasmRunSharedMemoryPtr = _lookup<
      ffi.NativeFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunSharedMemory>,
              ffi.Uint64,
              ffi.Uint64)>>('wire_atomic_wait64__method__WasmRunSharedMemory');
  late final _wire_atomic_wait64__method__WasmRunSharedMemory =
      _wire_atomic_wait64__method__WasmRunSharedMemoryPtr.asFunction<
          WireSyncReturn Function(
              ffi.Pointer<wire_WasmRunSharedMemory>, int, int)>();

  void wire_add__method__Atomics(
    int port_,
    ffi.Pointer<wire_Atomics> that,
    int offset,
    int kind,
    int val,
    int order,
  ) {
    return _wire_add__method__Atomics(
      port_,
      that,
      offset,
      kind,
      val,
      order,
    );
  }

  late final _wire_add__method__AtomicsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_Atomics>, ffi.UintPtr,
              ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_add__method__Atomics');
  late final _wire_add__method__Atomics =
      _wire_add__method__AtomicsPtr.asFunction<
          void Function(int, ffi.Pointer<wire_Atomics>, int, int, int, int)>();

  void wire_load__method__Atomics(
    int port_,
    ffi.Pointer<wire_Atomics> that,
    int offset,
    int kind,
    int order,
  ) {
    return _wire_load__method__Atomics(
      port_,
      that,
      offset,
      kind,
      order,
    );
  }

  late final _wire_load__method__AtomicsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_Atomics>, ffi.UintPtr,
              ffi.Int32, ffi.Int32)>>('wire_load__method__Atomics');
  late final _wire_load__method__Atomics =
      _wire_load__method__AtomicsPtr.asFunction<
          void Function(int, ffi.Pointer<wire_Atomics>, int, int, int)>();

  void wire_store__method__Atomics(
    int port_,
    ffi.Pointer<wire_Atomics> that,
    int offset,
    int kind,
    int val,
    int order,
  ) {
    return _wire_store__method__Atomics(
      port_,
      that,
      offset,
      kind,
      val,
      order,
    );
  }

  late final _wire_store__method__AtomicsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_Atomics>, ffi.UintPtr,
              ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_store__method__Atomics');
  late final _wire_store__method__Atomics =
      _wire_store__method__AtomicsPtr.asFunction<
          void Function(int, ffi.Pointer<wire_Atomics>, int, int, int, int)>();

  void wire_swap__method__Atomics(
    int port_,
    ffi.Pointer<wire_Atomics> that,
    int offset,
    int kind,
    int val,
    int order,
  ) {
    return _wire_swap__method__Atomics(
      port_,
      that,
      offset,
      kind,
      val,
      order,
    );
  }

  late final _wire_swap__method__AtomicsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_Atomics>, ffi.UintPtr,
              ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_swap__method__Atomics');
  late final _wire_swap__method__Atomics =
      _wire_swap__method__AtomicsPtr.asFunction<
          void Function(int, ffi.Pointer<wire_Atomics>, int, int, int, int)>();

  void wire_compare_exchange__method__Atomics(
    int port_,
    ffi.Pointer<wire_Atomics> that,
    int offset,
    int kind,
    int current,
    int new_value,
    int success,
    int failure,
  ) {
    return _wire_compare_exchange__method__Atomics(
      port_,
      that,
      offset,
      kind,
      current,
      new_value,
      success,
      failure,
    );
  }

  late final _wire_compare_exchange__method__AtomicsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(
              ffi.Int64,
              ffi.Pointer<wire_Atomics>,
              ffi.UintPtr,
              ffi.Int32,
              ffi.Int64,
              ffi.Int64,
              ffi.Int32,
              ffi.Int32)>>('wire_compare_exchange__method__Atomics');
  late final _wire_compare_exchange__method__Atomics =
      _wire_compare_exchange__method__AtomicsPtr.asFunction<
          void Function(
              int, ffi.Pointer<wire_Atomics>, int, int, int, int, int, int)>();

  void wire_sub__method__Atomics(
    int port_,
    ffi.Pointer<wire_Atomics> that,
    int offset,
    int kind,
    int val,
    int order,
  ) {
    return _wire_sub__method__Atomics(
      port_,
      that,
      offset,
      kind,
      val,
      order,
    );
  }

  late final _wire_sub__method__AtomicsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_Atomics>, ffi.UintPtr,
              ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_sub__method__Atomics');
  late final _wire_sub__method__Atomics =
      _wire_sub__method__AtomicsPtr.asFunction<
          void Function(int, ffi.Pointer<wire_Atomics>, int, int, int, int)>();

  void wire_and__method__Atomics(
    int port_,
    ffi.Pointer<wire_Atomics> that,
    int offset,
    int kind,
    int val,
    int order,
  ) {
    return _wire_and__method__Atomics(
      port_,
      that,
      offset,
      kind,
      val,
      order,
    );
  }

  late final _wire_and__method__AtomicsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_Atomics>, ffi.UintPtr,
              ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_and__method__Atomics');
  late final _wire_and__method__Atomics =
      _wire_and__method__AtomicsPtr.asFunction<
          void Function(int, ffi.Pointer<wire_Atomics>, int, int, int, int)>();

  void wire_or__method__Atomics(
    int port_,
    ffi.Pointer<wire_Atomics> that,
    int offset,
    int kind,
    int val,
    int order,
  ) {
    return _wire_or__method__Atomics(
      port_,
      that,
      offset,
      kind,
      val,
      order,
    );
  }

  late final _wire_or__method__AtomicsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_Atomics>, ffi.UintPtr,
              ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_or__method__Atomics');
  late final _wire_or__method__Atomics =
      _wire_or__method__AtomicsPtr.asFunction<
          void Function(int, ffi.Pointer<wire_Atomics>, int, int, int, int)>();

  void wire_xor__method__Atomics(
    int port_,
    ffi.Pointer<wire_Atomics> that,
    int offset,
    int kind,
    int val,
    int order,
  ) {
    return _wire_xor__method__Atomics(
      port_,
      that,
      offset,
      kind,
      val,
      order,
    );
  }

  late final _wire_xor__method__AtomicsPtr = _lookup<
      ffi.NativeFunction<
          ffi.Void Function(ffi.Int64, ffi.Pointer<wire_Atomics>, ffi.UintPtr,
              ffi.Int32, ffi.Int64, ffi.Int32)>>('wire_xor__method__Atomics');
  late final _wire_xor__method__Atomics =
      _wire_xor__method__AtomicsPtr.asFunction<
          void Function(int, ffi.Pointer<wire_Atomics>, int, int, int, int)>();

  wire_ArcRwLockSharedMemory new_ArcRwLockSharedMemory() {
    return _new_ArcRwLockSharedMemory();
  }

  late final _new_ArcRwLockSharedMemoryPtr =
      _lookup<ffi.NativeFunction<wire_ArcRwLockSharedMemory Function()>>(
          'new_ArcRwLockSharedMemory');
  late final _new_ArcRwLockSharedMemory = _new_ArcRwLockSharedMemoryPtr
      .asFunction<wire_ArcRwLockSharedMemory Function()>();

  wire_ArcStdSyncMutexModule new_ArcStdSyncMutexModule() {
    return _new_ArcStdSyncMutexModule();
  }

  late final _new_ArcStdSyncMutexModulePtr =
      _lookup<ffi.NativeFunction<wire_ArcStdSyncMutexModule Function()>>(
          'new_ArcStdSyncMutexModule');
  late final _new_ArcStdSyncMutexModule = _new_ArcStdSyncMutexModulePtr
      .asFunction<wire_ArcStdSyncMutexModule Function()>();

  wire_CallStack new_CallStack() {
    return _new_CallStack();
  }

  late final _new_CallStackPtr =
      _lookup<ffi.NativeFunction<wire_CallStack Function()>>('new_CallStack');
  late final _new_CallStack =
      _new_CallStackPtr.asFunction<wire_CallStack Function()>();

  wire_Global new_Global() {
    return _new_Global();
  }

  late final _new_GlobalPtr =
      _lookup<ffi.NativeFunction<wire_Global Function()>>('new_Global');
  late final _new_Global = _new_GlobalPtr.asFunction<wire_Global Function()>();

  wire_Memory new_Memory() {
    return _new_Memory();
  }

  late final _new_MemoryPtr =
      _lookup<ffi.NativeFunction<wire_Memory Function()>>('new_Memory');
  late final _new_Memory = _new_MemoryPtr.asFunction<wire_Memory Function()>();

  ffi.Pointer<wire_StringList> new_StringList_0(
    int len,
  ) {
    return _new_StringList_0(
      len,
    );
  }

  late final _new_StringList_0Ptr = _lookup<
          ffi.NativeFunction<ffi.Pointer<wire_StringList> Function(ffi.Int32)>>(
      'new_StringList_0');
  late final _new_StringList_0 = _new_StringList_0Ptr
      .asFunction<ffi.Pointer<wire_StringList> Function(int)>();

  wire_Table new_Table() {
    return _new_Table();
  }

  late final _new_TablePtr =
      _lookup<ffi.NativeFunction<wire_Table Function()>>('new_Table');
  late final _new_Table = _new_TablePtr.asFunction<wire_Table Function()>();

  wire_WFunc new_WFunc() {
    return _new_WFunc();
  }

  late final _new_WFuncPtr =
      _lookup<ffi.NativeFunction<wire_WFunc Function()>>('new_WFunc');
  late final _new_WFunc = _new_WFuncPtr.asFunction<wire_WFunc Function()>();

  ffi.Pointer<wire_WFunc> new_box_autoadd_WFunc_0() {
    return _new_box_autoadd_WFunc_0();
  }

  late final _new_box_autoadd_WFunc_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_WFunc> Function()>>(
          'new_box_autoadd_WFunc_0');
  late final _new_box_autoadd_WFunc_0 = _new_box_autoadd_WFunc_0Ptr
      .asFunction<ffi.Pointer<wire_WFunc> Function()>();

  ffi.Pointer<wire_Atomics> new_box_autoadd_atomics_0() {
    return _new_box_autoadd_atomics_0();
  }

  late final _new_box_autoadd_atomics_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_Atomics> Function()>>(
          'new_box_autoadd_atomics_0');
  late final _new_box_autoadd_atomics_0 = _new_box_autoadd_atomics_0Ptr
      .asFunction<ffi.Pointer<wire_Atomics> Function()>();

  ffi.Pointer<ffi.Bool> new_box_autoadd_bool_0(
    bool value,
  ) {
    return _new_box_autoadd_bool_0(
      value,
    );
  }

  late final _new_box_autoadd_bool_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Bool> Function(ffi.Bool)>>(
          'new_box_autoadd_bool_0');
  late final _new_box_autoadd_bool_0 = _new_box_autoadd_bool_0Ptr
      .asFunction<ffi.Pointer<ffi.Bool> Function(bool)>();

  ffi.Pointer<wire_CompiledModule> new_box_autoadd_compiled_module_0() {
    return _new_box_autoadd_compiled_module_0();
  }

  late final _new_box_autoadd_compiled_module_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_CompiledModule> Function()>>(
          'new_box_autoadd_compiled_module_0');
  late final _new_box_autoadd_compiled_module_0 =
      _new_box_autoadd_compiled_module_0Ptr
          .asFunction<ffi.Pointer<wire_CompiledModule> Function()>();

  ffi.Pointer<wire_MemoryTy> new_box_autoadd_memory_ty_0() {
    return _new_box_autoadd_memory_ty_0();
  }

  late final _new_box_autoadd_memory_ty_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_MemoryTy> Function()>>(
          'new_box_autoadd_memory_ty_0');
  late final _new_box_autoadd_memory_ty_0 = _new_box_autoadd_memory_ty_0Ptr
      .asFunction<ffi.Pointer<wire_MemoryTy> Function()>();

  ffi.Pointer<wire_ModuleConfig> new_box_autoadd_module_config_0() {
    return _new_box_autoadd_module_config_0();
  }

  late final _new_box_autoadd_module_config_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_ModuleConfig> Function()>>(
          'new_box_autoadd_module_config_0');
  late final _new_box_autoadd_module_config_0 =
      _new_box_autoadd_module_config_0Ptr
          .asFunction<ffi.Pointer<wire_ModuleConfig> Function()>();

  ffi.Pointer<wire_ModuleConfigWasmi> new_box_autoadd_module_config_wasmi_0() {
    return _new_box_autoadd_module_config_wasmi_0();
  }

  late final _new_box_autoadd_module_config_wasmi_0Ptr = _lookup<
          ffi.NativeFunction<ffi.Pointer<wire_ModuleConfigWasmi> Function()>>(
      'new_box_autoadd_module_config_wasmi_0');
  late final _new_box_autoadd_module_config_wasmi_0 =
      _new_box_autoadd_module_config_wasmi_0Ptr
          .asFunction<ffi.Pointer<wire_ModuleConfigWasmi> Function()>();

  ffi.Pointer<wire_ModuleConfigWasmtime>
      new_box_autoadd_module_config_wasmtime_0() {
    return _new_box_autoadd_module_config_wasmtime_0();
  }

  late final _new_box_autoadd_module_config_wasmtime_0Ptr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<wire_ModuleConfigWasmtime> Function()>>(
      'new_box_autoadd_module_config_wasmtime_0');
  late final _new_box_autoadd_module_config_wasmtime_0 =
      _new_box_autoadd_module_config_wasmtime_0Ptr
          .asFunction<ffi.Pointer<wire_ModuleConfigWasmtime> Function()>();

  ffi.Pointer<wire_TableArgs> new_box_autoadd_table_args_0() {
    return _new_box_autoadd_table_args_0();
  }

  late final _new_box_autoadd_table_args_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_TableArgs> Function()>>(
          'new_box_autoadd_table_args_0');
  late final _new_box_autoadd_table_args_0 = _new_box_autoadd_table_args_0Ptr
      .asFunction<ffi.Pointer<wire_TableArgs> Function()>();

  ffi.Pointer<ffi.Uint32> new_box_autoadd_u32_0(
    int value,
  ) {
    return _new_box_autoadd_u32_0(
      value,
    );
  }

  late final _new_box_autoadd_u32_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint32> Function(ffi.Uint32)>>(
          'new_box_autoadd_u32_0');
  late final _new_box_autoadd_u32_0 = _new_box_autoadd_u32_0Ptr
      .asFunction<ffi.Pointer<ffi.Uint32> Function(int)>();

  ffi.Pointer<ffi.Uint64> new_box_autoadd_u64_0(
    int value,
  ) {
    return _new_box_autoadd_u64_0(
      value,
    );
  }

  late final _new_box_autoadd_u64_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ffi.Uint64> Function(ffi.Uint64)>>(
          'new_box_autoadd_u64_0');
  late final _new_box_autoadd_u64_0 = _new_box_autoadd_u64_0Ptr
      .asFunction<ffi.Pointer<ffi.Uint64> Function(int)>();

  ffi.Pointer<ffi.UintPtr> new_box_autoadd_usize_0(
    int value,
  ) {
    return _new_box_autoadd_usize_0(
      value,
    );
  }

  late final _new_box_autoadd_usize_0Ptr = _lookup<
          ffi.NativeFunction<ffi.Pointer<ffi.UintPtr> Function(ffi.UintPtr)>>(
      'new_box_autoadd_usize_0');
  late final _new_box_autoadd_usize_0 = _new_box_autoadd_usize_0Ptr
      .asFunction<ffi.Pointer<ffi.UintPtr> Function(int)>();

  ffi.Pointer<wire_WasiConfigNative> new_box_autoadd_wasi_config_native_0() {
    return _new_box_autoadd_wasi_config_native_0();
  }

  late final _new_box_autoadd_wasi_config_native_0Ptr = _lookup<
          ffi.NativeFunction<ffi.Pointer<wire_WasiConfigNative> Function()>>(
      'new_box_autoadd_wasi_config_native_0');
  late final _new_box_autoadd_wasi_config_native_0 =
      _new_box_autoadd_wasi_config_native_0Ptr
          .asFunction<ffi.Pointer<wire_WasiConfigNative> Function()>();

  ffi.Pointer<wire_WasiStackLimits> new_box_autoadd_wasi_stack_limits_0() {
    return _new_box_autoadd_wasi_stack_limits_0();
  }

  late final _new_box_autoadd_wasi_stack_limits_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_WasiStackLimits> Function()>>(
          'new_box_autoadd_wasi_stack_limits_0');
  late final _new_box_autoadd_wasi_stack_limits_0 =
      _new_box_autoadd_wasi_stack_limits_0Ptr
          .asFunction<ffi.Pointer<wire_WasiStackLimits> Function()>();

  ffi.Pointer<wire_WasmRunInstanceId> new_box_autoadd_wasm_run_instance_id_0() {
    return _new_box_autoadd_wasm_run_instance_id_0();
  }

  late final _new_box_autoadd_wasm_run_instance_id_0Ptr = _lookup<
          ffi.NativeFunction<ffi.Pointer<wire_WasmRunInstanceId> Function()>>(
      'new_box_autoadd_wasm_run_instance_id_0');
  late final _new_box_autoadd_wasm_run_instance_id_0 =
      _new_box_autoadd_wasm_run_instance_id_0Ptr
          .asFunction<ffi.Pointer<wire_WasmRunInstanceId> Function()>();

  ffi.Pointer<wire_WasmRunModuleId> new_box_autoadd_wasm_run_module_id_0() {
    return _new_box_autoadd_wasm_run_module_id_0();
  }

  late final _new_box_autoadd_wasm_run_module_id_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_WasmRunModuleId> Function()>>(
          'new_box_autoadd_wasm_run_module_id_0');
  late final _new_box_autoadd_wasm_run_module_id_0 =
      _new_box_autoadd_wasm_run_module_id_0Ptr
          .asFunction<ffi.Pointer<wire_WasmRunModuleId> Function()>();

  ffi.Pointer<wire_WasmRunSharedMemory>
      new_box_autoadd_wasm_run_shared_memory_0() {
    return _new_box_autoadd_wasm_run_shared_memory_0();
  }

  late final _new_box_autoadd_wasm_run_shared_memory_0Ptr = _lookup<
          ffi.NativeFunction<ffi.Pointer<wire_WasmRunSharedMemory> Function()>>(
      'new_box_autoadd_wasm_run_shared_memory_0');
  late final _new_box_autoadd_wasm_run_shared_memory_0 =
      _new_box_autoadd_wasm_run_shared_memory_0Ptr
          .asFunction<ffi.Pointer<wire_WasmRunSharedMemory> Function()>();

  ffi.Pointer<wire_WasmVal> new_box_autoadd_wasm_val_0() {
    return _new_box_autoadd_wasm_val_0();
  }

  late final _new_box_autoadd_wasm_val_0Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<wire_WasmVal> Function()>>(
          'new_box_autoadd_wasm_val_0');
  late final _new_box_autoadd_wasm_val_0 = _new_box_autoadd_wasm_val_0Ptr
      .asFunction<ffi.Pointer<wire_WasmVal> Function()>();

  ffi.Pointer<wire_list_env_variable> new_list_env_variable_0(
    int len,
  ) {
    return _new_list_env_variable_0(
      len,
    );
  }

  late final _new_list_env_variable_0Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<wire_list_env_variable> Function(
              ffi.Int32)>>('new_list_env_variable_0');
  late final _new_list_env_variable_0 = _new_list_env_variable_0Ptr
      .asFunction<ffi.Pointer<wire_list_env_variable> Function(int)>();

  ffi.Pointer<wire_list_module_import> new_list_module_import_0(
    int len,
  ) {
    return _new_list_module_import_0(
      len,
    );
  }

  late final _new_list_module_import_0Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<wire_list_module_import> Function(
              ffi.Int32)>>('new_list_module_import_0');
  late final _new_list_module_import_0 = _new_list_module_import_0Ptr
      .asFunction<ffi.Pointer<wire_list_module_import> Function(int)>();

  ffi.Pointer<wire_list_preopened_dir> new_list_preopened_dir_0(
    int len,
  ) {
    return _new_list_preopened_dir_0(
      len,
    );
  }

  late final _new_list_preopened_dir_0Ptr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<wire_list_preopened_dir> Function(
              ffi.Int32)>>('new_list_preopened_dir_0');
  late final _new_list_preopened_dir_0 = _new_list_preopened_dir_0Ptr
      .asFunction<ffi.Pointer<wire_list_preopened_dir> Function(int)>();

  ffi.Pointer<wire_list_value_ty> new_list_value_ty_0(
    int len,
  ) {
    return _new_list_value_ty_0(
      len,
    );
  }

  late final _new_list_value_ty_0Ptr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<wire_list_value_ty> Function(ffi.Int32)>>(
      'new_list_value_ty_0');
  late final _new_list_value_ty_0 = _new_list_value_ty_0Ptr
      .asFunction<ffi.Pointer<wire_list_value_ty> Function(int)>();

  ffi.Pointer<wire_list_wasm_val> new_list_wasm_val_0(
    int len,
  ) {
    return _new_list_wasm_val_0(
      len,
    );
  }

  late final _new_list_wasm_val_0Ptr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<wire_list_wasm_val> Function(ffi.Int32)>>(
      'new_list_wasm_val_0');
  late final _new_list_wasm_val_0 = _new_list_wasm_val_0Ptr
      .asFunction<ffi.Pointer<wire_list_wasm_val> Function(int)>();

  ffi.Pointer<wire_uint_8_list> new_uint_8_list_0(
    int len,
  ) {
    return _new_uint_8_list_0(
      len,
    );
  }

  late final _new_uint_8_list_0Ptr = _lookup<
          ffi
          .NativeFunction<ffi.Pointer<wire_uint_8_list> Function(ffi.Int32)>>(
      'new_uint_8_list_0');
  late final _new_uint_8_list_0 = _new_uint_8_list_0Ptr
      .asFunction<ffi.Pointer<wire_uint_8_list> Function(int)>();

  void drop_opaque_ArcRwLockSharedMemory(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _drop_opaque_ArcRwLockSharedMemory(
      ptr,
    );
  }

  late final _drop_opaque_ArcRwLockSharedMemoryPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'drop_opaque_ArcRwLockSharedMemory');
  late final _drop_opaque_ArcRwLockSharedMemory =
      _drop_opaque_ArcRwLockSharedMemoryPtr
          .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> share_opaque_ArcRwLockSharedMemory(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _share_opaque_ArcRwLockSharedMemory(
      ptr,
    );
  }

  late final _share_opaque_ArcRwLockSharedMemoryPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('share_opaque_ArcRwLockSharedMemory');
  late final _share_opaque_ArcRwLockSharedMemory =
      _share_opaque_ArcRwLockSharedMemoryPtr
          .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  void drop_opaque_ArcStdSyncMutexModule(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _drop_opaque_ArcStdSyncMutexModule(
      ptr,
    );
  }

  late final _drop_opaque_ArcStdSyncMutexModulePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'drop_opaque_ArcStdSyncMutexModule');
  late final _drop_opaque_ArcStdSyncMutexModule =
      _drop_opaque_ArcStdSyncMutexModulePtr
          .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> share_opaque_ArcStdSyncMutexModule(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _share_opaque_ArcStdSyncMutexModule(
      ptr,
    );
  }

  late final _share_opaque_ArcStdSyncMutexModulePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('share_opaque_ArcStdSyncMutexModule');
  late final _share_opaque_ArcStdSyncMutexModule =
      _share_opaque_ArcStdSyncMutexModulePtr
          .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  void drop_opaque_CallStack(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _drop_opaque_CallStack(
      ptr,
    );
  }

  late final _drop_opaque_CallStackPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'drop_opaque_CallStack');
  late final _drop_opaque_CallStack = _drop_opaque_CallStackPtr
      .asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> share_opaque_CallStack(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _share_opaque_CallStack(
      ptr,
    );
  }

  late final _share_opaque_CallStackPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('share_opaque_CallStack');
  late final _share_opaque_CallStack = _share_opaque_CallStackPtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  void drop_opaque_Global(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _drop_opaque_Global(
      ptr,
    );
  }

  late final _drop_opaque_GlobalPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'drop_opaque_Global');
  late final _drop_opaque_Global =
      _drop_opaque_GlobalPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> share_opaque_Global(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _share_opaque_Global(
      ptr,
    );
  }

  late final _share_opaque_GlobalPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('share_opaque_Global');
  late final _share_opaque_Global = _share_opaque_GlobalPtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  void drop_opaque_Memory(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _drop_opaque_Memory(
      ptr,
    );
  }

  late final _drop_opaque_MemoryPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'drop_opaque_Memory');
  late final _drop_opaque_Memory =
      _drop_opaque_MemoryPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> share_opaque_Memory(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _share_opaque_Memory(
      ptr,
    );
  }

  late final _share_opaque_MemoryPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('share_opaque_Memory');
  late final _share_opaque_Memory = _share_opaque_MemoryPtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  void drop_opaque_Table(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _drop_opaque_Table(
      ptr,
    );
  }

  late final _drop_opaque_TablePtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'drop_opaque_Table');
  late final _drop_opaque_Table =
      _drop_opaque_TablePtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> share_opaque_Table(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _share_opaque_Table(
      ptr,
    );
  }

  late final _share_opaque_TablePtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('share_opaque_Table');
  late final _share_opaque_Table = _share_opaque_TablePtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  void drop_opaque_WFunc(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _drop_opaque_WFunc(
      ptr,
    );
  }

  late final _drop_opaque_WFuncPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(ffi.Pointer<ffi.Void>)>>(
          'drop_opaque_WFunc');
  late final _drop_opaque_WFunc =
      _drop_opaque_WFuncPtr.asFunction<void Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ffi.Void> share_opaque_WFunc(
    ffi.Pointer<ffi.Void> ptr,
  ) {
    return _share_opaque_WFunc(
      ptr,
    );
  }

  late final _share_opaque_WFuncPtr = _lookup<
      ffi.NativeFunction<
          ffi.Pointer<ffi.Void> Function(
              ffi.Pointer<ffi.Void>)>>('share_opaque_WFunc');
  late final _share_opaque_WFunc = _share_opaque_WFuncPtr
      .asFunction<ffi.Pointer<ffi.Void> Function(ffi.Pointer<ffi.Void>)>();

  ffi.Pointer<ExternalValueKind> inflate_ExternalValue_Func() {
    return _inflate_ExternalValue_Func();
  }

  late final _inflate_ExternalValue_FuncPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ExternalValueKind> Function()>>(
          'inflate_ExternalValue_Func');
  late final _inflate_ExternalValue_Func = _inflate_ExternalValue_FuncPtr
      .asFunction<ffi.Pointer<ExternalValueKind> Function()>();

  ffi.Pointer<ExternalValueKind> inflate_ExternalValue_Global() {
    return _inflate_ExternalValue_Global();
  }

  late final _inflate_ExternalValue_GlobalPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ExternalValueKind> Function()>>(
          'inflate_ExternalValue_Global');
  late final _inflate_ExternalValue_Global = _inflate_ExternalValue_GlobalPtr
      .asFunction<ffi.Pointer<ExternalValueKind> Function()>();

  ffi.Pointer<ExternalValueKind> inflate_ExternalValue_Table() {
    return _inflate_ExternalValue_Table();
  }

  late final _inflate_ExternalValue_TablePtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ExternalValueKind> Function()>>(
          'inflate_ExternalValue_Table');
  late final _inflate_ExternalValue_Table = _inflate_ExternalValue_TablePtr
      .asFunction<ffi.Pointer<ExternalValueKind> Function()>();

  ffi.Pointer<ExternalValueKind> inflate_ExternalValue_Memory() {
    return _inflate_ExternalValue_Memory();
  }

  late final _inflate_ExternalValue_MemoryPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ExternalValueKind> Function()>>(
          'inflate_ExternalValue_Memory');
  late final _inflate_ExternalValue_Memory = _inflate_ExternalValue_MemoryPtr
      .asFunction<ffi.Pointer<ExternalValueKind> Function()>();

  ffi.Pointer<ExternalValueKind> inflate_ExternalValue_SharedMemory() {
    return _inflate_ExternalValue_SharedMemory();
  }

  late final _inflate_ExternalValue_SharedMemoryPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<ExternalValueKind> Function()>>(
          'inflate_ExternalValue_SharedMemory');
  late final _inflate_ExternalValue_SharedMemory =
      _inflate_ExternalValue_SharedMemoryPtr
          .asFunction<ffi.Pointer<ExternalValueKind> Function()>();

  ffi.Pointer<WasmValKind> inflate_WasmVal_i32() {
    return _inflate_WasmVal_i32();
  }

  late final _inflate_WasmVal_i32Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<WasmValKind> Function()>>(
          'inflate_WasmVal_i32');
  late final _inflate_WasmVal_i32 =
      _inflate_WasmVal_i32Ptr.asFunction<ffi.Pointer<WasmValKind> Function()>();

  ffi.Pointer<WasmValKind> inflate_WasmVal_i64() {
    return _inflate_WasmVal_i64();
  }

  late final _inflate_WasmVal_i64Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<WasmValKind> Function()>>(
          'inflate_WasmVal_i64');
  late final _inflate_WasmVal_i64 =
      _inflate_WasmVal_i64Ptr.asFunction<ffi.Pointer<WasmValKind> Function()>();

  ffi.Pointer<WasmValKind> inflate_WasmVal_f32() {
    return _inflate_WasmVal_f32();
  }

  late final _inflate_WasmVal_f32Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<WasmValKind> Function()>>(
          'inflate_WasmVal_f32');
  late final _inflate_WasmVal_f32 =
      _inflate_WasmVal_f32Ptr.asFunction<ffi.Pointer<WasmValKind> Function()>();

  ffi.Pointer<WasmValKind> inflate_WasmVal_f64() {
    return _inflate_WasmVal_f64();
  }

  late final _inflate_WasmVal_f64Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<WasmValKind> Function()>>(
          'inflate_WasmVal_f64');
  late final _inflate_WasmVal_f64 =
      _inflate_WasmVal_f64Ptr.asFunction<ffi.Pointer<WasmValKind> Function()>();

  ffi.Pointer<WasmValKind> inflate_WasmVal_v128() {
    return _inflate_WasmVal_v128();
  }

  late final _inflate_WasmVal_v128Ptr =
      _lookup<ffi.NativeFunction<ffi.Pointer<WasmValKind> Function()>>(
          'inflate_WasmVal_v128');
  late final _inflate_WasmVal_v128 = _inflate_WasmVal_v128Ptr
      .asFunction<ffi.Pointer<WasmValKind> Function()>();

  ffi.Pointer<WasmValKind> inflate_WasmVal_funcRef() {
    return _inflate_WasmVal_funcRef();
  }

  late final _inflate_WasmVal_funcRefPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<WasmValKind> Function()>>(
          'inflate_WasmVal_funcRef');
  late final _inflate_WasmVal_funcRef = _inflate_WasmVal_funcRefPtr
      .asFunction<ffi.Pointer<WasmValKind> Function()>();

  ffi.Pointer<WasmValKind> inflate_WasmVal_externRef() {
    return _inflate_WasmVal_externRef();
  }

  late final _inflate_WasmVal_externRefPtr =
      _lookup<ffi.NativeFunction<ffi.Pointer<WasmValKind> Function()>>(
          'inflate_WasmVal_externRef');
  late final _inflate_WasmVal_externRef = _inflate_WasmVal_externRefPtr
      .asFunction<ffi.Pointer<WasmValKind> Function()>();

  void free_WireSyncReturn(
    WireSyncReturn ptr,
  ) {
    return _free_WireSyncReturn(
      ptr,
    );
  }

  late final _free_WireSyncReturnPtr =
      _lookup<ffi.NativeFunction<ffi.Void Function(WireSyncReturn)>>(
          'free_WireSyncReturn');
  late final _free_WireSyncReturn =
      _free_WireSyncReturnPtr.asFunction<void Function(WireSyncReturn)>();
}

final class _Dart_Handle extends ffi.Opaque {}

final class wire_ArcStdSyncMutexModule extends ffi.Struct {
  external ffi.Pointer<ffi.Void> ptr;
}

final class wire_CompiledModule extends ffi.Struct {
  external wire_ArcStdSyncMutexModule field0;
}

final class wire_uint_8_list extends ffi.Struct {
  external ffi.Pointer<ffi.Uint8> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_StringList extends ffi.Struct {
  external ffi.Pointer<ffi.Pointer<wire_uint_8_list>> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_EnvVariable extends ffi.Struct {
  external ffi.Pointer<wire_uint_8_list> name;

  external ffi.Pointer<wire_uint_8_list> value;
}

final class wire_list_env_variable extends ffi.Struct {
  external ffi.Pointer<wire_EnvVariable> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_PreopenedDir extends ffi.Struct {
  external ffi.Pointer<wire_uint_8_list> wasm_guest_path;

  external ffi.Pointer<wire_uint_8_list> host_path;
}

final class wire_list_preopened_dir extends ffi.Struct {
  external ffi.Pointer<wire_PreopenedDir> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_WasiConfigNative extends ffi.Struct {
  @ffi.Bool()
  external bool capture_stdout;

  @ffi.Bool()
  external bool capture_stderr;

  @ffi.Bool()
  external bool inherit_stdin;

  @ffi.Bool()
  external bool inherit_env;

  @ffi.Bool()
  external bool inherit_args;

  external ffi.Pointer<wire_StringList> args;

  external ffi.Pointer<wire_list_env_variable> env;

  external ffi.Pointer<wire_StringList> preopened_files;

  external ffi.Pointer<wire_list_preopened_dir> preopened_dirs;
}

final class wire_WasiStackLimits extends ffi.Struct {
  @ffi.UintPtr()
  external int initial_value_stack_height;

  @ffi.UintPtr()
  external int maximum_value_stack_height;

  @ffi.UintPtr()
  external int maximum_recursion_depth;
}

final class wire_ModuleConfigWasmi extends ffi.Struct {
  external ffi.Pointer<wire_WasiStackLimits> stack_limits;

  external ffi.Pointer<ffi.UintPtr> cached_stacks;

  external ffi.Pointer<ffi.Bool> mutable_global;

  external ffi.Pointer<ffi.Bool> sign_extension;

  external ffi.Pointer<ffi.Bool> saturating_float_to_int;

  external ffi.Pointer<ffi.Bool> tail_call;

  external ffi.Pointer<ffi.Bool> extended_const;

  external ffi.Pointer<ffi.Bool> floats;
}

final class wire_ModuleConfigWasmtime extends ffi.Struct {
  external ffi.Pointer<ffi.Bool> debug_info;

  external ffi.Pointer<ffi.Bool> wasm_backtrace;

  external ffi.Pointer<ffi.Bool> native_unwind_info;

  external ffi.Pointer<ffi.UintPtr> max_wasm_stack;

  external ffi.Pointer<ffi.Bool> wasm_threads;

  external ffi.Pointer<ffi.Bool> wasm_simd;

  external ffi.Pointer<ffi.Bool> wasm_relaxed_simd;

  external ffi.Pointer<ffi.Bool> relaxed_simd_deterministic;

  external ffi.Pointer<ffi.Bool> wasm_multi_memory;

  external ffi.Pointer<ffi.Bool> wasm_memory64;

  external ffi.Pointer<ffi.Uint64> static_memory_maximum_size;

  external ffi.Pointer<ffi.Bool> static_memory_forced;

  external ffi.Pointer<ffi.Uint64> static_memory_guard_size;

  external ffi.Pointer<ffi.Bool> parallel_compilation;

  external ffi.Pointer<ffi.Bool> generate_address_map;
}

final class wire_ModuleConfig extends ffi.Struct {
  external ffi.Pointer<ffi.Bool> multi_value;

  external ffi.Pointer<ffi.Bool> bulk_memory;

  external ffi.Pointer<ffi.Bool> reference_types;

  external ffi.Pointer<ffi.Bool> consume_fuel;

  external ffi.Pointer<wire_ModuleConfigWasmi> wasmi;

  external ffi.Pointer<wire_ModuleConfigWasmtime> wasmtime;
}

final class wire_WasmRunInstanceId extends ffi.Struct {
  @ffi.Uint32()
  external int field0;
}

final class wire_CallStack extends ffi.Struct {
  external ffi.Pointer<ffi.Void> ptr;
}

final class wire_WasmRunModuleId extends ffi.Struct {
  @ffi.Uint32()
  external int field0;

  external wire_CallStack field1;
}

final class wire_WFunc extends ffi.Struct {
  external ffi.Pointer<ffi.Void> ptr;
}

final class wire_ExternalValue_Func extends ffi.Struct {
  external wire_WFunc field0;
}

final class wire_Global extends ffi.Struct {
  external ffi.Pointer<ffi.Void> ptr;
}

final class wire_ExternalValue_Global extends ffi.Struct {
  external wire_Global field0;
}

final class wire_Table extends ffi.Struct {
  external ffi.Pointer<ffi.Void> ptr;
}

final class wire_ExternalValue_Table extends ffi.Struct {
  external wire_Table field0;
}

final class wire_Memory extends ffi.Struct {
  external ffi.Pointer<ffi.Void> ptr;
}

final class wire_ExternalValue_Memory extends ffi.Struct {
  external wire_Memory field0;
}

final class wire_ArcRwLockSharedMemory extends ffi.Struct {
  external ffi.Pointer<ffi.Void> ptr;
}

final class wire_WasmRunSharedMemory extends ffi.Struct {
  external wire_ArcRwLockSharedMemory field0;
}

final class wire_ExternalValue_SharedMemory extends ffi.Struct {
  external ffi.Pointer<wire_WasmRunSharedMemory> field0;
}

final class ExternalValueKind extends ffi.Union {
  external ffi.Pointer<wire_ExternalValue_Func> Func;

  external ffi.Pointer<wire_ExternalValue_Global> Global;

  external ffi.Pointer<wire_ExternalValue_Table> Table;

  external ffi.Pointer<wire_ExternalValue_Memory> Memory;

  external ffi.Pointer<wire_ExternalValue_SharedMemory> SharedMemory;
}

final class wire_ExternalValue extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external ffi.Pointer<ExternalValueKind> kind;
}

final class wire_ModuleImport extends ffi.Struct {
  external ffi.Pointer<wire_uint_8_list> module;

  external ffi.Pointer<wire_uint_8_list> name;

  external wire_ExternalValue value;
}

final class wire_list_module_import extends ffi.Struct {
  external ffi.Pointer<wire_ModuleImport> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_WasmVal_i32 extends ffi.Struct {
  @ffi.Int32()
  external int field0;
}

final class wire_WasmVal_i64 extends ffi.Struct {
  @ffi.Int64()
  external int field0;
}

final class wire_WasmVal_f32 extends ffi.Struct {
  @ffi.Float()
  external double field0;
}

final class wire_WasmVal_f64 extends ffi.Struct {
  @ffi.Double()
  external double field0;
}

final class wire_WasmVal_v128 extends ffi.Struct {
  external ffi.Pointer<wire_uint_8_list> field0;
}

final class wire_WasmVal_funcRef extends ffi.Struct {
  external ffi.Pointer<wire_WFunc> field0;
}

final class wire_WasmVal_externRef extends ffi.Struct {
  external ffi.Pointer<ffi.Uint32> field0;
}

final class WasmValKind extends ffi.Union {
  external ffi.Pointer<wire_WasmVal_i32> i32;

  external ffi.Pointer<wire_WasmVal_i64> i64;

  external ffi.Pointer<wire_WasmVal_f32> f32;

  external ffi.Pointer<wire_WasmVal_f64> f64;

  external ffi.Pointer<wire_WasmVal_v128> v128;

  external ffi.Pointer<wire_WasmVal_funcRef> funcRef;

  external ffi.Pointer<wire_WasmVal_externRef> externRef;
}

final class wire_WasmVal extends ffi.Struct {
  @ffi.Int32()
  external int tag;

  external ffi.Pointer<WasmValKind> kind;
}

final class wire_list_wasm_val extends ffi.Struct {
  external ffi.Pointer<wire_WasmVal> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_list_value_ty extends ffi.Struct {
  external ffi.Pointer<ffi.Int32> ptr;

  @ffi.Int32()
  external int len;
}

final class wire_MemoryTy extends ffi.Struct {
  @ffi.Bool()
  external bool shared;

  @ffi.Uint32()
  external int minimum;

  external ffi.Pointer<ffi.Uint32> maximum;
}

final class wire_TableArgs extends ffi.Struct {
  @ffi.Uint32()
  external int minimum;

  external ffi.Pointer<ffi.Uint32> maximum;
}

final class wire_Atomics extends ffi.Struct {
  @ffi.UintPtr()
  external int field0;
}

typedef DartPostCObjectFnType = ffi.Pointer<
    ffi.NativeFunction<
        ffi.Bool Function(DartPort port_id, ffi.Pointer<ffi.Void> message)>>;
typedef DartPort = ffi.Int64;

juancastillo0 / wasm_run / 6448410382

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous