servicepoint/crates/servicepoint_binding_cs/ServicePoint/BindGen/ServicePoint.g.cs

// <auto-generated>
// This code is generated by csbindgen.
// DON'T CHANGE THIS DIRECTLY.
// </auto-generated>
#pragma warning disable CS8500
#pragma warning disable CS8981
using System;
using System.Runtime.InteropServices;


namespace ServicePoint.BindGen
{
    public static unsafe partial class NativeMethods
    {
        const string __DllName = "servicepoint_binding_c";

        public const byte SP_BRIGHTNESS_MIN = 0;
        public const byte SP_BRIGHTNESS_MAX = 11;
        public const byte SP_BRIGHTNESS_LEVELS = 12;
        public const nuint SP_TILE_SIZE = 8;
        public const nuint SP_TILE_WIDTH = 56;
        public const nuint SP_TILE_HEIGHT = 20;


        /// <summary>
        ///  Creates a new [SPBitmap] with the specified dimensions.
        ///
        ///  # Arguments
        ///
        ///  - `width`: size in pixels in x-direction
        ///  - `height`: size in pixels in y-direction
        ///
        ///  returns: [SPBitmap] initialized to all pixels off. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when the width is not dividable by 8
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_bitmap_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitmap_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Bitmap* sp_bitmap_new(nuint width, nuint height);

        /// <summary>
        ///  Loads a [SPBitmap] with the specified dimensions from the provided data.
        ///
        ///  # Arguments
        ///
        ///  - `width`: size in pixels in x-direction
        ///  - `height`: size in pixels in y-direction
        ///
        ///  returns: [SPBitmap] that contains a copy of the provided data. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `data` is NULL
        ///  - when the dimensions and data size do not match exactly.
        ///  - when the width is not dividable by 8
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `data` points to a valid memory location of at least `data_length` bytes in size.
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_bitmap_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitmap_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Bitmap* sp_bitmap_load(nuint width, nuint height, byte* data, nuint data_length);

        /// <summary>
        ///  Clones a [SPBitmap].
        ///
        ///  Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `bitmap` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bitmap` points to a valid [SPBitmap]
        ///  - `bitmap` is not written to concurrently
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_bitmap_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitmap_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Bitmap* sp_bitmap_clone(Bitmap* bitmap);

        /// <summary>
        ///  Deallocates a [SPBitmap].
        ///
        ///  # Panics
        ///
        ///  - when `bitmap` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bitmap` points to a valid [SPBitmap]
        ///  - `bitmap` is not used concurrently or after bitmap call
        ///  - `bitmap` was not passed to another consuming function, e.g. to create a [SPCommand]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitmap_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_bitmap_free(Bitmap* bitmap);

        /// <summary>
        ///  Gets the current value at the specified position in the [SPBitmap].
        ///
        ///  # Arguments
        ///
        ///  - `bitmap`: instance to read from
        ///  - `x` and `y`: position of the cell to read
        ///
        ///  # Panics
        ///
        ///  - when `bitmap` is NULL
        ///  - when accessing `x` or `y` out of bounds
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bitmap` points to a valid [SPBitmap]
        ///  - `bitmap` is not written to concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitmap_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        [return: MarshalAs(UnmanagedType.U1)]
        public static extern bool sp_bitmap_get(Bitmap* bitmap, nuint x, nuint y);

        /// <summary>
        ///  Sets the value of the specified position in the [SPBitmap].
        ///
        ///  # Arguments
        ///
        ///  - `bitmap`: instance to write to
        ///  - `x` and `y`: position of the cell
        ///  - `value`: the value to write to the cell
        ///
        ///  returns: old value of the cell
        ///
        ///  # Panics
        ///
        ///  - when `bitmap` is NULL
        ///  - when accessing `x` or `y` out of bounds
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bitmap` points to a valid [SPBitmap]
        ///  - `bitmap` is not written to or read from concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitmap_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_bitmap_set(Bitmap* bitmap, nuint x, nuint y, [MarshalAs(UnmanagedType.U1)] bool value);

