maplibre_native_ffi/generated/

map.rs

// Generated from C headers by tools/bindgen. Do not edit.
use super::*;

native_owner! {
    /// Owns one native handle.
    ///
    /// A map, with its style and camera.
    ///
    /// See `mln_map` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/base_8h.html).
    pub struct MapHandle(mln_map) dispose |raw| crate::error::check(|out_diagnostic| unsafe { sys::mln_map_dispose(raw, out_diagnostic) });
    /// Returns the native handle value, which runtime events report as their source.
    fn id;
}

impl MapHandle {
    /// Adds a source whose GeoJSON tiles come from callbacks.
    ///
    /// See `mln_map_add_custom_geometry_source` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::AlreadyExists` when the style already has a source named
    ///   `source_id`.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn add_custom_geometry_source(
        &self,
        source_id: &str,
        options: CustomGeometrySourceOptions,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let options = call.reference(&options)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_custom_geometry_source(
                map,
                source_id,
                options,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Adds a source whose vector tiles come from callbacks.
    ///
    /// See `mln_map_add_custom_vector_source` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::AlreadyExists` when the style already has a source named
    ///   `source_id`.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn add_custom_vector_source(
        &self,
        source_id: &str,
        options: CustomVectorSourceOptions,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let options = call.reference(&options)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_custom_vector_source(
                map,
                source_id,
                options,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Adds a GeoJSON source with no data.
    ///
    /// Give it data with `MapHandle::set_geo_json_source_data()` or
    /// `MapHandle::set_geo_json_source_url()`. Its options stay fixed for as
    /// long as the style holds it.
    ///
    /// `attribution` is the source's
    /// \[attribution\](https://maplibre.org/maplibre-style-spec/sources/#attribution),
    /// or empty for none.
    ///
    /// See `mln_map_add_geo_json_source` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidArgument` when an option in `options` is out of range.
    /// - `Status::AlreadyExists` when the style already has a source named
    ///   `source_id`.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn add_geo_json_source(
        &self,
        source_id: &str,
        options: Option<&GeoJsonSourceOptions>,
        attribution: Option<&str>,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let options = call.optional_reference(options.as_ref())?;
        let attribution = call.input(&attribution)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_geo_json_source(
                map,
                source_id,
                options,
                attribution,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Adds an image source that shows `image`.
    ///
    /// `coordinates` are the image's four corners, clockwise from the top left.
    ///
    /// See `mln_map_add_image_source_image` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::AlreadyExists` when the style already has a source named
    ///   `source_id`.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn add_image_source_image(
        &self,
        source_id: &str,
        coordinates: &[LatLng],
        image: &PremultipliedRgba8Image<'_>,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let coordinate_count = convert::count(coordinates.len())?;
        let source_id = call.input(&source_id)?;
        let coordinates = call.array(coordinates)?;
        let image = call.reference(&image)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_image_source_image(
                map,
                source_id,
                coordinates,
                coordinate_count,
                image,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Adds a layer to the map's style.
    ///
    /// `layer_json` is a
    /// \[layer\](https://maplibre.org/maplibre-style-spec/layers/) object. The
    /// layer goes below the layer named `before_layer_id`, or above every layer
    /// when `before_layer_id` is empty.
    ///
    /// See `mln_map_add_style_layer_json` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no layer named
    ///   `before_layer_id`, or no source with the ID that the layer uses.
    /// - `Status::AlreadyExists` when the style already has a layer with the
    ///   new layer's ID.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn add_style_layer_json(
        &self,
        layer_json: &str,
        before_layer_id: Option<&str>,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let layer_json = call.input(&layer_json)?;
        let before_layer_id = call.input(&before_layer_id)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_style_layer_json(
                map,
                layer_json,
                before_layer_id,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Adds a source to the map's style.
    ///
    /// `source_json` is a
    /// \[source\](https://maplibre.org/maplibre-style-spec/sources/) object.
    ///
    /// See `mln_map_add_style_source_json` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::AlreadyExists` when the style already has a source named
    ///   `source_id`.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn add_style_source_json(
        &self,
        source_id: &str,
        source_json: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let source_json = call.input(&source_json)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_style_source_json(
                map,
                source_id,
                source_json,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Moves the camera relative to where it is, as a gesture does.
    ///
    /// `delta` can pan the map's content by an offset on the screen, scale the
    /// zoom, and add to the bearing and pitch. An anchor keeps one screen point
    /// in place while the scale, bearing, or pitch changes. An anchor needs one
    /// of those changes, and combines with an offset only when the delta has no
    /// animation. The function finishes when the map applies the delta, before
    /// an animation ends.
    ///
    /// A delta that replaces an animated one starts from where that animation
    /// left the camera, so the rest of the replaced change never happens. To
    /// reach an exact camera, use `MapHandle::update_camera()`.
    ///
    /// A delta in the end phase can carry momentum, which keeps the camera
    /// moving from the gesture's release velocities and slows it on each
    /// rendered frame. The gesture lasts until the momentum ends: the snapshot
    /// keeps `gesture_in_progress` set, and camera events report
    /// `CameraChangeSource::Momentum`. With momentum, `animation` sets only
    /// `transition_id` and the end handler, which runs when the gesture ends.
    ///
    /// A delta in the begin phase, `MapHandle::cancel_camera_transitions()`, or
    /// a cancellation by that ID stops the momentum. A later command that sets
    /// a field stops only the parts of the momentum that move that field. On a
    /// tilted map, the pan moves the map's content the same distance on the
    /// screen in every direction.
    ///
    /// See `mln_map_apply_camera_delta` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn apply_camera_delta(
        &self,
        delta: &CameraDelta,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let delta = call.reference(&delta)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_apply_camera_delta(map, delta, completion, out_diagnostic)
        })
    }

    /// Creates a session that renders the map into a ring of Android hardware
    /// buffers that the library allocates.
    ///
    /// Acquire each frame with `RenderSessionHandle::acquire_frame()`, and get
    /// its buffer with `AcquiredFrameView::get_android_hardware_buffer()`.
    /// `RenderSessionHandle::resize()` gives the ring new buffers of the new
    /// size.
    ///
    /// A Vulkan build renders with `device`, or, when `device` is null, with a
    /// device that the library creates. An OpenGL build uses an EGL context on
    /// the default display, and `device` must be null. Attach with
    /// `RenderDriverKind::CoreWorker`.
    ///
    /// To show the buffers through Android's UI, such as with
    /// `Bitmap.wrapHardwareBuffer`, attach without `GpuSyncKindFlag::SYNC_FD`
    /// in `RenderSessionAttachOptions::producer_sync_kinds`, so that each frame
    /// finishes before you acquire it. Keep each frame acquired until the next
    /// one replaces it on screen, then release it with
    /// `GpuSyncKind::CpuComplete`. Give the ring 3 buffers, so the session can
    /// render while you hold two frames.
    ///
    /// See `mln_map_attach_android_hardware_buffer_ring` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/android_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when Android is older than 8.0, API level 26, or
    ///   when the graphics context can't render into hardware buffers: the
    ///   Vulkan device lacks
    ///   VK_ANDROID_external_memory_android_hardware_buffer, or the EGL display
    ///   lacks EGL_ANDROID_get_native_client_buffer or
    ///   EGL_ANDROID_image_native_buffer.
    /// - `Status::NativeError` when the library can't create its Vulkan device
    ///   or initialize the default EGL display.
    #[cfg(target_os = "android")]
    pub fn attach_android_hardware_buffer_ring(
        &self,
        descriptor: &AndroidHardwareBufferRingDescriptor,
        device: Option<&VulkanDeviceHandle>,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let device = device.map_or(sys::mln_vulkan_device(0), |device| device.inner.native());
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_android_hardware_buffer_ring(
                    map,
                    descriptor,
                    device,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that presents the map to an Android window, with a
    /// graphics context that the library creates.
    ///
    /// A Vulkan build presents with `device`, or, when `device` is null, with a
    /// device that the library creates. An OpenGL build uses an EGL context on
    /// the default display, and `device` must be null. Attach with
    /// `RenderDriverKind::CoreWorker`.
    ///
    /// When the platform destroys the window, such as in
    /// `SurfaceHolder.Callback.surfaceDestroyed`, release the target with
    /// `RenderSessionHandle::release_target()`, or give the session a new
    /// window with `RenderSessionHandle::set_android_surface_target()`, without
    /// waiting for that to complete. The session keeps its own reference to the
    /// window and stays usable for the next window. A frame to the destroyed
    /// window finishes with `RenderResult::TargetNotReady`, or with
    /// `RenderResult::Rendered` if the window went away while the frame was
    /// presenting.
    ///
    /// See `mln_map_attach_android_surface` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/android_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidArgument` when `surface` has no window, such as after
    ///   the platform destroyed it.
    /// - `Status::Unsupported` when you created `device` without
    ///   `VulkanDeviceOptions::presentation`.
    /// - `Status::Unsupported` when the GPU or the Vulkan loader can't present.
    /// - `Status::NativeError` when the library can't create the graphics
    ///   context or the window's surface.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    #[cfg(target_os = "android")]
    pub unsafe fn attach_android_surface(
        &self,
        descriptor: &AndroidSurfaceDescriptor,
        device: Option<&VulkanDeviceHandle>,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let device = device.map_or(sys::mln_vulkan_device(0), |device| device.inner.native());
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_android_surface(
                    map,
                    descriptor,
                    device,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that renders the map into a ring of dmabufs that the
    /// library allocates.
    ///
    /// Acquire each frame with `RenderSessionHandle::acquire_frame()`, and get
    /// its buffer with `AcquiredFrameView::get_dma_buf()`.
    /// `RenderSessionHandle::resize()` gives the ring new buffers of the new
    /// size.
    ///
    /// A Vulkan build renders with `device`, or, when `device` is null, with a
    /// device that the library creates. An OpenGL build uses an EGL context of
    /// its own, and `device` must be null. Attach with
    /// `RenderDriverKind::CoreWorker`.
    ///
    /// For a reader that waits on no sync file, such as a Wayland compositor
    /// without explicit synchronization, attach without
    /// `GpuSyncKindFlag::SYNC_FD` in
    /// `RenderSessionAttachOptions::producer_sync_kinds`, so that each frame
    /// finishes before you acquire it. Keep each frame acquired until its
    /// reader is done with the buffer. Give the ring 3 buffers, so the session
    /// can render while you hold two frames.
    ///
    /// See `mln_map_attach_dma_buf_ring` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/linux_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when the graphics context can't render into a
    ///   dmabuf of any of `formats`.
    /// - `Status::NativeError` when the library can't create its Vulkan device
    ///   or initialize an EGL display.
    #[cfg(any(
        target_os = "freebsd",
        all(target_os = "linux", not(target_env = "ohos"))
    ))]
    pub fn attach_dma_buf_ring(
        &self,
        descriptor: &DmaBufRingDescriptor,
        device: Option<&VulkanDeviceHandle>,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let device = device.map_or(sys::mln_vulkan_device(0), |device| device.inner.native());
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_dma_buf_ring(
                    map,
                    descriptor,
                    device,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that renders the map into a ring of DXGI shared
    /// textures that the library allocates.
    ///
    /// Acquire each frame with `RenderSessionHandle::acquire_frame()`, and get
    /// its texture with `AcquiredFrameView::get_dxgi_shared_texture()`.
    /// `RenderSessionHandle::resize()` gives the ring new textures of the new
    /// size.
    ///
    /// The session renders with the Vulkan device `device`, or, when `device`
    /// is null, with one that the library creates. The textures belong to the
    /// device's GPU, so open them on a D3D11 or D3D12 device of the same
    /// adapter. To pick the GPU, create `device` with
    /// `VulkanDeviceOptions::device_luid` set to your adapter's LUID. Attach
    /// with `RenderDriverKind::CoreWorker`.
    ///
    /// For a reader that waits on no fence, such as Flutter's texture
    /// registrar, attach without `GpuSyncKindFlag::D3D12_FENCE` in
    /// `RenderSessionAttachOptions::producer_sync_kinds`, so that each frame
    /// finishes before you acquire it. Release a frame with
    /// `GpuSyncKind::CpuComplete` only once the reader has finished with its
    /// texture.
    ///
    /// See `mln_map_attach_dxgi_shared_texture_ring` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/win32_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` in an OpenGL build, or when the GPU can't share
    ///   the textures: D3D11 has no adapter with the Vulkan device's LUID or
    ///   can't share textures through NT handles, or the device lacks
    ///   VK_KHR_external_memory_win32 or can't import D3D11 textures.
    /// - `Status::NativeError` when the library can't create its Vulkan device
    ///   or a D3D11 device on the adapter.
    #[cfg(target_os = "windows")]
    pub fn attach_dxgi_shared_texture_ring(
        &self,
        descriptor: &DxgiSharedTextureRingDescriptor,
        device: Option<&VulkanDeviceHandle>,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let device = device.map_or(sys::mln_vulkan_device(0), |device| device.inner.native());
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_dxgi_shared_texture_ring(
                    map,
                    descriptor,
                    device,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that renders the map into a ring of IOSurfaces that
    /// the library allocates.
    ///
    /// Acquire each frame with `RenderSessionHandle::acquire_frame()`, and get
    /// its surface with `AcquiredFrameView::get_io_surface()`.
    /// `RenderSessionHandle::resize()` gives the ring new surfaces of the new
    /// size. Attach with `RenderDriverKind::CoreWorker`.
    ///
    /// To hand frames to a reader that can't wait on an event, such as
    /// Flutter's `copyPixelBuffer`, attach without
    /// `GpuSyncKindFlag::METAL_SHARED_EVENT` in
    /// `RenderSessionAttachOptions::producer_sync_kinds`, so that each frame
    /// finishes before you acquire it. Release a frame with
    /// `GpuSyncKind::CpuComplete` only once the reader has finished with its
    /// surface.
    ///
    /// See `mln_map_attach_io_surface_ring` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/apple_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when `supported_render_backend_mask()` lacks
    ///   `RenderBackendFlag::METAL`.
    /// - `Status::NativeError` when `context` names no device and the system
    ///   has no Metal device.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    #[cfg(any(
        target_os = "ios",
        target_os = "macos",
        target_os = "tvos",
        target_os = "visionos"
    ))]
    pub unsafe fn attach_io_surface_ring(
        &self,
        descriptor: &IoSurfaceRingDescriptor,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_io_surface_ring(
                    map,
                    descriptor,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that renders the map into a ring of your Metal
    /// textures.
    ///
    /// See `mln_map_attach_metal_borrowed_texture` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/texture_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when `supported_render_backend_mask()` lacks
    ///   `RenderBackendFlag::METAL`, or when the target supports none of the
    ///   `producer_sync_kinds` in `options`.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    #[cfg(any(
        target_os = "ios",
        target_os = "macos",
        target_os = "tvos",
        target_os = "visionos"
    ))]
    pub unsafe fn attach_metal_borrowed_texture(
        &self,
        descriptor: &MetalBorrowedTextureDescriptor,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_metal_borrowed_texture(
                    map,
                    descriptor,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that renders the map to a Metal layer.
    ///
    /// See `mln_map_attach_metal_surface` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/surface_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when `supported_render_backend_mask()` lacks
    ///   `RenderBackendFlag::METAL`.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    #[cfg(any(
        target_os = "ios",
        target_os = "macos",
        target_os = "tvos",
        target_os = "visionos"
    ))]
    pub unsafe fn attach_metal_surface(
        &self,
        descriptor: &MetalSurfaceDescriptor,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_metal_surface(
                    map,
                    descriptor,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Attaches a render session that renders the map offscreen.
    ///
    /// Read each image's pixels with `RenderSessionHandle::read_texture()`.
    ///
    /// The session renders on `device`. When `device` is null, the session
    /// creates a device with the default options, and releases it when the
    /// session ends.
    ///
    /// See `mln_map_attach_offscreen` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/offscreen_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidState` when the map already has a render session.
    /// - `Status::NativeError` when `device` is null and the platform can't
    ///   create a device.
    pub fn attach_offscreen(
        &self,
        descriptor: &OffscreenDescriptor,
        options: &RenderSessionAttachOptions,
        device: Option<&OffscreenDeviceHandle>,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let device = device.map_or(sys::mln_offscreen_device(0), |device| device.inner.native());
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_offscreen(
                    map,
                    descriptor,
                    options,
                    device,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that presents the map to an OpenHarmony window, with a
    /// graphics context that the library creates.
    ///
    /// A Vulkan build presents with `device`, or, when `device` is null, with a
    /// device that the library creates. An OpenGL build uses an EGL context on
    /// the default display, and `device` must be null. Attach with
    /// `RenderDriverKind::CoreWorker`.
    ///
    /// When the platform destroys the window, such as in an `XComponent`'s
    /// `onSurfaceDestroyed` callback, release the target with
    /// `RenderSessionHandle::release_target()`, or give the session a new
    /// window with `RenderSessionHandle::set_ohos_surface_target()`, without
    /// waiting for that to complete. The session keeps its own reference to the
    /// window and stays usable for the next window. A frame to the destroyed
    /// window finishes with `RenderResult::TargetNotReady`, or with
    /// `RenderResult::Rendered` if the window went away while the frame was
    /// presenting.
    ///
    /// See `mln_map_attach_ohos_surface` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/ohos_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidArgument` when no surface in this process has
    ///   `OhosSurfaceDescriptor::surface_id`, such as after the platform
    ///   destroyed it.
    /// - `Status::Unsupported` when you created `device` without
    ///   `VulkanDeviceOptions::presentation`.
    /// - `Status::Unsupported` when the GPU or the Vulkan loader can't present.
    /// - `Status::NativeError` when the library can't create the graphics
    ///   context or the window's surface.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    #[cfg(target_env = "ohos")]
    pub unsafe fn attach_ohos_surface(
        &self,
        descriptor: &OhosSurfaceDescriptor,
        device: Option<&VulkanDeviceHandle>,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let device = device.map_or(sys::mln_vulkan_device(0), |device| device.inner.native());
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_ohos_surface(
                    map,
                    descriptor,
                    device,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that renders the map into a ring of your OpenGL
    /// textures.
    ///
    /// See `mln_map_attach_open_gl_borrowed_texture` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/texture_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when `open_gl_supported_context_provider_mask()`
    ///   lacks the context's platform, or when the target supports none of the
    ///   `producer_sync_kinds` in `options`.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    pub unsafe fn attach_open_gl_borrowed_texture(
        &self,
        descriptor: &OpenGlBorrowedTextureDescriptor<'_>,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_open_gl_borrowed_texture(
                    map,
                    descriptor,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that renders the map to an OpenGL surface.
    ///
    /// See `mln_map_attach_open_gl_surface` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/surface_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when `open_gl_supported_context_provider_mask()`
    ///   lacks the context's platform.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    pub unsafe fn attach_open_gl_surface(
        &self,
        descriptor: &OpenGlSurfaceDescriptor<'_>,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_open_gl_surface(
                    map,
                    descriptor,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that renders the map into a ring of your Vulkan
    /// images.
    ///
    /// See `mln_map_attach_vulkan_borrowed_texture` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/texture_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when `supported_render_backend_mask()` lacks
    ///   `RenderBackendFlag::VULKAN`, or when the target supports none of the
    ///   `producer_sync_kinds` in `options`.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    #[cfg(any(
        target_os = "android",
        target_os = "freebsd",
        target_os = "linux",
        target_os = "macos",
        target_os = "windows"
    ))]
    pub unsafe fn attach_vulkan_borrowed_texture(
        &self,
        descriptor: &VulkanBorrowedTextureDescriptor,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_vulkan_borrowed_texture(
                    map,
                    descriptor,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that renders the map to a Vulkan surface.
    ///
    /// See `mln_map_attach_vulkan_surface` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/surface_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when `supported_render_backend_mask()` lacks
    ///   `RenderBackendFlag::VULKAN`.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    #[cfg(any(
        target_os = "android",
        target_os = "freebsd",
        target_os = "linux",
        target_os = "macos",
        target_os = "windows"
    ))]
    pub unsafe fn attach_vulkan_surface(
        &self,
        descriptor: &VulkanSurfaceDescriptor,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_vulkan_surface(
                    map,
                    descriptor,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that presents the map to a Wayland surface, with a
    /// graphics context that the library creates.
    ///
    /// A Vulkan build presents with `device`, or, when `device` is null, with a
    /// device that the library creates. An OpenGL build uses an EGL context on
    /// the display, and `device` must be null. Attach with
    /// `RenderDriverKind::CoreWorker`.
    ///
    /// The session presents without waiting for the compositor, so demand at
    /// most one frame per display refresh.
    ///
    /// Keep the surface until a release or replacement of the target, or a
    /// detach of the session, completes. Keep the display connected until the
    /// session's detach completes. In an OpenGL build, if you also use EGL on
    /// the display, initialize it before you attach.
    ///
    /// See `mln_map_attach_wayland_surface` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/wayland_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when you created `device` without
    ///   `VulkanDeviceOptions::presentation`.
    /// - `Status::Unsupported` when the GPU or the Vulkan loader can't present
    ///   to Wayland.
    /// - `Status::NativeError` when the library can't create the graphics
    ///   context or present to the surface.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    #[cfg(any(
        target_os = "freebsd",
        all(target_os = "linux", not(target_env = "ohos"))
    ))]
    pub unsafe fn attach_wayland_surface(
        &self,
        descriptor: &WaylandSurfaceDescriptor,
        device: Option<&VulkanDeviceHandle>,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let device = device.map_or(sys::mln_vulkan_device(0), |device| device.inner.native());
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_wayland_surface(
                    map,
                    descriptor,
                    device,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that renders the map into a ring of your WebGPU
    /// textures.
    ///
    /// See `mln_map_attach_web_gpu_borrowed_texture` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/texture_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when `supported_render_backend_mask()` lacks
    ///   `RenderBackendFlag::WEB_GPU`, or when the target supports none of the
    ///   `producer_sync_kinds` in `options`.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    #[cfg(target_os = "emscripten")]
    pub unsafe fn attach_web_gpu_borrowed_texture(
        &self,
        descriptor: &WebGpuBorrowedTextureDescriptor,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_web_gpu_borrowed_texture(
                    map,
                    descriptor,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that renders the map to a WebGPU surface.
    ///
    /// See `mln_map_attach_web_gpu_surface` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/surface_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Unsupported` when `supported_render_backend_mask()` lacks
    ///   `RenderBackendFlag::WEB_GPU`.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    #[cfg(target_os = "emscripten")]
    pub unsafe fn attach_web_gpu_surface(
        &self,
        descriptor: &WebGpuSurfaceDescriptor,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_web_gpu_surface(
                    map,
                    descriptor,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Creates a session that presents the map to a Win32 window, with a
    /// graphics context that the library creates.
    ///
    /// A Vulkan build presents with `device`, or, when `device` is null, with a
    /// device that the library creates. An OpenGL build uses a WGL context, and
    /// `device` must be null. Attach with `RenderDriverKind::CoreWorker`.
    ///
    /// An OpenGL build sets the window's pixel format, so don't set one
    /// yourself.
    ///
    /// The session presents without waiting for the display, so demand at most
    /// one frame per display refresh. While the window is minimized, frame
    /// demands finish with `RenderResult::TargetNotReady`.
    ///
    /// Keep the window until a release or replacement of the target, or a
    /// detach of the session, completes.
    ///
    /// See `mln_map_attach_win32_window` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/win32_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidArgument` when `window` isn't a window, or, in an
    ///   OpenGL build, already has another pixel format.
    /// - `Status::InvalidState` when `window` is minimized or has no client
    ///   area.
    /// - `Status::Unsupported` when you created `device` without
    ///   `VulkanDeviceOptions::presentation`.
    /// - `Status::InvalidState` when `window` was minimized before the attach
    ///   ran.
    /// - `Status::Unsupported` when the GPU or the Vulkan loader can't present.
    /// - `Status::NativeError` when the library can't create the graphics
    ///   context or present to the window.
    ///
    /// # Safety
    /// Native graphics objects must have the types, lifetimes, and synchronization required by the C operation.
    #[cfg(target_os = "windows")]
    pub unsafe fn attach_win32_window(
        &self,
        descriptor: &Win32WindowDescriptor,
        device: Option<&VulkanDeviceHandle>,
        options: &RenderSessionAttachOptions,
    ) -> Result<(RenderSessionHandle, NativeFuture<()>)> {
        let mut call = self.inner.call();
        let device = device.map_or(sys::mln_vulkan_device(0), |device| device.inner.native());
        let mut out_session = sys::mln_render_session(0);
        let descriptor = call.reference(&descriptor)?;
        let options = call.reference(&options)?;
        let future = call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_attach_win32_window(
                    map,
                    descriptor,
                    device,
                    options,
                    &mut out_session,
                    completion,
                    out_diagnostic,
                )
            },
            completion::unit,
        )?;
        Ok((RenderSessionHandle::adopt(out_session)?, future))
    }

    /// Holds back the map's changes from rendering until
    /// `MapHandle::end_command_group()`, so they show in the same frame.
    ///
    /// Groups nest, and the changes render when the outermost group ends.
    ///
    /// See `mln_map_begin_command_group` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn begin_command_group(&self) -> Result<NativeFuture<CommandCompletion>> {
        let call = self.inner.call();
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_begin_command_group(map, completion, out_diagnostic)
        })
    }

    /// Computes a camera that fits a GeoJSON geometry in the map's view.
    ///
    /// `geometry` is a GeoJSON geometry object with at least one coordinate,
    /// not a feature. The camera keeps the map's bearing and pitch unless
    /// `fit_options` sets them, and its zoom stays within the map's zoom
    /// limits.
    ///
    /// See `mln_map_camera_for_geometry` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidArgument` when the padding in `fit_options` leaves no
    ///   room for the area.
    pub fn camera_for_geometry(
        &self,
        geometry: &str,
        fit_options: Option<&CameraFitOptions>,
    ) -> Result<NativeFuture<CameraOptions>> {
        let mut call = self.inner.call();
        let geometry = call.input(&geometry)?;
        let fit_options = call.optional_reference(fit_options.as_ref())?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_camera_for_geometry(
                    map,
                    geometry,
                    fit_options,
                    completion,
                    out_diagnostic,
                )
            },
            completion::value::<sys::mln_camera_options, _>,
        )
    }

    /// Computes a camera that fits `bounds` in the map's view.
    ///
    /// The camera keeps the map's bearing and pitch unless `fit_options` sets
    /// them, and its zoom stays within the map's zoom limits.
    ///
    /// See `mln_map_camera_for_lat_lng_bounds` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidArgument` when the padding in `fit_options` leaves no
    ///   room for the area.
    pub fn camera_for_lat_lng_bounds(
        &self,
        bounds: LatLngBounds,
        fit_options: Option<&CameraFitOptions>,
    ) -> Result<NativeFuture<CameraOptions>> {
        let mut call = self.inner.call();
        let bounds = call.input(&bounds)?;
        let fit_options = call.optional_reference(fit_options.as_ref())?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_camera_for_lat_lng_bounds(
                    map,
                    bounds,
                    fit_options,
                    completion,
                    out_diagnostic,
                )
            },
            completion::value::<sys::mln_camera_options, _>,
        )
    }

    /// Computes a camera that fits `coordinates` in the map's view.
    ///
    /// `coordinates` must not be empty. The camera keeps the map's bearing and
    /// pitch unless `fit_options` sets them, and its zoom stays within the
    /// map's zoom limits.
    ///
    /// See `mln_map_camera_for_lat_lngs` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidArgument` when the padding in `fit_options` leaves no
    ///   room for the area.
    pub fn camera_for_lat_lngs(
        &self,
        coordinates: &[LatLng],
        fit_options: Option<&CameraFitOptions>,
    ) -> Result<NativeFuture<CameraOptions>> {
        let mut call = self.inner.call();
        let coordinate_count = convert::count(coordinates.len())?;
        let coordinates = call.array(coordinates)?;
        let fit_options = call.optional_reference(fit_options.as_ref())?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_camera_for_lat_lngs(
                    map,
                    coordinates,
                    coordinate_count,
                    fit_options,
                    completion,
                    out_diagnostic,
                )
            },
            completion::value::<sys::mln_camera_options, _>,
        )
    }

    /// Stops every running camera animation where it is.
    ///
    /// The end handler of each stopped animation reports
    /// `CameraTransitionOutcome::Cancelled`.
    ///
    /// See `mln_map_cancel_camera_transitions` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn cancel_camera_transitions(&self) -> Result<NativeFuture<CommandCompletion>> {
        let call = self.inner.call();
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_cancel_camera_transitions(map, completion, out_diagnostic)
        })
    }

    /// Stops the running camera animations whose animation options set
    /// `transition_id`.
    ///
    /// Other animations keep running. The end handler of each stopped animation
    /// reports `CameraTransitionOutcome::Cancelled`.
    ///
    /// See `mln_map_cancel_camera_transitions_with_id` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn cancel_camera_transitions_with_id(
        &self,
        transition_id: u64,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let call = self.inner.call();
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_cancel_camera_transitions_with_id(
                map,
                transition_id,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Releases the map in any state, and finishes in the background.
    ///
    /// Use it from destructors and finalizers. Otherwise, use
    /// `MapHandle::release()`.
    ///
    /// See `mln_map_dispose` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn dispose(self) -> std::result::Result<(), ReleaseError<Self>> {
        self.consume(|map| {
            let mut call = Call::new(map);
            call.status(|map, out_diagnostic| unsafe { sys::mln_map_dispose(map, out_diagnostic) })
        })
    }

    /// Logs debugging information about the map's style and sources.
    ///
    /// See `mln_map_dump_debug_logs` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn dump_debug_logs(&self) -> Result<NativeFuture<CommandCompletion>> {
        let call = self.inner.call();
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_dump_debug_logs(map, completion, out_diagnostic)
        })
    }

    /// Ends the group that `MapHandle::begin_command_group()` began.
    ///
    /// See `mln_map_end_command_group` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn end_command_group(&self) -> Result<NativeFuture<CommandCompletion>> {
        let call = self.inner.call();
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_end_command_group(map, completion, out_diagnostic)
        })
    }

    /// Moves the camera to fit a GeoJSON geometry in the map's view, at once or
    /// with an animation.
    ///
    /// `geometry` is a GeoJSON geometry object with at least one coordinate,
    /// not a feature. The camera is the one that
    /// `MapHandle::camera_for_geometry()` computes after the commands sent
    /// before this one apply. The function finishes when the map applies the
    /// change, before an animation ends.
    ///
    /// See `mln_map_fit_camera_to_geometry` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidArgument` when the padding in `update` leaves no room
    ///   for the area. The camera doesn't move.
    pub fn fit_camera_to_geometry(
        &self,
        geometry: &str,
        update: &CameraFitUpdate,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let geometry = call.input(&geometry)?;
        let update = call.reference(&update)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_fit_camera_to_geometry(map, geometry, update, completion, out_diagnostic)
        })
    }

    /// Moves the camera to fit `bounds` in the map's view, at once or with an
    /// animation.
    ///
    /// The camera is the one that `MapHandle::camera_for_lat_lng_bounds()`
    /// computes after the commands sent before this one apply. The function
    /// finishes when the map applies the change, before an animation ends.
    ///
    /// See `mln_map_fit_camera_to_lat_lng_bounds` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidArgument` when the padding in `update` leaves no room
    ///   for the area. The camera doesn't move.
    pub fn fit_camera_to_lat_lng_bounds(
        &self,
        bounds: LatLngBounds,
        update: &CameraFitUpdate,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let bounds = call.input(&bounds)?;
        let update = call.reference(&update)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_fit_camera_to_lat_lng_bounds(
                map,
                bounds,
                update,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Moves the camera to fit `coordinates` in the map's view, at once or with
    /// an animation.
    ///
    /// `coordinates` must not be empty. The camera is the one that
    /// `MapHandle::camera_for_lat_lngs()` computes after the commands sent
    /// before this one apply. The function finishes when the map applies the
    /// change, before an animation ends.
    ///
    /// See `mln_map_fit_camera_to_lat_lngs` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidArgument` when the padding in `update` leaves no room
    ///   for the area. The camera doesn't move.
    pub fn fit_camera_to_lat_lngs(
        &self,
        coordinates: &[LatLng],
        update: &CameraFitUpdate,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let coordinate_count = convert::count(coordinates.len())?;
        let coordinates = call.array(coordinates)?;
        let update = call.reference(&update)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_fit_camera_to_lat_lngs(
                map,
                coordinates,
                coordinate_count,
                update,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Reads the map's camera.
    ///
    /// The query reads the camera after the map applies the commands sent
    /// before it.
    ///
    /// See `mln_map_get_camera` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn get_camera(&self) -> Result<NativeFuture<CameraQueryResult>> {
        let call = self.inner.call();
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_camera(map, completion, out_diagnostic)
            },
            completion::value::<sys::mln_camera_query_result, _>,
        )
    }

    /// Reads the state of a feature, as a JSON object.
    ///
    /// The object is empty when the feature has no state.
    ///
    /// See `mln_map_get_feature_state` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn get_feature_state(
        &self,
        selector: &FeatureStateSelector<'_>,
    ) -> Result<NativeFuture<String>> {
        let mut call = self.inner.call();
        let selector = call.reference(&selector)?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_feature_state(map, selector, completion, out_diagnostic)
            },
            completion::value::<sys::mln_buffer_view, _>,
        )
    }

    /// Reads the global state of the map's style as a JSON object.
    ///
    /// See `mln_map_get_global_state` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn get_global_state(&self) -> Result<NativeFuture<String>> {
        let call = self.inner.call();
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_global_state(map, completion, out_diagnostic)
            },
            completion::value::<sys::mln_buffer_view, _>,
        )
    }

    /// Reads the corners of an image source's image, clockwise from the top
    /// left.
    ///
    /// See `mln_map_get_image_source_coordinates` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't an
    ///   image source.
    pub fn get_image_source_coordinates(
        &self,
        source_id: &str,
    ) -> Result<NativeFuture<Vec<LatLng>>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_image_source_coordinates(
                    map,
                    source_id,
                    completion,
                    out_diagnostic,
                )
            },
            completion::list::<sys::mln_lat_lng, _>,
        )
    }

    /// Reads the JSON of the style that the map loaded.
    ///
    /// The JSON doesn't include the changes made to the style since it loaded.
    ///
    /// See `mln_map_get_loaded_style_json` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn get_loaded_style_json(&self) -> Result<NativeFuture<String>> {
        let call = self.inner.call();
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_loaded_style_json(map, completion, out_diagnostic)
            },
            completion::value::<sys::mln_buffer_view, _>,
        )
    }

    /// Copies the map's state.
    ///
    /// The copy doesn't wait for pending commands. To read the camera after
    /// they apply, use `MapHandle::get_camera()`.
    ///
    /// See `mln_map_get_snapshot` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidState` until `RuntimeHandle::create_map()` completes
    ///   with `Status::Ok`.
    pub fn get_snapshot(&self) -> Result<MapSnapshot> {
        let mut call = self.inner.call();
        let mut out_snapshot: sys::mln_map_snapshot = unsafe { std::mem::zeroed() };
        out_snapshot.size = std::mem::size_of::<sys::mln_map_snapshot>() as _;
        call.status(|map, out_diagnostic| unsafe {
            sys::mln_map_get_snapshot(map, &mut out_snapshot, out_diagnostic)
        })?;
        Ok(unsafe { from_native(out_snapshot) }?)
    }

    /// Reads an image of the map's style.
    ///
    /// Completes with no value when the style has no image named `image_id`.
    ///
    /// See `mln_map_get_style_image` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn get_style_image(&self, image_id: &str) -> Result<NativeFuture<Option<StyleImageInfo>>> {
        let mut call = self.inner.call();
        let image_id = call.input(&image_id)?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_style_image(map, image_id, completion, out_diagnostic)
            },
            completion::optional::<sys::mln_style_image_info, _>,
        )
    }

    /// Reads a layer of the map's style.
    ///
    /// Completes with no value when the style has no layer named `layer_id`.
    ///
    /// See `mln_map_get_style_layer` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn get_style_layer(&self, layer_id: &str) -> Result<NativeFuture<Option<StyleLayerInfo>>> {
        let mut call = self.inner.call();
        let layer_id = call.input(&layer_id)?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_style_layer(map, layer_id, completion, out_diagnostic)
            },
            completion::optional::<sys::mln_style_layer_info, _>,
        )
    }

    /// Reads a layer of the map's style as a
    /// \[layer\](https://maplibre.org/maplibre-style-spec/layers/) object.
    ///
    /// Completes with no value when the style has no layer named `layer_id`.
    ///
    /// See `mln_map_get_style_layer_json` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn get_style_layer_json(&self, layer_id: &str) -> Result<NativeFuture<Option<String>>> {
        let mut call = self.inner.call();
        let layer_id = call.input(&layer_id)?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_style_layer_json(map, layer_id, completion, out_diagnostic)
            },
            completion::optional::<sys::mln_buffer_view, _>,
        )
    }

    /// Reads a property of a layer in the map's style.
    ///
    /// The value can differ in form from the value that was set: a color set as
    /// `"#ff0000"` reads back as `["rgba", 255, 0, 0, 1]`.
    ///
    /// Completes with no value when the layer doesn't set the property.
    ///
    /// See `mln_map_get_style_layer_property` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no layer named `layer_id`.
    pub fn get_style_layer_property(
        &self,
        layer_id: &str,
        property_name: &str,
    ) -> Result<NativeFuture<Option<String>>> {
        let mut call = self.inner.call();
        let layer_id = call.input(&layer_id)?;
        let property_name = call.input(&property_name)?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_style_layer_property(
                    map,
                    layer_id,
                    property_name,
                    completion,
                    out_diagnostic,
                )
            },
            completion::optional::<sys::mln_buffer_view, _>,
        )
    }

    /// Reads a property of the light of the map's style.
    ///
    /// The value can differ in form from the value that was set: a color set as
    /// `"#ff0000"` reads back as `["rgba", 255, 0, 0, 1]`.
    ///
    /// Completes with no value when the light doesn't set the property.
    ///
    /// See `mln_map_get_style_light_property` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn get_style_light_property(
        &self,
        property_name: &str,
    ) -> Result<NativeFuture<Option<String>>> {
        let mut call = self.inner.call();
        let property_name = call.input(&property_name)?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_style_light_property(
                    map,
                    property_name,
                    completion,
                    out_diagnostic,
                )
            },
            completion::optional::<sys::mln_buffer_view, _>,
        )
    }

    /// Reads a source of the map's style.
    ///
    /// A tile source with a `url` has an empty attribution until its TileJSON
    /// loads, which raises `RuntimeEventType::MapSourceChanged`.
    ///
    /// Completes with no value when the style has no source named `source_id`.
    ///
    /// See `mln_map_get_style_source` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn get_style_source(
        &self,
        source_id: &str,
    ) -> Result<NativeFuture<Option<StyleSourceInfo>>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_style_source(map, source_id, completion, out_diagnostic)
            },
            completion::optional::<sys::mln_style_source_info, _>,
        )
    }

    /// Reads the default transition of the map's style.
    ///
    /// See `mln_map_get_style_transition_options` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn get_style_transition_options(&self) -> Result<NativeFuture<StyleTransitionOptions>> {
        let call = self.inner.call();
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_style_transition_options(map, completion, out_diagnostic)
            },
            completion::value::<sys::mln_style_transition_options, _>,
        )
    }

    /// Reads the URL of the map's style.
    ///
    /// The URL is empty when the style came from `MapHandle::set_style_json()`.
    ///
    /// See `mln_map_get_style_url` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn get_style_url(&self) -> Result<NativeFuture<String>> {
        let call = self.inner.call();
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_get_style_url(map, completion, out_diagnostic)
            },
            completion::value::<sys::mln_buffer_view, _>,
        )
    }

    /// Makes a custom geometry source ask again for the tiles in `bounds` that
    /// the map still needs.
    ///
    /// See `mln_map_invalidate_custom_geometry_source_region` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't a
    ///   custom geometry source.
    pub fn invalidate_custom_geometry_source_region(
        &self,
        source_id: &str,
        bounds: LatLngBounds,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let bounds = call.input(&bounds)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_invalidate_custom_geometry_source_region(
                map,
                source_id,
                bounds,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Makes a custom geometry source ask for a tile again when the map needs
    /// it.
    ///
    /// See `mln_map_invalidate_custom_geometry_source_tile` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't a
    ///   custom geometry source.
    pub fn invalidate_custom_geometry_source_tile(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_invalidate_custom_geometry_source_tile(
                map,
                source_id,
                tile_id,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Makes a custom vector source ask again for the tiles in `bounds` that
    /// the map still needs.
    ///
    /// See `mln_map_invalidate_custom_vector_source_region` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't a
    ///   custom vector source.
    pub fn invalidate_custom_vector_source_region(
        &self,
        source_id: &str,
        bounds: LatLngBounds,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let bounds = call.input(&bounds)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_invalidate_custom_vector_source_region(
                map,
                source_id,
                bounds,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Makes a custom vector source ask for a tile again when the map needs it.
    ///
    /// See `mln_map_invalidate_custom_vector_source_tile` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't a
    ///   custom vector source.
    pub fn invalidate_custom_vector_source_tile(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_invalidate_custom_vector_source_tile(
                map,
                source_id,
                tile_id,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Computes the area that the map would show with `camera`.
    ///
    /// Camera fields that `camera` doesn't set come from the map's camera. The
    /// longitudes can fall outside -180 to 180, so a view across the
    /// antimeridian gives one continuous range.
    ///
    /// See `mln_map_lat_lng_bounds_for_camera` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn lat_lng_bounds_for_camera(
        &self,
        camera: &CameraOptions,
    ) -> Result<NativeFuture<LatLngBounds>> {
        let mut call = self.inner.call();
        let camera = call.reference(&camera)?;
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_lat_lng_bounds_for_camera(map, camera, completion, out_diagnostic)
            },
            completion::value::<sys::mln_lat_lng_bounds, _>,
        )
    }

    /// Lists the layers of the map's style, from bottom to top.
    ///
    /// See `mln_map_list_style_layers` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn list_style_layers(&self) -> Result<NativeFuture<Vec<StyleLayerInfo>>> {
        let call = self.inner.call();
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_list_style_layers(map, completion, out_diagnostic)
            },
            completion::list::<sys::mln_style_layer_info, _>,
        )
    }

    /// Lists the sources of the map's style.
    ///
    /// See `mln_map_list_style_sources` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn list_style_sources(&self) -> Result<NativeFuture<Vec<StyleSourceInfo>>> {
        let call = self.inner.call();
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_list_style_sources(map, completion, out_diagnostic)
            },
            completion::list::<sys::mln_style_source_info, _>,
        )
    }

    /// Moves a layer of the map's style below the layer named
    /// `before_layer_id`, or above every layer when `before_layer_id` is empty.
    ///
    /// See `mln_map_move_style_layer` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no layer named `layer_id` or
    ///   `before_layer_id`.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn move_style_layer(
        &self,
        layer_id: &str,
        before_layer_id: Option<&str>,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let layer_id = call.input(&layer_id)?;
        let before_layer_id = call.input(&before_layer_id)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_move_style_layer(
                map,
                layer_id,
                before_layer_id,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Releases the map.
    ///
    /// Detach the map's render session first.
    ///
    /// See `mln_map_release` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn release(self) -> std::result::Result<NativeFuture<()>, ReleaseError<Self>> {
        self.consume(|map| {
            let call = Call::new(map);
            call.complete(
                |map, completion, out_diagnostic| unsafe {
                    sys::mln_map_release(map, completion, out_diagnostic)
                },
                completion::unit,
            )
        })
    }

    /// Removes the feature state that `selector` selects.
    ///
    /// See `mln_map_remove_feature_state` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn remove_feature_state(
        &self,
        selector: &FeatureStateSelector<'_>,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let selector = call.reference(&selector)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_remove_feature_state(map, selector, completion, out_diagnostic)
        })
    }

    /// Removes an image from the map's style.
    ///
    /// See `mln_map_remove_style_image` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no image named `image_id`.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn remove_style_image(&self, image_id: &str) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let image_id = call.input(&image_id)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_remove_style_image(map, image_id, completion, out_diagnostic)
        })
    }

    /// Removes a layer from the map's style.
    ///
    /// See `mln_map_remove_style_layer` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no layer named `layer_id`.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn remove_style_layer(&self, layer_id: &str) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let layer_id = call.input(&layer_id)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_remove_style_layer(map, layer_id, completion, out_diagnostic)
        })
    }

    /// Removes a source from the map's style.
    ///
    /// See `mln_map_remove_style_source` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidState` when a layer still uses the source, or while
    ///   the style isn't loaded, as `MapHandle::set_style_url()` describes.
    pub fn remove_style_source(&self, source_id: &str) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_remove_style_source(map, source_id, completion, out_diagnostic)
        })
    }

    /// Renders a new frame of a continuous map, even when nothing changed.
    ///
    /// See `mln_map_request_repaint` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn request_repaint(&self) -> Result<NativeFuture<CommandCompletion>> {
        let call = self.inner.call();
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_request_repaint(map, completion, out_diagnostic)
        })
    }

    /// Renders a still image of a static or tile map.
    ///
    /// The map's render session draws the image once every resource that the
    /// image needs has loaded.
    ///
    /// See `mln_map_request_still_image` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::Cancelled` when the map is released before the image is done.
    /// - `Status::NativeError` when the style or a resource that the image
    ///   needs fails to load.
    pub fn request_still_image(&self) -> Result<NativeFuture<()>> {
        let call = self.inner.call();
        call.complete(
            |map, completion, out_diagnostic| unsafe {
                sys::mln_map_request_still_image(map, completion, out_diagnostic)
            },
            completion::unit,
        )
    }

    /// Sets the map's size.
    ///
    /// A map with a render session takes its size from the session, so resize
    /// the session with `RenderSessionHandle::resize()` instead.
    ///
    /// See `mln_map_resize` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidState` when the map has a render session.
    /// - `Status::InvalidState` when a render session attached to the map
    ///   before the resize applied.
    pub fn resize(&self, logical_size: LogicalSize) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let logical_size = call.input(&logical_size)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_resize(map, logical_size, completion, out_diagnostic)
        })
    }

    /// Limits the camera's center to an area, and its zoom and pitch to ranges.
    ///
    /// Limits that `options` doesn't set keep their current values. When the
    /// camera is outside the new limits, it moves inside them.
    ///
    /// See `mln_map_set_bounds` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_bounds(&self, options: &BoundOptions) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let options = call.reference(&options)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_bounds(map, options, completion, out_diagnostic)
        })
    }

    /// Sets the data of a tile in a custom geometry source.
    ///
    /// `data` is a GeoJSON feature collection, feature, or geometry. The source
    /// ignores data for a tile that it hasn't asked for, or has since
    /// cancelled.
    ///
    /// See `mln_map_set_custom_geometry_source_tile_data` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't a
    ///   custom geometry source.
    pub fn set_custom_geometry_source_tile_data(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
        data: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        let data = call.input(&data)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_custom_geometry_source_tile_data(
                map,
                source_id,
                tile_id,
                data,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Reports that a tile of a custom geometry source failed to load.
    ///
    /// See `mln_map_set_custom_geometry_source_tile_error` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't a
    ///   custom geometry source.
    pub fn set_custom_geometry_source_tile_error(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
        message: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        let message = call.input(&message)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_custom_geometry_source_tile_error(
                map,
                source_id,
                tile_id,
                message,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Sets the data of a tile in a custom vector source.
    ///
    /// `data` is the tile, encoded as `encoding`. The source ignores data for a
    /// tile that it hasn't asked for, or has since cancelled.
    ///
    /// See `mln_map_set_custom_vector_source_tile_data` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't a
    ///   custom vector source.
    pub fn set_custom_vector_source_tile_data(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
        encoding: StyleVectorTileEncoding,
        data: &[u8],
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        let data = call.input(&data)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_custom_vector_source_tile_data(
                map,
                source_id,
                tile_id,
                encoding.as_raw(),
                data,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Reports that a tile of a custom vector source failed to load.
    ///
    /// See `mln_map_set_custom_vector_source_tile_error` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't a
    ///   custom vector source.
    pub fn set_custom_vector_source_tile_error(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
        message: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        let message = call.input(&message)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_custom_vector_source_tile_error(
                map,
                source_id,
                tile_id,
                message,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Draws debugging overlays, such as tile borders, on the map.
    ///
    /// `flags` replaces the overlays set before.
    ///
    /// See `mln_map_set_debug_flags` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_debug_flags(&self, flags: MapDebugFlag) -> Result<NativeFuture<CommandCompletion>> {
        let call = self.inner.call();
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_debug_flags(map, flags.bits(), completion, out_diagnostic)
        })
    }

    /// Selects the events that the map reports.
    ///
    /// See `mln_map_set_event_mask` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn set_event_mask(
        &self,
        mask: RuntimeEventFlag,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let call = self.inner.call();
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_event_mask(map, mask.bits(), completion, out_diagnostic)
        })
    }

    /// Merges `state` into the state of a feature.
    ///
    /// `state` is a JSON object. Its keys replace the same keys in the
    /// feature's state, and the other keys stay.
    ///
    /// See `mln_map_set_feature_state` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn set_feature_state(
        &self,
        selector: &FeatureStateSelector<'_>,
        state: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let selector = call.reference(&selector)?;
        let state = call.input(&state)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_feature_state(map, selector, state, completion, out_diagnostic)
        })
    }

    /// Places the camera at a position and orientation in space.
    ///
    /// The map adjusts them to a camera that it can show. It stops running
    /// camera animations first, and their end handlers report
    /// `CameraTransitionOutcome::Cancelled`.
    ///
    /// See `mln_map_set_free_camera_options` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_free_camera_options(
        &self,
        options: &FreeCameraOptions,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let options = call.reference(&options)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_free_camera_options(map, options, completion, out_diagnostic)
        })
    }

    /// Replaces the data of a GeoJSON source.
    ///
    /// `data` is a GeoJSON feature collection, feature, or geometry. The
    /// library prepares it for the source with the source's options, off the
    /// threads that the caller and the runtime use, and the command completes
    /// once the source holds it. Later commands don't wait for it. While the
    /// source is still preparing earlier data, only the newest data waits to
    /// follow it.
    ///
    /// With synchronous tiling on, as
    /// `MapHandle::set_geo_json_source_synchronous_tiling()` describes, the
    /// command prepares `data` before later commands run, so the data shows in
    /// the next frame.
    ///
    /// See `mln_map_set_geo_json_source_data` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't a
    ///   GeoJSON source, when `data` isn't valid GeoJSON, or when the source
    ///   clusters and `data` isn't a feature collection of points. The source
    ///   keeps its data.
    /// - `Status::Cancelled` when newer data for the source replaces `data`
    ///   while it waits, or when the source's URL, its removal, a style load,
    ///   or the map's release replaces the source's data before `data` is
    ///   ready.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_geo_json_source_data(
        &self,
        source_id: &str,
        data: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let data = call.input(&data)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_geo_json_source_data(map, source_id, data, completion, out_diagnostic)
        })
    }

    /// Sets whether a GeoJSON source builds its tiles while the map renders.
    ///
    /// Building tiles while the map renders, instead of in the background,
    /// makes new data show in the next frame. The setting replaces the
    /// `synchronousUpdate` member of the source's JSON, which defaults to
    /// false.
    ///
    /// See `mln_map_set_geo_json_source_synchronous_tiling` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't a
    ///   GeoJSON source.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_geo_json_source_synchronous_tiling(
        &self,
        source_id: &str,
        enabled: bool,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_geo_json_source_synchronous_tiling(
                map,
                source_id,
                enabled,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Makes a GeoJSON source load its data from `url`.
    ///
    /// See `mln_map_set_geo_json_source_url` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't a
    ///   GeoJSON source.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_geo_json_source_url(
        &self,
        source_id: &str,
        url: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let url = call.input(&url)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_geo_json_source_url(map, source_id, url, completion, out_diagnostic)
        })
    }

    /// Sets a value that the style's `global-state`
    /// \[expressions\](https://maplibre.org/maplibre-style-spec/expressions/)
    /// read.
    ///
    /// See `mln_map_set_global_state_property` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_global_state_property(
        &self,
        property_name: &str,
        value: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let property_name = call.input(&property_name)?;
        let value = call.input(&value)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_global_state_property(
                map,
                property_name,
                value,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Moves the image of an image source.
    ///
    /// `coordinates` are the image's four corners, clockwise from the top left.
    ///
    /// See `mln_map_set_image_source_coordinates` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't an
    ///   image source.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_image_source_coordinates(
        &self,
        source_id: &str,
        coordinates: &[LatLng],
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let coordinate_count = convert::count(coordinates.len())?;
        let source_id = call.input(&source_id)?;
        let coordinates = call.array(coordinates)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_image_source_coordinates(
                map,
                source_id,
                coordinates,
                coordinate_count,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Replaces the image of an image source.
    ///
    /// See `mln_map_set_image_source_image` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't an
    ///   image source.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_image_source_image(
        &self,
        source_id: &str,
        image: &PremultipliedRgba8Image<'_>,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let image = call.reference(&image)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_image_source_image(map, source_id, image, completion, out_diagnostic)
        })
    }

    /// Makes an image source load its image from `url`.
    ///
    /// See `mln_map_set_image_source_url` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidArgument` when the source named `source_id` isn't an
    ///   image source.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_image_source_url(
        &self,
        source_id: &str,
        url: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        let url = call.input(&url)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_image_source_url(map, source_id, url, completion, out_diagnostic)
        })
    }

    /// Sets whether the map draws in perspective or axonometric projection, and
    /// how much it skews the view.
    ///
    /// Settings that `options` doesn't set keep their current values.
    ///
    /// See `mln_map_set_projection_mode` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_projection_mode(
        &self,
        options: &ProjectionModeOptions,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let options = call.reference(&options)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_projection_mode(map, options, completion, out_diagnostic)
        })
    }

    /// Shows or hides an overlay of rendering statistics on the map.
    ///
    /// See `mln_map_set_rendering_stats_view_enabled` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_rendering_stats_view_enabled(
        &self,
        enabled: bool,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let call = self.inner.call();
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_rendering_stats_view_enabled(map, enabled, completion, out_diagnostic)
        })
    }

    /// Adds an image to the map's style, or replaces the image named
    /// `image_id`.
    ///
    /// See `mln_map_set_style_image` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_style_image(
        &self,
        image_id: &str,
        image: &PremultipliedRgba8Image<'_>,
        options: Option<&StyleImageOptions>,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let image_id = call.input(&image_id)?;
        let image = call.reference(&image)?;
        let options = call.optional_reference(options.as_ref())?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_image(map, image_id, image, options, completion, out_diagnostic)
        })
    }

    /// Loads the map's style from `json`.
    ///
    /// The command completes once the style has parsed, and the map's style is
    /// then loaded, as `MapHandle::set_style_url()` describes. The style's
    /// sources, sprites, and glyphs load in the background.
    ///
    /// See `mln_map_set_style_json` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NativeError` when `json` isn't a valid style. The map keeps
    ///   its current style.
    pub fn set_style_json(&self, json: &str) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let json = call.input(&json)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_json(map, json, completion, out_diagnostic)
        })
    }

    /// Sets a property of a layer in the map's style.
    ///
    /// `property_name` is one of the layer's layout or paint
    /// \[properties\](https://maplibre.org/maplibre-style-spec/layers/), or
    /// `filter`, `minzoom`, `maxzoom`, `source`, or `source-layer`. A null
    /// `value` resets any of these but `source` and `source-layer` to its
    /// default.
    ///
    /// See `mln_map_set_style_layer_property` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no layer named `layer_id`.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_style_layer_property(
        &self,
        layer_id: &str,
        property_name: &str,
        value: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let layer_id = call.input(&layer_id)?;
        let property_name = call.input(&property_name)?;
        let value = call.input(&value)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_layer_property(
                map,
                layer_id,
                property_name,
                value,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Replaces the \[light\](https://maplibre.org/maplibre-style-spec/light/)
    /// of the map's style.
    ///
    /// See `mln_map_set_style_light_json` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_style_light_json(
        &self,
        light_json: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let light_json = call.input(&light_json)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_light_json(map, light_json, completion, out_diagnostic)
        })
    }

    /// Sets a property of the light of the map's style.
    ///
    /// See `mln_map_set_style_light_property` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_style_light_property(
        &self,
        property_name: &str,
        value: &str,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let property_name = call.input(&property_name)?;
        let value = call.input(&value)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_light_property(
                map,
                property_name,
                value,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Sets whether a source is volatile.
    ///
    /// The map doesn't store the tiles of a volatile source in the persistent
    /// cache.
    ///
    /// See `mln_map_set_style_source_volatile` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NotFound` when the style has no source named `source_id`.
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_style_source_volatile(
        &self,
        source_id: &str,
        is_volatile: bool,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let source_id = call.input(&source_id)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_source_volatile(
                map,
                source_id,
                is_volatile,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Sets the default transition of the map's style.
    ///
    /// See `mln_map_set_style_transition_options` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidState` while the style isn't loaded, as
    ///   `MapHandle::set_style_url()` describes.
    pub fn set_style_transition_options(
        &self,
        options: &StyleTransitionOptions,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let options = call.reference(&options)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_transition_options(map, options, completion, out_diagnostic)
        })
    }

    /// Loads the map's style from `url`.
    ///
    /// The command completes once the style document has loaded and parsed. The
    /// style's sources, sprites, and glyphs then load in the background.
    ///
    /// The map's style is loaded from the time a style document parses until
    /// the next call to this function. While the style isn't loaded, the
    /// commands that change it complete with `Status::InvalidState`. To change
    /// a new map's style without a style document, first load an empty style,
    /// such as `{"version":8,"sources":{},"layers":[]}`.
    ///
    /// See `mln_map_set_style_url` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::NativeError` when the style document fails to load or isn't a
    ///   valid style.
    /// - `Status::Cancelled` when the map is released, or this function or
    ///   `MapHandle::set_style_json()` loads another style, before the style
    ///   document parses.
    pub fn set_style_url(&self, url: &str) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let url = call.input(&url)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_url(map, url, completion, out_diagnostic)
        })
    }

    /// Sets how the map chooses which tiles to load, and at what detail.
    ///
    /// Settings that `options` doesn't set keep their current values.
    ///
    /// See `mln_map_set_tile_options` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_tile_options(
        &self,
        options: &MapTileOptions,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let options = call.reference(&options)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_tile_options(map, options, completion, out_diagnostic)
        })
    }

    /// Sets how the map orients and constrains its view.
    ///
    /// Settings that `options` doesn't set keep their current values.
    ///
    /// See `mln_map_set_viewport_options` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_viewport_options(
        &self,
        options: &MapViewportOptions,
    ) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let options = call.reference(&options)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_viewport_options(map, options, completion, out_diagnostic)
        })
    }

    /// Moves the camera, at once or with an animation.
    ///
    /// Camera fields that `update` doesn't set keep their values, and the
    /// update stops any running animation of the fields it sets. The function
    /// finishes when the map applies the update, before an animation ends. To
    /// learn when an animation ends, set an `CameraTransitionHandler` in its
    /// animation options.
    ///
    /// See `mln_map_update_camera` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn update_camera(&self, update: &CameraUpdate) -> Result<NativeFuture<CommandCompletion>> {
        let mut call = self.inner.call();
        let update = call.reference(&update)?;
        call.command(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_update_camera(map, update, completion, out_diagnostic)
        })
    }
}

