wasmvision 0.7.0

// Generated by `wit-bindgen` 0.38.0. DO NOT EDIT!
// Options used:
#[allow(dead_code, clippy::all)]
pub mod wasmvision {
  pub mod platform {

    #[allow(dead_code, unused_imports, clippy::all)]
    pub mod time {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      use super::super::super::_rt;
      #[allow(unused_unsafe, clippy::all)]
      /// Get the current time in milliseconds since the Unix epoch. Use 0 for the `tz` parameter for now.
      pub fn now(tz: u32,) -> u64{
        unsafe {

          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "wasmvision:platform/time")]
          extern "C" {
            #[link_name = "now"]
            fn wit_import0(_: i32, ) -> i64;
          }

          #[cfg(not(target_arch = "wasm32"))]
          extern "C" fn wit_import0(_: i32, ) -> i64{ unreachable!() }
          let ret = wit_import0(_rt::as_i32(&tz));
          ret as u64
        }
      }

    }


    #[allow(dead_code, unused_imports, clippy::all)]
    pub mod logging {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      #[allow(unused_unsafe, clippy::all)]
      /// DEPRECATED: Log a message on the host.
      /// Instead use error, warn, info, or debug.
      pub fn log(msg: &str,) -> (){
        unsafe {
          let vec0 = msg;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();

          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "wasmvision:platform/logging")]
          extern "C" {
            #[link_name = "log"]
            fn wit_import1(_: *mut u8, _: usize, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          extern "C" fn wit_import1(_: *mut u8, _: usize, ){ unreachable!() }
          wit_import1(ptr0.cast_mut(), len0);
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      /// Log an error on the host.
      pub fn error(msg: &str,) -> (){
        unsafe {
          let vec0 = msg;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();

          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "wasmvision:platform/logging")]
          extern "C" {
            #[link_name = "error"]
            fn wit_import1(_: *mut u8, _: usize, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          extern "C" fn wit_import1(_: *mut u8, _: usize, ){ unreachable!() }
          wit_import1(ptr0.cast_mut(), len0);
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      /// Log a warning on the host.
      pub fn warn(msg: &str,) -> (){
        unsafe {
          let vec0 = msg;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();

          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "wasmvision:platform/logging")]
          extern "C" {
            #[link_name = "warn"]
            fn wit_import1(_: *mut u8, _: usize, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          extern "C" fn wit_import1(_: *mut u8, _: usize, ){ unreachable!() }
          wit_import1(ptr0.cast_mut(), len0);
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      /// Log some non-critical information on the host.
      pub fn info(msg: &str,) -> (){
        unsafe {
          let vec0 = msg;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();

          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "wasmvision:platform/logging")]
          extern "C" {
            #[link_name = "info"]
            fn wit_import1(_: *mut u8, _: usize, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          extern "C" fn wit_import1(_: *mut u8, _: usize, ){ unreachable!() }
          wit_import1(ptr0.cast_mut(), len0);
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      /// Log some debugging info on the host.
      pub fn debug(msg: &str,) -> (){
        unsafe {
          let vec0 = msg;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();

          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "wasmvision:platform/logging")]
          extern "C" {
            #[link_name = "debug"]
            fn wit_import1(_: *mut u8, _: usize, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          extern "C" fn wit_import1(_: *mut u8, _: usize, ){ unreachable!() }
          wit_import1(ptr0.cast_mut(), len0);
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      /// Print a message on the host. Intended to bypassing the normal logging system.
      pub fn println(msg: &str,) -> (){
        unsafe {
          let vec0 = msg;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();

          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "wasmvision:platform/logging")]
          extern "C" {
            #[link_name = "println"]
            fn wit_import1(_: *mut u8, _: usize, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          extern "C" fn wit_import1(_: *mut u8, _: usize, ){ unreachable!() }
          wit_import1(ptr0.cast_mut(), len0);
        }
      }

    }


    #[allow(dead_code, unused_imports, clippy::all)]
    pub mod config {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      use super::super::super::_rt;
      #[repr(u8)]
      #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
      pub enum ConfigError {
        /// success, all is well.
        Success,
        /// The requested key does not exist in the configuration.
        NoSuchKey,
      }
      impl ConfigError{
        pub fn name(&self) -> &'static str {
          match self {
            ConfigError::Success => "success",
            ConfigError::NoSuchKey => "no-such-key",
          }
        }
        pub fn message(&self) -> &'static str {
          match self {
            ConfigError::Success => "success, all is well.",
            ConfigError::NoSuchKey => "The requested key does not exist in the configuration.",
          }
        }
      }
      impl ::core::fmt::Debug for ConfigError{
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("ConfigError")
          .field("code", &(*self as i32))
          .field("name", &self.name())
          .field("message", &self.message())
          .finish()
        }
      }
      impl ::core::fmt::Display for ConfigError{
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          write!(f, "{} (error {})", self.name(), *self as i32)
        }
      }

      impl std::error::Error for ConfigError {}

      impl ConfigError{
        #[doc(hidden)]
        pub unsafe fn _lift(val: u8) -> ConfigError{
          if !cfg!(debug_assertions) {
            return ::core::mem::transmute(val);
          }

          match val {
            0 => ConfigError::Success,
            1 => ConfigError::NoSuchKey,

            _ => panic!("invalid enum discriminant"),
          }
        }
      }

      #[allow(unused_unsafe, clippy::all)]
      pub fn get_config(key: &str,) -> Result<_rt::String,ConfigError>{
        unsafe {
          #[repr(align(4))]
          struct RetArea([::core::mem::MaybeUninit::<u8>; 12]);
          let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
          let vec0 = key;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();
          let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "wasmvision:platform/config")]
          extern "C" {
            #[link_name = "get-config"]
            fn wit_import2(_: *mut u8, _: usize, _: *mut u8, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          extern "C" fn wit_import2(_: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
          wit_import2(ptr0.cast_mut(), len0, ptr1);
          let l3 = i32::from(*ptr1.add(0).cast::<u8>());
          let result8 = match l3 {
            0 => {
              let e = {
                let l4 = *ptr1.add(4).cast::<*mut u8>();
                let l5 = *ptr1.add(8).cast::<usize>();
                let len6 = l5;
                let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6);

                _rt::string_lift(bytes6)
              };
              Ok(e)
            }
            1 => {
              let e = {
                let l7 = i32::from(*ptr1.add(4).cast::<u8>());

                ConfigError::_lift(l7 as u8)
              };
              Err(e)
            }
            _ => _rt::invalid_enum_discriminant(),
          };
          result8
        }
      }

    }


    #[allow(dead_code, unused_imports, clippy::all)]
    pub mod http {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      use super::super::super::_rt;
      /// HTTP errors returned by the runtime.
      #[repr(u8)]
      #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
      pub enum HttpError {
        Success,
        DestinationNotAllowed,
        InvalidUrl,
        RequestError,
        RuntimeError,
        TooManyRequests,
      }
      impl HttpError{
        pub fn name(&self) -> &'static str {
          match self {
            HttpError::Success => "success",
            HttpError::DestinationNotAllowed => "destination-not-allowed",
            HttpError::InvalidUrl => "invalid-url",
            HttpError::RequestError => "request-error",
            HttpError::RuntimeError => "runtime-error",
            HttpError::TooManyRequests => "too-many-requests",
          }
        }
        pub fn message(&self) -> &'static str {
          match self {
            HttpError::Success => "",
            HttpError::DestinationNotAllowed => "",
            HttpError::InvalidUrl => "",
            HttpError::RequestError => "",
            HttpError::RuntimeError => "",
            HttpError::TooManyRequests => "",
          }
        }
      }
      impl ::core::fmt::Debug for HttpError{
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("HttpError")
          .field("code", &(*self as i32))
          .field("name", &self.name())
          .field("message", &self.message())
          .finish()
        }
      }
      impl ::core::fmt::Display for HttpError{
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          write!(f, "{} (error {})", self.name(), *self as i32)
        }
      }

      impl std::error::Error for HttpError {}

      impl HttpError{
        #[doc(hidden)]
        pub unsafe fn _lift(val: u8) -> HttpError{
          if !cfg!(debug_assertions) {
            return ::core::mem::transmute(val);
          }

          match val {
            0 => HttpError::Success,
            1 => HttpError::DestinationNotAllowed,
            2 => HttpError::InvalidUrl,
            3 => HttpError::RequestError,
            4 => HttpError::RuntimeError,
            5 => HttpError::TooManyRequests,

            _ => panic!("invalid enum discriminant"),
          }
        }
      }

      #[allow(unused_unsafe, clippy::all)]
      /// Get the content at the specified URL.
      /// Returns either the content or an error.
      pub fn get(url: &str,) -> Result<_rt::String,HttpError>{
        unsafe {
          #[repr(align(4))]
          struct RetArea([::core::mem::MaybeUninit::<u8>; 12]);
          let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
          let vec0 = url;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();
          let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "wasmvision:platform/http")]
          extern "C" {
            #[link_name = "get"]
            fn wit_import2(_: *mut u8, _: usize, _: *mut u8, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          extern "C" fn wit_import2(_: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
          wit_import2(ptr0.cast_mut(), len0, ptr1);
          let l3 = i32::from(*ptr1.add(0).cast::<u8>());
          let result8 = match l3 {
            0 => {
              let e = {
                let l4 = *ptr1.add(4).cast::<*mut u8>();
                let l5 = *ptr1.add(8).cast::<usize>();
                let len6 = l5;
                let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6);

                _rt::string_lift(bytes6)
              };
              Ok(e)
            }
            1 => {
              let e = {
                let l7 = i32::from(*ptr1.add(4).cast::<u8>());

                HttpError::_lift(l7 as u8)
              };
              Err(e)
            }
            _ => _rt::invalid_enum_discriminant(),
          };
          result8
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      /// Post the content to the specified URL.
      /// Returns either the response content or an error.
      pub fn post(url: &str,content_type: &str,body: &[u8],) -> Result<_rt::String,HttpError>{
        unsafe {
          #[repr(align(4))]
          struct RetArea([::core::mem::MaybeUninit::<u8>; 12]);
          let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
          let vec0 = url;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();
          let vec1 = content_type;
          let ptr1 = vec1.as_ptr().cast::<u8>();
          let len1 = vec1.len();
          let vec2 = body;
          let ptr2 = vec2.as_ptr().cast::<u8>();
          let len2 = vec2.len();
          let ptr3 = ret_area.0.as_mut_ptr().cast::<u8>();
          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "wasmvision:platform/http")]
          extern "C" {
            #[link_name = "post"]
            fn wit_import4(_: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          extern "C" fn wit_import4(_: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
          wit_import4(ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, ptr2.cast_mut(), len2, ptr3);
          let l5 = i32::from(*ptr3.add(0).cast::<u8>());
          let result10 = match l5 {
            0 => {
              let e = {
                let l6 = *ptr3.add(4).cast::<*mut u8>();
                let l7 = *ptr3.add(8).cast::<usize>();
                let len8 = l7;
                let bytes8 = _rt::Vec::from_raw_parts(l6.cast(), len8, len8);

                _rt::string_lift(bytes8)
              };
              Ok(e)
            }
            1 => {
              let e = {
                let l9 = i32::from(*ptr3.add(4).cast::<u8>());

                HttpError::_lift(l9 as u8)
              };
              Err(e)
            }
            _ => _rt::invalid_enum_discriminant(),
          };
          result10
        }
      }
      #[allow(unused_unsafe, clippy::all)]
      /// Post the image to the specified URL.
      /// Template is the template to use to send the image.
      /// If the content-type is image/jpeg or image/png, the template is ignored, and the image is simply converted and sent in that format.
      /// Otherwise, the template is used to convert the image to the desired format using simple substitution of the symbol %IMAGE%
      /// after base64 encoding the image.
      /// The response-item is the item in the response to return. Usually this will be a JSON element that will be parsed.
      /// Mat is the reference to to the Mat to use.
      pub fn post_image(url: &str,content_type: &str,request_template: &[u8],response_item: &str,mat: u32,) -> Result<_rt::String,HttpError>{
        unsafe {
          #[repr(align(4))]
          struct RetArea([::core::mem::MaybeUninit::<u8>; 12]);
          let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
          let vec0 = url;
          let ptr0 = vec0.as_ptr().cast::<u8>();
          let len0 = vec0.len();
          let vec1 = content_type;
          let ptr1 = vec1.as_ptr().cast::<u8>();
          let len1 = vec1.len();
          let vec2 = request_template;
          let ptr2 = vec2.as_ptr().cast::<u8>();
          let len2 = vec2.len();
          let vec3 = response_item;
          let ptr3 = vec3.as_ptr().cast::<u8>();
          let len3 = vec3.len();
          let ptr4 = ret_area.0.as_mut_ptr().cast::<u8>();
          #[cfg(target_arch = "wasm32")]
          #[link(wasm_import_module = "wasmvision:platform/http")]
          extern "C" {
            #[link_name = "post-image"]
            fn wit_import5(_: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, _: usize, _: i32, _: *mut u8, );
          }

          #[cfg(not(target_arch = "wasm32"))]
          extern "C" fn wit_import5(_: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, _: usize, _: i32, _: *mut u8, ){ unreachable!() }
          wit_import5(ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, ptr2.cast_mut(), len2, ptr3.cast_mut(), len3, _rt::as_i32(&mat), ptr4);
          let l6 = i32::from(*ptr4.add(0).cast::<u8>());
          let result11 = match l6 {
            0 => {
              let e = {
                let l7 = *ptr4.add(4).cast::<*mut u8>();
                let l8 = *ptr4.add(8).cast::<usize>();
                let len9 = l8;
                let bytes9 = _rt::Vec::from_raw_parts(l7.cast(), len9, len9);

                _rt::string_lift(bytes9)
              };
              Ok(e)
            }
            1 => {
              let e = {
                let l10 = i32::from(*ptr4.add(4).cast::<u8>());

                HttpError::_lift(l10 as u8)
              };
              Err(e)
            }
            _ => _rt::invalid_enum_discriminant(),
          };
          result11
        }
      }

    }


    #[allow(dead_code, unused_imports, clippy::all)]
    pub mod datastore {
      #[used]
      #[doc(hidden)]
      static __FORCE_SECTION_REF: fn() =
      super::super::super::__link_custom_section_describing_imports;
      
      use super::super::super::_rt;
      /// datastore errors returned by the runtime.
      #[repr(u8)]
      #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
      pub enum DatastoreError {
        Success,
        NoSuchFrame,
        NoSuchKey,
        RuntimeError,
      }
      impl DatastoreError{
        pub fn name(&self) -> &'static str {
          match self {
            DatastoreError::Success => "success",
            DatastoreError::NoSuchFrame => "no-such-frame",
            DatastoreError::NoSuchKey => "no-such-key",
            DatastoreError::RuntimeError => "runtime-error",
          }
        }
        pub fn message(&self) -> &'static str {
          match self {
            DatastoreError::Success => "",
            DatastoreError::NoSuchFrame => "",
            DatastoreError::NoSuchKey => "",
            DatastoreError::RuntimeError => "",
          }
        }
      }
      impl ::core::fmt::Debug for DatastoreError{
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          f.debug_struct("DatastoreError")
          .field("code", &(*self as i32))
          .field("name", &self.name())
          .field("message", &self.message())
          .finish()
        }
      }
      impl ::core::fmt::Display for DatastoreError{
        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
          write!(f, "{} (error {})", self.name(), *self as i32)
        }
      }

      impl std::error::Error for DatastoreError {}

      impl DatastoreError{
        #[doc(hidden)]
        pub unsafe fn _lift(val: u8) -> DatastoreError{
          if !cfg!(debug_assertions) {
            return ::core::mem::transmute(val);
          }

          match val {
            0 => DatastoreError::Success,
            1 => DatastoreError::NoSuchFrame,
            2 => DatastoreError::NoSuchKey,
            3 => DatastoreError::RuntimeError,

            _ => panic!("invalid enum discriminant"),
          }
        }
      }

      /// frame-store is the interface for storing data associated with a specific frame.

      #[derive(Debug)]
      #[repr(transparent)]
      pub struct FrameStore{
        handle: _rt::Resource<FrameStore>,
      }

      impl FrameStore{
        #[doc(hidden)]
        pub unsafe fn from_handle(handle: u32) -> Self {
          Self {
            handle: _rt::Resource::from_handle(handle),
          }
        }

        #[doc(hidden)]
        pub fn take_handle(&self) -> u32 {
          _rt::Resource::take_handle(&self.handle)
        }

        #[doc(hidden)]
        pub fn handle(&self) -> u32 {
          _rt::Resource::handle(&self.handle)
        }
      }


      unsafe impl _rt::WasmResource for FrameStore{
        #[inline]
        unsafe fn drop(_handle: u32) {
          #[cfg(not(target_arch = "wasm32"))]
          unreachable!();

          #[cfg(target_arch = "wasm32")]
          {
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[resource-drop]frame-store"]
              fn drop(_: u32);
            }

            drop(_handle);
          }
        }
      }

      /// processor-store is the interface for storing data associated with a processor.

      #[derive(Debug)]
      #[repr(transparent)]
      pub struct ProcessorStore{
        handle: _rt::Resource<ProcessorStore>,
      }

      impl ProcessorStore{
        #[doc(hidden)]
        pub unsafe fn from_handle(handle: u32) -> Self {
          Self {
            handle: _rt::Resource::from_handle(handle),
          }
        }

        #[doc(hidden)]
        pub fn take_handle(&self) -> u32 {
          _rt::Resource::take_handle(&self.handle)
        }

        #[doc(hidden)]
        pub fn handle(&self) -> u32 {
          _rt::Resource::handle(&self.handle)
        }
      }


      unsafe impl _rt::WasmResource for ProcessorStore{
        #[inline]
        unsafe fn drop(_handle: u32) {
          #[cfg(not(target_arch = "wasm32"))]
          unreachable!();

          #[cfg(target_arch = "wasm32")]
          {
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[resource-drop]processor-store"]
              fn drop(_: u32);
            }

            drop(_handle);
          }
        }
      }

      impl FrameStore {
        #[allow(unused_unsafe, clippy::all)]
        /// The id param is currently ignored
        pub fn new(id: u32,) -> Self{
          unsafe {

            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[constructor]frame-store"]
              fn wit_import0(_: i32, ) -> i32;
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import0(_: i32, ) -> i32{ unreachable!() }
            let ret = wit_import0(_rt::as_i32(&id));
            FrameStore::from_handle(ret as u32)
          }
        }
      }
      impl FrameStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Get the value associated with the specified `key` for the specific frame.
        ///
        /// Returns `ok(none)` if the key does not exist.
        pub fn get(&self,frame: u32,key: &str,) -> Result<_rt::String,DatastoreError>{
          unsafe {
            #[repr(align(4))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 12]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
            let vec0 = key;
            let ptr0 = vec0.as_ptr().cast::<u8>();
            let len0 = vec0.len();
            let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]frame-store.get"]
              fn wit_import2(_: i32, _: i32, _: *mut u8, _: usize, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import2(_: i32, _: i32, _: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
            wit_import2((self).handle() as i32, _rt::as_i32(&frame), ptr0.cast_mut(), len0, ptr1);
            let l3 = i32::from(*ptr1.add(0).cast::<u8>());
            let result8 = match l3 {
              0 => {
                let e = {
                  let l4 = *ptr1.add(4).cast::<*mut u8>();
                  let l5 = *ptr1.add(8).cast::<usize>();
                  let len6 = l5;
                  let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6);

                  _rt::string_lift(bytes6)
                };
                Ok(e)
              }
              1 => {
                let e = {
                  let l7 = i32::from(*ptr1.add(4).cast::<u8>());

                  DatastoreError::_lift(l7 as u8)
                };
                Err(e)
              }
              _ => _rt::invalid_enum_discriminant(),
            };
            result8
          }
        }
      }
      impl FrameStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Set the `value` associated with the specified `key` for the specific frame
        /// overwriting any existing value.
        pub fn set(&self,frame: u32,key: &str,value: &str,) -> Result<(),DatastoreError>{
          unsafe {
            #[repr(align(1))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 2]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2]);
            let vec0 = key;
            let ptr0 = vec0.as_ptr().cast::<u8>();
            let len0 = vec0.len();
            let vec1 = value;
            let ptr1 = vec1.as_ptr().cast::<u8>();
            let len1 = vec1.len();
            let ptr2 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]frame-store.set"]
              fn wit_import3(_: i32, _: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import3(_: i32, _: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
            wit_import3((self).handle() as i32, _rt::as_i32(&frame), ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, ptr2);
            let l4 = i32::from(*ptr2.add(0).cast::<u8>());
            let result6 = match l4 {
              0 => {
                let e = ();
                Ok(e)
              }
              1 => {
                let e = {
                  let l5 = i32::from(*ptr2.add(1).cast::<u8>());

                  DatastoreError::_lift(l5 as u8)
                };
                Err(e)
              }
              _ => _rt::invalid_enum_discriminant(),
            };
            result6
          }
        }
      }
      impl FrameStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Delete the data with the specified `key` for the specified `frame`
        ///
        /// No error is raised if a tuple did not previously exist for `key`.
        pub fn delete(&self,frame: u32,key: &str,) -> Result<(),DatastoreError>{
          unsafe {
            #[repr(align(1))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 2]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2]);
            let vec0 = key;
            let ptr0 = vec0.as_ptr().cast::<u8>();
            let len0 = vec0.len();
            let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]frame-store.delete"]
              fn wit_import2(_: i32, _: i32, _: *mut u8, _: usize, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import2(_: i32, _: i32, _: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
            wit_import2((self).handle() as i32, _rt::as_i32(&frame), ptr0.cast_mut(), len0, ptr1);
            let l3 = i32::from(*ptr1.add(0).cast::<u8>());
            let result5 = match l3 {
              0 => {
                let e = ();
                Ok(e)
              }
              1 => {
                let e = {
                  let l4 = i32::from(*ptr1.add(1).cast::<u8>());

                  DatastoreError::_lift(l4 as u8)
                };
                Err(e)
              }
              _ => _rt::invalid_enum_discriminant(),
            };
            result5
          }
        }
      }
      impl FrameStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Delete all data for the specified `frame`.
        ///
        /// No error is raised if no data exists for the `frame`.
        pub fn delete_all(&self,frame: u32,) -> Result<(),DatastoreError>{
          unsafe {
            #[repr(align(1))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 2]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2]);
            let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]frame-store.delete-all"]
              fn wit_import1(_: i32, _: i32, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import1(_: i32, _: i32, _: *mut u8, ){ unreachable!() }
            wit_import1((self).handle() as i32, _rt::as_i32(&frame), ptr0);
            let l2 = i32::from(*ptr0.add(0).cast::<u8>());
            let result4 = match l2 {
              0 => {
                let e = ();
                Ok(e)
              }
              1 => {
                let e = {
                  let l3 = i32::from(*ptr0.add(1).cast::<u8>());

                  DatastoreError::_lift(l3 as u8)
                };
                Err(e)
              }
              _ => _rt::invalid_enum_discriminant(),
            };
            result4
          }
        }
      }
      impl FrameStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Return whether data exists for the specified `frame`
        pub fn exists(&self,frame: u32,) -> Result<bool,DatastoreError>{
          unsafe {
            #[repr(align(1))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 2]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2]);
            let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]frame-store.exists"]
              fn wit_import1(_: i32, _: i32, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import1(_: i32, _: i32, _: *mut u8, ){ unreachable!() }
            wit_import1((self).handle() as i32, _rt::as_i32(&frame), ptr0);
            let l2 = i32::from(*ptr0.add(0).cast::<u8>());
            let result5 = match l2 {
              0 => {
                let e = {
                  let l3 = i32::from(*ptr0.add(1).cast::<u8>());

                  _rt::bool_lift(l3 as u8)
                };
                Ok(e)
              }
              1 => {
                let e = {
                  let l4 = i32::from(*ptr0.add(1).cast::<u8>());

                  DatastoreError::_lift(l4 as u8)
                };
                Err(e)
              }
              _ => _rt::invalid_enum_discriminant(),
            };
            result5
          }
        }
      }
      impl FrameStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Return a list of all the keys. returns empty list if no keys are present.
        pub fn get_keys(&self,frame: u32,) -> _rt::Vec::<_rt::String>{
          unsafe {
            #[repr(align(4))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 8]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
            let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]frame-store.get-keys"]
              fn wit_import1(_: i32, _: i32, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import1(_: i32, _: i32, _: *mut u8, ){ unreachable!() }
            wit_import1((self).handle() as i32, _rt::as_i32(&frame), ptr0);
            let l2 = *ptr0.add(0).cast::<*mut u8>();
            let l3 = *ptr0.add(4).cast::<usize>();
            let base7 = l2;
            let len7 = l3;
            let mut result7 = _rt::Vec::with_capacity(len7);
            for i in 0..len7 {
              let base = base7.add(i * 8);
              let e7 = {
                let l4 = *base.add(0).cast::<*mut u8>();
                let l5 = *base.add(4).cast::<usize>();
                let len6 = l5;
                let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6);

                _rt::string_lift(bytes6)
              };
              result7.push(e7);
            }
            _rt::cabi_dealloc(base7, len7 * 8, 4);
            let result8 = result7;
            result8
          }
        }
      }
      impl ProcessorStore {
        #[allow(unused_unsafe, clippy::all)]
        /// The id param is currently ignored
        pub fn new(id: u32,) -> Self{
          unsafe {

            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[constructor]processor-store"]
              fn wit_import0(_: i32, ) -> i32;
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import0(_: i32, ) -> i32{ unreachable!() }
            let ret = wit_import0(_rt::as_i32(&id));
            ProcessorStore::from_handle(ret as u32)
          }
        }
      }
      impl ProcessorStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Get the value associated with the specified `key`
        ///
        /// Returns `ok(none)` if the key does not exist.
        pub fn get(&self,processor: &str,key: &str,) -> Result<_rt::String,DatastoreError>{
          unsafe {
            #[repr(align(4))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 12]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
            let vec0 = processor;
            let ptr0 = vec0.as_ptr().cast::<u8>();
            let len0 = vec0.len();
            let vec1 = key;
            let ptr1 = vec1.as_ptr().cast::<u8>();
            let len1 = vec1.len();
            let ptr2 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]processor-store.get"]
              fn wit_import3(_: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import3(_: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
            wit_import3((self).handle() as i32, ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, ptr2);
            let l4 = i32::from(*ptr2.add(0).cast::<u8>());
            let result9 = match l4 {
              0 => {
                let e = {
                  let l5 = *ptr2.add(4).cast::<*mut u8>();
                  let l6 = *ptr2.add(8).cast::<usize>();
                  let len7 = l6;
                  let bytes7 = _rt::Vec::from_raw_parts(l5.cast(), len7, len7);

                  _rt::string_lift(bytes7)
                };
                Ok(e)
              }
              1 => {
                let e = {
                  let l8 = i32::from(*ptr2.add(4).cast::<u8>());

                  DatastoreError::_lift(l8 as u8)
                };
                Err(e)
              }
              _ => _rt::invalid_enum_discriminant(),
            };
            result9
          }
        }
      }
      impl ProcessorStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Set the `value` associated with the specified `key` overwriting any existing value.
        pub fn set(&self,processor: &str,key: &str,value: &str,) -> Result<(),DatastoreError>{
          unsafe {
            #[repr(align(1))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 2]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2]);
            let vec0 = processor;
            let ptr0 = vec0.as_ptr().cast::<u8>();
            let len0 = vec0.len();
            let vec1 = key;
            let ptr1 = vec1.as_ptr().cast::<u8>();
            let len1 = vec1.len();
            let vec2 = value;
            let ptr2 = vec2.as_ptr().cast::<u8>();
            let len2 = vec2.len();
            let ptr3 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]processor-store.set"]
              fn wit_import4(_: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import4(_: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
            wit_import4((self).handle() as i32, ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, ptr2.cast_mut(), len2, ptr3);
            let l5 = i32::from(*ptr3.add(0).cast::<u8>());
            let result7 = match l5 {
              0 => {
                let e = ();
                Ok(e)
              }
              1 => {
                let e = {
                  let l6 = i32::from(*ptr3.add(1).cast::<u8>());

                  DatastoreError::_lift(l6 as u8)
                };
                Err(e)
              }
              _ => _rt::invalid_enum_discriminant(),
            };
            result7
          }
        }
      }
      impl ProcessorStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Delete the tuple with the specified `key`
        ///
        /// No error is raised if a tuple did not previously exist for `key`.
        pub fn delete(&self,processor: &str,key: &str,) -> Result<(),DatastoreError>{
          unsafe {
            #[repr(align(1))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 2]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2]);
            let vec0 = processor;
            let ptr0 = vec0.as_ptr().cast::<u8>();
            let len0 = vec0.len();
            let vec1 = key;
            let ptr1 = vec1.as_ptr().cast::<u8>();
            let len1 = vec1.len();
            let ptr2 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]processor-store.delete"]
              fn wit_import3(_: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import3(_: i32, _: *mut u8, _: usize, _: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
            wit_import3((self).handle() as i32, ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, ptr2);
            let l4 = i32::from(*ptr2.add(0).cast::<u8>());
            let result6 = match l4 {
              0 => {
                let e = ();
                Ok(e)
              }
              1 => {
                let e = {
                  let l5 = i32::from(*ptr2.add(1).cast::<u8>());

                  DatastoreError::_lift(l5 as u8)
                };
                Err(e)
              }
              _ => _rt::invalid_enum_discriminant(),
            };
            result6
          }
        }
      }
      impl ProcessorStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Delete all the data for the specified `processor`.
        ///
        /// No error is raised if no data exists for the `processor`.
        pub fn delete_all(&self,processor: &str,) -> Result<(),DatastoreError>{
          unsafe {
            #[repr(align(1))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 2]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2]);
            let vec0 = processor;
            let ptr0 = vec0.as_ptr().cast::<u8>();
            let len0 = vec0.len();
            let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]processor-store.delete-all"]
              fn wit_import2(_: i32, _: *mut u8, _: usize, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import2(_: i32, _: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
            wit_import2((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
            let l3 = i32::from(*ptr1.add(0).cast::<u8>());
            let result5 = match l3 {
              0 => {
                let e = ();
                Ok(e)
              }
              1 => {
                let e = {
                  let l4 = i32::from(*ptr1.add(1).cast::<u8>());

                  DatastoreError::_lift(l4 as u8)
                };
                Err(e)
              }
              _ => _rt::invalid_enum_discriminant(),
            };
            result5
          }
        }
      }
      impl ProcessorStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Return whether data exists for the specified `processor`.
        pub fn exists(&self,processor: &str,) -> Result<bool,DatastoreError>{
          unsafe {
            #[repr(align(1))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 2]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2]);
            let vec0 = processor;
            let ptr0 = vec0.as_ptr().cast::<u8>();
            let len0 = vec0.len();
            let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]processor-store.exists"]
              fn wit_import2(_: i32, _: *mut u8, _: usize, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import2(_: i32, _: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
            wit_import2((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
            let l3 = i32::from(*ptr1.add(0).cast::<u8>());
            let result6 = match l3 {
              0 => {
                let e = {
                  let l4 = i32::from(*ptr1.add(1).cast::<u8>());

                  _rt::bool_lift(l4 as u8)
                };
                Ok(e)
              }
              1 => {
                let e = {
                  let l5 = i32::from(*ptr1.add(1).cast::<u8>());

                  DatastoreError::_lift(l5 as u8)
                };
                Err(e)
              }
              _ => _rt::invalid_enum_discriminant(),
            };
            result6
          }
        }
      }
      impl ProcessorStore {
        #[allow(unused_unsafe, clippy::all)]
        /// Return a list of all the keys. returns empty list if no keys are present.
        pub fn get_keys(&self,processor: &str,) -> _rt::Vec::<_rt::String>{
          unsafe {
            #[repr(align(4))]
            struct RetArea([::core::mem::MaybeUninit::<u8>; 8]);
            let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
            let vec0 = processor;
            let ptr0 = vec0.as_ptr().cast::<u8>();
            let len0 = vec0.len();
            let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
            #[cfg(target_arch = "wasm32")]
            #[link(wasm_import_module = "wasmvision:platform/datastore")]
            extern "C" {
              #[link_name = "[method]processor-store.get-keys"]
              fn wit_import2(_: i32, _: *mut u8, _: usize, _: *mut u8, );
            }

            #[cfg(not(target_arch = "wasm32"))]
            extern "C" fn wit_import2(_: i32, _: *mut u8, _: usize, _: *mut u8, ){ unreachable!() }
            wit_import2((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
            let l3 = *ptr1.add(0).cast::<*mut u8>();
            let l4 = *ptr1.add(4).cast::<usize>();
            let base8 = l3;
            let len8 = l4;
            let mut result8 = _rt::Vec::with_capacity(len8);
            for i in 0..len8 {
              let base = base8.add(i * 8);
              let e8 = {
                let l5 = *base.add(0).cast::<*mut u8>();
                let l6 = *base.add(4).cast::<usize>();
                let len7 = l6;
                let bytes7 = _rt::Vec::from_raw_parts(l5.cast(), len7, len7);

                _rt::string_lift(bytes7)
              };
              result8.push(e8);
            }
            _rt::cabi_dealloc(base8, len8 * 8, 4);
            let result9 = result8;
            result9
          }
        }
      }

    }

  }
}
mod _rt {
  #![allow(dead_code, clippy::all)]

  pub fn as_i32<T: AsI32>(t: T) -> i32 {
    t.as_i32()
  }

  pub trait AsI32 {
    fn as_i32(self) -> i32;
  }

  impl<'a, T: Copy + AsI32> AsI32 for &'a T {
    fn as_i32(self) -> i32 {
      (*self).as_i32()
    }
  }
  
  impl AsI32 for i32 {
    #[inline]
    fn as_i32(self) -> i32 {
      self as i32
    }
  }
  
  impl AsI32 for u32 {
    #[inline]
    fn as_i32(self) -> i32 {
      self as i32
    }
  }
  
  impl AsI32 for i16 {
    #[inline]
    fn as_i32(self) -> i32 {
      self as i32
    }
  }
  
  impl AsI32 for u16 {
    #[inline]
    fn as_i32(self) -> i32 {
      self as i32
    }
  }
  
  impl AsI32 for i8 {
    #[inline]
    fn as_i32(self) -> i32 {
      self as i32
    }
  }
  
  impl AsI32 for u8 {
    #[inline]
    fn as_i32(self) -> i32 {
      self as i32
    }
  }
  
  impl AsI32 for char {
    #[inline]
    fn as_i32(self) -> i32 {
      self as i32
    }
  }
  
  impl AsI32 for usize {
    #[inline]
    fn as_i32(self) -> i32 {
      self as i32
    }
  }
  pub use alloc_crate::string::String;
  pub use alloc_crate::vec::Vec;
  pub unsafe fn string_lift(bytes: Vec<u8>) -> String {
    if cfg!(debug_assertions) {
      String::from_utf8(bytes).unwrap()
    } else {
      String::from_utf8_unchecked(bytes)
    }
  }
  pub unsafe fn invalid_enum_discriminant<T>() -> T {
    if cfg!(debug_assertions) {
      panic!("invalid enum discriminant")
    } else {
      core::hint::unreachable_unchecked()
    }
  }
  

  use core::fmt;
  use core::marker;
  use core::sync::atomic::{AtomicU32, Ordering::Relaxed};

  /// A type which represents a component model resource, either imported or
  /// exported into this component.
  ///
  /// This is a low-level wrapper which handles the lifetime of the resource
  /// (namely this has a destructor). The `T` provided defines the component model
  /// intrinsics that this wrapper uses.
  ///
  /// One of the chief purposes of this type is to provide `Deref` implementations
  /// to access the underlying data when it is owned.
  ///
  /// This type is primarily used in generated code for exported and imported
  /// resources.
  #[repr(transparent)]
  pub struct Resource<T: WasmResource> {
    // NB: This would ideally be `u32` but it is not. The fact that this has
    // interior mutability is not exposed in the API of this type except for the
    // `take_handle` method which is supposed to in theory be private.
    //
    // This represents, almost all the time, a valid handle value. When it's
    // invalid it's stored as `u32::MAX`.
    handle: AtomicU32,
    _marker: marker::PhantomData<T>,
  }

  /// A trait which all wasm resources implement, namely providing the ability to
  /// drop a resource.
  ///
  /// This generally is implemented by generated code, not user-facing code.
  #[allow(clippy::missing_safety_doc)]
  pub unsafe trait WasmResource {
    /// Invokes the `[resource-drop]...` intrinsic.
    unsafe fn drop(handle: u32);
  }

  impl<T: WasmResource> Resource<T> {
    #[doc(hidden)]
    pub unsafe fn from_handle(handle: u32) -> Self {
      debug_assert!(handle != u32::MAX);
      Self {
        handle: AtomicU32::new(handle),
        _marker: marker::PhantomData,
      }
    }

    /// Takes ownership of the handle owned by `resource`.
    ///
    /// Note that this ideally would be `into_handle` taking `Resource<T>` by
    /// ownership. The code generator does not enable that in all situations,
    /// unfortunately, so this is provided instead.
    ///
    /// Also note that `take_handle` is in theory only ever called on values
    /// owned by a generated function. For example a generated function might
    /// take `Resource<T>` as an argument but then call `take_handle` on a
    /// reference to that argument. In that sense the dynamic nature of
    /// `take_handle` should only be exposed internally to generated code, not
    /// to user code.
    #[doc(hidden)]
    pub fn take_handle(resource: &Resource<T>) -> u32 {
      resource.handle.swap(u32::MAX, Relaxed)
    }

    #[doc(hidden)]
    pub fn handle(resource: &Resource<T>) -> u32 {
      resource.handle.load(Relaxed)
    }
  }

  impl<T: WasmResource> fmt::Debug for Resource<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
      f.debug_struct("Resource")
      .field("handle", &self.handle)
      .finish()
    }
  }

  impl<T: WasmResource> Drop for Resource<T> {
    fn drop(&mut self) {
      unsafe {
        match self.handle.load(Relaxed) {
          // If this handle was "taken" then don't do anything in the
          // destructor.
          u32::MAX => {}

          // ... but otherwise do actually destroy it with the imported
          // component model intrinsic as defined through `T`.
          other => T::drop(other),
        }
      }
    }
  }
  pub unsafe fn bool_lift(val: u8) -> bool {
    if cfg!(debug_assertions) {
      match val {
        0 => false,
        1 => true,
        _ => panic!("invalid bool discriminant"),
      }
    } else {
      val != 0
    }
  }
  pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) {
    if size == 0 {
      return;
    }
    let layout = alloc::Layout::from_size_align_unchecked(size, align);
    alloc::dealloc(ptr, layout);
  }
  extern crate alloc as alloc_crate;
  pub use alloc_crate::alloc;
}