        /// <summary>
        ///  Sets the state of all pixels in the [SPBitmap].
        ///
        ///  # Arguments
        ///
        ///  - `bitmap`: instance to write to
        ///  - `value`: the value to set all pixels to
        ///
        ///  # Panics
        ///
        ///  - when `bitmap` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bitmap` points to a valid [SPBitmap]
        ///  - `bitmap` is not written to or read from concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitmap_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_bitmap_fill(Bitmap* bitmap, [MarshalAs(UnmanagedType.U1)] bool value);

        /// <summary>
        ///  Gets the width in pixels of the [SPBitmap] instance.
        ///
        ///  # Arguments
        ///
        ///  - `bitmap`: instance to read from
        ///
        ///  # Panics
        ///
        ///  - when `bitmap` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bitmap` points to a valid [SPBitmap]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitmap_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern nuint sp_bitmap_width(Bitmap* bitmap);

        /// <summary>
        ///  Gets the height in pixels of the [SPBitmap] instance.
        ///
        ///  # Arguments
        ///
        ///  - `bitmap`: instance to read from
        ///
        ///  # Panics
        ///
        ///  - when `bitmap` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bitmap` points to a valid [SPBitmap]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitmap_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern nuint sp_bitmap_height(Bitmap* bitmap);

        /// <summary>
        ///  Gets an unsafe reference to the data of the [SPBitmap] instance.
        ///
        ///  # Panics
        ///
        ///  - when `bitmap` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bitmap` points to a valid [SPBitmap]
        ///  - the returned memory range is never accessed after the passed [SPBitmap] has been freed
        ///  - the returned memory range is never accessed concurrently, either via the [SPBitmap] or directly
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitmap_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern ByteSlice sp_bitmap_unsafe_data_ref(Bitmap* bitmap);

        /// <summary>
        ///  Creates a new [SPBitVec] instance.
        ///
        ///  # Arguments
        ///
        ///  - `size`: size in bits.
        ///
        ///  returns: [SPBitVec] with all bits set to false. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `size` is not divisible by 8.
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_bitvec_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitvec_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern BitVec* sp_bitvec_new(nuint size);

        /// <summary>
        ///  Interpret the data as a series of bits and load then into a new [SPBitVec] instance.
        ///
        ///  returns: [SPBitVec] instance containing data. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `data` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `data` points to a valid memory location of at least `data_length`
        ///    bytes in size.
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_bitvec_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitvec_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern BitVec* sp_bitvec_load(byte* data, nuint data_length);

        /// <summary>
        ///  Clones a [SPBitVec].
        ///
        ///  returns: new [SPBitVec] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `bit_vec` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid [SPBitVec]
        ///  - `bit_vec` is not written to concurrently
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_bitvec_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitvec_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern BitVec* sp_bitvec_clone(BitVec* bit_vec);

        /// <summary>
        ///  Deallocates a [SPBitVec].
        ///
        ///  # Panics
        ///
        ///  - when `but_vec` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid [SPBitVec]
        ///  - `bit_vec` is not used concurrently or after this call
        ///  - `bit_vec` was not passed to another consuming function, e.g. to create a [SPCommand]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitvec_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_bitvec_free(BitVec* bit_vec);

        /// <summary>
        ///  Gets the value of a bit from the [SPBitVec].
        ///
        ///  # Arguments
        ///
        ///  - `bit_vec`: instance to read from
        ///  - `index`: the bit index to read
        ///
        ///  returns: value of the bit
        ///
        ///  # Panics
        ///
        ///  - when `bit_vec` is NULL
        ///  - when accessing `index` out of bounds
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid [SPBitVec]
        ///  - `bit_vec` is not written to concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitvec_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        [return: MarshalAs(UnmanagedType.U1)]
        public static extern bool sp_bitvec_get(BitVec* bit_vec, nuint index);