/// Submits [`MapHandle`] commands without a completion. Each call returns
/// the same acceptance status as its completing form, and native logs a
/// command that later fails as a warning through the log handler.
pub struct MapHandleDiscarding<'a>(&'a MapHandle);
impl MapHandle {
    pub fn discarding(&self) -> MapHandleDiscarding<'_> {
        MapHandleDiscarding(self)
    }
}
impl MapHandleDiscarding<'_> {
    /// Adds a source whose GeoJSON tiles come from callbacks.
    ///
    /// See `mln_map_add_custom_geometry_source` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn add_custom_geometry_source(
        &self,
        source_id: &str,
        options: CustomGeometrySourceOptions,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let options = call.reference(&options)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_custom_geometry_source(
                map,
                source_id,
                options,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Adds a source whose vector tiles come from callbacks.
    ///
    /// See `mln_map_add_custom_vector_source` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn add_custom_vector_source(
        &self,
        source_id: &str,
        options: CustomVectorSourceOptions,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let options = call.reference(&options)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_custom_vector_source(
                map,
                source_id,
                options,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Adds a GeoJSON source with no data.
    ///
    /// Give it data with `MapHandle::set_geo_json_source_data()` or
    /// `MapHandle::set_geo_json_source_url()`. Its options stay fixed for as
    /// long as the style holds it.
    ///
    /// `attribution` is the source's
    /// \[attribution\](https://maplibre.org/maplibre-style-spec/sources/#attribution),
    /// or empty for none.
    ///
    /// See `mln_map_add_geo_json_source` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidArgument` when an option in `options` is out of range.
    pub fn add_geo_json_source(
        &self,
        source_id: &str,
        options: Option<&GeoJsonSourceOptions>,
        attribution: Option<&str>,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let options = call.optional_reference(options.as_ref())?;
        let attribution = call.input(&attribution)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_geo_json_source(
                map,
                source_id,
                options,
                attribution,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Adds an image source that shows `image`.
    ///
    /// `coordinates` are the image's four corners, clockwise from the top left.
    ///
    /// See `mln_map_add_image_source_image` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn add_image_source_image(
        &self,
        source_id: &str,
        coordinates: &[LatLng],
        image: &PremultipliedRgba8Image<'_>,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let coordinate_count = convert::count(coordinates.len())?;
        let source_id = call.input(&source_id)?;
        let coordinates = call.array(coordinates)?;
        let image = call.reference(&image)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_image_source_image(
                map,
                source_id,
                coordinates,
                coordinate_count,
                image,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Adds a layer to the map's style.
    ///
    /// `layer_json` is a
    /// \[layer\](https://maplibre.org/maplibre-style-spec/layers/) object. The
    /// layer goes below the layer named `before_layer_id`, or above every layer
    /// when `before_layer_id` is empty.
    ///
    /// See `mln_map_add_style_layer_json` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn add_style_layer_json(
        &self,
        layer_json: &str,
        before_layer_id: Option<&str>,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let layer_json = call.input(&layer_json)?;
        let before_layer_id = call.input(&before_layer_id)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_style_layer_json(
                map,
                layer_json,
                before_layer_id,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Adds a source to the map's style.
    ///
    /// `source_json` is a
    /// \[source\](https://maplibre.org/maplibre-style-spec/sources/) object.
    ///
    /// See `mln_map_add_style_source_json` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn add_style_source_json(&self, source_id: &str, source_json: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let source_json = call.input(&source_json)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_add_style_source_json(
                map,
                source_id,
                source_json,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Moves the camera relative to where it is, as a gesture does.
    ///
    /// `delta` can pan the map's content by an offset on the screen, scale the
    /// zoom, and add to the bearing and pitch. An anchor keeps one screen point
    /// in place while the scale, bearing, or pitch changes. An anchor needs one
    /// of those changes, and combines with an offset only when the delta has no
    /// animation. The function finishes when the map applies the delta, before
    /// an animation ends.
    ///
    /// A delta that replaces an animated one starts from where that animation
    /// left the camera, so the rest of the replaced change never happens. To
    /// reach an exact camera, use `MapHandle::update_camera()`.
    ///
    /// A delta in the end phase can carry momentum, which keeps the camera
    /// moving from the gesture's release velocities and slows it on each
    /// rendered frame. The gesture lasts until the momentum ends: the snapshot
    /// keeps `gesture_in_progress` set, and camera events report
    /// `CameraChangeSource::Momentum`. With momentum, `animation` sets only
    /// `transition_id` and the end handler, which runs when the gesture ends.
    ///
    /// A delta in the begin phase, `MapHandle::cancel_camera_transitions()`, or
    /// a cancellation by that ID stops the momentum. A later command that sets
    /// a field stops only the parts of the momentum that move that field. On a
    /// tilted map, the pan moves the map's content the same distance on the
    /// screen in every direction.
    ///
    /// See `mln_map_apply_camera_delta` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn apply_camera_delta(&self, delta: &CameraDelta) -> Result<()> {
        let mut call = self.0.inner.call();
        let delta = call.reference(&delta)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_apply_camera_delta(map, delta, completion, out_diagnostic)
        })
    }

    /// Holds back the map's changes from rendering until
    /// `MapHandle::end_command_group()`, so they show in the same frame.
    ///
    /// Groups nest, and the changes render when the outermost group ends.
    ///
    /// See `mln_map_begin_command_group` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn begin_command_group(&self) -> Result<()> {
        let call = self.0.inner.call();
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_begin_command_group(map, completion, out_diagnostic)
        })
    }

    /// Stops every running camera animation where it is.
    ///
    /// The end handler of each stopped animation reports
    /// `CameraTransitionOutcome::Cancelled`.
    ///
    /// See `mln_map_cancel_camera_transitions` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn cancel_camera_transitions(&self) -> Result<()> {
        let call = self.0.inner.call();
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_cancel_camera_transitions(map, completion, out_diagnostic)
        })
    }

    /// Stops the running camera animations whose animation options set
    /// `transition_id`.
    ///
    /// Other animations keep running. The end handler of each stopped animation
    /// reports `CameraTransitionOutcome::Cancelled`.
    ///
    /// See `mln_map_cancel_camera_transitions_with_id` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn cancel_camera_transitions_with_id(&self, transition_id: u64) -> Result<()> {
        let call = self.0.inner.call();
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_cancel_camera_transitions_with_id(
                map,
                transition_id,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Logs debugging information about the map's style and sources.
    ///
    /// See `mln_map_dump_debug_logs` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn dump_debug_logs(&self) -> Result<()> {
        let call = self.0.inner.call();
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_dump_debug_logs(map, completion, out_diagnostic)
        })
    }

    /// Ends the group that `MapHandle::begin_command_group()` began.
    ///
    /// See `mln_map_end_command_group` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn end_command_group(&self) -> Result<()> {
        let call = self.0.inner.call();
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_end_command_group(map, completion, out_diagnostic)
        })
    }

    /// Moves the camera to fit a GeoJSON geometry in the map's view, at once or
    /// with an animation.
    ///
    /// `geometry` is a GeoJSON geometry object with at least one coordinate,
    /// not a feature. The camera is the one that
    /// `MapHandle::camera_for_geometry()` computes after the commands sent
    /// before this one apply. The function finishes when the map applies the
    /// change, before an animation ends.
    ///
    /// See `mln_map_fit_camera_to_geometry` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn fit_camera_to_geometry(&self, geometry: &str, update: &CameraFitUpdate) -> Result<()> {
        let mut call = self.0.inner.call();
        let geometry = call.input(&geometry)?;
        let update = call.reference(&update)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_fit_camera_to_geometry(map, geometry, update, completion, out_diagnostic)
        })
    }

    /// Moves the camera to fit `bounds` in the map's view, at once or with an
    /// animation.
    ///
    /// The camera is the one that `MapHandle::camera_for_lat_lng_bounds()`
    /// computes after the commands sent before this one apply. The function
    /// finishes when the map applies the change, before an animation ends.
    ///
    /// See `mln_map_fit_camera_to_lat_lng_bounds` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn fit_camera_to_lat_lng_bounds(
        &self,
        bounds: LatLngBounds,
        update: &CameraFitUpdate,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let bounds = call.input(&bounds)?;
        let update = call.reference(&update)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_fit_camera_to_lat_lng_bounds(
                map,
                bounds,
                update,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Moves the camera to fit `coordinates` in the map's view, at once or with
    /// an animation.
    ///
    /// `coordinates` must not be empty. The camera is the one that
    /// `MapHandle::camera_for_lat_lngs()` computes after the commands sent
    /// before this one apply. The function finishes when the map applies the
    /// change, before an animation ends.
    ///
    /// See `mln_map_fit_camera_to_lat_lngs` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn fit_camera_to_lat_lngs(
        &self,
        coordinates: &[LatLng],
        update: &CameraFitUpdate,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let coordinate_count = convert::count(coordinates.len())?;
        let coordinates = call.array(coordinates)?;
        let update = call.reference(&update)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_fit_camera_to_lat_lngs(
                map,
                coordinates,
                coordinate_count,
                update,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Makes a custom geometry source ask again for the tiles in `bounds` that
    /// the map still needs.
    ///
    /// See `mln_map_invalidate_custom_geometry_source_region` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn invalidate_custom_geometry_source_region(
        &self,
        source_id: &str,
        bounds: LatLngBounds,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let bounds = call.input(&bounds)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_invalidate_custom_geometry_source_region(
                map,
                source_id,
                bounds,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Makes a custom geometry source ask for a tile again when the map needs
    /// it.
    ///
    /// See `mln_map_invalidate_custom_geometry_source_tile` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn invalidate_custom_geometry_source_tile(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_invalidate_custom_geometry_source_tile(
                map,
                source_id,
                tile_id,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Makes a custom vector source ask again for the tiles in `bounds` that
    /// the map still needs.
    ///
    /// See `mln_map_invalidate_custom_vector_source_region` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn invalidate_custom_vector_source_region(
        &self,
        source_id: &str,
        bounds: LatLngBounds,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let bounds = call.input(&bounds)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_invalidate_custom_vector_source_region(
                map,
                source_id,
                bounds,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Makes a custom vector source ask for a tile again when the map needs it.
    ///
    /// See `mln_map_invalidate_custom_vector_source_tile` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn invalidate_custom_vector_source_tile(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_invalidate_custom_vector_source_tile(
                map,
                source_id,
                tile_id,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Moves a layer of the map's style below the layer named
    /// `before_layer_id`, or above every layer when `before_layer_id` is empty.
    ///
    /// See `mln_map_move_style_layer` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn move_style_layer(&self, layer_id: &str, before_layer_id: Option<&str>) -> Result<()> {
        let mut call = self.0.inner.call();
        let layer_id = call.input(&layer_id)?;
        let before_layer_id = call.input(&before_layer_id)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_move_style_layer(
                map,
                layer_id,
                before_layer_id,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Removes the feature state that `selector` selects.
    ///
    /// See `mln_map_remove_feature_state` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn remove_feature_state(&self, selector: &FeatureStateSelector<'_>) -> Result<()> {
        let mut call = self.0.inner.call();
        let selector = call.reference(&selector)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_remove_feature_state(map, selector, completion, out_diagnostic)
        })
    }

    /// Removes an image from the map's style.
    ///
    /// See `mln_map_remove_style_image` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn remove_style_image(&self, image_id: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let image_id = call.input(&image_id)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_remove_style_image(map, image_id, completion, out_diagnostic)
        })
    }

    /// Removes a layer from the map's style.
    ///
    /// See `mln_map_remove_style_layer` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn remove_style_layer(&self, layer_id: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let layer_id = call.input(&layer_id)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_remove_style_layer(map, layer_id, completion, out_diagnostic)
        })
    }

    /// Removes a source from the map's style.
    ///
    /// See `mln_map_remove_style_source` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn remove_style_source(&self, source_id: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_remove_style_source(map, source_id, completion, out_diagnostic)
        })
    }

    /// Renders a new frame of a continuous map, even when nothing changed.
    ///
    /// See `mln_map_request_repaint` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn request_repaint(&self) -> Result<()> {
        let call = self.0.inner.call();
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_request_repaint(map, completion, out_diagnostic)
        })
    }

    /// Sets the map's size.
    ///
    /// A map with a render session takes its size from the session, so resize
    /// the session with `RenderSessionHandle::resize()` instead.
    ///
    /// See `mln_map_resize` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    ///
    /// # Errors
    ///
    /// - `Status::InvalidState` when the map has a render session.
    pub fn resize(&self, logical_size: LogicalSize) -> Result<()> {
        let mut call = self.0.inner.call();
        let logical_size = call.input(&logical_size)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_resize(map, logical_size, completion, out_diagnostic)
        })
    }

    /// Limits the camera's center to an area, and its zoom and pitch to ranges.
    ///
    /// Limits that `options` doesn't set keep their current values. When the
    /// camera is outside the new limits, it moves inside them.
    ///
    /// See `mln_map_set_bounds` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_bounds(&self, options: &BoundOptions) -> Result<()> {
        let mut call = self.0.inner.call();
        let options = call.reference(&options)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_bounds(map, options, completion, out_diagnostic)
        })
    }

    /// Sets the data of a tile in a custom geometry source.
    ///
    /// `data` is a GeoJSON feature collection, feature, or geometry. The source
    /// ignores data for a tile that it hasn't asked for, or has since
    /// cancelled.
    ///
    /// See `mln_map_set_custom_geometry_source_tile_data` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_custom_geometry_source_tile_data(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
        data: &str,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        let data = call.input(&data)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_custom_geometry_source_tile_data(
                map,
                source_id,
                tile_id,
                data,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Reports that a tile of a custom geometry source failed to load.
    ///
    /// See `mln_map_set_custom_geometry_source_tile_error` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_custom_geometry_source_tile_error(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
        message: &str,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        let message = call.input(&message)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_custom_geometry_source_tile_error(
                map,
                source_id,
                tile_id,
                message,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Sets the data of a tile in a custom vector source.
    ///
    /// `data` is the tile, encoded as `encoding`. The source ignores data for a
    /// tile that it hasn't asked for, or has since cancelled.
    ///
    /// See `mln_map_set_custom_vector_source_tile_data` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_custom_vector_source_tile_data(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
        encoding: StyleVectorTileEncoding,
        data: &[u8],
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        let data = call.input(&data)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_custom_vector_source_tile_data(
                map,
                source_id,
                tile_id,
                encoding.as_raw(),
                data,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Reports that a tile of a custom vector source failed to load.
    ///
    /// See `mln_map_set_custom_vector_source_tile_error` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_custom_vector_source_tile_error(
        &self,
        source_id: &str,
        tile_id: CanonicalTileId,
        message: &str,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let tile_id = call.input(&tile_id)?;
        let message = call.input(&message)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_custom_vector_source_tile_error(
                map,
                source_id,
                tile_id,
                message,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Draws debugging overlays, such as tile borders, on the map.
    ///
    /// `flags` replaces the overlays set before.
    ///
    /// See `mln_map_set_debug_flags` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_debug_flags(&self, flags: MapDebugFlag) -> Result<()> {
        let call = self.0.inner.call();
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_debug_flags(map, flags.bits(), completion, out_diagnostic)
        })
    }

    /// Selects the events that the map reports.
    ///
    /// See `mln_map_set_event_mask` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn set_event_mask(&self, mask: RuntimeEventFlag) -> Result<()> {
        let call = self.0.inner.call();
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_event_mask(map, mask.bits(), completion, out_diagnostic)
        })
    }

    /// Merges `state` into the state of a feature.
    ///
    /// `state` is a JSON object. Its keys replace the same keys in the
    /// feature's state, and the other keys stay.
    ///
    /// See `mln_map_set_feature_state` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn set_feature_state(
        &self,
        selector: &FeatureStateSelector<'_>,
        state: &str,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let selector = call.reference(&selector)?;
        let state = call.input(&state)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_feature_state(map, selector, state, completion, out_diagnostic)
        })
    }

    /// Places the camera at a position and orientation in space.
    ///
    /// The map adjusts them to a camera that it can show. It stops running
    /// camera animations first, and their end handlers report
    /// `CameraTransitionOutcome::Cancelled`.
    ///
    /// See `mln_map_set_free_camera_options` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_free_camera_options(&self, options: &FreeCameraOptions) -> Result<()> {
        let mut call = self.0.inner.call();
        let options = call.reference(&options)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_free_camera_options(map, options, completion, out_diagnostic)
        })
    }

    /// Replaces the data of a GeoJSON source.
    ///
    /// `data` is a GeoJSON feature collection, feature, or geometry. The
    /// library prepares it for the source with the source's options, off the
    /// threads that the caller and the runtime use, and the command completes
    /// once the source holds it. Later commands don't wait for it. While the
    /// source is still preparing earlier data, only the newest data waits to
    /// follow it.
    ///
    /// With synchronous tiling on, as
    /// `MapHandle::set_geo_json_source_synchronous_tiling()` describes, the
    /// command prepares `data` before later commands run, so the data shows in
    /// the next frame.
    ///
    /// See `mln_map_set_geo_json_source_data` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_geo_json_source_data(&self, source_id: &str, data: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let data = call.input(&data)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_geo_json_source_data(map, source_id, data, completion, out_diagnostic)
        })
    }

    /// Sets whether a GeoJSON source builds its tiles while the map renders.
    ///
    /// Building tiles while the map renders, instead of in the background,
    /// makes new data show in the next frame. The setting replaces the
    /// `synchronousUpdate` member of the source's JSON, which defaults to
    /// false.
    ///
    /// See `mln_map_set_geo_json_source_synchronous_tiling` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_geo_json_source_synchronous_tiling(
        &self,
        source_id: &str,
        enabled: bool,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_geo_json_source_synchronous_tiling(
                map,
                source_id,
                enabled,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Makes a GeoJSON source load its data from `url`.
    ///
    /// See `mln_map_set_geo_json_source_url` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_geo_json_source_url(&self, source_id: &str, url: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let url = call.input(&url)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_geo_json_source_url(map, source_id, url, completion, out_diagnostic)
        })
    }

    /// Sets a value that the style's `global-state`
    /// \[expressions\](https://maplibre.org/maplibre-style-spec/expressions/)
    /// read.
    ///
    /// See `mln_map_set_global_state_property` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_global_state_property(&self, property_name: &str, value: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let property_name = call.input(&property_name)?;
        let value = call.input(&value)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_global_state_property(
                map,
                property_name,
                value,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Moves the image of an image source.
    ///
    /// `coordinates` are the image's four corners, clockwise from the top left.
    ///
    /// See `mln_map_set_image_source_coordinates` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_image_source_coordinates(
        &self,
        source_id: &str,
        coordinates: &[LatLng],
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let coordinate_count = convert::count(coordinates.len())?;
        let source_id = call.input(&source_id)?;
        let coordinates = call.array(coordinates)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_image_source_coordinates(
                map,
                source_id,
                coordinates,
                coordinate_count,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Replaces the image of an image source.
    ///
    /// See `mln_map_set_image_source_image` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_image_source_image(
        &self,
        source_id: &str,
        image: &PremultipliedRgba8Image<'_>,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let image = call.reference(&image)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_image_source_image(map, source_id, image, completion, out_diagnostic)
        })
    }

    /// Makes an image source load its image from `url`.
    ///
    /// See `mln_map_set_image_source_url` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_image_source_url(&self, source_id: &str, url: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        let url = call.input(&url)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_image_source_url(map, source_id, url, completion, out_diagnostic)
        })
    }

    /// Sets whether the map draws in perspective or axonometric projection, and
    /// how much it skews the view.
    ///
    /// Settings that `options` doesn't set keep their current values.
    ///
    /// See `mln_map_set_projection_mode` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_projection_mode(&self, options: &ProjectionModeOptions) -> Result<()> {
        let mut call = self.0.inner.call();
        let options = call.reference(&options)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_projection_mode(map, options, completion, out_diagnostic)
        })
    }

    /// Shows or hides an overlay of rendering statistics on the map.
    ///
    /// See `mln_map_set_rendering_stats_view_enabled` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_rendering_stats_view_enabled(&self, enabled: bool) -> Result<()> {
        let call = self.0.inner.call();
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_rendering_stats_view_enabled(map, enabled, completion, out_diagnostic)
        })
    }

    /// Adds an image to the map's style, or replaces the image named
    /// `image_id`.
    ///
    /// See `mln_map_set_style_image` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_style_image(
        &self,
        image_id: &str,
        image: &PremultipliedRgba8Image<'_>,
        options: Option<&StyleImageOptions>,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let image_id = call.input(&image_id)?;
        let image = call.reference(&image)?;
        let options = call.optional_reference(options.as_ref())?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_image(map, image_id, image, options, completion, out_diagnostic)
        })
    }

    /// Loads the map's style from `json`.
    ///
    /// The command completes once the style has parsed, and the map's style is
    /// then loaded, as `MapHandle::set_style_url()` describes. The style's
    /// sources, sprites, and glyphs load in the background.
    ///
    /// See `mln_map_set_style_json` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn set_style_json(&self, json: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let json = call.input(&json)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_json(map, json, completion, out_diagnostic)
        })
    }

    /// Sets a property of a layer in the map's style.
    ///
    /// `property_name` is one of the layer's layout or paint
    /// \[properties\](https://maplibre.org/maplibre-style-spec/layers/), or
    /// `filter`, `minzoom`, `maxzoom`, `source`, or `source-layer`. A null
    /// `value` resets any of these but `source` and `source-layer` to its
    /// default.
    ///
    /// See `mln_map_set_style_layer_property` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_style_layer_property(
        &self,
        layer_id: &str,
        property_name: &str,
        value: &str,
    ) -> Result<()> {
        let mut call = self.0.inner.call();
        let layer_id = call.input(&layer_id)?;
        let property_name = call.input(&property_name)?;
        let value = call.input(&value)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_layer_property(
                map,
                layer_id,
                property_name,
                value,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Replaces the \[light\](https://maplibre.org/maplibre-style-spec/light/)
    /// of the map's style.
    ///
    /// See `mln_map_set_style_light_json` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_style_light_json(&self, light_json: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let light_json = call.input(&light_json)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_light_json(map, light_json, completion, out_diagnostic)
        })
    }

    /// Sets a property of the light of the map's style.
    ///
    /// See `mln_map_set_style_light_property` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_style_light_property(&self, property_name: &str, value: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let property_name = call.input(&property_name)?;
        let value = call.input(&value)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_light_property(
                map,
                property_name,
                value,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Sets whether a source is volatile.
    ///
    /// The map doesn't store the tiles of a volatile source in the persistent
    /// cache.
    ///
    /// See `mln_map_set_style_source_volatile` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_style_source_volatile(&self, source_id: &str, is_volatile: bool) -> Result<()> {
        let mut call = self.0.inner.call();
        let source_id = call.input(&source_id)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_source_volatile(
                map,
                source_id,
                is_volatile,
                completion,
                out_diagnostic,
            )
        })
    }

    /// Sets the default transition of the map's style.
    ///
    /// See `mln_map_set_style_transition_options` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/style_8h.html).
    pub fn set_style_transition_options(&self, options: &StyleTransitionOptions) -> Result<()> {
        let mut call = self.0.inner.call();
        let options = call.reference(&options)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_transition_options(map, options, completion, out_diagnostic)
        })
    }

    /// Loads the map's style from `url`.
    ///
    /// The command completes once the style document has loaded and parsed. The
    /// style's sources, sprites, and glyphs then load in the background.
    ///
    /// The map's style is loaded from the time a style document parses until
    /// the next call to this function. While the style isn't loaded, the
    /// commands that change it complete with `Status::InvalidState`. To change
    /// a new map's style without a style document, first load an empty style,
    /// such as `{"version":8,"sources":{},"layers":[]}`.
    ///
    /// See `mln_map_set_style_url` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/map_8h.html).
    pub fn set_style_url(&self, url: &str) -> Result<()> {
        let mut call = self.0.inner.call();
        let url = call.input(&url)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_style_url(map, url, completion, out_diagnostic)
        })
    }

    /// Sets how the map chooses which tiles to load, and at what detail.
    ///
    /// Settings that `options` doesn't set keep their current values.
    ///
    /// See `mln_map_set_tile_options` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_tile_options(&self, options: &MapTileOptions) -> Result<()> {
        let mut call = self.0.inner.call();
        let options = call.reference(&options)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_tile_options(map, options, completion, out_diagnostic)
        })
    }

    /// Sets how the map orients and constrains its view.
    ///
    /// Settings that `options` doesn't set keep their current values.
    ///
    /// See `mln_map_set_viewport_options` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn set_viewport_options(&self, options: &MapViewportOptions) -> Result<()> {
        let mut call = self.0.inner.call();
        let options = call.reference(&options)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_set_viewport_options(map, options, completion, out_diagnostic)
        })
    }

    /// Moves the camera, at once or with an animation.
    ///
    /// Camera fields that `update` doesn't set keep their values, and the
    /// update stops any running animation of the fields it sets. The function
    /// finishes when the map applies the update, before an animation ends. To
    /// learn when an animation ends, set an `CameraTransitionHandler` in its
    /// animation options.
    ///
    /// See `mln_map_update_camera` in the
    /// [C API reference](https://maplibre.org/maplibre-native-ffi/reference/c/camera_8h.html).
    pub fn update_camera(&self, update: &CameraUpdate) -> Result<()> {
        let mut call = self.0.inner.call();
        let update = call.reference(&update)?;
        call.discard(|map, completion, out_diagnostic| unsafe {
            sys::mln_map_update_camera(map, update, completion, out_diagnostic)
        })
    }
}