#[cfg(target_arch = "wasm32")]
#[unsafe(link_section = "component-type:wit-bindgen:0.38.0:wasmvision:platform:imports:encoded world")]
#[doc(hidden)]
#[allow(clippy::octal_escapes)]
pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 1643] = *b"\
\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xed\x0b\x01A\x02\x01\
A\x0a\x01B\x02\x01@\x01\x02tzy\0w\x04\0\x03now\x01\0\x03\0\x18wasmvision:platfor\
m/time\x05\0\x01B\x07\x01@\x01\x03msgs\x01\0\x04\0\x03log\x01\0\x04\0\x05error\x01\
\0\x04\0\x04warn\x01\0\x04\0\x04info\x01\0\x04\0\x05debug\x01\0\x04\0\x07println\
\x01\0\x03\0\x1bwasmvision:platform/logging\x05\x01\x01B\x05\x01m\x02\x07success\
\x0bno-such-key\x04\0\x0cconfig-error\x03\0\0\x01j\x01s\x01\x01\x01@\x01\x03keys\
\0\x02\x04\0\x0aget-config\x01\x03\x03\0\x1awasmvision:platform/config\x05\x02\x01\
B\x0a\x01m\x06\x07success\x17destination-not-allowed\x0binvalid-url\x0drequest-e\
rror\x0druntime-error\x11too-many-requests\x04\0\x0ahttp-error\x03\0\0\x01j\x01s\
\x01\x01\x01@\x01\x03urls\0\x02\x04\0\x03get\x01\x03\x01p}\x01@\x03\x03urls\x0cc\
ontent-types\x04body\x04\0\x02\x04\0\x04post\x01\x05\x01@\x05\x03urls\x0ccontent\
-types\x10request-template\x04\x0dresponse-items\x03maty\0\x02\x04\0\x0apost-ima\
ge\x01\x06\x03\0\x18wasmvision:platform/http\x05\x03\x01B(\x01m\x04\x07success\x0d\
no-such-frame\x0bno-such-key\x0druntime-error\x04\0\x0fdatastore-error\x03\0\0\x04\
\0\x0bframe-store\x03\x01\x04\0\x0fprocessor-store\x03\x01\x01i\x02\x01@\x01\x02\
idy\0\x04\x04\0\x18[constructor]frame-store\x01\x05\x01h\x02\x01j\x01s\x01\x01\x01\
@\x03\x04self\x06\x05framey\x03keys\0\x07\x04\0\x17[method]frame-store.get\x01\x08\
\x01j\0\x01\x01\x01@\x04\x04self\x06\x05framey\x03keys\x05values\0\x09\x04\0\x17\
[method]frame-store.set\x01\x0a\x01@\x03\x04self\x06\x05framey\x03keys\0\x09\x04\
\0\x1a[method]frame-store.delete\x01\x0b\x01@\x02\x04self\x06\x05framey\0\x09\x04\
\0\x1e[method]frame-store.delete-all\x01\x0c\x01j\x01\x7f\x01\x01\x01@\x02\x04se\
lf\x06\x05framey\0\x0d\x04\0\x1a[method]frame-store.exists\x01\x0e\x01ps\x01@\x02\
\x04self\x06\x05framey\0\x0f\x04\0\x1c[method]frame-store.get-keys\x01\x10\x01i\x03\
\x01@\x01\x02idy\0\x11\x04\0\x1c[constructor]processor-store\x01\x12\x01h\x03\x01\
@\x03\x04self\x13\x09processors\x03keys\0\x07\x04\0\x1b[method]processor-store.g\
et\x01\x14\x01@\x04\x04self\x13\x09processors\x03keys\x05values\0\x09\x04\0\x1b[\
method]processor-store.set\x01\x15\x01@\x03\x04self\x13\x09processors\x03keys\0\x09\
\x04\0\x1e[method]processor-store.delete\x01\x16\x01@\x02\x04self\x13\x09process\
ors\0\x09\x04\0\"[method]processor-store.delete-all\x01\x17\x01@\x02\x04self\x13\
\x09processors\0\x0d\x04\0\x1e[method]processor-store.exists\x01\x18\x01@\x02\x04\
self\x13\x09processors\0\x0f\x04\0\x20[method]processor-store.get-keys\x01\x19\x03\
\0\x1dwasmvision:platform/datastore\x05\x04\x04\0\x1bwasmvision:platform/imports\
\x04\0\x0b\x0d\x01\0\x07imports\x03\0\0\0G\x09producers\x01\x0cprocessed-by\x02\x0d\
wit-component\x070.224.0\x10wit-bindgen-rust\x060.38.0";

#[inline(never)]
#[doc(hidden)]
pub fn __link_custom_section_describing_imports() {
  wit_bindgen::rt::maybe_link_cabi_realloc();
}