        /// <summary>
        ///  Sets the value of a bit in the [SPBitVec].
        ///
        ///  # Arguments
        ///
        ///  - `bit_vec`: instance to write to
        ///  - `index`: the bit index to edit
        ///  - `value`: the value to set the bit to
        ///
        ///  # Panics
        ///
        ///  - when `bit_vec` is NULL
        ///  - when accessing `index` out of bounds
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid [SPBitVec]
        ///  - `bit_vec` is not written to or read from concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitvec_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_bitvec_set(BitVec* bit_vec, nuint index, [MarshalAs(UnmanagedType.U1)] bool value);

        /// <summary>
        ///  Sets the value of all bits in the [SPBitVec].
        ///
        ///  # Arguments
        ///
        ///  - `bit_vec`: instance to write to
        ///  - `value`: the value to set all bits to
        ///
        ///  # Panics
        ///
        ///  - when `bit_vec` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid [SPBitVec]
        ///  - `bit_vec` is not written to or read from concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitvec_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_bitvec_fill(BitVec* bit_vec, [MarshalAs(UnmanagedType.U1)] bool value);

        /// <summary>
        ///  Gets the length of the [SPBitVec] in bits.
        ///
        ///  # Arguments
        ///
        ///  - `bit_vec`: instance to write to
        ///
        ///  # Panics
        ///
        ///  - when `bit_vec` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid [SPBitVec]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitvec_len", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern nuint sp_bitvec_len(BitVec* bit_vec);

        /// <summary>
        ///  Returns true if length is 0.
        ///
        ///  # Arguments
        ///
        ///  - `bit_vec`: instance to write to
        ///
        ///  # Panics
        ///
        ///  - when `bit_vec` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid [SPBitVec]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitvec_is_empty", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        [return: MarshalAs(UnmanagedType.U1)]
        public static extern bool sp_bitvec_is_empty(BitVec* bit_vec);

        /// <summary>
        ///  Gets an unsafe reference to the data of the [SPBitVec] instance.
        ///
        ///  # Arguments
        ///
        ///  - `bit_vec`: instance to write to
        ///
        ///  # Panics
        ///
        ///  - when `bit_vec` is NULL
        ///
        ///  ## Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid [SPBitVec]
        ///  - the returned memory range is never accessed after the passed [SPBitVec] has been freed
        ///  - the returned memory range is never accessed concurrently, either via the [SPBitVec] or directly
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_bitvec_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern ByteSlice sp_bitvec_unsafe_data_ref(BitVec* bit_vec);

        /// <summary>
        ///  Creates a new [SPBrightnessGrid] with the specified dimensions.
        ///
        ///  returns: [SPBrightnessGrid] initialized to 0. Will never return NULL.
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_brightness_grid_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern BrightnessGrid* sp_brightness_grid_new(nuint width, nuint height);

        /// <summary>
        ///  Loads a [SPBrightnessGrid] with the specified dimensions from the provided data.
        ///
        ///  returns: new [SPBrightnessGrid] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `data` is NULL
        ///  - when the provided `data_length` does not match `height` and `width`
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `data` points to a valid memory location of at least `data_length`
        ///    bytes in size.
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_brightness_grid_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern BrightnessGrid* sp_brightness_grid_load(nuint width, nuint height, byte* data, nuint data_length);

        /// <summary>
        ///  Clones a [SPBrightnessGrid].
        ///
        ///  # Arguments
        ///
        ///  - `brightness_grid`: instance to read from
        ///
        ///  returns: new [SPBrightnessGrid] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `brightness_grid` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
        ///  - `brightness_grid` is not written to concurrently
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_brightness_grid_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern BrightnessGrid* sp_brightness_grid_clone(BrightnessGrid* brightness_grid);

        /// <summary>
        ///  Deallocates a [SPBrightnessGrid].
        ///
        ///  # Arguments
        ///
        ///  - `brightness_grid`: instance to read from
        ///
        ///  # Panics
        ///
        ///  - when `brightness_grid` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
        ///  - `brightness_grid` is not used concurrently or after this call
        ///  - `brightness_grid` was not passed to another consuming function, e.g. to create a [SPCommand]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_brightness_grid_free(BrightnessGrid* brightness_grid);

        /// <summary>
        ///  Gets the current value at the specified position.
        ///
        ///  # Arguments
        ///
        ///  - `brightness_grid`: instance to read from
        ///  - `x` and `y`: position of the cell to read
        ///
        ///  returns: value at position
        ///
        ///  # Panics
        ///
        ///  - when `brightness_grid` is NULL
        ///  - When accessing `x` or `y` out of bounds.
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
        ///  - `brightness_grid` is not written to concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern byte sp_brightness_grid_get(BrightnessGrid* brightness_grid, nuint x, nuint y);

        /// <summary>
        ///  Sets the value of the specified position in the [SPBrightnessGrid].
        ///
        ///  # Arguments
        ///
        ///  - `brightness_grid`: instance to write to
        ///  - `x` and `y`: position of the cell
        ///  - `value`: the value to write to the cell
        ///
        ///  returns: old value of the cell
        ///
        ///  # Panics
        ///
        ///  - when `brightness_grid` is NULL
        ///  - When accessing `x` or `y` out of bounds.
        ///  - When providing an invalid brightness value
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `brightness_grid` points to a valid [SPBitVec]
        ///  - `brightness_grid` is not written to or read from concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_brightness_grid_set(BrightnessGrid* brightness_grid, nuint x, nuint y, byte value);

        /// <summary>
        ///  Sets the value of all cells in the [SPBrightnessGrid].
        ///
        ///  # Arguments
        ///
        ///  - `brightness_grid`: instance to write to
        ///  - `value`: the value to set all cells to
        ///
        ///  # Panics
        ///
        ///  - when `brightness_grid` is NULL
        ///  - When providing an invalid brightness value
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
        ///  - `brightness_grid` is not written to or read from concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_brightness_grid_fill(BrightnessGrid* brightness_grid, byte value);

        /// <summary>
        ///  Gets the width of the [SPBrightnessGrid] instance.
        ///
        ///  # Arguments
        ///
        ///  - `brightness_grid`: instance to read from
        ///
        ///  returns: width
        ///
        ///  # Panics
        ///
        ///  - when `brightness_grid` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern nuint sp_brightness_grid_width(BrightnessGrid* brightness_grid);

        /// <summary>
        ///  Gets the height of the [SPBrightnessGrid] instance.
        ///
        ///  # Arguments
        ///
        ///  - `brightness_grid`: instance to read from
        ///
        ///  returns: height
        ///
        ///  # Panics
        ///
        ///  - when `brightness_grid` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern nuint sp_brightness_grid_height(BrightnessGrid* brightness_grid);

        /// <summary>
        ///  Gets an unsafe reference to the data of the [SPBrightnessGrid] instance.
        ///
        ///  # Arguments
        ///
        ///  - `brightness_grid`: instance to read from
        ///
        ///  returns: slice of bytes underlying the `brightness_grid`.
        ///
        ///  # Panics
        ///
        ///  - when `brightness_grid` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `brightness_grid` points to a valid [SPBrightnessGrid]
        ///  - the returned memory range is never accessed after the passed [SPBrightnessGrid] has been freed
        ///  - the returned memory range is never accessed concurrently, either via the [SPBrightnessGrid] or directly
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_brightness_grid_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern ByteSlice sp_brightness_grid_unsafe_data_ref(BrightnessGrid* brightness_grid);

        /// <summary>
        ///  Tries to turn a [SPPacket] into a [SPCommand].
        ///
        ///  The packet is deallocated in the process.
        ///
        ///  Returns: pointer to new [SPCommand] instance or NULL if parsing failed.
        ///
        ///  # Panics
        ///
        ///  - when `packet` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - [SPPacket] points to a valid instance of [SPPacket]
        ///  - [SPPacket] is not used concurrently or after this call
        ///  - the result is checked for NULL
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_try_from_packet", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_try_from_packet(Packet* packet);

        /// <summary>
        ///  Clones a [SPCommand] instance.
        ///
        ///  returns: new [SPCommand] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `command` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `command` points to a valid instance of [SPCommand]
        ///  - `command` is not written to concurrently
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_clone(Command* command);

        /// <summary>
        ///  Set all pixels to the off state.
        ///
        ///  Does not affect brightness.
        ///
        ///  Returns: a new [Command::Clear] instance. Will never return NULL.
        ///
        ///  # Examples
        ///
        ///  ```C
        ///  sp_connection_send_command(connection, sp_command_clear());
        ///  ```
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_clear", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_clear();

        /// <summary>
        ///  Kills the udp daemon on the display, which usually results in a restart.
        ///
        ///  Please do not send this in your normal program flow.
        ///
        ///  Returns: a new [Command::HardReset] instance. Will never return NULL.
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_hard_reset", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_hard_reset();

        /// <summary>
        ///  A yet-to-be-tested command.
        ///
        ///  Returns: a new `Command::FadeOut` instance. Will never return NULL.
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_fade_out", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_fade_out();

        /// <summary>
        ///  Set the brightness of all tiles to the same value.
        ///
        ///  Returns: a new [Command::Brightness] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - When the provided brightness value is out of range (0-11).
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_brightness", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_brightness(byte brightness);

        /// <summary>
        ///  Set the brightness of individual tiles in a rectangular area of the display.
        ///
        ///  The passed [SPBrightnessGrid] gets consumed.
        ///
        ///  Returns: a new [Command::CharBrightness] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `grid` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `grid` points to a valid instance of [SPBrightnessGrid]
        ///  - `grid` is not used concurrently or after this call
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_char_brightness", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_char_brightness(nuint x, nuint y, BrightnessGrid* grid);

        /// <summary>
        ///  Set pixel data starting at the pixel offset on screen.
        ///
        ///  The screen will continuously overwrite more pixel data without regarding the offset, meaning
        ///  once the starting row is full, overwriting will continue on column 0.
        ///
        ///  The contained [SPBitVec] is always uncompressed.
        ///
        ///  The passed [SPBitVec] gets consumed.
        ///
        ///  Returns: a new [Command::BitmapLinear] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `bit_vec` is null
        ///  - when `compression_code` is not a valid value
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid instance of [SPBitVec]
        ///  - `bit_vec` is not used concurrently or after this call
        ///  - `compression` matches one of the allowed enum values
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_bitmap_linear(nuint offset, BitVec* bit_vec, CompressionCode compression);

        /// <summary>
        ///  Set pixel data according to an and-mask starting at the offset.
        ///
        ///  The screen will continuously overwrite more pixel data without regarding the offset, meaning
        ///  once the starting row is full, overwriting will continue on column 0.
        ///
        ///  The contained [SPBitVec] is always uncompressed.
        ///
        ///  The passed [SPBitVec] gets consumed.
        ///
        ///  Returns: a new [Command::BitmapLinearAnd] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `bit_vec` is null
        ///  - when `compression_code` is not a valid value
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid instance of [SPBitVec]
        ///  - `bit_vec` is not used concurrently or after this call
        ///  - `compression` matches one of the allowed enum values
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_and", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_bitmap_linear_and(nuint offset, BitVec* bit_vec, CompressionCode compression);

        /// <summary>
        ///  Set pixel data according to an or-mask starting at the offset.
        ///
        ///  The screen will continuously overwrite more pixel data without regarding the offset, meaning
        ///  once the starting row is full, overwriting will continue on column 0.
        ///
        ///  The contained [SPBitVec] is always uncompressed.
        ///
        ///  The passed [SPBitVec] gets consumed.
        ///
        ///  Returns: a new [Command::BitmapLinearOr] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `bit_vec` is null
        ///  - when `compression_code` is not a valid value
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid instance of [SPBitVec]
        ///  - `bit_vec` is not used concurrently or after this call
        ///  - `compression` matches one of the allowed enum values
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_or", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_bitmap_linear_or(nuint offset, BitVec* bit_vec, CompressionCode compression);

        /// <summary>
        ///  Set pixel data according to a xor-mask starting at the offset.
        ///
        ///  The screen will continuously overwrite more pixel data without regarding the offset, meaning
        ///  once the starting row is full, overwriting will continue on column 0.
        ///
        ///  The contained [SPBitVec] is always uncompressed.
        ///
        ///  The passed [SPBitVec] gets consumed.
        ///
        ///  Returns: a new [Command::BitmapLinearXor] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `bit_vec` is null
        ///  - when `compression_code` is not a valid value
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bit_vec` points to a valid instance of [SPBitVec]
        ///  - `bit_vec` is not used concurrently or after this call
        ///  - `compression` matches one of the allowed enum values
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_xor", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_bitmap_linear_xor(nuint offset, BitVec* bit_vec, CompressionCode compression);

        /// <summary>
        ///  Show text on the screen.
        ///
        ///  The passed [SPCp437Grid] gets consumed.
        ///
        ///  Returns: a new [Command::Cp437Data] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `grid` is null
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `grid` points to a valid instance of [SPCp437Grid]
        ///  - `grid` is not used concurrently or after this call
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_cp437_data", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_cp437_data(nuint x, nuint y, Cp437Grid* grid);

        /// <summary>
        ///  Sets a window of pixels to the specified values.
        ///
        ///  The passed [SPBitmap] gets consumed.
        ///
        ///  Returns: a new [Command::BitmapLinearWin] instance. Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `bitmap` is null
        ///  - when `compression_code` is not a valid value
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `bitmap` points to a valid instance of [SPBitmap]
        ///  - `bitmap` is not used concurrently or after this call
        ///  - `compression` matches one of the allowed enum values
        ///  - the returned [SPCommand] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_command_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_bitmap_linear_win", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Command* sp_command_bitmap_linear_win(nuint x, nuint y, Bitmap* bitmap, CompressionCode compression_code);

        /// <summary>
        ///  Deallocates a [SPCommand].
        ///
        ///  # Examples
        ///
        ///  ```C
        ///  SPCommand c = sp_command_clear();
        ///  sp_command_free(c);
        ///  ```
        ///
        ///  # Panics
        ///
        ///  - when `command` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `command` points to a valid [SPCommand]
        ///  - `command` is not used concurrently or after this call
        ///  - `command` was not passed to another consuming function, e.g. to create a [SPPacket]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_command_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_command_free(Command* command);

        /// <summary>
        ///  Creates a new instance of [SPConnection].
        ///
        ///  returns: NULL if connection fails, or connected instance
        ///
        ///  # Panics
        ///
        ///  - when `host` is null or an invalid host
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_connection_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_connection_open", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Connection* sp_connection_open(byte* host);

        /// <summary>
        ///  Sends a [SPPacket] to the display using the [SPConnection].
        ///
        ///  The passed `packet` gets consumed.
        ///
        ///  returns: true in case of success
        ///
        ///  # Panics
        ///
        ///  - when `connection` is NULL
        ///  - when `packet` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `connection` points to a valid instance of [SPConnection]
        ///  - `packet` points to a valid instance of [SPPacket]
        ///  - `packet` is not used concurrently or after this call
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_connection_send_packet", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        [return: MarshalAs(UnmanagedType.U1)]
        public static extern bool sp_connection_send_packet(Connection* connection, Packet* packet);

        /// <summary>
        ///  Sends a [SPCommand] to the display using the [SPConnection].
        ///
        ///  The passed `command` gets consumed.
        ///
        ///  returns: true in case of success
        ///
        ///  # Panics
        ///
        ///  - when `connection` is NULL
        ///  - when `command` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `connection` points to a valid instance of [SPConnection]
        ///  - `command` points to a valid instance of [SPPacket]
        ///  - `command` is not used concurrently or after this call
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_connection_send_command", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        [return: MarshalAs(UnmanagedType.U1)]
        public static extern bool sp_connection_send_command(Connection* connection, Command* command);

        /// <summary>
        ///  Closes and deallocates a [SPConnection].
        ///
        ///  # Panics
        ///
        ///  - when `connection` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `connection` points to a valid [SPConnection]
        ///  - `connection` is not used concurrently or after this call
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_connection_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_connection_free(Connection* connection);

        /// <summary>
        ///  Creates a new [SPCp437Grid] with the specified dimensions.
        ///
        ///  returns: [SPCp437Grid] initialized to 0. Will never return NULL.
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_cp437_grid_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_new", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Cp437Grid* sp_cp437_grid_new(nuint width, nuint height);

        /// <summary>
        ///  Loads a [SPCp437Grid] with the specified dimensions from the provided data.
        ///
        ///  Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `data` is NULL
        ///  - when the provided `data_length` does not match `height` and `width`
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `data` points to a valid memory location of at least `data_length`
        ///    bytes in size.
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_cp437_grid_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Cp437Grid* sp_cp437_grid_load(nuint width, nuint height, byte* data, nuint data_length);

        /// <summary>
        ///  Clones a [SPCp437Grid].
        ///
        ///  Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `cp437_grid` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `cp437_grid` points to a valid [SPCp437Grid]
        ///  - `cp437_grid` is not written to concurrently
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_cp437_grid_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Cp437Grid* sp_cp437_grid_clone(Cp437Grid* cp437_grid);

        /// <summary>
        ///  Deallocates a [SPCp437Grid].
        ///
        ///  # Panics
        ///
        ///  - when `cp437_grid` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `cp437_grid` points to a valid [SPCp437Grid]
        ///  - `cp437_grid` is not used concurrently or after cp437_grid call
        ///  - `cp437_grid` was not passed to another consuming function, e.g. to create a [SPCommand]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_cp437_grid_free(Cp437Grid* cp437_grid);

        /// <summary>
        ///  Gets the current value at the specified position.
        ///
        ///  # Arguments
        ///
        ///  - `cp437_grid`: instance to read from
        ///  - `x` and `y`: position of the cell to read
        ///
        ///  # Panics
        ///
        ///  - when `cp437_grid` is NULL
        ///  - when accessing `x` or `y` out of bounds
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `cp437_grid` points to a valid [SPCp437Grid]
        ///  - `cp437_grid` is not written to concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_get", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern byte sp_cp437_grid_get(Cp437Grid* cp437_grid, nuint x, nuint y);

        /// <summary>
        ///  Sets the value of the specified position in the [SPCp437Grid].
        ///
        ///  # Arguments
        ///
        ///  - `cp437_grid`: instance to write to
        ///  - `x` and `y`: position of the cell
        ///  - `value`: the value to write to the cell
        ///
        ///  returns: old value of the cell
        ///
        ///  # Panics
        ///
        ///  - when `cp437_grid` is NULL
        ///  - when accessing `x` or `y` out of bounds
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `cp437_grid` points to a valid [SPBitVec]
        ///  - `cp437_grid` is not written to or read from concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_set", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_cp437_grid_set(Cp437Grid* cp437_grid, nuint x, nuint y, byte value);

        /// <summary>
        ///  Sets the value of all cells in the [SPCp437Grid].
        ///
        ///  # Arguments
        ///
        ///  - `cp437_grid`: instance to write to
        ///  - `value`: the value to set all cells to
        ///
        ///  # Panics
        ///
        ///  - when `cp437_grid` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `cp437_grid` points to a valid [SPCp437Grid]
        ///  - `cp437_grid` is not written to or read from concurrently
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_fill", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_cp437_grid_fill(Cp437Grid* cp437_grid, byte value);

        /// <summary>
        ///  Gets the width of the [SPCp437Grid] instance.
        ///
        ///  # Arguments
        ///
        ///  - `cp437_grid`: instance to read from
        ///
        ///  # Panics
        ///
        ///  - when `cp437_grid` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `cp437_grid` points to a valid [SPCp437Grid]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_width", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern nuint sp_cp437_grid_width(Cp437Grid* cp437_grid);

        /// <summary>
        ///  Gets the height of the [SPCp437Grid] instance.
        ///
        ///  # Arguments
        ///
        ///  - `cp437_grid`: instance to read from
        ///
        ///  # Panics
        ///
        ///  - when `cp437_grid` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `cp437_grid` points to a valid [SPCp437Grid]
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_height", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern nuint sp_cp437_grid_height(Cp437Grid* cp437_grid);

        /// <summary>
        ///  Gets an unsafe reference to the data of the [SPCp437Grid] instance.
        ///
        ///  Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `cp437_grid` is NULL
        ///
        ///  ## Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `cp437_grid` points to a valid [SPCp437Grid]
        ///  - the returned memory range is never accessed after the passed [SPCp437Grid] has been freed
        ///  - the returned memory range is never accessed concurrently, either via the [SPCp437Grid] or directly
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_cp437_grid_unsafe_data_ref", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern ByteSlice sp_cp437_grid_unsafe_data_ref(Cp437Grid* cp437_grid);

        /// <summary>
        ///  Turns a [SPCommand] into a [SPPacket].
        ///  The [SPCommand] gets consumed.
        ///
        ///  Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `command` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - [SPCommand] points to a valid instance of [SPCommand]
        ///  - [SPCommand] is not used concurrently or after this call
        ///  - the returned [SPPacket] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_packet_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_packet_from_command", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Packet* sp_packet_from_command(Command* command);

        /// <summary>
        ///  Tries to load a [SPPacket] from the passed array with the specified length.
        ///
        ///  returns: NULL in case of an error, pointer to the allocated packet otherwise
        ///
        ///  # Panics
        ///
        ///  - when `data` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `data` points to a valid memory region of at least `length` bytes
        ///  - `data` is not written to concurrently
        ///  - the returned [SPPacket] instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_packet_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_packet_try_load", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Packet* sp_packet_try_load(byte* data, nuint length);

        /// <summary>
        ///  Clones a [SPPacket].
        ///
        ///  Will never return NULL.
        ///
        ///  # Panics
        ///
        ///  - when `packet` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `packet` points to a valid [SPPacket]
        ///  - `packet` is not written to concurrently
        ///  - the returned instance is freed in some way, either by using a consuming function or
        ///    by explicitly calling `sp_packet_free`.
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_packet_clone", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern Packet* sp_packet_clone(Packet* packet);

        /// <summary>
        ///  Deallocates a [SPPacket].
        ///
        ///  # Panics
        ///
        ///  - when `sp_packet_free` is NULL
        ///
        ///  # Safety
        ///
        ///  The caller has to make sure that:
        ///
        ///  - `packet` points to a valid [SPPacket]
        ///  - `packet` is not used concurrently or after this call
        /// </summary>
        [DllImport(__DllName, EntryPoint = "sp_packet_free", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
        public static extern void sp_packet_free(Packet* packet);


    }

    [StructLayout(LayoutKind.Sequential)]
    public unsafe partial struct Bitmap
    {
    }

    [StructLayout(LayoutKind.Sequential)]
    public unsafe partial struct BitVec
    {
    }

    [StructLayout(LayoutKind.Sequential)]
    public unsafe partial struct BrightnessGrid
    {
    }

    [StructLayout(LayoutKind.Sequential)]
    public unsafe partial struct ByteSlice
    {
        public byte* start;
        public nuint length;
    }

    [StructLayout(LayoutKind.Sequential)]
    public unsafe partial struct Command
    {
    }

    [StructLayout(LayoutKind.Sequential)]
    public unsafe partial struct Connection
    {
    }

    [StructLayout(LayoutKind.Sequential)]
    public unsafe partial struct Cp437Grid
    {
    }

    [StructLayout(LayoutKind.Sequential)]
    public unsafe partial struct Packet
    {
    }


    public enum CompressionCode : ushort
    {
        Uncompressed = 0,
        Zlib = 26490,
        Bzip2 = 25210,
        Lzma = 27770,
        Zstd = 31347,
    }


}